muscles-cli 1.0.0__py3-none-any.whl

muscles/cli/cli/constants.py

@@ -0,0 +1,3 @@
+CLI_HEADER_TITLE = "Muscular"
+CLI_HEADER_SUBTITLE = "CLI"
+CLI_HEADER_AUTHOR = "(c) Muscles Team"

muscles/cli/cli/error_handler.py

@@ -0,0 +1,6 @@
+
+
+class ConsoleErrorHandler(Exception):
+
+    def handler(self, reason: str | None = None):
+        return Exception(reason)

muscles/cli/cli/func.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+import threading
+import getpass
+
+# import sys
+#
+#
+# def parse_arguments():
+#     args = sys.argv[1:]  # Игнорировать первый элемент, так как он является именем скрипта
+#     parsed_args = {}
+#
+#     i = 0
+#     while i < len(args):
+#         arg = args[i]
+#         if arg.startswith("--"):
+#             # Длинный аргумент с префиксом "--"
+#             if "=" in arg:  # Аргумент содержит значение
+#                 key, value = arg[2:].split("=")
+#                 parsed_args[key] = value
+#             else:  # Аргумент является флагом
+#                 key = arg[2:]
+#                 parsed_args[key] = True
+#         elif arg.startswith("-"):
+#             # Короткая версия аргумента с префиксом "-"
+#             if len(arg) > 2:  # Аргумент содержит значение
+#                 key = arg[1]
+#                 value = arg[2:]
+#                 parsed_args[key] = value
+#             else:  # Аргумент является флагом
+#                 key = arg[1]
+#                 parsed_args[key] = True
+#         i += 1
+#
+#     return parsed_args
+
+
+def argsparse(arguments, args):
+    """
+    @TODO переписать логику
+    Парсер аргументов командной строки
+
+    :param arguments:
+    :param args:
+    :return:
+    """
+    kwargs = {}
+    args = list(args)
+    i = 0
+    arguments.reverse()
+    for argument in arguments:
+        if argument.required and argument.argument not in args:
+            args.insert(i, argument.argument)
+            i = i + 1
+    new_args = args
+    for argument in arguments:
+        if argument.nargs > 1 or argument.multiple:
+            kwargs[argument.dest] = []
+        else:
+            kwargs[argument.dest] = argument.default
+        _args = iter(args)
+        arg = next(_args, None)
+        while arg:
+            next_arg = next(_args, None)
+            if arg == argument.argument or arg == argument.short:
+                if arg in new_args:
+                    new_args.remove(arg)
+                if argument.nargs <= 0:
+                    '''Обрабатываем флаги'''
+                    kwargs[argument.dest] = argument.flag_value
+                elif argument.nargs == 1:
+                    '''Обрабатываем элемент со значением'''
+                    value = None if isinstance(next_arg, str) and next_arg[0:1] == '-' else next_arg
+                    if value:
+                        if value in new_args:
+                            new_args.remove(value)
+                        if argument.multiple:
+                            kwargs[argument.dest].append(value)
+                        else:
+                            kwargs[argument.dest] = value
+                    if argument.prompt and not kwargs[argument.dest] and argument.password:
+                        kwargs[argument.dest] = getpass.getpass(
+                            f"{argument.prompt if argument.prompt else 'Password'}: ").strip()
+                    if argument.prompt and not kwargs[argument.dest] and not argument.password:
+                        kwargs[argument.dest] = input(f"{argument.prompt}: ").strip()
+                elif argument.nargs > 1:
+                    '''Обрабатываем списки аргументов'''
+                    for l in range(argument.nargs):
+                        value = None if isinstance(next_arg, str) and next_arg[0:1] == '-' else next_arg
+                        if value:
+                            if value in new_args:
+                                new_args.remove(value)
+                            kwargs[argument.dest].append(value)
+                        if argument.prompt and len(kwargs[argument.dest]) <= l:
+                            kwargs[argument.dest].append(input(f"{argument.prompt}: ").strip())
+                        # arg = next_arg
+                        if value:
+                            '''Берем следующий только если текущий был найден, 
+                            иначе будем получать пропуски элементов'''
+                            next_arg = next(_args, None)
+            arg = next_arg
+
+        if argument.nargs > 1:
+            if argument.required and argument.nargs != len(kwargs[argument.dest]):
+                raise Exception(
+                    f"Argument {argument.argument if argument.argument else argument.short} is required")
+        elif argument.required and not kwargs[argument.dest]:
+            raise Exception(
+                f"Argument {argument.argument if argument.argument else argument.short} is required")
+
+    return tuple(new_args), kwargs
+
+
+def parse_arguments(argument_list, args):
+    """
+    Парсер аргументов командной строки
+
+    :param argument_list: Список возможных аргументов командной строки в виде объектов
+    :param args: Список аргументов командной строки
+    :return: Кортеж с невостребованными аргументами и словарь полученных аргументов
+    """
+    kwargs = {}
+    unused_args = list(args)
+
+    for argument in argument_list:
+        if argument.argument:
+            prefix = f"{argument.argument}="
+            for idx, token in enumerate(list(unused_args)):
+                if isinstance(token, str) and token.startswith(prefix):
+                    value = token[len(prefix):]
+                    unused_args[idx:idx + 1] = [argument.argument, value]
+                    break
+        if argument.short:
+            prefix = f"{argument.short}="
+            for idx, token in enumerate(list(unused_args)):
+                if isinstance(token, str) and token.startswith(prefix):
+                    value = token[len(prefix):]
+                    unused_args[idx:idx + 1] = [argument.short, value]
+                    break
+
+        if argument.dest not in kwargs and argument.default is not None:
+            kwargs[argument.dest] = argument.default
+
+        if argument.short and argument.short in unused_args:
+            index = unused_args.index(argument.short)
+            process_argument(argument, unused_args, kwargs, index)
+
+        elif argument.argument and argument.argument in unused_args:
+            index = unused_args.index(argument.argument)
+            process_argument(argument, unused_args, kwargs, index)
+
+        if argument.required and argument.dest not in kwargs:
+            if argument.prompt:
+                value = getpass.getpass(argument.prompt) if argument.hide else input(argument.prompt).strip()
+                kwargs[argument.dest] = value.strip()
+            else:
+                raise ValueError(
+                    f"Required argument {argument.argument if argument.argument else argument.short} is missing")
+
+    return tuple(unused_args), kwargs
+
+
+def process_argument(argument, unused_args, kwargs, index):
+    """
+    Обработка аргумента командной строки
+
+    :param argument: Объект аргумента командной строки
+    :param unused_args: Список невостребованных аргументов
+    :param kwargs: Словарь полученных аргументов
+    :param index: Индекс аргумента в списке аргументов командной строки
+    """
+
+    if argument.multiple:
+        values = []
+        for value in unused_args[index + 1:]:
+            if value.startswith('-'):
+                break
+            values.append(value)
+        kwargs[argument.dest] = values
+        del unused_args[index: index + len(values) + 1]
+
+    elif argument.nargs > 1:
+        values = unused_args[index + 1: index + 1 + argument.nargs]
+        kwargs[argument.dest] = values
+        del unused_args[index: index + 1 + argument.nargs]
+
+    elif argument.flag_value is True:
+        kwargs[argument.dest] = argument.flag_value
+        del unused_args[index]
+
+    elif argument.nargs == 1:
+        try:
+            value = unused_args[index + 1].strip()
+            kwargs[argument.dest] = value
+            del unused_args[index: index + 2]
+        except IndexError as e:
+            pass
+
+    else:
+        raise ValueError(f"Invalid argument: {unused_args[index]}")
+
+
+def daemon(*args, function=None, as_daemon=False, **kwargs):
+    """
+    Создает процесс демона
+
+    :param args:
+    :param function: Функция для запуска в качестве демона
+    :param as_daemon: запускает как демон. Т.е. ждем когда функция закончит выполнения перед остановкой демона
+    :param kwargs:
+    :return:
+    """
+    thread = threading.current_thread()
+    if callable(function):
+        function(thread)
+
+    # print(thread.__dict__)
+    # print(thread.daemon)
+    # print(thread.isDaemon())
+    # set thread as Daemon
+    # thread.setDaemon(True)
+    # print(thread.isDaemon())

