1.0.3 (#39)

Author: 欧林宝

jdcloud_cli/cement/__init__.py

@@ -0,0 +1,126 @@
+"""
+Cement core argument module.
+
+"""
+
+from ..core import interface
+from ..core.handler import CementBaseHandler
+from ..utils.misc import minimal_logger
+
+LOG = minimal_logger(__name__)
+
+
+# pylint: disable=w0613
+def argument_validator(klass, obj):
+    """Validates a handler implementation against the IArgument interface."""
+    members = [
+        '_setup',
+        'parse',
+        'add_argument',
+    ]
+
+    interface.validate(IArgument, obj, members)
+
+
+# pylint: disable=W0105,W0232,W0232,R0903,E0213,R0923
+class IArgument(interface.Interface):
+
+    """
+    This class defines the Argument Handler Interface.  Classes that
+    implement this handler must provide the methods and attributes defined
+    below.  Implementations do *not* subclass from interfaces.
+
+    Example:
+
+    .. code-block:: python
+
+        from cement.core import interface, arg
+
+        class MyArgumentHandler(arg.CementArgumentHandler):
+            class Meta:
+                interface = arg.IArgument
+                label = 'my_argument_handler'
+
+    """
+    class IMeta:
+
+        """Interface meta-data options."""
+
+        label = 'argument'
+        """The string identifier of the interface."""
+
+        validator = argument_validator
+        """Interface validator function."""
+
+    # Must be provided by the implementation
+    Meta = interface.Attribute('Handler Meta-data')
+
+    def _setup(app_obj):
+        """
+        The _setup function is called during application initialization and
+        must 'setup' the handler object making it ready for the framework
+        or the application to make further calls to it.
+
+        :param app_obj: The application object
+        :returns: ``None``
+
+        """
+
+    # pylint: disable=E0211
+    def add_argument(*args, **kw):
+        """
+        Add arguments for parsing.  This should be -o/--option or positional.
+        Note that the interface defines the following parameters so that at
+        the very least, external extensions can guarantee that they can
+        properly add command line arguments when necessary.  The
+        implementation itself should, and will provide and support many more
+        options than those listed here.  That said, the implementation must
+        support the following:
+
+        :arg args: List of option arguments.  Generally something like
+            ['-h', '--help'].
+        :keyword dest: The destination name (var).  Default: arg[0]'s string.
+        :keyword help: The help text for --help output (for that argument).
+        :keyword action: Must support: ['store', 'store_true', 'store_false',
+            'store_const']
+        :keyword choices:  A list of valid values that can be passed to an
+         option whose action is ``store``.
+        :keyword const: The value stored if action == 'store_const'.
+        :keyword default: The default value.
+        :returns: ``None``
+
+        """
+
+    def parse(arg_list):
+        """
+        Parse the argument list (i.e. sys.argv).  Can return any object as
+        long as it's members contain those of the added arguments.  For
+        example, if adding a '-v/--version' option that stores to the dest of
+        'version', then the member must be callable as 'Object().version'.
+
+        :param arg_list: A list of command line arguments.
+        :returns: Callable object
+
+        """
+
+
+# pylint: disable=W0105
+class CementArgumentHandler(CementBaseHandler):
+
+    """Base class that all Argument Handlers should sub-class from."""
+
+    class Meta:
+
+        """
+        Handler meta-data (can be passed as keyword arguments to the parent
+        class).
+        """
+
+        label = None
+        """The string identifier of the handler implementation."""
+
+        interface = IArgument
+        """The interface that this class implements."""
+
+    def __init__(self, *args, **kw):
+        super(CementArgumentHandler, self).__init__(*args, **kw)

jdcloud_cli/cement/core/__init__.py

@@ -0,0 +1,7 @@
+"""Cement core backend module."""
+
+VERSION = (2, 11, 1, 'alpha', 0)  # pragma: nocover
+
+# global hooks/handlers (DEPRECATED)
+__handlers__ = {}   # pragma: nocover
+__hooks__ = {}      # pragma: nocover

jdcloud_cli/cement/core/arg.py

@@ -0,0 +1,133 @@
+"""Cement core cache module."""
+
+from ..core import interface, handler
+from ..utils.misc import minimal_logger
+
+LOG = minimal_logger(__name__)
+
+
+def cache_validator(klass, obj):
+    """Validates a handler implementation against the ICache interface."""
+
+    members = [
+        '_setup',
+        'get',
+        'set',
+        'delete',
+        'purge',
+    ]
+    interface.validate(ICache, obj, members)
+
+
+class ICache(interface.Interface):
+
+    """
+    This class defines the Cache Handler Interface.  Classes that
+    implement this handler must provide the methods and attributes defined
+    below.
+
+    Implementations do *not* subclass from interfaces.
+
+    Usage:
+
+    .. code-block:: python
+
+        from cement.core import cache
+
+        class MyCacheHandler(object):
+            class Meta:
+                interface = cache.ICache
+                label = 'my_cache_handler'
+            ...
+
+    """
+    # pylint: disable=W0232, C0111, R0903
+    class IMeta:
+
+        """Interface meta-data."""
+
+        label = 'cache'
+        """The label (or type identifier) of the interface."""
+
+        validator = cache_validator
+        """Interface validator function."""
+
+    # Must be provided by the implementation
+    Meta = interface.Attribute('Handler meta-data')
+
+    def _setup(app_obj):
+        """
+        The _setup function is called during application initialization and
+        must 'setup' the handler object making it ready for the framework
+        or the application to make further calls to it.
+
+        :param app_obj: The application object.
+        :returns: ``None``
+
+        """
+
+    def get(key, fallback=None):
+        """
+        Get the value for a key in the cache.  If the key does not exist
+        or the key/value in cache is expired, this functions must return
+        'fallback' (which in turn must default to None).
+
+        :param key: The key of the value stored in cache
+        :param fallback: Optional value that is returned if the cache is
+         expired or the key does not exist.  Default: None
+        :returns: Unknown (whatever the value is in cache, or the `fallback`)
+
+        """
+
+    def set(key, value, time=None):
+        """
+        Set the key/value in the cache for a set amount of `time`.
+
+        :param key: The key of the value to store in cache.
+        :param value: The value of that key to store in cache.
+        :param time: A one-off expire time.  If no time is given, then a
+            default value is used (determined by the implementation).
+        :type time: ``int`` (seconds) or ``None``
+        :returns: ``None``
+
+        """
+
+    def delete(key):
+        """
+        Deletes a key/value from the cache.
+
+        :param key: The key in the cache to delete.
+        :returns: True if the key is successfully deleted, False otherwise.
+        :rtype: ``boolean``
+
+        """
+
+    # pylint: disable=E0211
+    def purge():
+        """
+        Clears all data from the cache.
+
+        """
+
+
+class CementCacheHandler(handler.CementBaseHandler):
+
+    """
+    Base class that all Cache Handlers should sub-class from.
+
+    """
+    class Meta:
+
+        """
+        Handler meta-data (can be passed as keyword arguments to the parent
+        class).
+        """
+
+        label = None
+        """String identifier of this handler implementation."""
+
+        interface = ICache
+        """The interface that this handler class implements."""
+
+    def __init__(self, *args, **kw):
+        super(CementCacheHandler, self).__init__(*args, **kw)