cli2 5.1.6__tar.gz → 5.2.1rc1__tar.gz

{cli2-5.1.6/cli2.egg-info → cli2-5.2.1rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.1.6
+Version: 5.2.1rc1
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,5 +63,6 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
+- **AI assisted programing CLI & framework with code2**
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.1.6 → cli2-5.2.1rc1}/README.rst

@@ -25,5 +25,6 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
+- **AI assisted programing CLI & framework with code2**
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/__init__.py

@@ -8,20 +8,26 @@ from .cli import (
     Command,
     Group,
     EntryPoint,
+    Cli2Error,
+    Cli2ValueError,
 )
 from .asyncio import async_resolve, async_run, Queue
 from .colors import colors as c
+from .theme import theme, t
 
 from .configuration import Configuration, cfg
 from .display import diff, diff_data, render, print, highlight, yaml_highlight
+from .interactive import choice, editor
 try:
     import fcntl
 except ImportError:
     """ windows """
 else:
     from .lock import Lock
+
 from .log import configure, log, parse
 from .mask import Mask
+from .notlevenshtein import closest, closest_path
 from .table import Table
 
 

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/cli.py

@@ -14,6 +14,14 @@ from .asyncio import async_resolve
 from .colors import colors
 
 
+class Cli2Error(Exception):
+    pass
+
+
+class Cli2ValueError(Cli2Error):
+    pass
+
+
 class Overrides(dict):
     """
     Lazy overrides dict
@@ -299,6 +307,9 @@ class Group(EntryPoint, dict):
                 continue
             if leaf and getattr(final, name, '_') is None:
                 continue
+            if isinstance(method, classmethod):
+                # get the bound method
+                method = getattr(cls, name)
             self.load_method(final, method)
 
     def load_obj(self, obj):
@@ -308,9 +319,10 @@ class Group(EntryPoint, dict):
         for name in dir(obj):
             if name.startswith('_'):
                 continue
-            if not callable(getattr(type(obj), name)):
+            if not callable(getattr(type(obj), name, None)):
                 continue
-            self.load_method(obj, getattr(obj, name))
+            method = getattr(obj, name)
+            self.load_method(obj, method)
 
     def load_method(self, obj, method):
         wrapped_method = getattr(method, '__func__', None)
@@ -325,7 +337,7 @@ class Group(EntryPoint, dict):
         if condition:
             if not condition(obj):
                 return
-        self.cmd(wrapped_method or method)
+        self.cmd(method)
 
     def __call__(self, *argv):
         self.exit_code = 0
@@ -648,9 +660,14 @@ class Command(EntryPoint, dict):
         except KeyboardInterrupt:
             print('exiting cleanly...')
             self.exit_code = 1
+        except Exception as exc:
+            self.handle_exception(exc)
         finally:
             self.post_result = self.post_call()
 
+    def handle_exception(self, exc):
+        raise exc
+
     async def async_call(self, *argv):
         """ Call with async stuff in single event loop """
         error = self.parse(*argv)
@@ -665,8 +682,11 @@ class Command(EntryPoint, dict):
 
         await self.factories_resolve()
 
-        result = self.call(*self.bound.args, **self.bound.kwargs)
-        return await async_resolve(result, output=True)
+        try:
+            result = self.call(*self.bound.args, **self.bound.kwargs)
+            return await async_resolve(result, output=True)
+        except Exception as exc:
+            self.handle_exception(exc)
 
     async def factories_resolve(self):
         """ Resolve all factories values. """
@@ -825,7 +845,11 @@ class Argument:
             self.type = param.annotation
 
         self.negate = None
-        if self.iskw and self.param.annotation == bool:
+        if (
+            self.iskw
+            and self.param.annotation == bool
+            and self.param.default is not False
+        ):
             self.negate = 'no-' + param.name
             if cmd.posix:
                 self.negate = self.negate.replace('_', '-')
@@ -978,7 +1002,11 @@ class Argument:
                 + colors.reset
             )
 
-        if self.type == bool and not self.negates:
+        if (
+            self.type == bool
+            and not self.negates
+            and self.param.default is not False
+        ):
             self.cmd.print(
                 'Accepted: '
                 + colors.blue3
@@ -1035,7 +1063,7 @@ class Argument:
             if self.default != self.param.empty:
                 return self.default
             msg = f'{self.param.name} has no CLI bound value nor default'
-            raise ValueError(msg) from exc
+            raise Cli2ValueError(msg) from exc
 
     @value.setter
     def value(self, value):

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/configuration.py

@@ -8,6 +8,8 @@ The developer story we are after:
 - 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'``
+- you can also set ``cli2.cfg.defaults['YOUR_ENV_VAR']`` if you prefer a
+  default value to an interactive prompt
 
 This is the user story we are after:
 
@@ -29,6 +31,8 @@ import shlex
 import textwrap
 from pathlib import Path
 
+from .log import log
+
 
 class Configuration(dict):
     """