muscles/cli/cli/instance.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from .command import Group, Command
+
+import os
+import shutil
+
+
+class Console:
+    """
+    Главный инстанс для подключения консольных команды
+    Так же создает базовую консольную группу cli
+
+    """
+
+    try:
+        size = shutil.get_terminal_size(fallback=(100, 50))
+        rows, columns = size.lines, size.columns
+    except BaseException as e:
+        rows = 50
+        columns = 100
+
+    def __init__(self):
+        self.root_group = Group(['cli'])
+        self.root_group.command_name = 'cli'
+        self.root_group.handler = self.handler
+        self.root_group.description = ''
+        self.root_group.function_name = 'console.handler'
+
+        command = Command(['help'] + self.root_group.key)
+        command.function_name = self.root_group.help.__name__
+        command.handler = self.root_group.help
+        command.command_name = 'help'
+        command.description = "Command List"
+
+        self.root_group.add(command)
+
+    def __call__(self, *args, **kwargs):
+        return self.root_group
+
+    def handler(self, *args, **kwargs):
+        pass
+
+
+console = Console()
+
+
+cli = console.root_group

muscles/cli/cli/strategy.py

@@ -0,0 +1,111 @@
+from muscles.core import BaseStrategy
+import io
+import sys
+import shutil
+import shlex
+from typing import Any, Optional, cast
+from .colory import Colors
+from .instance import cli, Console
+from .error_handler import ConsoleErrorHandler
+from .constants import CLI_HEADER_AUTHOR, CLI_HEADER_SUBTITLE, CLI_HEADER_TITLE
+
+
+class flushfile(object):
+
+    def __init__(self, f):
+        self.f = f
+
+    def write(self, x):
+        pass
+
+    def flush(self):
+        pass
+
+
+class CliStrategy(BaseStrategy):
+    """
+    Стратегия для контекста переводящая обработку в режим работы в консоли
+
+    """
+    try:
+        size = shutil.get_terminal_size(fallback=(100, 50))
+        rows, columns = size.lines, size.columns
+    except:
+        rows = 50
+        columns = 100
+
+    def _print_header(self):
+        """
+        Печатаем базовый заголовок в консоли
+
+        :return:
+        """
+        author = getattr(self, "cli_author", CLI_HEADER_AUTHOR)
+        title = getattr(self, "cli_title", CLI_HEADER_TITLE)
+        subtitle = getattr(self, "cli_subtitle", CLI_HEADER_SUBTITLE)
+        lines = [
+            '-' * (int(self.columns) - 4),
+            title,
+            subtitle,
+            author.rjust(int(self.columns)-len(author)),
+            '-' * (int(self.columns) - 4),
+        ]
+        for line in lines:
+            print(f"{Colors.HEADER}--{line.center(int(self.columns)-4)}--{Colors.ENDC}")
+
+    @staticmethod
+    def _resolve_root_group(context, kwargs) -> object | None:
+        root_group = kwargs.get('root_group')
+        if root_group is not None:
+            return root_group
+
+        if hasattr(context, 'param'):
+            try:
+                return context.param('root_group')
+            except Exception:
+                pass
+
+        try:
+            from .instance import cli as default_root_group
+        except Exception:
+            return None
+        return default_root_group
+
+    def execute(self, *args,
+                error_handler: Optional[ConsoleErrorHandler] = None,
+                shutup=False,
+                print_header=False,
+                **kwargs) -> Any:
+        """
+        Первичный обработчик консольных команд
+
+        :param args:
+        :param shutup: приглушаем весь вывод в stdout
+        :param error_handler:
+        :param kwargs:
+        :return:
+        """
+        try:
+            self.cli_title = kwargs.get("title", CLI_HEADER_TITLE)
+            self.cli_subtitle = kwargs.get("subtitle", CLI_HEADER_SUBTITLE)
+            self.cli_author = kwargs.get("author", CLI_HEADER_AUTHOR)
+            container = kwargs.get('container')
+            if shutup:
+                sys.stdout = io.StringIO()
+                print_header = False
+            if not print_header:
+                self._print_header()
+            if len(args) <= 0:
+                args = sys.argv[1:]
+            elif len(args) == 1 and isinstance(args[0], str):
+                args = tuple(shlex.split(args[0]))
+            root_group = self._resolve_root_group(container, kwargs)
+            if root_group is None:
+                raise RuntimeError("CLI root group is not configured")
+            result = cast(Any, root_group).execute(*args)
+            if shutup:
+                sys.stdout = sys.__stdout__
+            return result
+        except KeyboardInterrupt:
+            print(f"\n\n{Colors.WARNING}The programme was terminated (Ctrl+C).{Colors.ENDC}")
+            return None

