rats-apps 0.4.0.dev20241212213929__py3-none-any.whl → 0.5.0.dev20250102200830__py3-none-any.whl

rats_apps-0.5.0.dev20250102200830.dist-info/RECORD

@@ -0,0 +1,40 @@
+rats/annotations/__init__.py,sha256=YmydaopUSlpoX6MvQ-3p18sgEC_DB_y683wVICD-jnU,498
+rats/annotations/__main__.py,sha256=vlzQOM9y82P0OL5tYcmSM_4jTg0s8jayAcvEoi9cBvI,1065
+rats/annotations/_functions.py,sha256=UkHh3zdBivluE7dBeGQ17zoIfGdyIokMAkFmpWaIlDc,4284
+rats/annotations/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/apps/__init__.py,sha256=ZUFEuocGQTyWKOZlkYH3Q09NujfpAN-whTnFFg5-Rf4,1916
+rats/apps/_annotations.py,sha256=6M_M7K8haNVda0Tx02EpFf3s9EjnWYacNMjTIkNEdRU,4617
+rats/apps/_app_containers.py,sha256=Ym2NrRljmZVE7EXK2G8KgDHAGreYsuFlvu1QYTkhOsE,6109
+rats/apps/_composite_container.py,sha256=s_of6NyyrjFVYWGVehyEHe9WJIPRCnbB-tyWyNF8zyc,585
+rats/apps/_container.py,sha256=sYISCG-qVzl-bsBwX_CAWEP9gtXCnG-Jls3l8IKb4DQ,7208
+rats/apps/_executables.py,sha256=hXExNmAnuPU1KJXihNw1jEDAQpMlQ9E9_aPV8tpGbOY,1347
+rats/apps/_ids.py,sha256=T8Onrj79t8NPfBMQBk0xI6fIWDKF0m2JfFNrdtXAbWg,353
+rats/apps/_mains.py,sha256=2Q97mNk1cBzYROc_pJcm57EEeHmwRbXOWpfYXH37qcA,995
+rats/apps/_namespaces.py,sha256=THUV_Xj5PtweC23Ob-zsSpk8exC4fT-qRwjpQ6IDm0U,188
+rats/apps/_plugin_container.py,sha256=wmaBgxmvKo82ue9CrKHRXafgik5wIXh8XkEYMfhcTjs,1530
+rats/apps/_runtimes.py,sha256=l5Z26jZVHk4CvT8VyKUK5tpcCAKt2N1DWipd4gX_Bls,2060
+rats/apps/_scoping.py,sha256=6C2-ID22cCPR9Cbexf3CvCF3o9F_7ieURbwqkf6DI68,1360
+rats/apps/_static_container.py,sha256=KH4AwRMX5QPIwYrD9W_HayIpQIrbVn7clEMx44LFAGc,2113
+rats/apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/cli/__init__.py,sha256=PFwnpWtiAkHyV_wyQRNslKHKAOI659HpU5KBfswq8RQ,540
+rats/cli/__main__.py,sha256=WeldAKjA3Kmz9ZRnZVd3G8Ud66Y_gSRDLIPNE1JyhV0,1418
+rats/cli/_annotations.py,sha256=5voM1pNm7iybZpgQTSVpaq3rMIMz33jr4eUyoEmxWJ4,1359
+rats/cli/_app.py,sha256=EmLIJe1LTLob5u5gP8gpgxk3kFlALTvrpYlwxlILu0k,620
+rats/cli/_container.py,sha256=q3L6On6RS3PfUFZ67t6eUvKUQIK4Qxomz5ob86aNcR4,2143
+rats/cli/_plugin.py,sha256=IknKt0yLNpk2ZYH2yRiADC74jO5DowAGmoWOEvR6l4g,928
+rats/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats/logs/__init__.py,sha256=sizLa6JbqekhJGKDyRZUUQvTuqiJx6yxwA5jT-tDQck,152
+rats/logs/_app.py,sha256=TF6rfQXQfaHd3AFW2anAoAGaxzU31kqJMoKkjuBtbF0,1617
+rats/logs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rats_e2e/apps/__init__.py,sha256=c2QG818ACyS9MBXs_Evg5yYT6k-KPMQfIqF7Z77Cau0,142
+rats_e2e/apps/__main__.py,sha256=Ha_FTjgnX695huoXTBulqLUjKGG0aEwqXZx8tRDYKdY,351
+rats_e2e/apps/_example_cli.py,sha256=76bOZcYCNsRkNaRU81Wc1pIkjNaR0k7Bg1L0AiN79_A,2840
+rats_e2e/apps/inputs/__init__.py,sha256=A9OActelrdQR-YYxUAGzogUFiOt3sDayGtQ3_6orVzc,785
+rats_e2e/apps/inputs/__main__.py,sha256=Mf-a2iQKTTgh9hMd6AeuzmU9araMIyf1AtdWkh_L07E,117
+rats_e2e/apps/inputs/_app.py,sha256=FiaLgOZc-d1ryKSwKnL5XBNGcOP1bHbxxeMJqoU_RJg,1446
+rats_e2e/apps/minimal/__init__.py,sha256=bUR6Oexx6Jsouxor0cL9emXoVha4cm3WqyhU1pgchsI,521
+rats_e2e/apps/minimal/__main__.py,sha256=Mf-a2iQKTTgh9hMd6AeuzmU9araMIyf1AtdWkh_L07E,117
+rats_e2e/apps/minimal/_app.py,sha256=CQ09LVTNRarz7Pb1wiSuNHrZ_2KGcgH8nUqy4BjxMUY,849
+rats_apps-0.5.0.dev20250102200830.dist-info/METADATA,sha256=PoWUQ6BgiO0mAjT0itv2W9nGAQ2AGKe6idcQl74P8Rw,825
+rats_apps-0.5.0.dev20250102200830.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+rats_apps-0.5.0.dev20250102200830.dist-info/RECORD,,

