quickie-runner 0.1.0__py3-none-any.whl

quickie/__init__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""A CLI tool for quick tasks."""
+from ._meta import __author__, __copyright__, __email__, __home__, __version__
+
+__all__ = [
+    "__author__",
+    "__copyright__",
+    "__email__",
+    "__home__",
+    "__version__",
+]

quickie/__main__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+# PYTHON_ARGCOMPLETE_OK
+"""Entry point for the application script."""
+
+
+import sys
+
+from .cli import main
+
+
+def _run_main():
+    if __name__ == "__main__":
+        argv = sys.argv[1:]
+        main(argv)
+
+
+_run_main()

quickie/_meta.py

@@ -0,0 +1,7 @@
+"""Metadata for the package."""
+
+__version__ = "0.1.0"
+__author__ = "Adrian Martinez Rodriguez"
+__email__ = "adrianmrit@gmail.com"
+__home__ = "https://github.com/adrianmrit/quickie"
+__copyright__ = "Copyright (C) 2024 " + __author__

quickie/_version.py

@@ -0,0 +1,5 @@
+"""Read the version from installed package data."""
+
+from _meta import __version__
+
+__all__ = ["__version__"]

quickie/argparser.py

@@ -0,0 +1,73 @@
+"""Custom argument parser for quickie."""
+
+import typing
+from argparse import ArgumentParser
+
+import argcomplete
+
+from quickie._meta import __version__ as version
+from quickie.completion._internal import TaskCompleter
+
+
+class ArgumentsParser(ArgumentParser):
+    """Custom argument parser for quickie."""
+
+    @typing.override
+    def __init__(self, main):
+        super().__init__(description="A CLI tool for quick tasks.")
+        module_or_global_group = self.add_mutually_exclusive_group()
+        self.add_argument("-V", "--version", action="version", version=version)
+        self.add_argument("-l", "--list", action="store_true", help="List tasks")
+        module_or_global_group.add_argument(
+            "-m", "--module", type=str, help="The module to load tasks from"
+        )
+        module_or_global_group.add_argument(
+            "-g",
+            "--global",
+            action="store_true",
+            help="Use global defined tasks",
+            dest="use_global",
+        )
+        module_or_global_group.add_argument(
+            "--autocomplete",
+            help="Suggest autocompletion for the shell",
+            dest="suggest_auto_completion",
+            choices=["bash", "zsh"],
+        ).completer = argcomplete.ChoicesCompleter(["bash", "zsh"])
+        self.add_argument(
+            "task", nargs="?", help="The task to run"
+        ).completer = TaskCompleter(main)
+        # This does not need completion as it is handled by the task completer
+        self.add_argument("args", nargs="*", help="The arguments to pass to the task")
+
+    @typing.override
+    def parse_known_args(self, args=None, namespace=None):
+        qck_args, task_args = self._partition_args(args)
+        namespace, argv = super().parse_known_args(qck_args, namespace)
+
+        if argv:
+            # Because the unknown arguments are not task arguments, we raise an error
+            msg = "unrecognized arguments: %s"
+            self.error(msg % " ".join(argv))
+
+        # namespace.task = task
+        namespace.args = task_args
+        return namespace, []
+
+    def _partition_args(self, args):
+        qck_args = []
+        task_args = []
+        args = iter(args)
+        while arg := next(args, None):
+            if arg in {"-m", "--module", "--autocomplete"}:
+                qck_args.append(arg)
+                qck_args.append(next(args))
+            elif arg.startswith("-"):
+                qck_args.append(arg)
+            else:
+                # Task found
+                qck_args.append(arg)
+                # The rest of the arguments are task arguments
+                task_args = list(args)
+
+        return qck_args, task_args

quickie/cli.py

@@ -0,0 +1,193 @@
+"""The CLI entry of quickie."""
+
+import os
+import sys
+import tomllib
+from functools import cached_property
+from pathlib import Path
+
+import argcomplete
+from frozendict import frozendict
+from rich import traceback
+from rich.console import Console
+from rich.theme import Theme
+
+import quickie
+from quickie import constants
+from quickie.argparser import ArgumentsParser
+from quickie.context import Context
+from quickie.errors import QuickieError, TaskNotFoundError
+from quickie.loader import get_default_module_path, load_tasks_from_module
+from quickie.namespace import RootNamespace
+from quickie.utils import imports
+
+
+def main(argv=None, *, raise_error=False):
+    """Run the CLI."""
+    traceback.install(suppress=[quickie])
+    main = Main(argv=argv)
+    try:
+        main()
+    except QuickieError as e:
+        if raise_error:
+            raise e
+        main.console.print(f"Error: [error]{e}[/error]", style="error")
+        sys.exit(e.exit_code)
+
+
+class Main:
+    """Represents the CLI entry of quickie."""
+
+    def __init__(self, *, argv=None):  # noqa: PLR0913
+        """Initialize the CLI."""
+        self.settings = self.load_settings()
+        if argv is None:
+            argv = sys.argv[1:]
+        self.argv = argv
+
+        self.console = Console(theme=Theme(self.settings["style"]))
+
+        self.global_context = Context(
+            program_name=os.path.basename(sys.argv[0]),
+            cwd=os.getcwd(),
+            env=frozendict(os.environ),
+            console=self.console,
+        )
+
+        self.parser = ArgumentsParser(main=self)
+
+    def __call__(self):
+        """Run the CLI."""
+        if os.environ.get("_ARGCOMPLETE"):
+            comp_line = os.environ["COMP_LINE"]
+            comp_point = int(os.environ["COMP_POINT"])
+
+            # Hack to parse the arguments
+            (_, _, _, comp_words, _) = argcomplete.lexers.split_line(
+                comp_line, comp_point
+            )
+
+            # _ARGCOMPLETE is set by the shell script to tell us where comp_words
+            # should start, based on what we're completing.
+            # we ignore teh program name, hence no -1
+            start = int(os.environ["_ARGCOMPLETE"])
+            comp_words = comp_words[start:]
+            namespace = self.parser.parse_args(comp_words)
+            if namespace.task:
+                self.load_tasks_from_namespace(namespace)
+                task = self.get_task(namespace.task)
+                os.environ["_ARGCOMPLETE"] = str(comp_words.index(namespace.task))
+                argcomplete.autocomplete(task.parser)
+            else:
+                argcomplete.autocomplete(self.parser)
+
+        namespace = self.parser.parse_args(self.argv)
+        self.load_tasks_from_namespace(namespace)
+        if namespace.suggest_auto_completion:
+            if namespace.suggest_auto_completion == "bash":
+                self.suggest_autocompletion_bash()
+            elif namespace.suggest_auto_completion == "zsh":
+                self.suggest_autocompletion_zsh()
+        elif namespace.list:
+            self.list_tasks()
+        elif namespace.task is not None:
+            self.run_task(task_name=namespace.task, args=namespace.args)
+        else:
+            self.console.print(self.get_usage())
+        self.parser.exit()
+
+    @cached_property
+    def tasks_namespace(self):
+        """Get the namespace."""
+        return RootNamespace()
+
+    def suggest_autocompletion_bash(self):
+        """Suggest autocompletion for bash."""
+        self.console.print("Add the following to ~/.bashrc or ~/.bash_profile:")
+        self.console.print(
+            'eval "$(register-python-argcomplete qck)"',
+            style="bold green",
+        )
+
+    def suggest_autocompletion_zsh(self):
+        """Suggest autocompletion for zsh."""
+        self.console.print("Add the following to ~/.zshrc:")
+        self.console.print(
+            'eval "$(register-python-argcomplete qck)"',
+            style="bold green",
+        )
+
+    def load_tasks_from_namespace(self, namespace):
+        """Load tasks from the namespace."""
+        if namespace.module is not None:
+            tasks_module_path = Path(namespace.module)
+        elif namespace.use_global:
+            tasks_module_path = constants.HOME_PATH
+        else:
+            tasks_module_path = get_default_module_path()
+        self.load_tasks(path=tasks_module_path)
+
+    def load_settings(self):
+        """Load the console theme."""
+        defaults = frozendict({"style": constants.DEFAULT_CONSOLE_STYLE})
+        if constants.SETTINGS_PATH.exists():
+            with constants.SETTINGS_PATH.open("r") as f:
+                user_settings = tomllib.load(f)
+                user_settings["style"] = frozendict(
+                    defaults["style"] | user_settings.get("style", {})
+                )
+                return frozendict(user_settings)
+        return defaults
+
+    def list_tasks(self):
+        """List the available tasks."""
+        import rich.text
+        import rich.tree
+
+        tree = rich.tree.Tree(
+            "Available tasks:", style="bold green", guide_style="info"
+        )
+        node_by_namespace = {}
+        for task_path, task in sorted(self.tasks_namespace.items(), key=lambda x: x[0]):
+            if ":" in task_path:
+                namespace, task_name = task_path.rsplit(":", 1)
+            else:
+                task_name = task_path
+                namespace = ""
+
+            task_info = rich.text.Text(task_name, style="info")
+            if task._meta.short_help:
+                task_info.append(f"\n  {task._meta.short_help}", style="green")
+            if namespace:
+                if namespace not in node_by_namespace:
+                    node_by_namespace[namespace] = tree.add(
+                        namespace, style="bold yellow", guide_style="yellow"
+                    )
+                node = node_by_namespace[namespace]
+            else:
+                node = tree
+            node.add(task_info)
+        self.console.print(tree)
+
+    def load_tasks(self, *, path: Path):
+        """Load tasks from the tasks module."""
+        root = Path.cwd()
+        module = imports.import_from_path(root / path)
+        load_tasks_from_module(module, namespace=self.tasks_namespace)
+
+    def get_usage(self):
+        """Get the usage message."""
+        return self.parser.format_usage()
+
+    def get_task(self, task_name):
+        """Get a task by name."""
+        try:
+            task_class = self.tasks_namespace.get_task_class(task_name)
+            return task_class(name=task_name, context=self.global_context)
+        except KeyError:
+            raise TaskNotFoundError(task_name)
+
+    def run_task(self, task_name, args):
+        """Run a task."""
+        task = self.get_task(task_name)
+        return task(args)

quickie/completion/_internal.py

@@ -0,0 +1,31 @@
+"""Arg completers for quickie CLI."""
+
+from __future__ import annotations
+
+import typing
+
+from quickie.completion.base import BaseCompleter
+from quickie.errors import QuickieError
+
+if typing.TYPE_CHECKING:
+    from quickie.cli import Main as TMain  # pragma: no cover
+
+
+class TaskCompleter(BaseCompleter):
+    """For auto-completing task names. Used internally by the CLI."""
+
+    @typing.override
+    def __init__(self, main: TMain):
+        self.main = main
+
+    @typing.override
+    def complete(self, *, prefix, parsed_args, **_):
+        try:
+            self.main.load_tasks_from_namespace(parsed_args)
+            return {
+                key: task._meta.short_help or ""
+                for key, task in self.main.tasks_namespace.items()
+                if key.startswith(prefix)
+            }
+        except QuickieError:
+            pass

quickie/completion/base.py

@@ -0,0 +1,78 @@
+"""Base class for auto-completing python modules."""
+
+import argparse
+import os
+import traceback
+import typing
+
+import argcomplete
+
+
+class BaseCompleter(argcomplete.completers.BaseCompleter):
+    """For auto-completing python modules."""
+
+    def complete(
+        self,
+        *,
+        prefix: str,
+        action: argparse.Action,
+        parser: argparse.ArgumentParser,
+        parsed_args: argparse.Namespace,
+    ) -> list[str] | dict[str, str]:
+        """Complete the prefix."""
+        pass
+
+    @typing.override
+    def __call__(
+        self,
+        prefix: str,
+        action: argparse.Action,
+        parser: argparse.ArgumentParser,
+        parsed_args: argparse.Namespace,
+    ):
+        """Call the completer."""
+        try:
+            return self.complete(
+                prefix=prefix, action=action, parser=parser, parsed_args=parsed_args
+            )
+        except Exception:
+            # Include stack trace in the warning
+            argcomplete.warn(
+                f"Autocompletion by {self.__class__.__name__} failed with error:",
+                traceback.format_exc(),
+            )
+
+
+class PathCompleter(BaseCompleter):
+    """For auto-completing file paths."""
+
+    def get_pre_filtered_paths(self, target_dir: str) -> typing.Iterator[str]:
+        """Get path names in the target directory."""
+        try:
+            return os.listdir(target_dir or ".")
+        except Exception:
+            return []
+
+    def get_paths(self, prefix: str) -> typing.Generator[str, None, None]:
+        """Get path names that match the prefix."""
+        target_dir = os.path.dirname(prefix)
+        names = self.get_pre_filtered_paths(target_dir)
+        incomplete_part = os.path.basename(prefix)
+        # Iterate on target_dir entries and filter on given predicate
+        for name in names:
+            if not name.startswith(incomplete_part):
+                continue
+            candidate = os.path.join(target_dir, name)
+            yield candidate + "/" if os.path.isdir(candidate) else candidate
+
+    @typing.override
+    def complete(
+        self,
+        *,
+        prefix: str,
+        action: argparse.Action,
+        parser: argparse.ArgumentParser,
+        parsed_args: argparse.Namespace,
+    ):
+        """Complete the prefix."""
+        return list(self.get_paths(prefix))

quickie/completion/python.py

@@ -0,0 +1,84 @@
+"""Python completers for quickie."""
+
+import ast
+import typing
+
+from quickie.completion.base import PathCompleter
+
+
+class PytestCompleter(PathCompleter):
+    """For auto-completing pytest arguments."""
+
+    @typing.override
+    def complete(self, prefix, **kwargs):
+        path = prefix.split("::")
+        path = [part for part in path if part]
+        node_names = []
+        partial_name = None
+
+        if len(path) == 1:
+            file_path = path[0]
+        elif path:
+            file_path = path[0]
+            node_names = path[1:]
+            if not prefix.endswith("::"):
+                partial_name = node_names.pop()
+        else:
+            file_path = prefix
+
+        if file_path.endswith(".py"):
+            pre_resolved_path = file_path
+            if node_names:
+                pre_resolved_path += "::" + "::".join(node_names)
+
+            return [
+                f"{pre_resolved_path}::{node_name}"
+                for node_name in self.get_python_paths(
+                    file_path, node_names, partial_name
+                )
+            ]
+        else:
+            return super().complete(prefix=file_path, **kwargs)
+
+    @typing.override
+    def get_paths(self, prefix: str) -> typing.Generator[str, None, None]:
+        paths = super().get_paths(prefix)
+        for path in paths:
+            yield path
+            if path.endswith(".py"):
+                yield f"{path}::"
+
+    def read_python_file(self, file_path: str) -> str:
+        """Read the python file to a string."""
+        with open(file_path) as file:
+            return file.read()
+
+    def get_python_paths(
+        self, file_path: str, python_path: list[str], partial_name: str | None
+    ) -> typing.Generator[str, None, None]:
+        """Complete the module."""
+        try:
+            tree = ast.parse(self.read_python_file(file_path), file_path)
+        except SyntaxError:
+            return
+
+        # resolve the tree up to the last node
+        for item in python_path:
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ClassDef) and node.name == item:
+                    tree = node
+                    break
+            else:
+                # Either no class with the name was found, or the node was not a class
+                return
+
+        # Return immediate children of the class or module
+        for node in ast.iter_child_nodes(tree):
+            if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
+                if partial_name and not node.name.startswith(partial_name):
+                    continue
+
+                yield node.name
+                # Because the class might contain inner tests
+                if isinstance(node, (ast.ClassDef)):
+                    yield node.name + "::"

quickie/constants.py

@@ -0,0 +1,18 @@
+"""Settings for quickie."""
+
+from pathlib import Path
+
+from frozendict import frozendict
+
+HOME_PATH = Path.home() / "Quickie"
+SETTINGS_PATH = HOME_PATH / "settings.toml"
+TASKS_PATH = Path("__quickie")
+
+DEFAULT_CONSOLE_STYLE = frozendict(
+    {
+        "info": "cyan",
+        "warning": "yellow",
+        "error": "bold red",
+        "success": "green",
+    }
+)

quickie/context.py

@@ -0,0 +1,33 @@
+"""Task context."""
+
+import typing
+
+from frozendict import frozendict
+from rich.console import Console
+
+
+class Context:
+    """The context for a task."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        *,
+        program_name,
+        cwd: str,
+        env: typing.Mapping,
+        console: Console,
+    ):
+        """Initialize the context."""
+        self.program_name = program_name
+        self.cwd = cwd
+        self.env = frozendict(env)
+        self.console = console
+
+    def copy(self):
+        """Copy the context."""
+        return Context(
+            program_name=self.program_name,
+            cwd=self.cwd,
+            env=self.env,
+            console=self.console,
+        )