muscles/cli/providers.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from muscles.core import GenerationRequest, GeneratorRegistry
+
+
+def _write(path: Path, content: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content, encoding="utf-8")
+
+
+def _safe_write_file(path: Path, content: str, force: bool) -> str:
+    if path.exists() and not force:
+        raise FileExistsError(f"File `{path}` already exists. Use --force to overwrite.")
+    _write(path, content)
+    return str(path)
+
+
+class CliCommandGeneratorProvider:
+    name = "cli-command"
+
+    def supports(self, generator_type: str) -> bool:
+        return generator_type == "cli-command"
+
+    def generate(self, project_root: Path, request: GenerationRequest) -> list[str]:
+        app_dir = project_root / "app"
+        slug = request.name.replace(".", "_").replace("-", "_").lower()
+        generated = [
+            str(
+                Path(
+                    _safe_write_file(
+                        app_dir / "cli" / f"{slug}.py",
+                        f"def {slug}(*args, **kwargs):\n    return True\n",
+                        request.force,
+                    )
+                ).relative_to(project_root)
+            )
+        ]
+        if request.with_tests:
+            generated.append(
+                str(
+                    Path(
+                        _safe_write_file(
+                            project_root / "tests" / f"test_cli_{slug}.py",
+                            f"def test_cli_{slug}():\n    assert True\n",
+                            request.force,
+                        )
+                    ).relative_to(project_root)
+                )
+            )
+        return generated
+
+
+class CoreGeneratorProvider:
+    name = "core"
+
+    def supports(self, generator_type: str) -> bool:
+        return generator_type in {"page", "api-resource", "value-object", "resource"}
+
+    def generate(self, project_root: Path, request: GenerationRequest) -> list[str]:
+        app_dir = project_root / "app"
+        slug = request.name.replace(".", "_").replace("-", "_").lower()
+        generated: list[str] = []
+        generator_type = request.generator_type
+
+        if generator_type == "page":
+            generated.append(
+                str(
+                    Path(
+                        _safe_write_file(
+                            app_dir / "web" / f"{slug}.py",
+                            f"def {slug}(*args, **kwargs):\n    return '{request.name}'\n",
+                            request.force,
+                        )
+                    ).relative_to(project_root)
+                )
+            )
+            if request.with_tests:
+                generated.append(
+                    str(
+                        Path(
+                            _safe_write_file(
+                                project_root / "tests" / f"test_page_{slug}.py",
+                                f"def test_page_{slug}():\n    assert True\n",
+                                request.force,
+                            )
+                        ).relative_to(project_root)
+                    )
+                )
+            return generated
+
+        if generator_type == "api-resource":
+            generated.append(
+                str(
+                    Path(
+                        _safe_write_file(
+                            app_dir / "api" / f"{slug}.py",
+                            f"def create_{slug}(*args, **kwargs):\n    return {{'resource': '{request.name}'}}\n",
+                            request.force,
+                        )
+                    ).relative_to(project_root)
+                )
+            )
+            generated.append(
+                str(
+                    Path(
+                        _safe_write_file(
+                            app_dir / "schemas" / f"{slug}.py",
+                            f"class {request.name}Schema:\n    pass\n",
+                            request.force,
+                        )
+                    ).relative_to(project_root)
+                )
+            )
+            if request.with_tests:
+                generated.append(
+                    str(
+                        Path(
+                            _safe_write_file(
+                                project_root / "tests" / f"test_api_{slug}.py",
+                                f"def test_api_{slug}():\n    assert True\n",
+                                request.force,
+                            )
+                        ).relative_to(project_root)
+                    )
+                )
+            return generated
+
+        if generator_type == "value-object":
+            generated.append(
+                str(
+                    Path(
+                        _safe_write_file(
+                            app_dir / "domain" / f"{slug}.py",
+                            f"class {request.name}:\n    pass\n",
+                            request.force,
+                        )
+                    ).relative_to(project_root)
+                )
+            )
+            if request.with_tests:
+                generated.append(
+                    str(
+                        Path(
+                            _safe_write_file(
+                                project_root / "tests" / f"test_value_object_{slug}.py",
+                                f"def test_value_object_{slug}():\n    assert True\n",
+                                request.force,
+                            )
+                        ).relative_to(project_root)
+                    )
+                )
+            return generated
+
+        if generator_type == "resource":
+            registry = default_generator_registry()
+            generated.extend(
+                registry.resolve("api-resource").generate(
+                    project_root,
+                    GenerationRequest(generator_type="api-resource", name=request.name, force=request.force, with_tests=False),
+                )
+            )
+            generated.extend(
+                registry.resolve("cli-command").generate(
+                    project_root,
+                    GenerationRequest(generator_type="cli-command", name=request.name, force=request.force, with_tests=False),
+                )
+            )
+            if request.with_tests:
+                generated.append(
+                    str(
+                        Path(
+                            _safe_write_file(
+                                project_root / "tests" / f"test_resource_{slug}.py",
+                                f"def test_resource_{slug}():\n    assert True\n",
+                                request.force,
+                            )
+                        ).relative_to(project_root)
+                    )
+                )
+            return generated
+
+        raise ValueError(f"Unsupported generator type `{generator_type}`")
+
+
+_DEFAULT_REGISTRY: GeneratorRegistry | None = None
+
+
+def default_generator_registry() -> GeneratorRegistry:
+    global _DEFAULT_REGISTRY
+    if _DEFAULT_REGISTRY is None:
+        registry = GeneratorRegistry()
+        registry.register(CoreGeneratorProvider())
+        registry.register(CliCommandGeneratorProvider())
+        _DEFAULT_REGISTRY = registry
+    return _DEFAULT_REGISTRY
+