rats_e2e/apps/__init__.py

@@ -0,0 +1,7 @@
+"""Examples and end-to-end tests for the `rats.apps` package."""
+
+from ._example_cli import ExampleCliApp
+
+__all__ = [
+    "ExampleCliApp",
+]

rats_e2e/apps/__main__.py

@@ -0,0 +1,17 @@
+"""
+A set of cli commands that serve as examples of how to use the `rats.apps` package.
+
+Run this module with coverage.py: `coverage run --branch -m rats_e2e.runtime`.
+"""
+
+import logging
+
+from rats_e2e import apps as e2e
+
+from rats import apps
+
+logger = logging.getLogger(__name__)
+
+
+if __name__ == "__main__":
+    apps.run_plugin(e2e.ExampleCliApp)

rats_e2e/apps/_example_cli.py

@@ -0,0 +1,82 @@
+from random import randint
+from textwrap import dedent
+
+import click
+import rats_e2e.apps.inputs as inputs
+import rats_e2e.apps.minimal as minimal
+
+from rats import apps, cli, logs
+
+
+class ExampleContextContainer(apps.Container, apps.PluginMixin):
+    """
+    Our test context container provides the input data to our applications.
+
+    We'll pass this container into the different example applications, so the developer of a given
+    application can access the services defined here as being part of their parent container
+    defined in `self._app`.
+    """
+
+    @apps.service(inputs.AppServices.INPUT)
+    def _input(self) -> inputs.AppInput:
+        """
+        A random value we want to be made available to our example `inputs.Application`.
+
+        Because the `apps.Container` service providers are cached, our `uuid` will be static for
+        each instance of this container
+        """
+        return inputs.AppInput(randint(0, 5))
+
+
+class ExampleCliApp(apps.AppContainer, cli.Container, apps.PluginMixin):
+    """Test application that exposes a few example uses of `rats.apps`."""
+
+    def execute(self) -> None:
+        """Register our cli commands and run them using click."""
+        apps.run(apps.AppBundle(app_plugin=logs.ConfigureApplication))
+        cli.create_group(click.Group("rats_e2e.apps"), self)()
+
+    @cli.command()
+    def _run_all(self) -> None:
+        """Run examples using `apps.AppBundle()`."""
+        app_plugins = [
+            minimal.Application,
+            inputs.Application,
+        ]
+
+        print("running the following applications using the `apps.AppBundle` class:")
+        for cls in app_plugins:
+            print(f"  - {cls.__module__}:{cls.__name__}")
+
+        print("\nfirst running apps without any injected context")
+        print("=" * 20)
+
+        apps.run_plugin(*app_plugins)
+
+        print("=" * 20)
+
+        print(
+            dedent(f"""
+            running with external context container: {ExampleContextContainer}
+            when we specify the context using the `container_plugin` argument, each application
+            will receive a new instance of the context built by the `AppBundle` class.
+            """)
+        )
+        print("=" * 20)
+
+        for cls in app_plugins:
+            apps.run(apps.AppBundle(app_plugin=cls, container_plugin=ExampleContextContainer))
+
+        print("=" * 20)
+        print(
+            dedent(f"""
+            running with shared external context container: {ExampleContextContainer}
+            when we specify the context using the `context` argument, each application can be
+            given the same instance.
+            """)
+        )
+        print("=" * 20)
+
+        ctx = ExampleContextContainer(apps.CompositeContainer())
+        for cls in app_plugins:
+            apps.run(apps.AppBundle(app_plugin=cls, context=ctx))

