cli2 4.1.4__tar.gz → 4.2.1__tar.gz

{cli2-4.1.4/cli2.egg-info → cli2-4.2.1}/PKG-INFO

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

{cli2-4.1.4 → cli2-4.2.1}/cli2/__init__.py

@@ -24,11 +24,13 @@ try:
         FieldValueError,
         FieldExternalizeError,
         Client,
+        ClientCommand,
         DateTimeField,
         Field,
         Handler,
         JSONStringField,
         Model,
+        ModelCommand,
         Paginator,
         Related,
     )

{cli2-4.1.4 → cli2-4.2.1}/cli2/cli.py

@@ -658,6 +658,13 @@ class Command(EntryPoint, dict):
             self.exit_code = 1
             return self.help(missing=missing)
 
+        await self.factories_resolve()
+
+        result = self.call(*self.bound.args, **self.bound.kwargs)
+        return await async_resolve(result, output=True)
+
+    async def factories_resolve(self):
+        """ Resolve all factories values. """
         factories = self.values(factories=True)
         if factories:
             results = await asyncio.gather(*[
@@ -667,9 +674,6 @@ class Command(EntryPoint, dict):
             for _, arg in enumerate(factories):
                 arg.value = results[_]
 
-        result = self.call(*self.bound.args, **self.bound.kwargs)
-        return await async_resolve(result, output=True)
-
     def ordered(self, factories=False):
         """
         Order the parameters by priority.
@@ -1153,7 +1157,7 @@ class Argument:
             self.value = self.cast(value)
             return True
 
-    def factory_value(self):
+    def factory_value(self, cmd=None):
         """
         Run the factory function and return the value.
 
@@ -1164,11 +1168,15 @@ class Argument:
 
         It will forward any argument to the factory function if detected in
         it's signature, except for ``*args`` and ``**kwargs``.
+
+        :param cmd: Override for :py:attr:`cmd`, useful for getting the factory
+                    value of an argument from another class (advanced).
         """
         kwargs = dict()
+        cmd = cmd or self.cmd
         sig = inspect.signature(self.factory)
         if 'cmd' in sig.parameters:
-            kwargs['cmd'] = self.cmd
+            kwargs['cmd'] = cmd
         if 'arg' in sig.parameters:
             kwargs['arg'] = self
 
@@ -1176,7 +1184,7 @@ class Argument:
             inspect.Parameter.VAR_KEYWORD,
             inspect.Parameter.VAR_POSITIONAL,
         )
-        for key, arg in self.cmd.items():
+        for key, arg in cmd.items():
             if arg.param.kind in excluded:
                 continue
             if key in sig.parameters:

{cli2-4.1.4 → cli2-4.2.1}/cli2/client.py

@@ -23,7 +23,7 @@ except ImportError:
 
 from . import display
 from .asyncio import async_resolve
-from .cli import Command, Group, cmd, hide
+from .cli import Argument, Command, Group, cmd, hide
 from .colors import colors
 from .log import log
 
@@ -661,36 +661,43 @@ class ModelCommand(Command):
         super().__init__(target, *args, **kwargs)
         self.overrides['self']['factory'] = self.get_object
         self.overrides['cls']['factory'] = self.get_model
+        self.client = None
 
     def setargs(self):
+        """
+        ModelCommand setargs which calls setargs on the client class and
+        defines an id argument for object commands.
+        """
         super().setargs()
+        self.group.parent.client_class.setargs(self)
         if 'self' in self:
             self.arg('id', position=0, kind='POSITIONAL_ONLY', doc='ID')
 
-    async def get_client(self):
-        client = self.group.parent.overrides['self']['factory']()
-        return await async_resolve(client)
+    async def factories_resolve(self):
+        """
+        Return a client object from it's factory, will all args resolved.
+        """
+        # create a hidden Argument to use it's factory caller
+        argument = Argument(
+            self,
+            inspect.Parameter('_', kind=inspect.Parameter.POSITIONAL_ONLY),
+            factory=self.client_class.factory,
+        )
+        # this ensures the factory gets any kind of args
+        factory = await argument.factory_value(self)
+        self.client = await async_resolve(factory)
+        await super().factories_resolve()
 
     async def get_model(self):
-        return getattr(await self.get_client(), self.model.__name__)
+        """ Return a client instance bound model """
+        return getattr(self.client, self.model.__name__)
 
     async def get_object(self):
         model = await self.get_model()
         return await model.get(id=self['id'].value)
 
-
-class ModelGroup(Group):
-    def __init__(self, cls):
-        super().__init__(
-            name=cls.__name__.lower(),
-            doc=inspect.getdoc(cls),
-            cmdclass=type(
-                'ModelCommand',
-                (cls.model_command,),
-                dict(model=cls),
-            )
-        )
-        self.load(cls)
+    async def post_call(self):
+        await self.client.post_call(self)
 
 
 class ModelMetaclass(type):
@@ -699,10 +706,14 @@ class ModelMetaclass(type):
             attributes['paginator'] = attributes['Paginator']
 
         cls = super().__new__(cls, name, bases, attributes)
-        cls.Command = type(
+        client_class = getattr(cls, '_client_class', None)
+        cls.cmdclass = type(
             'ModelCommand',
-            (cls.Command,),
-            dict(model=cls),
+            (cls.cmdclass,),
+            dict(
+                model=cls,
+                client_class=client_class,
+            ),
         )
         client = getattr(cls, 'client', None)
         if client:
@@ -710,7 +721,6 @@ class ModelMetaclass(type):
                 cls.paginator = client.paginator
             return cls
 
-        client_class = getattr(cls, '_client_class', None)
         if client_class:
             client_class.models.append(cls)
 
@@ -744,7 +754,7 @@ class ModelMetaclass(type):
             cli_kwargs = dict(
                 name=cls.__name__.lower(),
                 doc=inspect.getdoc(cls),
-                cmdclass=cls.Command,
+                cmdclass=cls.cmdclass,
             )
             cli_kwargs.update(cls.cli_kwargs)
             cls._cli = Group(**cli_kwargs)
@@ -789,24 +799,20 @@ class Model(metaclass=ModelMetaclass):
         Dict of kwargs to use to create the :py:class:`~cli2.cli.Group` for
         this model.
 
-    .. py:attribute:: Command
+    .. py:attribute:: cmdclass
 
-        Define a Command class inside the ModelClass to use a specific
-        :py:class:`~cli2.cli.Command` class for a model.
-        Don't inherit from anything: a new class will be generated for you
-        inheriting from both :py:class:`~cls.cli2.client.ModelCommand` and
-        :py:attr:`~cli2.cli.Client.Command`.
+        :py:class:`ModelCommand` subclass. You generally don't need to
+        define this, instead, you should do what you need in the
+        :py:meth:`Client.factory`, :py:meth:`Client.setargs` and
+        :py:meth:`Client.post_call` methods.
     """
     paginator = None
-    model_command = ModelCommand
+    cmdclass = ModelCommand
     url_list = None
     url_detail = '{self.url_list}/{self.id_value}'
     id_field = 'id'
     cli_kwargs = dict()
 
-    class Command(ModelCommand):
-        pass
-
     def __init__(self, data=None, **values):
         """
         Instanciate a model.
@@ -984,10 +990,10 @@ class ClientMetaclass(type):
 
         cls = super().__new__(cls, name, bases, attributes)
 
-        cls.Command = type(
+        cls.cmdclass = type(
             'ClientCommand',
-            (cls.Command, Command),
-            dict(),
+            (cls.cmdclass,),
+            dict(client_class=cls),
         )
 
         # bind ourself as _client_class to any inherited model
@@ -1005,13 +1011,15 @@ class ClientMetaclass(type):
                     cls=dict(factory=lambda: cls),
                     self=dict(factory=lambda: cls())
                 ),
-                cmdclass=cls.Command,
+                cmdclass=cls.cmdclass,
             )
             cli_kwargs.update(cls.cli_kwargs)
             cli = Group(**cli_kwargs)
+            cli.client_class = cls
             cli.load(cls)
             for model in cls.models:
                 group = model.cli
+                group.client_class = cls
                 if len(group) > 1:
                     cli[model.__name__.lower()] = group
             cls._cli = cli
@@ -1248,6 +1256,37 @@ class FieldExternalizeError(FieldValueError):
     pass
 
 
+class ClientCommand(Command):
+    """
+    Client CLI command
+
+    .. py:attribute:: client
+
+        The client object that was constructed from :py:meth:`Client.factory`
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client = None
+
+    def setargs(self):
+        """
+        Set a `self` factory of :py:meth:`Client.factory` method, and call
+        :py:meth:`Client.setargs`.
+        """
+        super().setargs()
+        self['self'].factory = self.client_class.factory
+        self.client_class.setargs(self)
+
+    async def factories_resolve(self):
+        """ Set :py:attr:`client` after resolving factories. """
+        await super().factories_resolve()
+        self.client = self['self'].value
+
+    async def post_call(self):
+        """ Call :py:meth:`Client.post_call`. """
+        await self.client.post_call(self)
+
+
 class Client(metaclass=ClientMetaclass):
     """
     HTTPx Client Wrapper
@@ -1286,12 +1325,12 @@ class Client(metaclass=ClientMetaclass):
             class YourClient(cli2.Client):
                 cli_kwargs = dict(cmdclass=YourCommandClass)
 
-    .. py:attribute:: Command
+    .. py:attribute:: cmdclass
 
-        Define a Command class inside the Client class to use a specific
-        :py:class:`~cli2.cli.Command` class for a model.
-        Don't inherit from anything: a new class will be generated for you
-        inheriting from :py:attr:`~cli2.cli.Client.Command` for you.
+        :py:class:`ClientCommand` class or subclass. You usually won't have to
+        define this, instead, you should do what you need in the
+        :py:meth:`factory`, :py:meth:`setargs` and :py:meth:`post_call`
+        methods.
 
     .. py:attribute:: debug
 
@@ -1307,9 +1346,7 @@ class Client(metaclass=ClientMetaclass):
     semaphore = None
     mask = []
     debug = False
-
-    class Command:
-        pass
+    cmdclass = ClientCommand
 
     def __init__(self, *args, handler=None, semaphore=None, mask=None,
                  debug=False, **kwargs):
@@ -1341,6 +1378,30 @@ class Client(metaclass=ClientMetaclass):
                 model.url_list = model.url_list.format(client=self)
             setattr(self, model.__name__, model)
 
+    @classmethod
+    async def factory(cls):
+        """
+        Override this method to customize your client construction.
+
+        You can add custom args, if you declare them in :py:meth:`setargs()`.
+        """
+        return cls()
+
+    @classmethod
+    def setargs(cls, cmd):
+        """
+        Override this method to declare CLI args globally for this client.
+
+        :param cmd: :py:class:`ClientCommand` object
+        """
+
+    async def post_call(self, cmd):
+        """
+        Override this method which will run after a CLI exits.
+
+        :param cmd: :py:class:`ClientCommand` object
+        """
+
     @property
     def client(self):
         """

{cli2-4.1.4 → cli2-4.2.1/cli2.egg-info}/PKG-INFO

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

{cli2-4.1.4 → cli2-4.2.1}/setup.py

@@ -44,7 +44,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='4.1.4',
+    version='4.2.1',
     setup_requires='setupmeta',
     packages=['cli2'],
     install_requires=[

{cli2-4.1.4 → cli2-4.2.1}/tests/test_client.py

@@ -60,7 +60,10 @@ async def test_client_cli(client_class, httpx_mock):
     assert 'testmodel' in client_class.cli
     assert client_class.cli['testmodel']['get'].overrides['cls']['factory']
     assert not inspect.ismethod(client_class.cli['testmodel']['get'].target)
-    result = await client_class.cli['testmodel']['get']['cls'].factory_value()
+    command = client_class.cli['testmodel']['get']
+    command.parse()
+    await command.factories_resolve()
+    result = client_class.cli['testmodel']['get']['cls'].value
     assert issubclass(result, TestModel)
     assert isinstance(result.client, client_class)
 
@@ -148,7 +151,7 @@ async def test_client_cli_side_effect(client_class, httpx_mock):
 
     # Test that Client's __init_subclass__ did setup a factory for self
     assert isinstance(
-        example_client.APIClient.cli['get']['self'].factory_value(),
+        await example_client.APIClient.cli['get']['self'].factory_value(),
         example_client.APIClient,
     )
 
@@ -1151,17 +1154,40 @@ async def test_client_token_apply(client_class, httpx_mock):
     assert client.client.token == 2
 
 
-def test_client_command(client_class):
+def test_client_command(client_class, httpx_mock):
     class Client(client_class):
-        class Command(cli2.Command):
-            pass
+        post_call_called = False
+
+        def __init__(self, base_url, *args, **kwargs):
+            kwargs['base_url'] = base_url
+            super().__init__(*args, **kwargs)
+
+        @classmethod
+        async def factory(self, base_url):
+            return Client(base_url)
+
+        @classmethod
+        def setargs(self, cmd):
+            cmd.arg('base_url', position=0, kind='POSITIONAL_ONLY')
+
+        async def post_call(self, cmd):
+            await self.client.post('/logoff')
 
     class Model(Client.Model):
         url_list = '/foo'
-        class Command(Client.Command, cli2.Model.Command):
-            pass
 
-    assert issubclass(Client.cli.cmdclass, Client.Command)
-    assert issubclass(Client.cli['model'].cmdclass, Client.Command)
-    assert issubclass(Client.cli['model'].cmdclass, cli2.Model.Command)
     assert 'get' in Client.cli['model']
+
+    assert Client.cli['get'].client is None
+    cmd = Client.cli['get']
+    assert isinstance(cmd, Client.cmdclass)
+    httpx_mock.add_response(url='http://x/foo', json=[])
+    httpx_mock.add_response(url='http://x/logoff')
+    result = cmd('http://x', '/foo')
+    assert result.status_code == 200
+
+    httpx_mock.add_response(url='http://x/foo', json=[])
+    httpx_mock.add_response(url='http://x/logoff')
+    assert Client.cli['model']['get'].client is None
+    cmd = Client.cli['model']['find']
+    cmd('http://x')