sort output; prefix with _

Author: cs01

README.md

@@ -5,7 +5,7 @@
 </p>
 
 <a href="https://pypi.python.org/pypi/pythonloc/">
-<img src="https://img.shields.io/badge/pypi-0.1.1.1-blue.svg" /></a>
+<img src="https://img.shields.io/badge/pypi-0.1.1.2-blue.svg" /></a>
 
 **pythonloc** is a drop in replacement for `python` and `pip` that automatically recognizes a `__pypackages__` directory and prefers importing packages installed in this location over user or global site-packages. If you are familiar with node, `__pypackages__` works similarly to `node_modules`.
 
@@ -181,7 +181,7 @@ Successfully uninstalled requests-2.21.0
 
 While this PEP is pretty exciting, there are a some things it doesn't solve.
 
-* entrypoints: when you install a package, any entry points a package may have in the `bin` folder (like `black` or `tox`) are not accessible based on this PEP. A tool designed to install packages globally, yet keep them sandboxed is [pipx](https://github.com/pipxproject/pipx) (also my project). This works well for installing a single version globally, but using virtual environments directly will let you run entry points as you'd expect.
+* entrypoints: when you install a package, any entry points a package may have in the `bin` folder (like `black` or `tox`) are not accessible based on this PEP. [pipx](https://github.com/pipxproject/pipx) (also my project), is the perfect tool to search in `__pypackages__/3.6/lib/bin` for the entry point you want to run. So you would run `pipx run tox` and it would locate `__pypackages__/3.6/lib/bin`. (It doesn't currently do this.) This is very similar to [npx](https://www.npmjs.com/package/npx), which will search in `node_modules/bin`.
 * OS-dependent packages: The directory structure in `__pypackages__` is namespaced on python version, so packages for Python 3.6 will not mix with 3.7, which is great. But sometimes packages install differently for different OS's, so Windows may not match mac, etc.
 * site-packages: This PEP first looks to `__pypackages__` but will fall back to looking in `site-packages`. This is not entirely hermetic and could lead to some confusion around which packages are being used. I would prefer the search path be **only** `__pypackages__` and nothing else.
 * perceived downside -- bloat: Many have brought this up in various forums, comparing it to `node_modules`, but I don't think it applies here. For one, the same if not more "bloat" is installed into a virtual environment, so this just moves it into a local directory. No additional bloat. In fact, it is more obvious and can be deleted because it's not hidden away in a virtual env directory.  But more importantly, I think the assumption that it is bloated or will be abused stems from JavaScript's ecosystem. JavaScript has a notoriously limited standard library, and developers need to reach for third party packages more often. In addition, the JavaScript development heavily relies on many plugins and transpilation, something Python does not. I do not find the bloat argument convincing.

pythonloc/pythonloc.py

@@ -7,7 +7,7 @@
 import pip
 
 
-def get_pypackages_lib_path(script_path=None):
+def _get_pypackages_lib_path(script_path=None):
     """returns path in compliance with PEP 582
     https://www.python.org/dev/peps/pep-0582/
     """
@@ -24,37 +24,27 @@ def get_pypackages_lib_path(script_path=None):
     )
 
 
-def get_env(script_path=None):
+def _get_env(script_path=None):
     env = dict(os.environ)
     env["PYTHONPATH"] = os.path.pathsep.join(
-        [".", get_pypackages_lib_path(script_path)]
+        [".", _get_pypackages_lib_path(script_path)]
         + os.getenv("PYTHONPATH", "").split(os.path.pathsep)
     )
     return env
 
 
-def null_handler(signum, frame):
-    pass
-
-
-def get_script_path():
+def _get_script_path():
     for arg in sys.argv[1:]:
         if not arg.startswith("-"):
             return os.path.abspath(arg)
     return None
 
 
-def pythonloc():
-    args = [sys.executable] + sys.argv[1:]
-    script_path = get_script_path()
-    os.execve(sys.executable, args, get_env(script_path))
-
-
 def _get_pip_target_args(pip_args):
     if "install" in pip_args:
         if "--target" not in pip_args:
             # use target dir if installing
-            target = ["--target", get_pypackages_lib_path()]
+            target = ["--target", _get_pypackages_lib_path()]
         if (
             pip.__version__.startswith("9.") or pip.__version__.startswith("10.")
         ) and "--system" not in pip_args:
@@ -64,16 +54,22 @@ def _get_pip_target_args(pip_args):
     return target
 
 
+def pythonloc():
+    args = [sys.executable] + sys.argv[1:]
+    script_path = _get_script_path()
+    os.execve(sys.executable, args, _get_env(script_path))
+
+
 def piploc():
     pip_args = sys.argv[1:]
     target = _get_pip_target_args(pip_args)
     args = [sys.executable] + ["-m", "pip"] + pip_args + target
-    os.execve(sys.executable, args, get_env())
+    os.execve(sys.executable, args, _get_env())
 
 
 def pipfreezeloc():
     cmd = [sys.executable, "-m", "pip", "freeze"]
-    p = subprocess.Popen(cmd, env=get_env(), stdout=subprocess.PIPE)
+    p = subprocess.Popen(cmd, env=_get_env(), stdout=subprocess.PIPE)
     try:
         outs, errs = p.communicate()
         if outs is None:
@@ -94,7 +90,7 @@ def pipfreezeloc():
     except Exception:
         p.kill()
         exit("failed to run pip freeze")
-    for i in all_reqs - sys_reqs:
+    for i in sorted(all_reqs - sys_reqs):
         print(i)
 
 

setup.py

@@ -23,7 +23,7 @@
 
 setup(
     name="pythonloc",
-    version="0.1.1.1",
+    version="0.1.1.2",
     author="Chad Smith",
     author_email="[email protected]",
     description="Run Python using packages from local directory __pypackages__",