rats_e2e/apps/inputs/__init__.py

@@ -0,0 +1,31 @@
+"""
+Application using services expected to be provided externally.
+
+Instead of using the `RATS_E2E_NUM_VALUES` environment variable, this application introduces a
+small configuration object [rats_e2e.apps.inputs.AppInput][] that we can specify when running
+things.
+
+```python
+from rats import apps
+from rats_e2e.apps import inputs
+
+
+class AppContext(apps.Container, apps.PluginMixin):
+    @apps.service(inputs.AppServices.INPUT)
+    def _input(self) -> inputs.AppInput:
+        return inputs.AppInput(randint(0, 5))
+
+
+ctx = ExampleContextContainer(apps.AppContext())
+apps.run(apps.AppBundle(app_plugin=inputs.Application, context=ctx))
+```
+"""
+
+from ._app import AppInput, Application, AppServices, main
+
+__all__ = [
+    "AppInput",
+    "AppServices",
+    "Application",
+    "main",
+]

rats_e2e/apps/inputs/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for the example."""
+
+from rats_e2e.apps import minimal
+
+if __name__ == "__main__":
+    minimal.main()

rats_e2e/apps/inputs/_app.py

@@ -0,0 +1,46 @@
+import logging
+from typing import NamedTuple
+from uuid import uuid4
+
+from rats import apps
+
+logger = logging.getLogger(__name__)
+
+
+class AppInput(NamedTuple):
+    """A small data structure to provide the needed configuration for our application."""
+
+    num_rows: int
+    """The number of values we want printed by the [rats_e2e.apps.inputs.Application][] class."""
+
+
+@apps.autoscope
+class AppServices:
+    INPUT = apps.ServiceId[AppInput]("input")
+
+
+class Application(apps.AppContainer, apps.PluginMixin):
+    """
+    Prints a handful of random values to stdout.
+
+    We can run this application with `apps.run_plugin(minimal.Application)` or directly in the
+    terminal with `python -m rats_e2e.apps.inputs`. However, the library api allows the addition
+    of a [rats.apps.Container][] with a service used as configuration.
+    """
+
+    def execute(self) -> None:
+        """The main entry point to the application."""
+        app_input = self._app.get(AppServices.INPUT)
+        logger.info(f"running inputs application example with input: {app_input}")
+        for _x in range(app_input.num_rows):
+            print(uuid4())
+
+    @apps.fallback_service(AppServices.INPUT)
+    def _default_input(self) -> AppInput:
+        # we can throw an exception if we want the input to be required without defaults
+        logger.warning("default app input being used")
+        return AppInput(5)
+
+
+def main() -> None:
+    apps.run_plugin(Application)

rats_e2e/apps/minimal/__init__.py

@@ -0,0 +1,26 @@
+"""
+A minimal executable application example.
+
+You can run this example by using the [rats_e2e.apps.minimal.Application][] class within python,
+or directly through a terminal.
+
+=== ":material-language-python: python"
+    ```python
+    from rats import apps
+    from rats_e2e.apps import minimal
+
+    apps.run_plugin(minimal.Application)
+    ```
+
+=== ":material-console: ~/code"
+    ```bash
+    python -m rats_e2e.apps.minimal
+    ```
+"""
+
+from ._app import Application, main
+
+__all__ = [
+    "Application",
+    "main",
+]

rats_e2e/apps/minimal/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for the example."""
+
+from rats_e2e.apps import minimal
+
+if __name__ == "__main__":
+    minimal.main()

rats_e2e/apps/minimal/_app.py

