rats-apps 0.1.3.dev20240812192218__py3-none-any.whl → 0.2.0.dev20240813092513__py3-none-any.whl

rats/annotations/__main__.py

@@ -0,0 +1,46 @@
+# type: ignore[reportUntypedFunctionDecorator]
+"""..."""
+
+from typing import NamedTuple
+
+from rats import annotations
+
+
+class FruitId(NamedTuple):
+    """Any named tuple can be attached to functions."""
+
+    name: str
+    color: str
+
+
+def fruit(fid: FruitId) -> annotations.DecoratorType:
+    """A decorator that attached a fruit object to a function."""
+    return annotations.annotation("fruits", fid)
+
+
+@fruit(FruitId("apple", "red"))
+def some_function() -> None:
+    """..."""
+    pass
+
+
+@fruit(FruitId("banana", "yellow"))
+class SomeClass:
+    """Class definitions can also be annotated."""
+
+    @fruit(FruitId("cherry", "red"))
+    def some_method(self) -> None:
+        """Or class methods."""
+        pass
+
+
+def _example() -> None:
+    """Let's define a couple objects and annotate them."""
+    print(annotations.get_class_annotations(SomeClass))
+    print(annotations.get_annotations(SomeClass))
+    print(annotations.get_annotations(some_function))
+    print(annotations.get_annotations(SomeClass.some_method))
+
+
+if __name__ == "__main__":
+    _example()

rats/annotations/_functions.py

@@ -3,15 +3,14 @@ from __future__ import annotations
 from collections import defaultdict
 from collections.abc import Callable
 from functools import cache
-from typing import Any, Generic, ParamSpec, TypeVar
-from typing import NamedTuple as tNamedTuple
+from typing import Any, Generic, NamedTuple, ParamSpec, TypeVar
 
-from typing_extensions import NamedTuple
+from typing_extensions import NamedTuple as ExtNamedTuple
 
 T_GroupType = TypeVar("T_GroupType", bound=NamedTuple)
 
 
-class GroupAnnotations(NamedTuple, Generic[T_GroupType]):
+class GroupAnnotations(ExtNamedTuple, Generic[T_GroupType]):
     """The list of T_GroupType objects identified by a given name in a namespace."""
 
     name: str
@@ -21,7 +20,7 @@ class GroupAnnotations(NamedTuple, Generic[T_GroupType]):
     groups: tuple[T_GroupType, ...]
 
 
-class AnnotationsContainer(tNamedTuple):
+class AnnotationsContainer(NamedTuple):
     """
     Holds metadata about the annotated functions or class methods.
 
@@ -65,7 +64,7 @@ class AnnotationsBuilder:
     def __init__(self) -> None:
         self._group_ids = defaultdict(set)
 
-    def add(self, namespace: str, group_id: NamedTuple | tNamedTuple) -> None:
+    def add(self, namespace: str, group_id: ExtNamedTuple | NamedTuple) -> None:
         self._group_ids[namespace].add(group_id)
 
     def make(self, name: str) -> AnnotationsContainer:
@@ -84,7 +83,7 @@ DecoratorType = TypeVar("DecoratorType", bound=Callable[..., Any])
 
 def annotation(
     namespace: str,
-    group_id: NamedTuple | tNamedTuple,
+    group_id: ExtNamedTuple | NamedTuple,
 ) -> Callable[[DecoratorType], DecoratorType]:
     """
     Decorator to add an annotation to a function.

rats/apps/__init__.py

@@ -15,15 +15,15 @@ from ._annotations import (
 )
 from ._composite_container import CompositeContainer
 from ._container import (
-    AnnotatedContainer,  # type: ignore[reportDeprecated]
     Container,
     DuplicateServiceError,
+    Provider,
     ServiceNotFoundError,
     ServiceProvider,
     container,
 )
 from ._executables import App, Executable
-from ._ids import ServiceId, T_ExecutableType
+from ._ids import ServiceId, T_ExecutableType, T_ServiceType
 from ._namespaces import ProviderNamespaces
 from ._plugin_container import PluginContainers
 from ._plugins import PluginRunner