@@ -43,6 +47,12 @@ class Configuration(dict):
         configuration then question_string will be used as text to prompt the
         user.
 
+    .. py:attribute:: defaults
+
+        A dict of ``ENV_VAR='default_value'``, if an env var is missing from
+        configuration then the default value will be returned instead of
+        displaying an interactive prompt.
+
     .. py:attribute:: profile_path
 
         Path to the shell profile to save/read variables, defaults to
@@ -67,8 +77,9 @@ class Configuration(dict):
             api_url = cli2.cfg['USERNAME']
 
     """
-    def __init__(self, profile_path=None, **questions):
+    def __init__(self, profile_path=None, defaults=None, **questions):
         self.questions = questions
+        self.defaults = defaults or dict()
         self.profile_path = Path(
             profile_path or os.getenv('HOME') + '/.profile'
         )
@@ -155,6 +166,11 @@ class Configuration(dict):
         if key in self.profile_variables:
             return self.profile_variables[key]
 
+        if key in self.defaults:
+            value = self.defaults[key]
+            log.debug(f'Defaulting {key} to {value}')
+            return value
+
         prompt = self.questions.get(key, key)
         prompt = textwrap.dedent(prompt).strip()
         value = self.input(prompt)

cli2-5.2.1rc1/cli2/interactive.py

@@ -0,0 +1,80 @@
+""" Interactive user inputs """
+import os
+import shlex
+import subprocess
+import tempfile
+
+from .log import log
+
+
+def choice(question, choices=None, default=None):
+    """
+    Ask user to make a choice.
+
+    .. code-block::
+
+        accepted = cli2.choice('Accept terms?') == 'y'
+
+    :param question: String question to ask
+    :param choices: List of acceptable choices, y/n by default
+    :param default: Default value for when the user does not add a value.
+    """
+    choices = [c.lower() for c in choices or ['y', 'n']]
+
+    if default:
+        choices_display = [
+            c.upper() if c == default.lower() else c
+            for c in choices
+        ]
+    else:
+        choices_display = choices
+
+    question = question + f' ({"/".join(choices_display)})'
+
+    tries = 30
+    while tries:
+        answer = input(question)
+        if not answer and default:
+            return default
+
+        if answer.lower() in choices:
+            return answer.lower()
+
+        tries -= 1
+
+
+def editor(content=None):
+    """
+    Open $EDITOR with content, return the result.
+
+    Like git rebase -i does!
+
+    :param content: Initial content if any
+    :return: The edited content after $EDITOR exit
+    """
+    tmp = tempfile.NamedTemporaryFile(mode='w+', delete=False, suffix=".txt")
+    with tmp as f:
+        f.write(content)
+        f.flush()
+        filepath = f.name
+
+    editor = os.getenv('EDITOR', 'vim')
+
+    try:
+        command = f"{editor} {shlex.quote(filepath)}"
+        subprocess.run(shlex.split(command), check=True)
+
+        with open(filepath, 'r') as f:
+            content = f.read()
+        return content
+    except subprocess.CalledProcessError as e:
+        log.error(f"Error running Vim: {e}")
+        return None
+    except FileNotFoundError:
+        log.warn(f"Temporary file gone?? {filepath}")
+        return None
+    finally:
+        try:
+            os.remove(filepath)
+        except OSError as e:
+            log.warn(f"Error deleting temporary file {filepath}: {e}")

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/log.py

@@ -94,7 +94,6 @@ def configure(log_file=None):
     if os.getenv('DEBUG'):
         LOG_LEVEL = 'DEBUG'
 
-    timestamper = structlog.processors.TimeStamper(fmt='%Y-%m-%d %H:%M:%S')
     pre_chain = [
         # add log level and timestamp to event_dict
         structlog.stdlib.add_log_level,
@@ -102,9 +101,12 @@ def configure(log_file=None):
         # that values in the extra parameters of log methods pass through to
         # log output
         structlog.stdlib.ExtraAdder(),
-        timestamper,
     ]
 
+    if 'NO_TIMESTAMPER' not in os.environ:
+        timestamper = structlog.processors.TimeStamper(fmt='%Y-%m-%d %H:%M:%S')
+        pre_chain.append(timestamper)
+
     cmd = '_'.join([
         re.sub('[^0-9a-zA-Z]+', '_', arg.split('/')[-1])
         for arg in sys.argv
@@ -213,18 +215,23 @@ def configure(log_file=None):
 
     logging.config.dictConfig(LOGGING)
 
+    processors = [
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+    ]
+    if 'NO_TIMESTAMPER' not in os.environ:
+        processors.append(timestamper)
+    processors += [
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+    ]
+
     structlog.configure(
         logger_factory=structlog.stdlib.LoggerFactory(),
         wrapper_class=structlog.stdlib.BoundLogger,
         cache_logger_on_first_use=True,
-        processors=[
-            structlog.stdlib.add_log_level,
-            structlog.stdlib.PositionalArgumentsFormatter(),
-            timestamper,
-            structlog.processors.StackInfoRenderer(),
-            structlog.processors.format_exc_info,
-            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
-        ],
+        processors=processors,
     )
 
 

cli2-5.2.1rc1/cli2/notlevenshtein.py

@@ -0,0 +1,74 @@
+"""
+Like levenshtein with difflib.
+
+.. code-block:: python
+
+        source_word = "apple"
+        word_list = ["apply", "aple", "banana", "orange", "applet"]
+
+        closest = cli2.closest(source_word, word_list)
+        print(f"The closest word to '{source_word}' is: {closest}")
+"""
+
+import difflib
+
+
+def closest(source_token, token_list):
+    """
+    Finds the token in token_list with the shortest distance to source_token.
+
+    :param source_token: The source token (string).
+    :param token_list: A list of tokens (strings).
+    :return: The token with the shortest distance, or None if token_list is
+             empty.
+    """
+
+    if not token_list:
+        return None
+
+    closest_token = None
+    shortest_distance = float("inf")  # Initialize with infinity
+
+    for token in token_list:
+        matcher = difflib.SequenceMatcher(None, source_token, token)
+        distance = (
+            1 - matcher.ratio()
+        )  # Calculate a distance metric (1 - similarity ratio)
+
+        if distance < shortest_distance:
+            shortest_distance = distance
+            closest_token = token
+
+    return closest_token
+
+
+def closest_path(path, paths):
+    """
+    Find the closest path from paths.
+
+    LLM may output broken paths, this fixes them.
+
+    :param path: Path to find closest
+    :param paths: List of paths to search in.
+    """
+    parts = path.split('/')
+    for number, part in enumerate(parts):
+        paths_parts = {
+            str(path).split('/')[number]
+            for path in paths
+        }
+        if part not in paths_parts:
+            path_part = closest(part, paths_parts)
+            if not path_part:
+                return None  # not found at all
+        else:
+            path_part = part
+
+        parts[number] = path_part
+        paths = {
+            path
+            for path in paths
+            if str(path).startswith('/'.join(parts[:number + 1]))
+        }
+
+    return '/'.join(parts)

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/table.py

@@ -184,7 +184,7 @@ class Table(list):
                 if len(wrapped) > 1:
                     leftovers[colnum] = ' '.join(wrapped[1:])
                 if color:
-                    line[-1] = color + line[-1] + colors.reset
+                    line[-1] = str(color) + line[-1] + colors.reset
             for leftover in leftovers:
                 if len(leftover):
                     rows.insert(0, leftovers)

{cli2-5.1.6 → cli2-5.2.1rc1}/cli2/test.py

@@ -21,8 +21,8 @@ def autotest(path, cmd, ignore=None, env=None):
     """
     environ = copy.copy(os.environ)
     if env:
-        for key, value in env.items():
-            environ[key] = value
+        environ.update(env)
+    environ['CLI2_THEME'] = 'standard'
     environ['FORCE_TERMSIZE'] = '1'
     environ['PATH'] = ':'.join([
         environ.get('HOME', '') + '/.local/bin',
@@ -75,7 +75,7 @@ def autotest(path, cmd, ignore=None, env=None):
             '''.strip(),
         )
 
-    diff_cmd = 'diff -U 1 - "%s" | sed "1,2 d"' % path
+    diff_cmd = 'diff -U 1 "%s" - | sed "1,2 d"' % path
     proc = subprocess.Popen(
         diff_cmd,
         stdout=subprocess.PIPE,
@@ -88,8 +88,8 @@ def autotest(path, cmd, ignore=None, env=None):
     if diff_out:
         raise type(f'''
 DiffFound
-- {cmd}
-+ {path}
+- {path}
++ {cmd}
         '''.strip(), (Exception,), {})('\n' + diff_out.decode('utf8'))
 
 

cli2-5.2.1rc1/cli2/theme.py

@@ -0,0 +1,223 @@
+"""
+Color themes.
+
+The theme is available in the `cli2.t` namespace.
+
+.. envar:: CLI2_THEME
+
+    The default is "standard" but "monokai" and "flashy" are also available.
+    Standard theme uses basic colors, and lets you override them with
+    environment variables: CLI2_RED, CLI2_GREEN, and so on.
+
+Example:
+
+.. code-block:: python
+
+    import cli2
+
+    print(f'{cli2.theme.green}OK{cli2.theme.reset}')
+
+    # with a mode, such as bold, dim, italic, underline and strike:
+    print(f'{cli2.theme.green.bold}OK{cli2.theme.reset}')
+
+    # all is also callable appending the reset automatically
+    print(cli2.theme.green('OK'))
+    print(cli2.theme.green.bold('OK'))
+
+We also have shortcuts, ``cli2.theme`` is ``cli2.t``, each color can be
+referred to by first letter in lowercase, except for black and gray which are
+refered to by their first letter in uppercase. Modes can be referred to by
+first letter in lowercase too, and reset is rs:
+
+.. code-block:: python
+
+    # shortcuts
+    print(f'{cli2.t.g.b}OK{cli2.t.rs}')
+
+    # shorter with callable
+    print(cli2.t.g.b('OK'))
+
+Run ``cli2-theme`` for the list of colors by theme.
+"""
+import re
+import os
+
+from .cli import Command
+
+themes = dict(
+    standard=dict(
+        black=int(os.getenv('CLI2_BLACK', 0)),
+        red=int(os.getenv('CLI2_RED', 1)),
+        green=int(os.getenv('CLI2_GREEN', 2)),
+        yellow=int(os.getenv('CLI2_YELLOW', 3)),
+        orange=int(os.getenv('CLI2_ORANGE', 208)),
+        blue=int(os.getenv('CLI2_BLUE', 4)),
+        mauve=int(os.getenv('CLI2_MAUVE', 5)),
+        pink=int(os.getenv('CLI2_PINK', 164)),
+        cyan=int(os.getenv('CLI2_CYAN', 6)),
+        gray=int(os.getenv('CLI2_GRAY', 7)),
+    ),
+    flashy=dict(
+        black=0,
+        red=196,
+        green=46,
+        yellow=227,
+        blue=27,
+        mauve=129,
+        pink=201,
+        orange=202,
+        cyan=51,
+        gray=253,
+    ),
+    monokai=dict(
+        black=0,
+        red=124,
+        green=150,
+        yellow=179,
+        blue=67,
+        mauve=140,
+        pink=132,
+        orange=202,
+        cyan=80,
+        gray=246,
+    ),
+)
+
+
+class Renderer:
+    def __call__(self, *content):
+        return f'{self}{" ".join([str(c) for c in content])}{t.rs}'
+
+
+class Mode(Renderer):
+    def __init__(self, name, code):
+        self.name = name
+        self.code = code
+        self.alias = name[0]
+
+    def __str__(self):
+        return f'\u001b[{self.code}m'
+
+
+class ColorMode(Renderer):
+    def __init__(self, color, mode):
+        self.color = color
+        self.mode = mode
+
+    def __str__(self):
+        return f'\u001b[{self.mode.code};38;5;{self.color.code}m'
+
+
+modes = {
+    name: Mode(name, code)
+    for name, code in dict(
+        bold=1,
+        dim=2,
+        italic=3,
+        underline=4,
+        strike=9,
+    ).items()
+}
+
+
+class Color(Renderer):
+    def __init__(self, code, name=None, alias=None):
+        self.name = name
+        self.alias = alias
+        self.code = code
+
+        for mode, code in modes.items():
+            color_mode = ColorMode(self, code)
+            setattr(self, mode, color_mode)
+            setattr(self, mode[0], color_mode)
+
+    def __str__(self):
+        return f'\u001b[38;5;{self.code}m'
+
+
+class Theme:
+    def __init__(self, colors):
+        self.colors = colors
+
+        for name, mode in modes.items():
+            setattr(self, mode.name, mode)
+
+        for name, value in colors.items():
+            if name in ('black', 'gray'):
+                alias = name[0].upper()
+            else:
+                alias = name[0]
+
+            color = Color(value, name, alias)
+            setattr(self, name, color)
+            setattr(self, alias, color)
+
+        for name in ('reset', 'rs'):
+            setattr(self, name, '\u001b[0m')
+
+    @staticmethod
+    def len(string):
+        """
+        Counts the number of alphabetic characters in a string,
+        ignoring ANSI escape codes.
+
+        :param string: Input string
+        :return: Integer count of actual printable chars
+        """
+        # Regular expression to match ANSI escape codes
+        ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+        # Remove ANSI escape codes from the string
+        cleaned_text = ansi_escape.sub('', string)
+
+        # Count the alphabetic characters in the cleaned string
+        letter_count = 0
+        for char in cleaned_text:
+            if 'a' <= char <= 'z' or 'A' <= char <= 'Z':
+                letter_count += 1
+
+        return letter_count
+
+
+t = theme = Theme(themes[os.getenv('CLI2_THEME', 'standard')])
+
+
+def demo():
+    """
+    Print all colors and modes from the theme.
+    """
+    for name, theme in themes.items():
+        theme = Theme(themes[name])
+        print(f'\n\nTheme: {theme.bold(name)}')
+        _demo(theme)
+
+    print()
+    print(theme.bold('MODES:'))
+    for name in modes:
+        mode = getattr(theme, name)
+        print(f'{mode}t.{name}{t.rs}')
+
+
+def _demo(theme):
+    def color_data(alias, color):
+        data = [
+            (color, alias),
+        ]
+
+        for mode in modes:
+            data.append(
+                (getattr(color, mode[0]), f'{alias}.{mode[0]}'),
+            )
+
+        return data
+
+    from .table import Table
+    table = Table()
+    for name in t.colors:
+        color = getattr(theme, name)
+
+        table.append(color_data(color.alias, color))
+    table.print()
+
+
+cli = Command(demo)

{cli2-5.1.6 → cli2-5.2.1rc1/cli2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: cli2
-Version: 5.1.6
+Version: 5.2.1rc1
 Summary: image:: https://yourlabs.io/oss/cli2/badges/master/pipeline.svg
 Home-page: https://yourlabs.io/oss/cli2
 Author: James Pic
@@ -63,5 +63,6 @@ Batteries included, all of which are useful on their own:
   testing library so that you can go straight to the point in pytest
 - a good old fcntl based locking
 - a command line to run any python function over a beautiful CLI
+- **AI assisted programing CLI & framework with code2**
 
 `Documentation available on RTFD <https://cli2.rtfd.io>`_.