@@ -0,0 +1,28 @@
+import logging
+import os
+from uuid import uuid4
+
+from rats import apps
+
+logger = logging.getLogger(__name__)
+
+
+class Application(apps.AppContainer, apps.PluginMixin):
+    """
+    Prints a handful of random values to stdout.
+
+    We can run this application with `apps.run_plugin(minimal.Application)` or directly in the
+    terminal with `python -m rats_e2e.apps.minimal`. Use the `RATS_E2E_NUM_VALUES` environment
+    variable to alter the number of values to print.
+    """
+
+    def execute(self) -> None:
+        """The main entry point to the application."""
+        logger.info("running minimal application example")
+        for _x in range(int(os.environ.get("RATS_E2E_NUM_VALUES", 5))):
+            print(uuid4())
+
+
+def main() -> None:
+    """Entry point function to register this application as a script."""
+    apps.run_plugin(Application)

rats/apps/__main__.py

@@ -1,79 +0,0 @@
-"""..."""
-
-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/_plugins.py

@@ -1,23 +0,0 @@
-import warnings
-from collections.abc import Callable, Iterator
-from typing import Generic, TypeVar
-
-T_PluginType = TypeVar("T_PluginType")
-
-
-class PluginRunner(Generic[T_PluginType]):
-    """Client to apply a function to a list of plugins."""
-
-    _plugins: Iterator[T_PluginType]
-
-    def __init__(self, plugins: Iterator[T_PluginType]) -> None:
-        self._plugins = plugins
-
-    def apply(self, handler: Callable[[T_PluginType], None]) -> None:
-        warnings.warn(
-            "PluginRunner is deprecated. Use PluginContainer instances instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        for plugin in self._plugins:
-            handler(plugin)

rats/apps/_simple_apps.py

@@ -1,163 +0,0 @@
-from collections.abc import Callable, Iterable, Iterator
-from contextlib import contextmanager
-from typing import final
-
-from ._annotations import fallback_service, service
-from ._composite_container import CompositeContainer
-from ._container import Container, container
-from ._executables import App, Executable
-from ._ids import ServiceId
-from ._plugin_container import PluginContainers
-from ._runtimes import Runtime, T_ExecutableType
-from ._scoping import autoscope
-
-
-class ExecutableCallableContext(Executable):
-    """
-    An executable that can be set dynamically with a callable.
-
-    We use this class to support the use of `rats.apps` with a plain callable, like is expected of
-    standard python scripts. We give this class a service id, and set the callable before using
-    `apps.Runtime` to execute the chosen service id.
-    """
-
-    _exe_id: ServiceId[Executable]
-    _callables: list[Callable[[], None]]
-
-    def __init__(self, exe_id: ServiceId[Executable]) -> None:
-        self._exe_id = exe_id
-        self._callables = []
-
-    def execute(self) -> None:
-        if len(self._callables) == 0:
-            raise RuntimeError("No active executable found.")
-
-        self._callables[-1]()
-
-    @contextmanager
-    def open_callable(
-        self,
-        callable: Callable[[], None],
-    ) -> Iterator[Executable]:
-        self._callables.append(callable)
-        try:
-            yield App(callable)
-        finally:
-            self._callables.pop()
-
-
-@autoscope
-class AppServices:
-    """
-    Services used by simple apps that can generally be used anywhere.
-
-    Owners of applications can decide not to use or not to make these services available to plugin
-    authors.
-    """
-
-    RUNTIME = ServiceId[Runtime]("app-runtime")
-    STANDARD_RUNTIME = ServiceId[Runtime]("standard-runtime")
-    CONTAINER = ServiceId[Container]("app-container")
-    CALLABLE_EXE_CTX = ServiceId[ExecutableCallableContext]("callable-exe-ctx")
-    CALLABLE_EXE = ServiceId[Executable]("callable-exe")
-
-
-@final
-class StandardRuntime(Runtime):
-    """A simple runtime that executes sequentially and in a single thread."""
-
-    _app: Container
-
-    def __init__(self, app: Container) -> None:
-        self._app = app
-
-    def execute(self, *exe_ids: ServiceId[T_ExecutableType]) -> None:
-        for exe_id in exe_ids:
-            self._app.get(exe_id).execute()
-
-    def execute_group(self, *exe_group_ids: ServiceId[T_ExecutableType]) -> None:
-        for exe_group_id in exe_group_ids:
-            for exe in self._app.get_group(exe_group_id):
-                exe.execute()
-
-    def execute_callable(self, *callables: Callable[[], None]) -> None:
-        ctx: ExecutableCallableContext = self._app.get(AppServices.CALLABLE_EXE_CTX)
-        for cb in callables:
-            with ctx.open_callable(cb) as exe:
-                exe.execute()
-
-
-@final
-class SimpleApplication(Runtime, Container):
-    """An application without anything fancy."""
-
-    _plugin_groups: Iterable[str]
-    _runtime_plugin: Callable[[Container], Container] | None
-
-    def __init__(
-        self,
-        *plugin_groups: str,
-        runtime_plugin: Callable[[Container], Container] | None = None,
-    ) -> None:
-        self._plugin_groups = plugin_groups
-        self._runtime_plugin = runtime_plugin
-
-    def execute(self, *exe_ids: ServiceId[T_ExecutableType]) -> None:
-        self._runtime().execute(*exe_ids)
-
-    def execute_group(self, *exe_group_ids: ServiceId[T_ExecutableType]) -> None:
-        self._runtime().execute_group(*exe_group_ids)
-
-    def execute_callable(self, *callables: Callable[[], None]) -> None:
-        for cb in callables:
-            self._runtime().execute_callable(cb)
-
-    @fallback_service(AppServices.RUNTIME)
-    def _runtime(self) -> Runtime:
-        """
-        The default runtime defers to AppServices.STANDARD_RUNTIME.
-
-        Define a non-fallback service to override this default implementation.
-        """
-        return self.get(AppServices.STANDARD_RUNTIME)
-
-    @service(AppServices.STANDARD_RUNTIME)
-    def _std_runtime(self) -> Runtime:
-        """
-        The standard locally executed runtime.
-
-        Regardless of the configured AppServices.RUNTIME provider, everyone has access to this
-        class for plugin development.
-        """
-        return StandardRuntime(self)
-
-    @fallback_service(AppServices.CALLABLE_EXE)
-    def _callable_exe(self) -> Executable:
-        """We use the callable exe ctx here, so we can treat it like any other app downstream."""
-        return self.get(AppServices.CALLABLE_EXE_CTX)
-
-    @fallback_service(AppServices.CALLABLE_EXE_CTX)
-    def _callable_exe_ctx(self) -> ExecutableCallableContext:
-        """
-        The default executable context client for executing raw callables.
-
-        Define a non-fallback service to override this default implementation.
-        """
-        return ExecutableCallableContext(AppServices.CALLABLE_EXE)
-
-    @fallback_service(AppServices.CONTAINER)
-    def _container(self) -> Container:
-        """
-        The default container is the root application instance.
-
-        Define a non-fallback service to override this default implementation.
-        """
-        return self
-
-    @container()
-    def _plugins(self) -> Container:
-        plugins: list[Container] = [PluginContainers(self, group) for group in self._plugin_groups]
-        if self._runtime_plugin:
-            plugins.append(self._runtime_plugin(self))
-
-        return CompositeContainer(*plugins)

rats/logs/_plugin.py

@@ -1,64 +0,0 @@
-import logging.config
-from collections.abc import Iterator
-
-from rats import apps
-
-logger = logging.getLogger(__name__)
-
-
-@apps.autoscope
-class _PluginEvents:
-    CONFIGURE_LOGGING = apps.ServiceId[apps.Executable]("configure-logging")
-
-
-@apps.autoscope
-class PluginServices:
-    EVENTS = _PluginEvents
-
-
-class PluginContainer(apps.Container):
-    _app: apps.Container
-
-    def __init__(self, app: apps.Container) -> None:
-        self._app = app
-
-    @apps.group(PluginServices.EVENTS.CONFIGURE_LOGGING)
-    def _configure_logging(self) -> Iterator[apps.Executable]:
-        # in the future, we can use this plugin to make logging easily configurable
-        yield apps.App(
-            lambda: logging.config.dictConfig(
-                {
-                    "version": 1,
-                    "disable_existing_loggers": False,
-                    "formatters": {
-                        "colored": {
-                            "()": "colorlog.ColoredFormatter",
-                            "format": (
-                                "%(log_color)s%(asctime)s %(levelname)-8s [%(name)s][%(lineno)d]: "
-                                "%(message)s%(reset)s"
-                            ),
-                            "datefmt": "%Y-%m-%d %H:%M:%S",
-                            "log_colors": {
-                                "DEBUG": "white",
-                                "INFO": "green",
-                                "WARNING": "yellow",
-                                "ERROR": "red,",
-                                "CRITICAL": "bold_red",
-                            },
-                        }
-                    },
-                    "handlers": {
-                        "console": {
-                            "class": "logging.StreamHandler",
-                            "level": "DEBUG",
-                            "formatter": "colored",
-                            "stream": "ext://sys.stderr",
-                        }
-                    },
-                    "loggers": {
-                        "": {"level": "INFO", "handlers": ["console"]},
-                        "azure": {"level": "WARNING", "handlers": ["console"]},
-                    },
-                }
-            )
-        )

rats_apps-0.4.0.dev20241212213929.dist-info/RECORD

@@ -1,33 +0,0 @@
-rats/annotations/__init__.py,sha256=wsGhRQzZrV2oJTnBAX0aGgpyT1kYT235jkP3Wb8BTRY,498
-rats/annotations/__main__.py,sha256=vlzQOM9y82P0OL5tYcmSM_4jTg0s8jayAcvEoi9cBvI,1065
-rats/annotations/_functions.py,sha256=UkHh3zdBivluE7dBeGQ17zoIfGdyIokMAkFmpWaIlDc,4284
-rats/annotations/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/apps/__init__.py,sha256=1S5GcOE7aQQxRD2fJEpo6HipTi7sJgVx-RpVdcucOwY,1743
-rats/apps/__main__.py,sha256=KjdadN4rdP0xhWiLzdmtCsXejWx_gxOK-ah-L1r1dTI,1818
-rats/apps/_annotations.py,sha256=6M_M7K8haNVda0Tx02EpFf3s9EjnWYacNMjTIkNEdRU,4617
-rats/apps/_composite_container.py,sha256=s_of6NyyrjFVYWGVehyEHe9WJIPRCnbB-tyWyNF8zyc,585
-rats/apps/_container.py,sha256=Gb7jJmGyKGDZFjoe0s0C_gC7ymSpXaqordfQaJZGJf4,7283
-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=6C2-ID22cCPR9Cbexf3CvCF3o9F_7ieURbwqkf6DI68,1360
-rats/apps/_simple_apps.py,sha256=n-3zeHY3iintZ9LN597c7zDHv3DiIdl7c8NTk0gUk1Y,5477
-rats/apps/_static_container.py,sha256=5lzLh1CUoQVwhxfDhK6ZOQaBrPpudbRHWJkaDppphZo,881
-rats/apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/cli/__init__.py,sha256=GR_pZr0OtqkH2js73OPZlK4Pgj0C30bhSKPGfU32Zxk,580
-rats/cli/__main__.py,sha256=5OidbkRA4aglOAcvV6xQY9k7Ls9vd_EwNvI2aOrcPIQ,1649
-rats/cli/_annotations.py,sha256=5voM1pNm7iybZpgQTSVpaq3rMIMz33jr4eUyoEmxWJ4,1359
-rats/cli/_app.py,sha256=EmLIJe1LTLob5u5gP8gpgxk3kFlALTvrpYlwxlILu0k,620
-rats/cli/_container.py,sha256=q3L6On6RS3PfUFZ67t6eUvKUQIK4Qxomz5ob86aNcR4,2143
-rats/cli/_plugin.py,sha256=jkpqSCW0ELnMjK8fz-BVE50qgBIxbd5j4hILOnlla6U,1086
-rats/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/logs/__init__.py,sha256=fCn4pfpYiAcTtt5CsnUZX68CjOB3KJHxMSiYxsma4qE,183
-rats/logs/_plugin.py,sha256=OQ5fXToBm60YJRrMUVJ9_HVytUs3c69vaHY57jpivb0,2221
-rats/logs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats_apps-0.4.0.dev20241212213929.dist-info/METADATA,sha256=Sug-FUXtluJL-S6QzI7-dz9uhMjmA7p_FxdYsh2Xm1M,825
-rats_apps-0.4.0.dev20241212213929.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-rats_apps-0.4.0.dev20241212213929.dist-info/entry_points.txt,sha256=9oOvf2loQr5ACWQgvuu9Q3KZIVIxKE5Aa-rLuUII5WQ,91
-rats_apps-0.4.0.dev20241212213929.dist-info/RECORD,,

rats_apps-0.4.0.dev20241212213929.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-[rats.apps.plugins]
-rats.cli=rats.cli:PluginContainer
-rats.logs=rats.logs:PluginContainer
-