cli2 5.1.6__tar.gz → 5.1.8__tar.gz

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

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

{cli2-5.1.6 → cli2-5.1.8}/cli2/__init__.py

@@ -11,17 +11,21 @@ from .cli import (
 )
 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.1.8}/cli2/cli.py

@@ -299,6 +299,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 +311,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 +329,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
@@ -825,7 +829,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 +986,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

{cli2-5.1.6 → cli2-5.1.8}/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.1.8/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.1.8}/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.1.8/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.1.8}/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.1.8}/cli2/test.py

@@ -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.1.8/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.1.8/cli2.egg-info}/PKG-INFO

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

{cli2-5.1.6 → cli2-5.1.8}/cli2.egg-info/SOURCES.txt

@@ -10,13 +10,16 @@ cli2/colors.py
 cli2/configuration.py
 cli2/decorators.py
 cli2/display.py
+cli2/interactive.py
 cli2/lock.py
 cli2/log.py
 cli2/mask.py
 cli2/node.py
+cli2/notlevenshtein.py
 cli2/sphinx.py
 cli2/table.py
 cli2/test.py
+cli2/theme.py
 cli2.egg-info/PKG-INFO
 cli2.egg-info/SOURCES.txt
 cli2.egg-info/dependency_links.txt
@@ -44,9 +47,11 @@ tests/test_display.py
 tests/test_entry_point.py
 tests/test_group.py
 tests/test_inject.py
+tests/test_interactive.py
 tests/test_lock.py
 tests/test_log.py
 tests/test_mask.py
 tests/test_node.py
+tests/test_notlevenshtein.py
 tests/test_restful.py
 tests/test_table.py

{cli2-5.1.6 → cli2-5.1.8}/cli2.egg-info/entry_points.txt

@@ -4,3 +4,5 @@ cli2-example = cli2.examples.obj:cli.entry_point
 cli2-example-client = cli2.examples.client:cli.entry_point
 cli2-example-nesting = cli2.examples.nesting:cli.entry_point
 cli2-example2 = cli2.examples.obj2:cli.entry_point
+cli2-md = cli2.markdown:cli.entry_point
+cli2-theme = cli2.theme:cli.entry_point

{cli2-5.1.6 → cli2-5.1.8}/setup.py