@@ -32,7 +32,6 @@ from ._scoping import autoscope
 from ._simple_apps import AppServices, SimpleApplication, StandardRuntime
 
 __all__ = [
-    "AnnotatedContainer",
     "App",
     "CompositeContainer",
     "Container",
@@ -41,6 +40,7 @@ __all__ = [
     "PluginContainers",
     "ProviderNamespaces",
     "ServiceProvider",
+    "Provider",
     "ServiceId",
     "ServiceNotFoundError",
     "autoid_service",
@@ -53,6 +53,7 @@ __all__ = [
     "autoid",
     "service",
     "T_ExecutableType",
+    "T_ServiceType",
     "Runtime",
     "NullRuntime",
     "AppServices",

rats/apps/__main__.py

@@ -0,0 +1,79 @@
+"""..."""
+
+import json
+import logging
+import os
+import uuid
+from collections.abc import Iterator
+
+from rats import apps
+
+logger = logging.getLogger(__name__)
+
+
+class ExampleData:
+    """A simple data source that might come from another package."""
+
+    _num_samples: int
+
+    def __init__(self, num_samples: int) -> None:
+        """..."""
+        self._num_samples = num_samples
+
+    def fetch(self) -> Iterator[str]:
+        """Yields random samples."""
+        for i in range(self._num_samples):
+            yield json.dumps({"index": i, "sample": str(uuid.uuid4())})
+
+
+class ExampleExe(apps.Executable):
+    """..."""
+
+    _example_data: ExampleData
+
+    def __init__(self, example_data: ExampleData) -> None:
+        """..."""
+        self._example_data = example_data
+
+    def execute(self) -> None:
+        """..."""
+        for row in self._example_data.fetch():
+            print(row)
+
+
+@apps.autoscope
+class PluginServices:
+    """..."""
+
+    MAIN_EXE = apps.ServiceId[apps.Executable]("main")
+    EXAMPLE_DATA = apps.ServiceId[ExampleData]("example-data")
+
+
+class PluginContainer(apps.Container):
+    """..."""
+
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        """..."""
+        self._app = app
+
+    @apps.service(PluginServices.MAIN_EXE)
+    def _main_exe(self) -> apps.Executable:
+        """..."""
+        return ExampleExe(
+            example_data=self._app.get(PluginServices.EXAMPLE_DATA),
+        )
+
+    @apps.service(PluginServices.EXAMPLE_DATA)
+    def _example_data(self) -> ExampleData:
+        """..."""
+        return ExampleData(
+            num_samples=int(os.environ.get("EXAMPLE_DATA_NUM_SAMPLES", "5")),
+        )
+
+
+if __name__ == "__main__":
+    apps.SimpleApplication(runtime_plugin=PluginContainer).execute(
+        PluginServices.MAIN_EXE,
+    )

rats/apps/_annotations.py

@@ -1,5 +1,5 @@
 from collections.abc import Callable
-from typing import Any, ParamSpec
+from typing import Any, NamedTuple, ParamSpec, cast
 
 from rats import annotations
 
@@ -14,19 +14,19 @@ def service(
     service_id: ServiceId[T_ServiceType],
 ) -> Callable[[Callable[P, T_ServiceType]], Callable[P, T_ServiceType]]:
     """A service is anything you would create instances of?"""
-    return annotations.annotation(ProviderNamespaces.SERVICES, service_id)
+    return annotations.annotation(ProviderNamespaces.SERVICES, cast(NamedTuple, service_id))
 
 
 def autoid_service(fn: Callable[P, T_ServiceType]) -> Callable[P, T_ServiceType]:
     _service_id = autoid(fn)
-    return annotations.annotation(ProviderNamespaces.SERVICES, _service_id)(fn)
+    return annotations.annotation(ProviderNamespaces.SERVICES, cast(NamedTuple, _service_id))(fn)
 
 
 def group(
     group_id: ServiceId[T_ServiceType],
 ) -> Callable[[Callable[P, T_ServiceType]], Callable[P, T_ServiceType]]:
     """A group is a collection of services."""
-    return annotations.annotation(ProviderNamespaces.GROUPS, group_id)
+    return annotations.annotation(ProviderNamespaces.GROUPS, cast(NamedTuple, group_id))
 
 
 def fallback_service(
@@ -35,7 +35,7 @@ def fallback_service(
     """A fallback service gets used if no service is defined."""
     return annotations.annotation(
         ProviderNamespaces.FALLBACK_SERVICES,
-        service_id,
+        cast(NamedTuple, service_id),
     )
 
 
@@ -45,7 +45,7 @@ def fallback_group(
     """A fallback group gets used if no group is defined."""
     return annotations.annotation(
         ProviderNamespaces.FALLBACK_GROUPS,
-        group_id,
+        cast(NamedTuple, group_id),
     )
 
 

rats/apps/_container.py

@@ -1,10 +1,7 @@
-import abc
 import logging
 from abc import abstractmethod
 from collections.abc import Callable, Iterator
-from typing import Generic, ParamSpec, Protocol
-
-from typing_extensions import deprecated
+from typing import Generic, NamedTuple, ParamSpec, Protocol, cast
 
 from rats import annotations
 
@@ -14,12 +11,16 @@ from ._namespaces import ProviderNamespaces
 logger = logging.getLogger(__name__)
 
 
-class ServiceProvider(Protocol[Tco_ServiceType]):
+class Provider(Protocol[Tco_ServiceType]):
     @abstractmethod
     def __call__(self) -> Tco_ServiceType:
         """Return the service instance."""
 
 
+# temporary alias for backwards compatibility
+ServiceProvider = Provider
+
+
 class GroupProvider(Protocol[Tco_ServiceType]):
     @abstractmethod
     def __call__(self) -> Iterator[Tco_ServiceType]:
@@ -119,8 +120,9 @@ class Container(Protocol):
     ) -> Iterator[T_ServiceType]:
         """Retrieve a service group by its id, within a given service namespace."""
         tates = annotations.get_class_annotations(type(self))
+        # containers are a special service namespace that we look through recursively
         containers = tates.with_namespace(ProviderNamespaces.CONTAINERS)
-        groups = tates.with_group(namespace, group_id)
+        groups = tates.with_group(namespace, cast(NamedTuple, group_id))
 
         for annotation in groups.annotations:
             if not hasattr(self, f"__rats_cache_{annotation.name}"):
@@ -140,33 +142,14 @@ class Container(Protocol):
             yield from c.get_namespaced_group(namespace, group_id)
 
 
-@deprecated(
-    " ".join(
-        [
-            "AnnotatedContainer is deprecated and will be removed in the next major release.",
-            "The functionality has been moved into the apps.Container protocol.",
-            "Please extend apps.Container directly.",
-        ]
-    ),
-    stacklevel=2,
-)
-class AnnotatedContainer(Container, abc.ABC):
-    """
-    A Container implementation that extracts providers from its annotated methods.
-
-    .. deprecated:: 0.1.3
-    The behavior of this class has been made the default within ``Container``.
-    """
-
-
-DEFAULT_CONTAINER_GROUP = ServiceId[Container]("__default__")
+DEFAULT_CONTAINER_GROUP = ServiceId[Container](f"{__name__}:__default__")
 P = ParamSpec("P")
 
 
 def container(
     group_id: ServiceId[T_ServiceType] = DEFAULT_CONTAINER_GROUP,
 ) -> Callable[[Callable[P, T_ServiceType]], Callable[P, T_ServiceType]]:
-    return annotations.annotation(ProviderNamespaces.CONTAINERS, group_id)
+    return annotations.annotation(ProviderNamespaces.CONTAINERS, cast(NamedTuple, group_id))
 
 
 class ServiceNotFoundError(RuntimeError, Generic[T_ServiceType]):

rats/apps/_runtimes.py

@@ -1,9 +1,12 @@
+import logging
 from abc import abstractmethod
 from collections.abc import Callable
 from typing import Protocol, final
 
 from ._ids import ServiceId, T_ExecutableType
 
+logger = logging.getLogger(__name__)
+
 
 class Runtime(Protocol):
     @abstractmethod
@@ -31,11 +34,17 @@ class Runtime(Protocol):
 
 @final
 class NullRuntime(Runtime):
+    _msg: str
+
+    def __init__(self, msg: str) -> None:
+        self._msg = msg
+
     def execute(self, *exe_ids: ServiceId[T_ExecutableType]) -> None:
-        raise NotImplementedError("NullRuntime does not support execution.")
+        logger.error(self._msg)
+        raise NotImplementedError(f"NullRuntime cannot execute ids: {exe_ids}")
 
     def execute_group(self, *exe_group_ids: ServiceId[T_ExecutableType]) -> None:
-        raise NotImplementedError("NullRuntime does not support execution.")
+        raise NotImplementedError(f"NullRuntime cannot execute groups: {exe_group_ids}")
 
     def execute_callable(self, *callables: Callable[[], None]) -> None:
-        raise NotImplementedError("NullRuntime does not support execution.")
+        raise NotImplementedError(f"NullRuntime cannot execute callables: {callables}")

rats/cli/__init__.py

@@ -1,22 +1,17 @@
 """Uses `rats.cli` to streamline the creation of CLI commands written with Click."""
 
-from ._annotations import CommandId, command, group
-from ._click import ClickCommandGroup, ClickCommandMapper
-from ._executable import ClickExecutable
+from ._annotations import command, get_class_commands, get_class_groups, group
+from ._app import ClickApp
+from ._container import CommandContainer
 from ._plugin import PluginContainer, PluginServices
-from ._plugins import AttachClickCommands, AttachClickGroup, ClickGroupPlugin, CommandContainer
 
 __all__ = [
-    "CommandId",
     "PluginContainer",
     "command",
+    "get_class_commands",
+    "get_class_groups",
     "group",
+    "ClickApp",
     "PluginServices",
-    "ClickCommandMapper",
-    "ClickExecutable",
-    "ClickGroupPlugin",
-    "ClickCommandGroup",
-    "AttachClickCommands",
-    "AttachClickGroup",
     "CommandContainer",
 ]

rats/cli/__main__.py

@@ -0,0 +1,64 @@
+"""..."""
+
+import logging
+
+import click
+
+from rats import apps, cli
+
+logger = logging.getLogger(__name__)
+
+
+class ExampleCommands(cli.CommandContainer):
+    """An example collection of cli commands."""
+
+    @cli.command()
+    @click.option("--exe-id", multiple=True)
+    def _run_this(self, exe_id: tuple[str, ...]) -> None:
+        """Example cli command called run-this."""
+        print(f"running these exes: {exe_id}")
+
+    @cli.command()
+    @click.option("--exe-id", multiple=True)
+    def _run_that(self, exe_id: tuple[str, ...]) -> None:
+        """Example cli command called run-that."""
+        print(f"running those exes: {exe_id}")
+
+    @cli.group()
+    def _run_these(self) -> None:
+        """Example cli command called run-these."""
+        print("running these sub-things")
+
+
+@apps.autoscope
+class ExampleServices:
+    """
+    Services used by the example container.
+
+    These classes are global constants to identify the provided services.
+    """
+
+    MAIN = apps.ServiceId[apps.Executable]("main")
+
+
+class ExampleContainer(apps.Container):
+    """An example container of services."""
+
+    _app: apps.Container
+
+    def __init__(self, app: apps.Container) -> None:
+        """The root container allows us to access services in other plugins."""
+        self._app = app
+
+    @apps.service(ExampleServices.MAIN)
+    def _main(self) -> apps.Executable:
+        return cli.ClickApp(
+            group=click.Group("example", help="An example application."),
+            commands=ExampleCommands(),
+        )
+
+
+if __name__ == "__main__":
+    apps.SimpleApplication(runtime_plugin=ExampleContainer).execute(
+        ExampleServices.MAIN,
+    )

rats/cli/_annotations.py

@@ -4,37 +4,38 @@ from collections.abc import Callable
 from typing import Any, NamedTuple, TypeVar
 
 from rats import annotations as anns
+from rats import apps
 
 
 class CommandId(NamedTuple):
     name: str
 
-    # does this api make it impossible to reference a given command that was auto generated?
-    @staticmethod
-    def auto() -> CommandId:
-        return CommandId(name=f"{__name__}:auto")
-
 
+AUTO_COMMAND = CommandId("__auto__")
 T = TypeVar("T", bound=Callable[[Any], Any])
 
 
-def command(command_id: CommandId) -> Callable[[T], T]:
+def command(command_id: CommandId = AUTO_COMMAND) -> Callable[..., apps.Executable]:
     def decorator(fn: T) -> T:
-        if command_id == CommandId.auto():
+        if command_id == AUTO_COMMAND:
             return anns.annotation("commands", CommandId(fn.__name__.replace("_", "-")))(fn)
         return anns.annotation("commands", command_id)(fn)
 
-    return decorator
+    return decorator  # type: ignore[reportReturnType]
 
 
-def group(command_id: CommandId) -> Callable[[T], T]:
+def group(command_id: CommandId = AUTO_COMMAND) -> Callable[..., apps.Executable]:
     def decorator(fn: T) -> T:
-        if command_id == CommandId.auto():
+        if command_id == AUTO_COMMAND:
             return anns.annotation("command-groups", CommandId(fn.__name__.replace("_", "-")))(fn)
         return anns.annotation("commands", command_id)(fn)
 
-    return decorator
+    return decorator  # type: ignore[reportReturnType]
 
 
 def get_class_commands(cls: type) -> anns.AnnotationsContainer:
     return anns.get_class_annotations(cls).with_namespace("commands")
+
+
+def get_class_groups(cls: type) -> anns.AnnotationsContainer:
+    return anns.get_class_annotations(cls).with_namespace("command-groups")

rats/cli/_app.py

@@ -0,0 +1,29 @@
+from typing import final
+
+import click
+
+from rats import apps
+
+from ._container import CommandContainer
+
+
+@final
+class ClickApp(apps.Executable):
+    """..."""
+
+    _group: click.Group
+    _commands: CommandContainer
+
+    def __init__(
+        self,
+        group: click.Group,
+        commands: CommandContainer,
+    ) -> None:
+        """Not sure this is the right interface."""
+        self._group = group
+        self._commands = commands
+
+    def execute(self) -> None:
+        """This app executes a click application after letting rats plugins attach commands."""
+        self._commands.attach(self._group)
+        self._group.main()

rats/cli/_container.py

@@ -0,0 +1,50 @@
+import logging
+from collections.abc import Callable
+from functools import partial
+from typing import Any, Protocol
+
+import click
+
+from rats import apps
+
+from ._annotations import get_class_commands
+
+logger = logging.getLogger(__name__)
+
+
+class CommandContainer(apps.Container, Protocol):
+    """A container that can attach click commands to a click group."""
+
+    def attach(self, group: click.Group) -> None:
+        """..."""
+
+        def cb(_method: Callable[..., None], *args: Any, **kwargs: Any) -> None:
+            """
+            Callback handed to `click.Command`. Calls the method with matching name on this class.
+
+            When the command is decorated with `@click.params` and `@click.option`, `click` will
+            call this callback with the parameters in the order they were defined. This callback
+            then calls the method with the same name on this class, passing the parameters in
+            reverse order. This is because the method is defined with the parameters in the
+            reverse order to the decorator, so we need to reverse them again to get the correct
+            order.
+            """
+            _method(*args, **kwargs)
+
+        commands = get_class_commands(type(self))
+        tates = commands.annotations
+
+        for tate in tates:
+            method = getattr(self, tate.name)
+            params = list(reversed(getattr(method, "__click_params__", [])))
+            logger.debug(tate.namespace)
+            for command in tate.groups:
+                if tate.namespace == "commands":
+                    group.add_command(
+                        click.Command(
+                            name=command.name,
+                            callback=partial(cb, method),
+                            short_help=method.__doc__,
+                            params=params,
+                        )
+                    )

rats/cli/_plugin.py

@@ -7,24 +7,11 @@ from rats import apps
 
 @apps.autoscope
 class _PluginEvents:
-    @staticmethod
-    def command_open(cmd_id: apps.ServiceId[apps.Executable]) -> apps.ServiceId[apps.Executable]:
-        return apps.ServiceId(f"command-open[{cmd_id.name}]")
-
-    @staticmethod
-    def command_execute(
-        cmd_id: apps.ServiceId[apps.Executable],
-    ) -> apps.ServiceId[apps.Executable]:
-        return apps.ServiceId(f"command-execute[{cmd_id.name}]")
-
-    @staticmethod
-    def command_close(cmd_id: apps.ServiceId[apps.Executable]) -> apps.ServiceId[apps.Executable]:
-        return apps.ServiceId(f"command-close[{cmd_id.name}]")
+    pass
 
 
 @apps.autoscope
 class PluginServices:
-    ROOT_COMMAND = apps.ServiceId[apps.Executable]("root-command")
     EVENTS = _PluginEvents
 
     @staticmethod
@@ -45,24 +32,3 @@ class PluginContainer(apps.Container):
 
     def __init__(self, app: apps.Container) -> None:
         self._app = app
-
-    @apps.service(PluginServices.ROOT_COMMAND)
-    def _root_command(self) -> apps.Executable:
-        def run() -> None:
-            runtime = self._app.get(apps.AppServices.RUNTIME)
-            runtime.execute_group(
-                PluginServices.EVENTS.command_open(PluginServices.ROOT_COMMAND),
-                PluginServices.EVENTS.command_execute(PluginServices.ROOT_COMMAND),
-                PluginServices.EVENTS.command_close(PluginServices.ROOT_COMMAND),
-            )
-
-        return apps.App(run)
-
-    @apps.fallback_group(PluginServices.EVENTS.command_execute(PluginServices.ROOT_COMMAND))
-    def _default_command(self) -> apps.Executable:
-        group = self._app.get(PluginServices.click_command(PluginServices.ROOT_COMMAND))
-        return apps.App(lambda: group())
-
-    @apps.service(PluginServices.click_command(PluginServices.ROOT_COMMAND))
-    def _root_click_command(self) -> click.Group:
-        return click.Group("groot")

{rats_apps-0.1.3.dev20240812192218.dist-info → rats_apps-0.2.0.dev20240813092513.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rats-apps
-Version: 0.1.3.dev20240812192218
+Version: 0.2.0.dev20240813092513
 Summary: research analysis tools for building applications
 Home-page: https://github.com/microsoft/rats/
 License: MIT

rats_apps-0.2.0.dev20240813092513.dist-info/RECORD

@@ -0,0 +1,32 @@
+rats/annotations/__init__.py,sha256=wsGhRQzZrV2oJTnBAX0aGgpyT1kYT235jkP3Wb8BTRY,498
+rats/annotations/__main__.py,sha256=vlzQOM9y82P0OL5tYcmSM_4jTg0s8jayAcvEoi9cBvI,1065
+rats/annotations/_functions.py,sha256=2rIWruEVZ-mBviS_7un88ZODbfGmiJgzIp4CXZoAgEE,4346
+rats/annotations/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/apps/__init__.py,sha256=LiN5DSEwzB8IeAvTTEH7tQF5btD9QT4WNQwu7_48ZyU,1493
+rats/apps/__main__.py,sha256=KjdadN4rdP0xhWiLzdmtCsXejWx_gxOK-ah-L1r1dTI,1818
+rats/apps/_annotations.py,sha256=yOf4MKFGQz3x4hpaWgMf2y2GlbXtbIh4uED15voXzyY,2566
+rats/apps/_composite_container.py,sha256=s_of6NyyrjFVYWGVehyEHe9WJIPRCnbB-tyWyNF8zyc,585
+rats/apps/_container.py,sha256=sghUmXUFtzm2YwvhW6H1vlxX6-knxAsB6CNBApbJhK0,5851
+rats/apps/_executables.py,sha256=QJ5_UPdZPmDQ1a3cLRJDUoeUMzNMwa3ZHYhYeS3AVq4,971
+rats/apps/_ids.py,sha256=T8Onrj79t8NPfBMQBk0xI6fIWDKF0m2JfFNrdtXAbWg,353
+rats/apps/_namespaces.py,sha256=THUV_Xj5PtweC23Ob-zsSpk8exC4fT-qRwjpQ6IDm0U,188
+rats/apps/_plugin_container.py,sha256=wmaBgxmvKo82ue9CrKHRXafgik5wIXh8XkEYMfhcTjs,1530
+rats/apps/_plugins.py,sha256=mvSYQPi11wTGZpM4umoyD37Rc8CQX8nt5eAJbmLrBFM,688
+rats/apps/_runtimes.py,sha256=qKhsuaH3ZesSP4pGwRbS8zj2mwapysSxyS_F9pkUtM4,1738
+rats/apps/_scoping.py,sha256=EIUopw3b38CEV57kCmSKQTAnQQMcXHZ_vwtk9t0K__g,1453
+rats/apps/_simple_apps.py,sha256=n-3zeHY3iintZ9LN597c7zDHv3DiIdl7c8NTk0gUk1Y,5477
+rats/apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/cli/__init__.py,sha256=_g9xWv6Uy73AudzCn-A9JKP-IpfZMRgvoO1b64dAxPw,464
+rats/cli/__main__.py,sha256=3JZ7mrTTrrODQHutefm2zJp1-cQQB7I5-1xhYw7SMBU,1656
+rats/cli/_annotations.py,sha256=xSOfGFRYI2s9MTUdXgJ-ZcgcaD6EntZpiAuMqAVh0sI,1316
+rats/cli/_app.py,sha256=NjJfXKZYBdd1CZuLbrXyUFB_wRJQah1Rvtxe_zj4y_M,641
+rats/cli/_container.py,sha256=VddjrsH1lqiarJ6rXf4KUbuNtNXEduCr38UH_TwGgFE,1872
+rats/cli/_plugin.py,sha256=o5emP-E0LLOGvD14ZBYNY6h407pngrJf8ODMB5Wdd8U,711
+rats/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/logs/__init__.py,sha256=fCn4pfpYiAcTtt5CsnUZX68CjOB3KJHxMSiYxsma4qE,183
+rats/logs/_plugin.py,sha256=eAAG4ci-XS9A9ituXj9PrcI6zH-xlCqhJlUbSGC-MYM,2175
+rats/logs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats_apps-0.2.0.dev20240813092513.dist-info/METADATA,sha256=HItBWvbdKnqpKz3vSiVb-swPARAqeXrjm2Gqup6Llfk,774
+rats_apps-0.2.0.dev20240813092513.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+rats_apps-0.2.0.dev20240813092513.dist-info/entry_points.txt,sha256=9oOvf2loQr5ACWQgvuu9Q3KZIVIxKE5Aa-rLuUII5WQ,91
+rats_apps-0.2.0.dev20240813092513.dist-info/RECORD,,

rats/cli/_click.py

@@ -1,38 +0,0 @@
-from collections.abc import Callable, Mapping
-from typing import final
-
-import click
-
-
-class ClickCommandMapper:
-    _commands: Mapping[str, Callable[[], click.Command]]
-
-    def __init__(
-        self,
-        commands: Mapping[str, Callable[[], click.Command]],
-    ) -> None:
-        self._commands = commands
-
-    def names(self) -> frozenset[str]:
-        return frozenset(self._commands.keys())
-
-    def get(self, name: str) -> click.Command:
-        if name not in self._commands:
-            raise ValueError(f"Command {name} not found")
-
-        return self._commands[name]()
-
-
-@final
-class ClickCommandGroup(click.Group):
-    _mapper: ClickCommandMapper
-
-    def __init__(self, name: str, mapper: ClickCommandMapper) -> None:
-        super().__init__(name=name)
-        self._mapper = mapper
-
-    def get_command(self, ctx: click.Context, cmd_name: str) -> click.Command | None:
-        return self._mapper.get(cmd_name)
-
-    def list_commands(self, ctx: click.Context) -> list[str]:
-        return list(self._mapper.names())

rats/cli/_executable.py

@@ -1,23 +0,0 @@
-import click
-
-from rats import apps
-
-from ._plugins import ClickGroupPlugin
-
-
-class ClickExecutable(apps.Executable):
-    _command: apps.ServiceProvider[click.Group]
-    _plugins: apps.PluginRunner[ClickGroupPlugin]
-
-    def __init__(
-        self,
-        command: apps.ServiceProvider[click.Group],
-        plugins: apps.PluginRunner[ClickGroupPlugin],
-    ) -> None:
-        self._command = command
-        self._plugins = plugins
-
-    def execute(self) -> None:
-        cmd = self._command()
-        self._plugins.apply(lambda plugin: plugin.on_group_open(cmd))
-        cmd()

rats/cli/_plugins.py

@@ -1,81 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from collections.abc import Callable, Iterator
-from functools import partial
-from typing import Any, Protocol
-
-import click
-
-from rats import apps
-
-from ._annotations import get_class_commands
-
-
-class ClickGroupPlugin(Protocol):
-    @abstractmethod
-    def on_group_open(self, group: click.Group) -> None:
-        pass
-
-
-class AttachClickCommands(ClickGroupPlugin):
-    """When a group is opened, attach a set of commands to it."""
-
-    _commands: Iterator[click.Command]
-
-    def __init__(self, commands: Iterator[click.Command]) -> None:
-        self._commands = commands
-
-    def on_group_open(self, group: click.Group) -> None:
-        for command in self._commands:
-            group.add_command(command)
-
-
-class AttachClickGroup(ClickGroupPlugin):
-    _group: apps.ServiceProvider[click.Group]
-    _plugins: apps.PluginRunner[ClickGroupPlugin]
-
-    def __init__(
-        self,
-        group: apps.ServiceProvider[click.Group],
-        plugins: apps.PluginRunner[ClickGroupPlugin],
-    ) -> None:
-        self._group = group
-        self._plugins = plugins
-
-    def on_group_open(self, group: click.Group) -> None:
-        cmd = self._group()
-        self._plugins.apply(lambda plugin: plugin.on_group_open(cmd))
-        group.add_command(cmd)
-
-
-class CommandContainer(ClickGroupPlugin):
-    def on_group_open(self, group: click.Group) -> None:
-        def cb(_method: Callable[[Any], Any], *args: Any, **kwargs: Any) -> None:
-            """
-            Callback handed to `click.Command`. Calls the method with matching name on this class.
-
-            When the command is decorated with `@click.params` and `@click.option`, `click` will
-            call this callback with the parameters in the order they were defined. This callback
-            then calls the method with the same name on this class, passing the parameters in
-            reverse order. This is because the method is defined with the parameters in the
-            reverse order to the decorator, so we need to reverse them again to get the correct
-            order.
-            """
-            _method(*args, **kwargs)
-
-        commands = get_class_commands(type(self))
-        tates = commands.annotations
-
-        for tate in tates:
-            method = getattr(self, tate.name)
-            params = list(reversed(getattr(method, "__click_params__", [])))
-            for command in tate.groups:
-                group.add_command(
-                    click.Command(
-                        name=command.name,
-                        callback=partial(cb, method),
-                        short_help=method.__doc__,
-                        params=params,
-                    )
-                )

rats_apps-0.1.3.dev20240812192218.dist-info/RECORD

@@ -1,29 +0,0 @@
-rats/annotations/__init__.py,sha256=wsGhRQzZrV2oJTnBAX0aGgpyT1kYT235jkP3Wb8BTRY,498
-rats/annotations/_functions.py,sha256=ziAZOqS1lojfjDjZW7qPYNJUAFuLBWtVAoPsmJqxqpE,4356
-rats/annotations/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/apps/__init__.py,sha256=z_6eujGnU6pW12xTRR1caTJzv5v8VEbt8yLmwnMBiik,1511
-rats/apps/_annotations.py,sha256=6qBqjxfBBZyVMLT3COGgQ-flQL6Wkuzp_TtndD4TwmE,2458
-rats/apps/_composite_container.py,sha256=s_of6NyyrjFVYWGVehyEHe9WJIPRCnbB-tyWyNF8zyc,585
-rats/apps/_container.py,sha256=GTPu6qmVCy69w87kMsQcL5BJavgW9O9RxH0z0zQu3fY,6242
-rats/apps/_executables.py,sha256=QJ5_UPdZPmDQ1a3cLRJDUoeUMzNMwa3ZHYhYeS3AVq4,971
-rats/apps/_ids.py,sha256=T8Onrj79t8NPfBMQBk0xI6fIWDKF0m2JfFNrdtXAbWg,353
-rats/apps/_namespaces.py,sha256=THUV_Xj5PtweC23Ob-zsSpk8exC4fT-qRwjpQ6IDm0U,188
-rats/apps/_plugin_container.py,sha256=wmaBgxmvKo82ue9CrKHRXafgik5wIXh8XkEYMfhcTjs,1530
-rats/apps/_plugins.py,sha256=mvSYQPi11wTGZpM4umoyD37Rc8CQX8nt5eAJbmLrBFM,688
-rats/apps/_runtimes.py,sha256=nQWwC-O-j0bKCEkGpBSXhdtE0-X2ACeP7zXZfqaPGqg,1545
-rats/apps/_scoping.py,sha256=EIUopw3b38CEV57kCmSKQTAnQQMcXHZ_vwtk9t0K__g,1453
-rats/apps/_simple_apps.py,sha256=n-3zeHY3iintZ9LN597c7zDHv3DiIdl7c8NTk0gUk1Y,5477
-rats/apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/cli/__init__.py,sha256=dMrubxMJocbl8QoI_3fKI0Dt0QHYAM5Mxh5Vj8OaX-w,664
-rats/cli/_annotations.py,sha256=0dI8hu_y754Y53Pka1-mGEgHjjVcnIOGd8l1SFx8OBY,1190
-rats/cli/_click.py,sha256=7-ClnYSW4poFr_B-Q6NT45DnMF1XL7ntUgwQqQ7q_eo,1036
-rats/cli/_executable.py,sha256=kAQ9hImv3hBaScu6e19o_BMvl7tdYJql38E76S3FjSk,580
-rats/cli/_plugin.py,sha256=j9exzjL4sTCrGvine0rxumdfl0RPGpOFk7Ysk73aKWk,2278
-rats/cli/_plugins.py,sha256=H3-QdaICPJhCC5FkLHdXpwqe7Z0mpvsenakhNiPllC8,2739
-rats/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/logs/__init__.py,sha256=fCn4pfpYiAcTtt5CsnUZX68CjOB3KJHxMSiYxsma4qE,183
-rats/logs/_plugin.py,sha256=eAAG4ci-XS9A9ituXj9PrcI6zH-xlCqhJlUbSGC-MYM,2175
-rats_apps-0.1.3.dev20240812192218.dist-info/METADATA,sha256=kHFSAtQ6vCGDztELYoYp6GCYz76XPL6RPtdU-n6sojA,774
-rats_apps-0.1.3.dev20240812192218.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-rats_apps-0.1.3.dev20240812192218.dist-info/entry_points.txt,sha256=9oOvf2loQr5ACWQgvuu9Q3KZIVIxKE5Aa-rLuUII5WQ,91
-rats_apps-0.1.3.dev20240812192218.dist-info/RECORD,,