termkit 0.0.1b0__tar.gz

termkit-0.0.1b0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, Thomas Mahé
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

termkit-0.0.1b0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.1
+Name: termkit
+Version: 0.0.1b0
+Summary: Command Line Tools with ease
+Author: Thomas Mahé
+Author-email: contact@tmahe.dev
+Requires-Python: >=3.6,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Description-Content-Type: text/markdown
+
+# termkit
+Command Line Tools with ease
+

termkit-0.0.1b0/README.md

@@ -0,0 +1,2 @@
+# termkit
+Command Line Tools with ease

termkit-0.0.1b0/pyproject.toml

@@ -0,0 +1,17 @@
+[tool.poetry]
+name = "termkit"
+version = "0.0.1b"
+description = "Command Line Tools with ease"
+authors = ["Thomas Mahé <contact@tmahe.dev>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.6"
+
+
+[tool.poetry.group.dev.dependencies]
+mkdocs-material = {version = "^9.1.8", python = ">=3.7,<4.0"}
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

termkit-0.0.1b0/setup.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['termkit']
+
+package_data = \
+{'': ['*']}
+
+setup_kwargs = {
+    'name': 'termkit',
+    'version': '0.0.1b0',
+    'description': 'Command Line Tools with ease',
+    'long_description': '# termkit\nCommand Line Tools with ease\n',
+    'author': 'Thomas Mahé',
+    'author_email': 'contact@tmahe.dev',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'python_requires': '>=3.6,<4.0',
+}
+
+
+setup(**setup_kwargs)

termkit-0.0.1b0/termkit/__init__.py

@@ -0,0 +1,2 @@
+from .core import Termkit as Termkit
+from .core import run as run

termkit-0.0.1b0/termkit/_formatter.py

@@ -0,0 +1,65 @@
+import argparse
+import textwrap
+
+
+class TermkitDefaultFormatter(argparse.RawTextHelpFormatter):
+
+    def __init__(self, prog: str):
+        super().__init__(prog, width=80, max_help_position=35)
+
+    def _format_action(self, action):
+        if type(action) == argparse._SubParsersAction:
+            # inject new class variable for subcommand formatting
+            subactions = action._get_subactions()
+            invocations = [self._format_action_invocation(a) for a in subactions]
+            self._subcommand_max_length = max(len(i) for i in invocations)
+
+        if type(action) == argparse._SubParsersAction._ChoicesPseudoAction:
+            # format subcommand help line
+            subcommand = self._format_action_invocation(action)  # type: str
+            width = self._subcommand_max_length
+            help_text = ""
+            if action.help:
+                help_text = self._expand_help(action)
+
+            if len(help_text) > 0:
+                first_section = "  {} {} ".format(subcommand, "." * (width + 4 - len(subcommand)))
+                return "{}{}\n".format(first_section,
+                                       textwrap.shorten(help_text, width=80 - len(first_section), placeholder="..."),
+                                       width=width)
+            else:
+                return "  {}\n".format(subcommand, width=width)
+
+        elif type(action) == argparse._SubParsersAction:
+            # process subcommand help section
+            msg = ''
+            for subaction in action._get_subactions():
+                msg += self._format_action(subaction)
+            return msg
+        else:
+            return super(TermkitDefaultFormatter, self)._format_action(action)
+
+    def _format_action_invocation(self, action: argparse.Action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+        else:
+            parts = []
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s' % option_string)
+                parts[-1] += ' %s' % args_string
+            return ', '.join(parts)
+
+    def _get_help_string(self, action):
+        help = action.help
+        if '%(default)' not in action.help:
+            if action.default is not argparse.SUPPRESS and action.default is not None:
+                defaulting_nargs = [argparse.OPTIONAL, argparse.ZERO_OR_MORE]
+                if action.option_strings or action.nargs in defaulting_nargs:
+                    help += ' (default: %(default)s)'
+        return help

termkit-0.0.1b0/termkit/_helpers.py

@@ -0,0 +1,32 @@
+import inspect
+
+from termkit.options import Option
+
+
+def command_format(id: str):
+    return id.replace('_', '-').lower()
+
+
+def get_help(item, single_line=False, is_flag_argument=False):
+    if item.__class__.__name__ == "Termkit":
+        doc = item.description
+    elif inspect.isfunction(item):
+        doc = inspect.getdoc(item)
+    elif isinstance(item, inspect.Parameter):
+        default_type = item.annotation if not issubclass(item.annotation, inspect.Parameter.empty) else str
+        if is_flag_argument:
+            doc = "(default: %(default)s)"
+        else:
+            doc = f'{default_type.__name__.upper()}'
+            doc = "STRING" if doc == "STR" else doc
+    elif isinstance(item, Option):
+        doc = ' '
+    else:
+        doc = ' '
+
+    if doc in [None, ""]:
+        doc = ' '
+
+    if single_line and len(doc.splitlines()) > 1:
+        return doc.splitlines()[0].strip()
+    return doc.strip()

termkit-0.0.1b0/termkit/core.py

@@ -0,0 +1,198 @@
+import json
+
+from termkit._formatter import TermkitDefaultFormatter
+from termkit.options import *
+from termkit.options import __PROFILES__
+from termkit._helpers import command_format, get_help
+
+
+def get_filtered_args(arguments: argparse.Namespace):
+    args = arguments.__dict__.copy()
+    for k, v in args.copy().items():
+        if k[:9] == '_Termkit_':
+            del args[k]
+    return args
+
+
+def run(func: typing.Callable, with_named_profile=False, with_argcomplete=False):
+    if inspect.isfunction(func):
+        kit = Termkit(name=command_format(func.__name__),
+                      description=get_help(func),
+                      with_named_profile=with_named_profile,
+                      with_argcomplete=with_argcomplete)
+        kit._add_callback(func)
+        kit._run()
+
+    elif isinstance(func, Termkit):
+        func._build_parser()
+        func._run()
+
+
+class Termkit:
+    _callback: typing.Callable = None
+    _cli: typing.Dict = None
+    _named_profile: str = None
+
+    _parser: argparse.ArgumentParser = None
+    _formatter: argparse.HelpFormatter = TermkitDefaultFormatter
+    _with_named_profile: bool
+    _with_argcomplete: bool
+
+    def __repr__(self):
+        return json.dumps(self._cli, default=lambda o: f"<function {o.__name__}>" if inspect.isfunction(o) else o._cli,
+                          indent=2)
+
+    def __init__(self,
+                 name: str = os.path.basename(sys.argv[0]),
+                 description: str = None,
+                 with_named_profile: bool = False,
+                 with_argcomplete: bool = False,
+                 formatter: argparse.HelpFormatter = TermkitDefaultFormatter):
+        self.name = name
+        self.description = description
+        self._with_named_profile = with_named_profile
+        self._with_argcomplete = with_argcomplete
+        self._cli = dict()
+        self._formatter = formatter
+
+    def _setup_profile(self):
+        parser = argparse.ArgumentParser(exit_on_error=False, add_help=False)
+        self._build_parser(parser, add_help=False)
+        args, unrecognized = parser.parse_known_args()
+        self.profile = args.__dict__.get('profile', None)
+
+    def _run(self):
+        parser = self._build_parser()
+        if self._with_argcomplete:
+            import argcomplete
+            argcomplete.autocomplete(parser)
+        args = parser.parse_args()
+        try:
+            args.__CALLABLE(**get_filtered_args(args))
+        except AttributeError:
+            if self._callback is not None:
+                self._callback(**get_filtered_args(args))
+            else:
+                parser.print_help()
+        sys.exit(0)
+
+    def _setup_named_profile_defaults(self):
+        pass
+
+    def __call__(self, *args, **kwargs):
+        self._run()
+
+    def callback(self) -> typing.Callable:
+        def _decorator(func: typing.Callable):
+            self._add_callback(func)
+
+        return _decorator
+
+    def add(self, term) -> None:
+        self._cli.update({term.name: term})
+
+    def command(self, name: str = None) -> typing.Callable:
+        def _decorator(callback: typing.Callable, name: str = name):
+            if name is None:
+                name = callback.__name__
+            self._cli.update({name: callback})
+
+        return _decorator
+
+    def default_handler(self, inspect_default):
+        if isinstance(inspect_default, FromNamedProfile):
+            print("FROM NAMED PROFILE", self.profile)
+            if self.profile is not None:
+                print('inspect_default: ', inspect_default)
+                v = __PROFILES__.get(self.profile, {})
+                for l in inspect_default.loc:
+                    print(v, l)
+                    if isinstance(v, dict):
+                        v = v.get(l, {})
+                    else:
+                        v = v.get(l, inspect_default.if_unset)
+                return v
+
+            return inspect_default.if_unset
+
+        else:
+            return inspect_default
+
+    def _build_parser(self, parser=None, level=0, add_help=True, positional_args=None, required_args=None,
+                      optional_args=None):
+
+        if self._with_named_profile and level:
+            self._setup_profile()
+
+        if parser is None:
+            parser = argparse.ArgumentParser(prog=self.name, add_help=False,
+                                             description=self.description,
+                                             formatter_class=self._formatter)
+            positional_args = parser.add_argument_group("Positional arguments")
+            required_args = parser.add_argument_group("Required arguments")
+            optional_args = parser.add_argument_group("Optional arguments")
+            optional_args.add_argument("-h", "--help", action="help", help="show this help message and exit")
+
+        if inspect.isfunction(self._callback):
+            _populate(parser, '_callback', self._callback, positional_args, required_args, optional_args)
+
+        if inspect.isfunction(self._cli):
+            _populate(parser, "_cli", self._cli, positional_args, required_args, optional_args)
+
+        if isinstance(self._cli, typing.Dict) and len(self._cli.keys()) > 0:
+            _parser = parser.add_subparsers(title="commands")
+
+            for c_name, c_spec in self._cli.items():
+                p = _parser.add_parser(name=c_name, help=get_help(c_spec, single_line=True),
+                                       description=get_help(c_spec),
+                                       formatter_class=self._formatter, add_help=False)
+                positional_args = p.add_argument_group("Positional arguments")
+                required_args = p.add_argument_group("Required arguments")
+                optional_args = p.add_argument_group("Optional arguments")
+                optional_args.add_argument("-h", "--help", action="help", help="show this help message and exit")
+                if isinstance(c_spec, Termkit):
+                    c_spec._build_parser(parser=p, level=level + 1, add_help=add_help, positional_args=positional_args,
+                                         required_args=required_args,
+                                         optional_args=optional_args)
+                    if self._with_named_profile:
+                        optional_args.add_argument('--profile', help="Named Profile", dest="_Termkit__PROFILE",
+                                                   required=False, default=None, )
+                    continue
+
+                _populate(p, c_name, c_spec, positional_args, required_args, optional_args)
+
+        return parser
+
+    def _add_callback(self, func: typing.Callable):
+        self._callback = func
+
+
+def _populate(parser, arg_name, arg_spec, positional_args, required_args, optional_args):
+    if callable(arg_spec):
+        parser.add_argument('--_Termkit__CALLABLE', help=argparse.SUPPRESS, default=arg_spec, required=False)
+
+        signature = inspect.signature(arg_spec)
+
+        for arg, spec in signature.parameters.items():
+            if isinstance(spec.default, MutuallyExclusiveGroup):
+                spec.default._populate(parser, arg)
+
+            elif isinstance(spec.default, Choice):
+                spec.default._populate(required_args, arg) if spec.default.required else spec.default._populate(
+                    optional_args, arg)
+
+            elif isinstance(spec.default, Option):
+                if spec.default.required:
+                    spec.default._populate(required_args, dest=arg)
+                else:
+                    spec.default._populate(optional_args, dest=arg)
+
+            # Implicit arguments
+            elif spec.default == signature.empty:
+                default_type = spec.annotation if not issubclass(spec.annotation, inspect.Parameter.empty) else str
+                positional_args.add_argument(arg, type=default_type, help=get_help(spec))
+            else:
+                default_type = spec.annotation if not issubclass(spec.annotation, inspect.Parameter.empty) else str
+                optional_args.add_argument('--' + arg.replace('_', '-'), default=spec.default, type=default_type,
+                                           required=False,
+                                           help=get_help(spec, is_flag_argument=True), metavar=get_help(spec), dest=arg)

termkit-0.0.1b0/termkit/options.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+
+import argparse
+import inspect
+import typing
+import os
+import sys
+
+__PROFILES__ = {
+    "test": {
+        "bamboo": {
+            "name": "Overwrite"
+        }
+    }
+}
+
+
+class Choice:
+    def __init__(self, *flags, choices: typing.List, help="", required=False, default=None):
+        self.flags = flags
+        self.help = help
+        self.required = required
+        self.default = default
+        self.choices = choices
+
+    def _get_metavar(self):
+        if self.default is None:
+            return "STRING"
+
+        out = f"{type(self.default).__name__.upper()}"
+        return "STRING" if out == "STR" else out
+
+    def _get_default_type(self):
+        return str if self.default is None else type(self.default)
+
+    def get_help(self):
+        if self.default is not None:
+            return f"{self.help} (default: %(default)s)".strip()
+        return self.help
+
+    def _populate(self, parser: argparse.ArgumentParser, dest=None):
+        parser.add_argument(*self.flags,
+                            choices=self.choices,
+                            metavar=self._get_metavar(),
+                            type=self._get_default_type(),
+                            default=self.default,
+                            required=self.required,
+                            help=self.get_help(),
+                            dest=dest.strip())
+
+
+class Option:
+    def __init__(self, *flags, help="", required=False, default=None):
+        self.flags = flags
+        self.help = help
+        self.required = required
+        self.default = default
+
+    def _get_metavar(self):
+        if self.default is None:
+            return "STRING"
+
+        out = f"{type(self.default).__name__.upper()}"
+        return "STRING" if out == "STR" else out
+
+    def _get_default_type(self):
+        return str if self.default is None else type(self.default)
+
+    def get_help(self):
+        if self.default is not None:
+            return f"{self.help} (default: %(default)s)".strip()
+        return self.help
+
+    def _populate(self, parser: argparse.ArgumentParser, dest=None):
+        parser.add_argument(*self.flags,
+                            metavar=self._get_metavar(),
+                            type=self._get_default_type(),
+                            default=self.default,
+                            required=self.required,
+                            help=self.get_help(),
+                            dest=dest.strip())
+
+
+class MutuallyExclusiveGroup:
+
+    def __init__(self, *args: Option, name=None, required=False):
+        self.args = args
+        self.name = name
+        self.required = required
+
+    def _populate(self, parser: argparse.ArgumentParser, group_name: str):
+        if self.name is None:
+            self.name = group_name
+
+        if self.required:
+            self.name += ' (required)'
+
+        g_parser = parser.add_argument_group(self.name)
+        parser._action_groups.pop()
+        parser._action_groups.insert(0, g_parser)
+        group = g_parser.add_mutually_exclusive_group(required=False)
+        for option in self.args:
+            option._populate(group, dest=group_name)
+
+
+class FromNamedProfile:
+    def __init__(self, *loc, if_unset: typing.Any):
+        self.loc = loc
+        self.if_unset = if_unset
+
+
+class EBHelpFormatter(argparse.RawTextHelpFormatter):
+    def __init__(self, prog: str):
+        super().__init__(prog, width=80, max_help_position=35)
+
+    def _format_action(self, action):
+        if type(action) == argparse._SubParsersAction:
+            # inject new class variable for subcommand formatting
+            subactions = action._get_subactions()
+            invocations = [self._format_action_invocation(a) for a in subactions]
+            self._subcommand_max_length = max(len(i) for i in invocations)
+
+        if type(action) == argparse._SubParsersAction._ChoicesPseudoAction:
+            # format subcommand help line
+            subcommand = self._format_action_invocation(action)  # type: str
+            width = self._subcommand_max_length
+            help_text = ""
+            if action.help:
+                help_text = self._expand_help(action)
+
+            if len(help_text) > 0:
+                return "  {} {} {}\n".format(subcommand, "." * (width + 3 - len(subcommand)), help_text, width=width)
+            else:
+                return "  {}\n".format(subcommand, width=width)
+
+        elif type(action) == argparse._SubParsersAction:
+            # process subcommand help section
+            msg = ''
+            for subaction in action._get_subactions():
+                msg += self._format_action(subaction)
+            return msg
+        else:
+            return super(EBHelpFormatter, self)._format_action(action)
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+        else:
+            parts = []
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s' % option_string)
+                parts[-1] += ' %s' % args_string
+            return ', '.join(parts)
+
+# app = Termkit("nxp-tools", help="General utility to interact with NXP Services")
+#
+# bamboo_app = Termkit("bamboo", help="Set of command related to Bamboo")
+#
+#
+# @app.command()
+# def test(count: int,
+#          name: str = "test"):
+#     """
+#     Simple Hello world command
+#     :param count:
+#     :param name:
+#     :return:
+#     """
+#     for e in range(count):
+#         print(name)
+#
+#
+# @bamboo_app.command()
+# def test_2(profile: str = Option(flag="--profile"),
+#            name: str = Option(flag="--name", default=FromNamedProfile("bamboo", "name", if_unset="Thomas")),
+#            auth: typing.Any = MutuallyExclusiveGroup(Option(flag='--user'),
+#                                                      Option(flag='--access-token'))):
+#     print(f"{profile=}")
+#     print(f"{name=}")
+#
+#
+# @bamboo_app.command()
+# def test_3(name: str = "test"):
+#     """
+#     Simple command
+#     :param name:
+#     :return:
+#     """
+#     print(name)
+#
+#
+# app.add(bamboo_app)
+#
+# if __name__ == '__main__':
+#     app()

termkit-0.0.1b0/termkit/tests.py

@@ -0,0 +1,102 @@
+import contextlib
+import io
+import unittest
+from unittest import mock
+from unittest.mock import patch
+
+import sys
+import typing
+
+
+class PassException(Exception):
+    pass
+
+
+class TestCase(unittest.TestCase):
+    _termkit_arguments = []
+    _termkit_expected_exception = None
+
+    _termkit_with_capture_output = False
+
+    _termkit_captured_stdout: io.StringIO = None
+    _termkit_captured_stderr: io.StringIO = None
+    termkit_expected_stdout: str = None
+    termkit_expected_stderr: str = None
+
+    def setUp(self) -> None:
+        self.maxDiff = None
+        self._termkit_captured_stdout = io.StringIO()
+        self._termkit_captured_stderr = io.StringIO()
+        self.termkit_expected_stdout: str = None
+        self.termkit_expected_stderr: str = None
+
+    def tearDown(self) -> None:
+        if self._termkit_with_capture_output:
+            self.assertEqual(self.termkit_expected_stdout, self._termkit_captured_stdout.getvalue())
+            self.assertEqual(self.termkit_expected_stderr, self._termkit_captured_stderr.getvalue())
+        self._termkit_captured_stdout = io.StringIO()
+        self._termkit_captured_stderr = io.StringIO()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls._termkit_captured_stdout = io.StringIO()
+        cls._termkit_captured_stderr = io.StringIO()
+
+    def assertRaises(self, excClass, callableObj, *args, **kwargs):
+        try:
+            unittest.TestCase.assertRaises(self, PassException, callableObj, *args, **kwargs)
+        except:
+            print(f'>>> {repr(sys.exc_info()[1])}')
+            self.assertEqual(f'{repr(self._termkit_expected_exception)}', f'{repr(sys.exc_info()[1])}')
+
+
+def with_captured_output():
+    """Marks test to expect the specified exception. Call assertRaises internally"""
+
+    def test_decorator(fn):
+        def test_decorated(self):
+            with contextlib.redirect_stdout(self._termkit_captured_stdout):
+                with contextlib.redirect_stdout(self._termkit_captured_stdout):
+                    with patch.object(sys, 'argv', ['prog_name'] + self._termkit_arguments):
+                        if len(self._termkit_arguments) > 0:
+                            print(f'>>> call with arguments {self._termkit_arguments}')
+                        else:
+                            print(f'>>> call without arguments')
+                        self._termkit_with_capture_output = True
+                        return fn(self)
+
+        return test_decorated
+
+    return test_decorator
+
+
+def with_assert_raises(exception):
+    """Marks test to expect the specified exception. Call assertRaises internally"""
+
+    def test_decorator(fn):
+        def test_decorated(self, *args, **kwargs):
+            self._termkit_expected_exception = exception
+            self.assertRaises(type(exception), fn, self, *args, **kwargs)
+            return self
+
+        return test_decorated
+
+    return test_decorator
+
+
+def with_arguments(*arguments: str):
+    """Marks test to expect the specified exception. Call assertRaises internally"""
+    def test_decorator(fn):
+        def test_decorated(self, *args, **kwargs):
+            self._termkit_arguments = list(arguments)
+            return fn(self)
+        return test_decorated
+    return test_decorator
+
+# def with_arguments(*args: str):
+#
+#     def wrapper(func: typing.Callable, args=args):
+#         func._termkit_arguments = list(map(str, args))
+#         return func
+#
+#     return wrapper