cli2 3.3.45__tar.gz → 3.4.0__tar.gz

{cli2-3.3.45/cli2.egg-info → cli2-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 3.3.45
+Version: 3.4.0
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic

{cli2-3.3.45 → cli2-3.4.0}/cli2/__init__.py

@@ -28,7 +28,7 @@ except ImportError:
     # httpx not installed
     pass
 from .decorators import arg, cmd
-from .display import diff, print, highlight
+from .display import diff, diff_data, render, print, highlight
 from .group import Group
 from .node import Node
 from .table import Table

cli2-3.4.0/cli2/ansible.py

@@ -0,0 +1,273 @@
+"""
+Experimental: my base class for Ansible actions.
+
+TODO: Turn this into a cool framework.
+"""
+
+import asyncio
+import cli2
+import copy
+import mock
+import os
+import re
+import traceback
+
+from cli2 import logging
+
+from ansible.plugins.action import ActionBase
+
+# colors:
+# black
+# bright gray
+# blue
+# white
+# green
+# cyan
+# bright green
+# red
+# bright cyan
+# purple
+# bright red
+# yellow
+# bright purple
+# dark gray
+# magenta
+# bright magenta
+# normal
+
+# 7-bit C1 ANSI sequences
+ansi_escape = re.compile(r'''
+    \x1B  # ESC
+    (?:   # 7-bit C1 Fe (except CSI)
+        [@-Z\\-_]
+    |     # or [ for CSI, followed by a control sequence
+        \[
+        [0-?]*  # Parameter bytes
+        [ -/]*  # Intermediate bytes
+        [@-~]   # Final byte
+    )
+''', re.VERBOSE)
+
+
+UNSET_DEFAULT = '__UNSET__DEFAULT__'
+
+
+class Option:
+    """
+    Ansible Option descriptor.
+
+    .. py:attribute:: arg
+
+        Name of the task argument to get this option value from
+
+    .. py:attribute:: fact
+
+        Name of the fact, if any, to get a value for this option if no task arg
+        is provided
+
+    .. py:attribute:: default
+
+        Default value, if any, in case neither of arg and fact were defined.
+    """
+    UNSET_DEFAULT = UNSET_DEFAULT
+
+    def __init__(self, arg=None, fact=None, default=UNSET_DEFAULT):
+        self.arg = arg
+        self.fact = fact
+        self.default = default
+
+    @property
+    def kwargs(self):
+        kwargs = dict(default=self.default)
+        if self.arg:
+            kwargs['arg_name'] = self.arg
+        if self.fact:
+            kwargs['fact_name'] = self.fact
+        return kwargs
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        try:
+            return obj.get(**self.kwargs)
+        except AttributeError:
+            raise AnsibleOptionError(self)
+
+
+class AnsibleError(Exception):
+    pass
+
+
+class AnsibleOptionError(AnsibleError):
+    def __init__(self, option):
+        self.option = option
+        super().__init__(option.kwargs)
+
+    @property
+    def message(self):
+        message = ['Missing']
+        if self.option.arg:
+            message.append(f'arg `{self.option.arg}`')
+            if self.option.fact:
+                message.append('or')
+        if self.option.fact:
+            message.append(f'fact `{self.option.fact}`')
+        return ' '.join(message)
+
+
+class ActionBase(ActionBase):
+    """
+    Base action class
+
+    .. py:attribute:: result
+
+        Result dict that will be returned to Ansible
+
+    .. py:attribute:: task_vars
+
+        The task_vars that the module was called with
+
+    .. py:attribute:: client
+
+        The client object generated by :py:meth:`client_factory` if you
+        implement it.
+    """
+    def get(self, arg_name, fact_name=None, default=UNSET_DEFAULT):
+        if arg_name in self._task.args:
+            return self._task.args[arg_name]
+        if fact_name and fact_name in self.task_vars:
+            return self.task_vars[fact_name]
+        if default != UNSET_DEFAULT:
+            return default
+        if fact_name:
+            raise AttributeError(f'Undefined {arg_name} or {fact_name}')
+        else:
+            raise AttributeError(f'Undefined arg {arg_name}')
+
+    def run(self, tmp=None, task_vars=None):
+        self.tmp = tmp
+        self.task_vars = task_vars
+        self.result = super().run(tmp, task_vars)
+        asyncio.run(self.run_wrapped_async())
+        return self.result
+
+    async def run_wrapped_async(self):
+        self.verbosity = self.task_vars.get('ansible_verbosity', 0)
+
+        if 'LOG_LEVEL' in os.environ or 'DEBUG' in os.environ:
+            logging.configure()
+        else:
+            if self.verbosity == 1:
+                os.environ['LOG_LEVEL'] = 'INFO'
+            elif self.verbosity >= 2:
+                os.environ['LOG_LEVEL'] = 'DEBUG'
+            logging.configure()
+
+        try:
+            try:
+                self.client = await self.client_factory()
+            except NotImplementedError:
+                self.client = None
+            await self.run_async()
+        except Exception as exc:
+            self.result['failed'] = True
+
+            if isinstance(exc, AnsibleError):
+                self.result['error'] = exc.message
+            elif self.verbosity:
+                traceback.print_exc()
+
+            # for pytest to raise
+            self.exc = exc
+        finally:
+            if (
+                self._before_data != UNSET_DEFAULT
+                and self._after_data != UNSET_DEFAULT
+            ):
+                diff = cli2.diff_data(
+                    self._before_data,
+                    self._after_data,
+                    self._before_label,
+                    self._after_label,
+                )
+                if self.client and self.client.mask:
+                    output = '\n'.join([
+                        line.rstrip() for line in diff if line.strip()
+                    ])
+                    output = re.sub(
+                        f'({"|".join(self.client.mask)}): (.*)',
+                        '\\1: ***MASKED***',
+                        ''.join(output),
+                    )
+                    print(cli2.highlight(output, 'Diff'))
+                else:
+                    cli2.diff(diff)
+
+    async def run_async(self):
+        """
+        The method you are supposed to implement.
+
+        It should:
+
+        - provision the :py:attr:`result` dict
+        - find task_vars in :py:attr:`task_vars`
+        """
+
+    async def client_factory(self):
+        """
+        Return a client instance.
+
+        :raise NotImplementedError: By default
+        """
+        raise NotImplementedError()
+
+    @classmethod
+    async def run_test_async(cls, args=None, facts=None, client=None,
+                             fail=False):
+        """
+        Test run the module in a mocked context.
+
+        :param args: Dict of task arguments
+        :param facts: Dict of play facts
+        :param client: Client instance, overrides the factory
+        :param fail: Allow this test to fail without exception
+        """
+        obj = cls(*[mock.Mock()] * 6)
+        obj.tmp = None
+        obj.task_vars = mock.Mock()
+        obj.result = dict()
+        obj._task = mock.Mock()
+        obj._task.args = args or {}
+        obj.task_vars = facts or {}
+        obj.task_vars['ansible_verbosity'] = 1
+        obj.exc = False
+        if client:
+            async def _factory():
+                return client
+            obj.client_factory = _factory
+        old = obj.client_factory
+
+        async def set_tries():
+            client = await old()
+            client.handler.tries = 0
+            return client
+        obj.client_factory = set_tries
+        await obj.run_wrapped_async()
+        if obj.exc and not fail:
+            raise obj.exc
+        if obj.result.get('failed', False) and not fail:
+            raise Exception('Module failed, and fail is not True {obj.result}')
+        return obj
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._before_data = UNSET_DEFAULT
+        self._after_data = UNSET_DEFAULT
+
+    def before_set(self, data, label='before'):
+        self._before_data = copy.deepcopy(data)
+        self._before_label = label
+
+    def after_set(self, data, label='after'):
+        self._after_data = copy.deepcopy(data)
+        self._after_label = label

{cli2-3.3.45 → cli2-3.4.0}/cli2/client.py

@@ -181,14 +181,12 @@ class Paginator:
         .. code-block:: python
 
             def pagination_parameters(self, params, page_number):
-                # this is the default implementation
                 params['page'] = page_number
 
         :param params: Dict of base GET parameters
         :param page_number: Page number to get
         """
-        if page_number > 1:
-            params['page'] = page_number
+        raise NotImplementedError("pagination_parameters not implemented")
 
     def response_items(self, response):
         """
@@ -231,7 +229,11 @@ class Paginator:
 
         :param page_number: Page number to get the items from
         """
-        return self.response_items(await self.page_response(page_number))
+        try:
+            return self.response_items(await self.page_response(page_number))
+        except NotImplementedError:
+            # pagination_parameters not implemented, can't paginate
+            return []
 
     async def page_response(self, page_number):
         """
@@ -240,7 +242,11 @@ class Paginator:
         :param page_number: Page number to get the items from
         """
         params = self.params.copy()
-        self.pagination_parameters(params, page_number)
+        try:
+            self.pagination_parameters(params, page_number)
+        except NotImplementedError:
+            if page_number > 1:
+                raise
         for expression in self.expressions:
             if expression.parameterable:
                 expression.params(params)
@@ -365,6 +371,12 @@ class Field:
         - Use :py:meth:`internal_set` to actually set the internal
           :py:attr:`Model.data`
         """
+        try:
+            old_value = getattr(obj, self.name)
+            if self.name not in obj.changed_fields and value != old_value:
+                obj.changed_fields[self.name] = old_value
+        except FieldExternalizeError:
+            obj.changed_fields[self.name] = None
         value = self.internalize(obj, value)
         self.internal_set(obj, value)
 
@@ -527,6 +539,8 @@ class JSONStringField(MutableField):
         return json.dumps(data, **self.options)
 
     def externalize(self, obj, value):
+        if value == '':
+            return value
         return json.loads(value)
 
 
@@ -676,6 +690,8 @@ class ModelGroup(Group):
 
 class ModelMetaclass(type):
     def __new__(cls, name, bases, attributes):
+        if 'Paginator' in attributes:
+            attributes['paginator'] = attributes['Paginator']
         cls = super().__new__(cls, name, bases, attributes)
         client = getattr(cls, 'client', None)
         if client:
@@ -767,9 +783,13 @@ class Model(metaclass=ModelMetaclass):
         self._dirty_fields = []
         self._field_cache = dict()
 
+        self.changed_fields = dict()
         for key, value in values.items():
             setattr(self, key, value)
 
+        # actually reset that
+        self.changed_fields = dict()
+
     @property
     def data(self):
         """
@@ -787,6 +807,10 @@ class Model(metaclass=ModelMetaclass):
     def data(self, value):
         self._data = value
 
+    @property
+    def data_masked(self):
+        return self.client.mask_data(self.data)
+
     @classmethod
     @hide('expressions')
     @cmd(color='green', condition=lambda cls: cls.url_list)
@@ -864,6 +888,7 @@ class Model(metaclass=ModelMetaclass):
         """
         response = await self.client.get(self.url)
         self.data.update(response.json())
+        self.changed_fields = dict()
 
     async def save(self):
         """
@@ -917,6 +942,8 @@ class Model(metaclass=ModelMetaclass):
 
 class ClientMetaclass(type):
     def __new__(cls, name, bases, attributes):
+        if 'Paginator' in attributes:
+            attributes['paginator'] = attributes['Paginator']
         cls = super().__new__(cls, name, bases, attributes)
 
         # bind ourself as _client_class to any inherited model
@@ -1044,13 +1071,52 @@ class ClientError(Exception):
 
 
 class ResponseError(ClientError):
+    """
+    Beautiful Response Error class.
+
+    .. py:attribute:: response
+
+        httpx Response object
+
+    .. py:attribute:: request
+
+        httpx Request object
+
+    .. py:attribute:: status_code
+
+        Response status code
+
+    .. py:attribute:: url
+
+        Request url
+
+    .. py:attribute:: method
+
+        Request method
+    """
     def __init__(self, client, response, tries, mask, msg=None):
         self.client = client
         self.response = response
         self.tries = tries
         self.mask = mask
-        msg = msg or getattr(self, 'msg', '').format(self=self)
-        super().__init__(self.enhance(msg))
+        self.msg = msg or getattr(self, 'msg', '').format(self=self)
+        super().__init__(self.enhance(self.msg))
+
+    @property
+    def request(self):
+        return self.response.request
+
+    @property
+    def method(self):
+        return str(self.request.method)
+
+    @property
+    def url(self):
+        return str(self.request.url)
+
+    @property
+    def status_code(self):
+        return str(self.response.status_code)
 
     def enhance(self, msg):
         """
@@ -1442,7 +1508,9 @@ class Client(metaclass=ClientMetaclass):
 
         return response
 
-    def response_log_data(self, response, mask):
+    def response_log_data(self, response, mask=None):
+        if mask is None:
+            mask = self.mask
         try:
             data = response.json()
         except json.JSONDecodeError:

{cli2-3.3.45 → cli2-3.4.0}/cli2/display.py

@@ -4,8 +4,10 @@ Generic pretty display utils.
 This module defines a print function that's supposed to be able to pretty-print
 anything, as well as a pretty diff printer.
 """
+import difflib
 import os
 import sys
+import yaml
 
 try:
     import jsonlight as json
@@ -34,7 +36,6 @@ def highlight(string, lexer):
 
 
 def yaml_dump(data):
-    import yaml
     if isinstance(data, dict):
         # ensure that objects inheriting from dict render nicely
         data = dict(data)
@@ -45,7 +46,7 @@ def yaml_highlight(yaml_string):
     return highlight(yaml_string, 'Yaml')
 
 
-def render(arg):
+def render(arg, highlight=True):
     """
     Try to render arg as yaml.
 
@@ -78,6 +79,8 @@ def render(arg):
         pass
 
     string = arg if isinstance(arg, str) else yaml_dump(arg)
+    if not highlight:
+        return string
     return yaml_highlight(string)
 
 
@@ -111,3 +114,12 @@ def diff(diff, **kwargs):
         cli2.diff(difflib.unified_diff(old, new))
     """
     _print(diff_highlight(diff), **kwargs)
+
+
+def diff_data(before, after, before_label='before', after_label='after'):
+    return difflib.unified_diff(
+        yaml.dump(before).splitlines(),
+        yaml.dump(after).splitlines(),
+        before_label,
+        after_label,
+    )

{cli2-3.3.45 → cli2-3.4.0}/cli2/example_client.py

@@ -4,9 +4,17 @@ import cli2
 class APIClient(cli2.Client):
     """
     Client for restful-api.dev
+
+    Prior to using this, run at the root of this repository:
+
+        pip install django djangorestframework
+        ./manage.py migrate
+        ./manage.py runserver
     """
+    mask = ["Capacity"]
+
     def __init__(self, *args, **kwargs):
-        kwargs.setdefault('base_url', 'https://api.restful-api.dev/')
+        kwargs.setdefault('base_url', 'http://localhost:8000')
         super().__init__(*args, **kwargs)
 
     @cli2.cmd
@@ -23,8 +31,8 @@ class Object(APIClient.Model):
 
     cli2-example-client object create name=cli2 capacity=2TB
     """
-    url_list = '/objects'
-    url_detail = '/objects/{self.id}'
+    url_list = '/objects/'
+    url_detail = '/objects/{self.id}/'
 
     id = cli2.Field()
     name = cli2.Field()

cli2-3.4.0/cli2/locker.py

@@ -0,0 +1,62 @@
+import fcntl
+import os
+
+
+class Locker:
+    def __init__(self, lock_path, blocking=True, prefix=None):
+        self.lock_path = lock_path
+        self.blocking = blocking
+        self.acquired = True
+        self.prefix = prefix or ''
+
+    def display(self, msg):
+        _ = []
+        if self.blocking:
+            _.append('[BLOCKING LOCK]')
+        else:
+            _.append('[NON BLOCKING LOCK]')
+        if self.prefix:
+            _.append(f'[{self.prefix}]')
+        _.append(f'[{self.lock_path}]')
+        _.append(f' {msg}')
+        self.print(''.join(_))
+
+    def print(self, msg):
+        print(msg)
+
+    def __enter__(self):
+        self.display('Waiting')
+        self.lock_path.parent.mkdir(parents=True, exists_ok=True)
+        self.fp = self.lock_path.open('w+')
+
+        if self.blocking:
+            fcntl.flock(self.fp.fileno(), fcntl.LOCK_EX)
+            self.display('Acquired')
+            return self
+
+        try:
+            fcntl.flock(
+                self.fp.fileno(),
+                fcntl.LOCK_EX | fcntl.LOCK_NB,
+            )
+        except BlockingIOError:
+            self.display('Not acquired but non blocking: proceeding')
+            self.acquired = False
+        else:
+            self.display('Acquired')
+        return self
+
+    def __exit__(self, _type, value, tb):
+        self.display('Releasing')
+        if self.acquired or not self.blocking:
+            fcntl.flock(self.fp.fileno(), fcntl.LOCK_UN)
+            self.fp.close()
+            self.display('Released')
+
+        if self.acquired:
+            try:
+                os.unlink(self.lock_path)
+            except FileNotFoundError:
+                pass  # already deleted, or locked by another process
+            else:
+                self.display('Deleted')

{cli2-3.3.45 → cli2-3.4.0}/cli2/logging.py

@@ -15,9 +15,9 @@ class YAMLFormatter:
 
     def __call__(self, key, value):
         value = cli2.display.yaml_dump(value)
-        if not self.colors:
-            return value
-        return cli2.display.yaml_highlight(value)
+        if self.colors:
+            value = cli2.display.yaml_highlight(value)
+        return '\n' + value
 
 
 def configure():