cli2 3.2.0__tar.gz → 3.3.0__tar.gz

{cli2-3.2.0/cli2.egg-info → cli2-3.3.0}/PKG-INFO

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

{cli2-3.2.0 → cli2-3.3.0}/cli2/__init__.py

@@ -3,6 +3,7 @@ from .argument import Argument
 from .colors import colors as c
 import importlib.metadata
 
+from .configuration import Configuration, cfg
 from .command import Command
 try:
     from .client import (

{cli2-3.2.0 → cli2-3.3.0}/cli2/command.py

@@ -1,5 +1,6 @@
 import asyncio
 import inspect
+import json
 import sys
 
 from docstring_parser import parse
@@ -295,10 +296,47 @@ class Command(EntryPoint, dict):
         except KeyboardInterrupt:
             print('exiting')
             sys.exit(1)
+        except HTTPStatusError as exc:
+            # we probably can have a generic exception handler registry
+            # of some sort instead of this, but this will do for now
+            self.http_exception_enhance(exc)
+            raise
         finally:
-            self.post_result = await async_resolve(self.post_call())
+            try:
+                self.post_result = await async_resolve(self.post_call())
+            except HTTPStatusError as exc:
+                self.http_exception_enhance(exc)
+                raise
         return result
 
+    def http_exception_enhance(self, exc):
+        """
+        Enhance an httpx.HTTPStatusError
+
+        Adds beatiful request/response data to the exception.
+
+        :param exc: httpx.HTTPStatusError
+        """
+        try:
+            request = display.yaml_dump(
+                json.loads(exc.request.content.decode()),
+            )
+        except json.JSONDecodeError:
+            request = exc.request.content
+
+        try:
+            response = display.yaml_dump(exc.response.json())
+        except json.JSONDecodeError:
+            response = exc.response.content
+
+        exc.args = ('\n'.join([
+            exc.args[0],
+            'Request data:',
+            request,
+            'Response data:',
+            response,
+        ]),)
+
     def ordered(self, factories=False):
         """
         Order the parameters by priority.

cli2-3.3.0/cli2/configuration.py

@@ -0,0 +1,190 @@
+"""
+12-factor interactive self-building lazy configuration.
+
+The developer story we are after:
+
+- there's nothing to do, just expect ``cli2.cfg['YOUR_ENV_VAR']`` to work one
+  way or another
+- when there's a minute to be nice to the user, add some help that will be
+  displayed to them: ``cli2.cfg.questions['YOUR_ENV_VAR'] = 'this is a help
+  text that will be display to the user when we prompt them for YOUR_ENV_VAR'``
+
+This is the user story we are after:
+
+- user runs your cli2 command right after install without any configuration
+- the user is prompted for a variable
+- the variable is saved in their ~/.profile in a new export line
+- the user runs a command again in the same shell: we should find the variable
+  in ~/.profile so he doesn't have to start a new shell for his new
+  configuration to work
+
+Of course, if the environment variable is already present in the environment
+then this basically returns it from ``os.environ``.
+"""
+
+import functools
+import os
+import re
+import shlex
+from pathlib import Path
+
+
+class Configuration(dict):
+    """
+    Configuration object.
+
+    Wraps around environment variable and can question the user for missing
+    variables and save them in his shell profile.
+
+    .. py:attribute:: questions
+
+        A dict of ``ENV_VAR=question_string``, if an env var is missing from
+        configuration then question_string will be used as text to prompt the
+        user.
+
+    .. py:attribute:: profile_path
+
+        Path to the shell profile to save/read variables, defaults to
+        ~/.profile which should work in many shells.
+
+    You can also just work with the module level ("singleton") instance, have
+    scripts like:
+
+    .. code-block:: python
+
+        import cli2
+
+        cli = cli2.Group()
+
+        cli2.cfg['API_URL'] = 'What is your API URL?'
+
+        @cli.cmd
+        def foo():
+            api_url = cli2.cfg['API_URL']
+
+            # when there's no question, it'll use the var name as prompt
+            api_url = cli2.cfg['USERNAME']
+
+    """
+    def __init__(self, profile_path=None, **questions):
+        self.questions = questions
+        self.profile_path = Path(
+            profile_path or os.getenv('HOME') + '/.profile'
+        )
+        self._profile_script = None
+        self._profile_variables = dict()
+        self.environ = os.environ.copy()
+
+    def input(self, prompt):
+        """
+        Wraps around Python's input but adds confirmation.
+
+        :param prompt: Prompt text to display.
+        """
+        value = input(prompt + '\n> ')
+        confirm = None
+        while confirm not in ('', 'y', 'Y', 'n'):
+            confirm = input(f'Confirm value of:\n{value}?\n(Y/n) >')
+        if confirm in ('', 'y', 'Y'):
+            # user is satisfied
+            return value
+        # ok let's try again
+        return self.input(prompt)
+
+    def __getitem__(self, key):
+        """
+        If the key is not in self, call :py:meth:`configure`.
+
+        :param key: Environment variable name
+        """
+        if key not in self:
+            self[key] = self.configure(key)
+        return super().__getitem__(key)
+
+    @property
+    def profile_script(self):
+        """
+        Cached :py:attr:`profile_path` reader.
+        """
+        if self._profile_script:
+            return self._profile_script
+
+        if self.profile_path.exists():
+            with self.profile_path.open('r') as f:
+                self._profile_script = f.read()
+        else:
+            self.profile_path.touch()
+            self._profile_script = ''
+        return self._profile_script
+
+    @functools.cached_property
+    def profile_variables(self):
+        """
+        Cached environment variable parsing from :py:attr:`profile_path`.
+        """
+        if self._profile_variables:
+            return self._profile_variables
+
+        for line in self.profile_script.split('\n'):
+            if not line.startswith('export '):
+                continue
+            name, value = re.findall('export ([^=]*)=(.*)', line)[0]
+            value = shlex.split(value)[0]
+            self._profile_variables[name] = value
+        return self._profile_variables
+
+    def configure(self, key):
+        """
+        Core logic to figure a variable.
+
+        - if present in os.environ: return that
+        - if parsed in profile_variables: return that
+        - otherwise prompt it, with the question if any, then save it to
+          :py:attr:`profile_path`
+        """
+        if key in self.environ:
+            return self.environ[key]
+
+        # ok, let's love our user, and try to parse the variable
+        # from self.profile, after all, perhaps they are running
+        # their command for the second time in the same shell
+        if key in self.profile_variables:
+            return self.profile_variables[key]
+
+        prompt = self.questions.get(key, key)
+        value = self.input(prompt)
+        escaped_value = shlex.quote(value)
+        with self.profile_path.open('a') as f:
+            f.write(f'\nexport {key}={escaped_value}')
+        return value
+
+    def delete(self, key, reason=None):
+        """
+        Delete a variable from everywhere, useful if an api key expired.
+
+        :param key: Env var name to delete
+        :param reason: Reason to print to the user
+        """
+        with self.profile_path.open('r') as f:
+            lines = f.read().split('\n')
+
+        contents = [
+            line
+            for line in lines
+            if not line.startswith(f'export {key}=')
+        ]
+        if len(contents) != len(lines):
+            if reason:
+                print(reason)
+            print(f'Removing {key} configuration')
+
+        new_script = '\n'.join(contents)
+        with self.profile_path.open('w') as f:
+            f.write(new_script)
+        self._profile_script = new_script
+        self._profile_variables.pop(key, None)
+        self.pop(key, None)
+        self.environ.pop(key, None)
+
+
+cfg = Configuration()

{cli2-3.2.0 → cli2-3.3.0}/cli2/example_client.py

@@ -16,5 +16,10 @@ class Object(APIClient.model):
     url_list = '/objects'
     url_detail = '/objects/{self.url_id}'
 
+    @classmethod
+    @cli.cmd
+    async def fail(cls):
+        await cls.client.post('/foo', json=[1])
+
 
 cli.cmd(Object.find)

{cli2-3.2.0 → cli2-3.3.0}/cli2/test_client.py

@@ -1,6 +1,7 @@
 import cli2
 import httpx
 import pytest
+import textwrap
 from datetime import datetime
 
 
@@ -13,7 +14,7 @@ raised = False
 
 
 @pytest.mark.asyncio
-async def test_error(httpx_mock):
+async def test_error_remote(httpx_mock):
     client = Client()
     httpx_mock.add_response(url='http://lol', json=[1])
 
@@ -29,6 +30,26 @@ async def test_error(httpx_mock):
     assert response.json() == [1]
 
 
+@pytest.mark.asyncio
+async def test_error_status(httpx_mock):
+    client = Client()
+    httpx_mock.add_response(url='http://lol', status_code=403, json=[1])
+
+    async def request():
+        await client.post('http://lol', json=[2])
+    cmd = cli2.Command(request)
+    with pytest.raises(httpx.HTTPStatusError) as excinfo:
+        await cmd.async_call()
+    expected = textwrap.dedent('''
+    Request data:
+    - 2
+
+    Response data:
+    - 1
+    ''').strip()
+    assert excinfo.value.args[0].strip().endswith(expected)
+
+
 @pytest.mark.asyncio
 async def test_token(httpx_mock):
     class HasToken(Client):

cli2-3.3.0/cli2/test_configuration.py

@@ -0,0 +1,62 @@
+import cli2
+import os
+import subprocess
+
+
+class Configuration(cli2.Configuration):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.expected_prompts = dict()
+
+    def input(self, prompt):
+        return self.expected_prompts.pop(prompt)
+
+
+def test_idempotent(tmp_path):
+    profile_path = tmp_path / 'bashrc'
+    cfg = Configuration(
+        profile_path=profile_path,
+        ENV_VAR1='What 1?',
+    )
+
+    # get something hard to escape
+    value = '''foo$a#e'"'''
+    cfg.expected_prompts['What 1?'] = value
+    assert cfg['ENV_VAR1'] == value
+
+    # no expected prompt here: it should parse it again from profile_path
+    cfg = Configuration(
+        profile_path=profile_path,
+        ENV_VAR1='What 1?',
+    )
+    assert 'ENV_VAR1' in cfg.profile_variables
+    assert cfg['ENV_VAR1'] == value
+
+    # let's make sure we get the same value from new shells
+    result = subprocess.check_output(
+        f'. {profile_path} && echo $ENV_VAR1',
+        shell=True,
+    )
+    assert result.decode().strip() == value
+
+    # we don't like the value of the variable anymore (ie. password changed,
+    # api key revoked ...), ask for a new one
+    with cfg.profile_path.open('r') as f:
+        before = f.read()
+    assert 'export ENV_VAR1=' in before
+    cfg.delete('ENV_VAR1')
+    with cfg.profile_path.open('r') as f:
+        after = f.read()
+    assert 'export ENV_VAR1=' not in after
+    assert 'export ENV_VAR1=' not in cfg.profile_script
+    assert 'ENV_VAR1' not in cfg.profile_variables
+    assert 'ENV_VAR1' not in cfg.environ
+    assert 'ENV_VAR1' not in cfg
+
+    # it should also find it from os.environ
+    os.environ['ENV_VAR2'] = value
+    cfg = Configuration(
+        profile_path=profile_path,
+        ENV_VAR2='What 2?',
+    )
+    assert cfg['ENV_VAR2'] == value

{cli2-3.2.0 → cli2-3.3.0/cli2.egg-info}/PKG-INFO

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

{cli2-3.2.0 → cli2-3.3.0}/cli2.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ cli2/cli.py
 cli2/client.py
 cli2/colors.py
 cli2/command.py
+cli2/configuration.py
 cli2/decorators.py
 cli2/display.py
 cli2/entry_point.py
@@ -25,6 +26,7 @@ cli2/test.py
 cli2/test_cli.py
 cli2/test_client.py
 cli2/test_command.py
+cli2/test_configuration.py
 cli2/test_decorators.py
 cli2/test_display.py
 cli2/test_entry_point.py

{cli2-3.2.0 → cli2-3.3.0}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='3.2.0',
+    version='3.3.0',
     setup_requires='setupmeta',
     install_requires=[
         'docstring_parser',