@@ -44,7 +44,7 @@ from setuptools import setup
 
 setup(
     name='cli2',
-    version='5.1.6',
+    version='5.1.8',
     setup_requires='setupmeta',
     packages=['cli2'],
     install_requires=[
@@ -75,6 +75,8 @@ setup(
     entry_points={
         'console_scripts': [
             'cli2 = cli2.cli2:main.entry_point',
+            'cli2-theme = cli2.theme:cli.entry_point',
+            'cli2-md = cli2.markdown:cli.entry_point',
             'cli2-example = cli2.examples.obj:cli.entry_point',
             'cli2-example2 = cli2.examples.obj2:cli.entry_point',
             'cli2-example-nesting = cli2.examples.nesting:cli.entry_point',

{cli2-5.1.6 → cli2-5.1.8}/tests/test_ansible.py

@@ -1,7 +1,7 @@
 import cli2
 import chttpx
 import httpx
-import mock
+from unittest import mock
 import pytest
 import textwrap
 import yaml

{cli2-5.1.6 → cli2-5.1.8}/tests/test_cli.py

@@ -13,19 +13,19 @@ def test_call():
     assert "args=('http://?x=bar',)" in result
 
 
-def test_doc_by_default(mocker):
+def test_doc_by_default():
     main.outfile = Outfile()
     main('cli2.examples.test')
     assert 'example_function' in main.outfile
 
 
-def test_help_argument(mocker):
+def test_help_argument():
     main.outfile = Outfile()
     main('help', 'cli2.examples.test')
     assert 'example_function' in main.outfile
 
 
-def test_help_no_argument(mocker):
+def test_help_no_argument():
     main.outfile = Outfile()
     main()
     assert 'help' in main.outfile

{cli2-5.1.6 → cli2-5.1.8}/tests/test_client.py

@@ -3,7 +3,7 @@ import cli2
 import chttpx
 import httpx
 import inspect
-import mock
+from unittest import mock
 import pytest
 
 
@@ -304,7 +304,7 @@ async def test_handler(client_class):
     response = httpx.Response(status_code=200)
     response.request = httpx.Request('POST', '/', json=[1])
     result = await handler(client, response, 0, log)
-    log.info.assert_called_once_with(
+    log.warn.assert_called_once_with(
         'retry', status_code=200, tries=0, sleep=.0
     )
     assert not result
@@ -313,7 +313,7 @@ async def test_handler(client_class):
     response.request = httpx.Request('POST', '/', json=[1])
     with pytest.raises(chttpx.RetriesExceededError) as exc:
         await handler(client, response, handler.tries + 1, log)
-    log.info.assert_called_once_with(
+    log.warn.assert_called_once_with(
         'retry', status_code=200, tries=0, sleep=.0
     )
 
@@ -347,8 +347,9 @@ async def test_handler(client_class):
     assert not client.client_reset.await_count
     exc = httpx.TransportError('foo')
     exc.request = response.request
+    log.warn.reset_mock()
     result = await handler(client, exc, 0, log)
-    log.warn.assert_called_once_with(
+    log.warn.assert_called_with(
         'reconnect',
         error="TransportError('foo')",
         method='POST',
@@ -366,7 +367,7 @@ async def test_handler(client_class):
     assert not client.token_reset.await_count
     log.warn.reset_mock()
     result = await handler(client, response, 0, log)
-    log.warn.assert_called_once_with('retoken')
+    assert mock.call('retoken') in log.warn.call_args_list
     assert not result
     assert client.token_reset.await_count == 1
 

{cli2-5.1.6 → cli2-5.1.8}/tests/test_command.py

@@ -4,6 +4,7 @@ import cli2.test
 import inspect
 import pytest
 import os
+from unittest import mock
 
 
 os.environ['FORCE_COLOR'] = '1'
@@ -438,16 +439,16 @@ def test_docstring():
     )
 
 
-def test_print(mocker):
-    cmd = cli2.Command(lambda: True, outfile=mocker.Mock())
+def test_print():
+    cmd = cli2.Command(lambda: True, outfile=mock.Mock())
     cmd.print('orangebold', 'foo', 'bar')
     assert cmd.outfile.write.call_args_list[0].args == (
         '\x1b[1;38;5;202mfoo bar\x1b[0m',
     )
 
 
-def test_print_bold(mocker):
-    cmd = cli2.Command(lambda: True, outfile=mocker.Mock())
+def test_print_bold():
+    cmd = cli2.Command(lambda: True, outfile=mock.Mock())
     cmd.print('ORANGE', 'foo', 'bar')
     assert cmd.outfile.write.call_args_list[0].args == (
         '\x1b[1;38;5;202mfoo bar\x1b[0m',

{cli2-5.1.6 → cli2-5.1.8}/tests/test_configuration.py

@@ -75,3 +75,6 @@ def test_idempotent(tmp_path):
     assert cfg.prints[0][0][0] == (
         f'Appended to {cfg.profile_path}:\nexport TEST=success'
     )
+
+    cfg.defaults['HASDEF'] = 1
+    assert cfg['HASDEF'] == 1

{cli2-5.1.6 → cli2-5.1.8}/tests/test_group.py

@@ -195,9 +195,12 @@ def test_load():
             raise Exception('fails')
 
     class Bar(metaclass=BarMetaclass):
+        def __init__(self, init=None):
+            self.init = init
+
         @cli2.cmd
         def test(self):
-            pass
+            return self.init
 
         @classmethod
         @cli2.cmd
@@ -228,11 +231,16 @@ def test_load():
     group.load(Foo)
     assert list(group.keys()) == ['help', 'test', 'classmeth', 'test2']
 
-    group = cli2.Group(overrides=dict(self=dict(factory=lambda: Foo())))
-    group.load(Foo())
-    assert list(group.keys()) == ['help', 'classmeth', 'test', 'test2']
-
-    assert isinstance(group['test2'](), Foo)
+    group = cli2.Group()
+    group['0'] = group.group('0')
+    group['1'] = group.group('1')
+    group['0'].load(Foo(0))
+    group['1'].load(Foo(1))
+    assert list(group['0'].keys()) == ['help', 'classmeth', 'test', 'test2']
+
+    assert isinstance(group['0']['test2'](), Foo)
+    assert group['1']['test']() == 1
+    assert group['0']['test']() == 0
 
     class Child(Foo):
         test2 = None

cli2-5.1.8/tests/test_interactive.py

@@ -0,0 +1,50 @@
+import cli2
+from unittest import mock
+
+
+def test_default_choices_y():
+    with mock.patch("builtins.input", return_value="y"):
+        result = cli2.choice("Test question")
+        assert result == "y"
+
+
+def test_default_choices_n():
+    with mock.patch("builtins.input", return_value="n"):
+        result = cli2.choice("Test question")
+        assert result == "n"
+
+
+def test_custom_choices():
+    with mock.patch("builtins.input", return_value="b"):
+        result = cli2.choice("Test question", choices=["a", "b", "c"])
+        assert result == "b"
+
+
+def test_default_value_provided():
+    with mock.patch("builtins.input", return_value=""):
+        result = cli2.choice("Test question", choices=["a", "b", "c"], default="b")
+        assert result == "b"
+
+
+def test_default_value_not_provided():
+    with mock.patch("builtins.input", return_value=""):
+        result = cli2.choice("Test question", choices=["a", "b", "c"])
+        assert result is None  # because the while loop breaks without return.
+
+
+def test_case_insensitive_input():
+    with mock.patch("builtins.input", return_value="A"):
+        result = cli2.choice("Test question", choices=["a", "b", "c"])
+        assert result == "a"
+
+
+def test_invalid_input():
+    with mock.patch("builtins.input", side_effect=["d", "a"]):
+        result = cli2.choice("Test question", choices=["a", "b", "c"])
+        assert result == "a"
+
+
+def test_empty_choices_defaults_to_yn():
+    with mock.patch("builtins.input", return_value="y"):
+        result = cli2.choice("Test question", choices=[])
+        assert result == "y"

{cli2-5.1.6 → cli2-5.1.8}/tests/test_lock.py

@@ -7,7 +7,7 @@ Another test to do is to run, in two terminals:
 - python tests/lock.py
 """
 import cli2
-import mock
+from unittest import mock
 
 
 def test_non_blocking(tmp_path):

cli2-5.1.8/tests/test_notlevenshtein.py

@@ -0,0 +1,46 @@
+import pytest
+import cli2
+
+
+def test_find_closest_token_basic():
+    source_word = "apple"
+    word_list = ["apply", "aple", "banana", "orange", "applet"]
+    assert cli2.closest(source_word, word_list) == "applet"
+
+
+def test_find_closest_token_exact_match():
+    source_word = "cat"
+    word_list = ["dog", "cat", "bat"]
+    assert cli2.closest(source_word, word_list) == "cat"
+
+
+def test_find_closest_token_multiple_close():
+    source_word = "car"
+    word_list = ["card", "cart", "care"]
+    assert cli2.closest(source_word, word_list) == "card"
+
+
+def test_find_closest_token_empty_list():
+    source_word = "test"
+    word_list = []
+    assert cli2.closest(source_word, word_list) is None
+
+
+def test_find_closest_token_no_close_match():
+    source_word = "xyz"
+    word_list = ["apple", "banana", "orange"]
+    # difflib will pick the first if no close matches.
+    assert cli2.closest(source_word, word_list) == "apple"
+
+
+def test_find_closest_token_different_lengths():
+    source_word = "longword"
+    word_list = ["short", "longer", "longestword"]
+    assert cli2.closest(source_word, word_list) == "longestword"
+
+
+def test_find_closest_token_same_distance_multiple():
+  source_word = "test"
+  word_list = ["tesa", "tesb", "tesc"]
+  # difflib will pick the first if same distances.
+  assert cli2.closest(source_word, word_list) == "tesa"