Use zetup.toplevel, .module for nodely, .bin

Author: userzimmermann

nodely/__init__.py

@@ -22,24 +22,33 @@
 """
 
 import json
+import os
 import sys
 
 from path import Path
+from pkg_resources import get_distribution
 import whichcraft
 import zetup
 
-# __version__ module is created by setuptools_scm during setup
-from .__version__ import version as __version__
-
 from .error import NodeCommandError
 
-__all__ = (
-    'install', 'uninstall', 'which', 'Popen', 'call',
-    'NodeCommandError')
+# HACK: Fix inconsistently hard-coded whichcraft.__version__
+whichcraft.__version__ = get_distribution('whichcraft').version
+
+zetup.toplevel(__name__, [
+    'NodeCommandError',
+    'Popen',
+    'call',
+    'install',
+    'uninstall',
+    'which',
+])
 
 
-#: The absolute path to the local node_modules/ sub-directory used for
-#  installing Node.js packages under the python environment root
+#:  The absolute path to the local ``node_modules/`` sub-directory.
+#
+#   Which is located under the current Python environment root, and which is
+#   used for installing Node.js packages into
 NODE_MODULES_DIR = (Path(sys.prefix) / 'node_modules').mkdir_p()
 
 # create a dummy package.json in python environment root for making npm
@@ -56,33 +65,33 @@
 
 def install(package):
     """
-    Install given Node.js `package` into ``node_modules/`` of current Python
-    environment
+    Install given Node.js `package`.
+
+    Into ``node_modules/`` of current Python environment
     """
     command = ['npm', 'install', package]
     with Path(sys.prefix):
         status = zetup.call(command)
     if status:
-        raise RuntimeError("Command {!r} failed with status {}"
-                           .format(command, status))
+        raise NodeCommandError(command, status, os.getcwd())
 
 
 def uninstall(package):
     """
-    Uninstall given Node.js `package` from ``node_modules/`` of current Python
-    environment
+    Uninstall given Node.js `package`.
+
+    From ``node_modules/`` of current Python environment
     """
     command = ['npm', 'uninstall', package]
     with Path(sys.prefix):
         status = zetup.call(command)
     if status:  # pragma: no cover
-        raise RuntimeError("Command {!r} failed with status {}"
-                           .format(command, status))
+        raise NodeCommandError(command, status, os.getcwd())
 
 
 def which(executable):
     """
-    Find `executable` in ``node_modules/.bin/`` of current Python environment
+    Find `executable` in ``node_modules/.bin/`` of current Python environment.
 
     :return: Absolute ``path.Path`` instance or ``None``
     """
@@ -93,9 +102,13 @@ def which(executable):
 
 def Popen(executable, args=None, **kwargs):
     """
-    Create a subprocess for given Node.js `executable` with given sequence
-    of `args` strings and optional `kwargs` for ``zetup.Popen``, including all
-    options for ``subprocess.Popen``
+    Create a subprocess for given Node.js `executable`.
+
+    :param args:
+        Optional sequence of command argument strings
+    :param options:
+        General options for ``zetup.call``, including all options for
+        ``subprocess.call``
     """
     import nodely.bin
 
@@ -105,9 +118,13 @@ def Popen(executable, args=None, **kwargs):
 
 def call(executable, args=None, **kwargs):
     """
-    Call given Node.js `executable` with given sequence of `args` strings and
-    optional `kwargs` for ``zetup.call``, including all options for
-    ``subprocess.call``
+    Call given Node.js `executable`.
+
+    :param args:
+        Optional sequence of command argument strings
+    :param kwargs:
+        General options for ``zetup.call``, including all options for
+        ``subprocess.call``
     """
     import nodely.bin
 

nodely/bin.py

@@ -34,68 +34,44 @@
 
 from .error import NodeCommandError
 
-__all__ = ['Command']
+zetup.module(
+    __name__, ['Command'],
+    __getitem__=lambda cmdname: __getitem__(cmdname),
+    __getattr__=lambda name: __getattr__(name),
+    __dir__=lambda: __dir__())
 
 
 #: Running on Windows?
 WIN = platform.system() == 'Windows'
 
 
-#: The original nodely.bin module object
-ORIGIN = sys.modules[__name__]
-
-
-class Module(ModuleType):
+def __getitem__(cmdname):
     """
-    Wrapper module class for :mod:`nodely.bin`.
+    Get a :class:`nodely.bin.Command` instance for given `cmdname`.
 
-    Makes module directly act as command proxy to the ``node_modules/.bin/``
-    directory via :meth:`.__getitem__` and :meth:`.__getattr__`
+    :raises OSError: if executable can not be found
     """
+    return Command(cmdname)
 
-    def __init__(self):
-        """
-        Set ``.__name__`` and ``.__doc__``, and update ``.__dict__``.
-
-        All taken from original ``nodely.bin`` module
-        """
-        super(Module, self).__init__(__name__, ORIGIN.__doc__)
-        self.__dict__.update(ORIGIN.__dict__)
-
-    def __getitem__(self, cmdname):
-        """
-        Get a :class:`nodely.bin.Command` instance for given `cmdname`.
 
-        :raises OSError: if executable can not be found
-        """
-        return Command(cmdname)
+def __getattr__(name):
+    """
+    Get a :class:`nodely.bin.Command` instance for given command `name`.
 
-    def __getattr__(self, name):
-        """
-        Get a :class:`nodely.bin.Command` instance for given command `name`.
+    :raises OSError: if executable cannot be found
+    """
+    try:
+        return __getitem__(name)
 
-        :raises OSError: if executable cannot be found
-        """
-        try:  # first check if original module has the given attribute
-            return getattr(ORIGIN, name)
-        except AttributeError:
-            pass
-        # and don't treat special Python member names as Node.js commands
-        if name.startswith('__'):
-            raise AttributeError(
-                "{!r} has no attribute {!r}".format(self, name))
-        return self[name]
-
-    def __dir__(self):
-        cmdnames = (f.basename()
-                    for f in (NODE_MODULES_DIR / '.bin').files())
-        if WIN:  # pragma: no cover
-            cmdnames = (cmd for cmd in cmdnames if cmd.ext.lower() != '.cmd')
-        return dir(ORIGIN) + list(cmdnames)
+    except (IOError, OSError) as exc:
+        raise AttributeError(str(exc))
 
 
-# replace nodely.bin module with wrapper instance
-sys.modules[__name__] = Module()
+def __dir__():
+    cmdnames = (f.basename() for f in (NODE_MODULES_DIR / '.bin').files())
+    if WIN:  # pragma: no cover
+        cmdnames = (cmd for cmd in cmdnames if cmd.ext.lower() != '.cmd')
+    return list(cmdnames)
 
 
 class Command(zetup.object, Path):