muscles/cli/streaming.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import json
+import sys
+from dataclasses import dataclass
+from typing import Any, TextIO
+
+from muscles.core import stream_events
+
+
+@dataclass(frozen=True)
+class CliStreamRenderResult:
+    exit_code: int
+    events: list[dict[str, Any]]
+
+
+def render_stream_result(
+    stream_result: Any,
+    *,
+    json_lines: bool = False,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> CliStreamRenderResult:
+    out = stdout or sys.stdout
+    err = stderr or sys.stderr
+    rendered: list[dict[str, Any]] = []
+    exit_code = 0
+
+    for event in stream_events(stream_result):
+        payload = {
+            "event": event.type,
+            "data": event.data,
+            "id": event.event_id,
+            "metadata": dict(event.metadata),
+        }
+        rendered.append(payload)
+        if json_lines:
+            out.write(json.dumps(payload, ensure_ascii=False) + "\n")
+            continue
+        if event.type == "progress":
+            out.write(f"progress: {event.data}\n")
+        elif event.type == "log":
+            out.write(f"log: {event.data}\n")
+        elif event.type == "result":
+            out.write(f"result: {event.data}\n")
+        elif event.type == "error":
+            exit_code = 1
+            err.write(f"error: {event.data}\n")
+
+    return CliStreamRenderResult(exit_code=exit_code, events=rendered)