quickie/errors.py

@@ -0,0 +1,26 @@
+"""Errors for quickie."""
+
+
+class QuickieError(Exception):
+    """Base class for quickie errors."""
+
+    def __init__(self, message, *, exit_code):
+        """Initialize the error."""
+        super().__init__(message)
+        self.exit_code = exit_code
+
+
+class TaskNotFoundError(QuickieError):
+    """Raised when a task is not found."""
+
+    def __init__(self, task_name):
+        """Initialize the error."""
+        super().__init__(f"Task '{task_name}' not found", exit_code=1)
+
+
+class TasksModuleNotFoundError(QuickieError):
+    """Raised when a module is not found."""
+
+    def __init__(self, module_name):
+        """Initialize the error."""
+        super().__init__(f"Tasks module {module_name} not found", exit_code=2)

quickie/loader.py

@@ -0,0 +1,54 @@
+"""Task loader."""
+
+from pathlib import Path
+
+from quickie import constants
+from quickie.errors import TasksModuleNotFoundError
+from quickie.namespace import Namespace
+from quickie.tasks import Task
+
+
+def get_default_module_path():
+    """Get the default module path."""
+    current = Path.cwd()
+    while True:
+        path = current / constants.TASKS_PATH
+        if (path).exists():
+            return path
+        if current == current.parent:
+            break
+        current = current.parent
+    raise TasksModuleNotFoundError(constants.TASKS_PATH)
+
+
+def load_tasks_from_module(module, namespace):
+    """Load tasks from a module."""
+    modules = [(module, namespace)]
+    handled_modules = set()
+    while modules:
+        module, namespace = modules.pop()
+        # If the module has a namespace, we handle them first. This way
+        # if their namespace name is empty, and there is a task with the same
+        # name in both the parent module and the child module, the parent
+        # module task will be registered last and will be the one that is
+        # returned when getting the task by name.
+        if hasattr(module, "QCK_NAMESPACES") and module not in handled_modules:
+            modules.append((module, namespace))
+            handled_modules.add(module)
+            for name, sub_module in module.QCK_NAMESPACES.items():
+                if name:
+                    sub_namespace = Namespace(name=name, parent=namespace)
+                else:
+                    sub_namespace = namespace
+                modules.append((sub_module, sub_namespace))
+        else:
+            for name, obj in module.__dict__.items():
+                if isinstance(obj, type) and issubclass(obj, Task):
+                    meta = getattr(obj, "_meta")
+                    if meta.abstract:
+                        continue
+                    aliases = meta.alias
+                    if isinstance(aliases, str):
+                        aliases = [aliases]
+                    for alias in aliases:
+                        namespace.register(obj, name=alias)