rats-apps 0.11.0.dev20250521180658__py3-none-any.whl → 0.11.1__py3-none-any.whl

rats/apps/_app_containers.py

@@ -53,11 +53,7 @@ This is the companion type to [rats.apps.ContainerPlugin][].
 
 ContainerPlugin = _ContainerPluginType | Callable[[Container], Container]
 """
-Main interface for a function that returns an [rats.apps.Container][] instance.
-
-Containers that implement this type—for example, by using the [rats.apps.PluginMixin][] mixin—can
-be used easily in functions that need to defer the construction of an application container. See
-[rats.apps.AppBundle][] for additional examples.
+Factory function protocol that returns an [rats.apps.Container][] instance.
 """
 
 
@@ -155,7 +151,7 @@ class AppBundle(AppContainer):
         context: Container = EMPTY_CONTEXT,
     ):
         """
-        Create an instance by providing the [rats.apps.AppPlugin] type and any additional context.
+        Create an instance by providing the [rats.apps.AppPlugin][] type and any additional context.
 
         Example:
             ```python
@@ -164,17 +160,22 @@ class AppBundle(AppContainer):
 
             class ExamplePlugin(apps.Container, apps.PluginMixin):
                 @apps.service(apps.ServiceId[str]("some-value"))
-                def _some_value() -> str:
+                def _some_value(self) -> str:
                     return "hello, world!"
 
 
             class ExampleApplication(apps.AppContainer, apps.PluginMixin):
-                def execute() -> None:
+                def execute(self) -> None:
                     print(self._app.get(apps.ServiceId[str]("some-value")))
 
 
             if __name__ == "__main__":
-                apps.run(apps.AppBundle(ExampleApplication, ExamplePlugin))
+                apps.run(
+                    apps.AppBundle(
+                        app_plugin=ExampleApplication,
+                        container_plugin=ExamplePlugin,
+                    )
+                )
             ```
 
         Args:

rats/apps/_container.py

@@ -108,7 +108,6 @@ class Container(Protocol):
         """Retrieve a service group by its id."""
         if not self.has_namespace(ProviderNamespaces.GROUPS, group_id):
             # groups are expected to return iterable services
-            # TODO: we need to clean up the meaning of groups and services somehow
             for i in self.get_namespaced_group(ProviderNamespaces.FALLBACK_GROUPS, group_id):
                 yield from cast(Iterator[T_ServiceType], i)
 
@@ -151,7 +150,14 @@ def _get_cached_services_for_group(
 
     for provider in info_cache[(namespace, group_id)]:
         if provider not in provider_cache:
-            provider_cache[provider] = getattr(c, provider.attr)()
+            if namespace in [
+                ProviderNamespaces.CONTAINERS,
+                ProviderNamespaces.SERVICES,
+                ProviderNamespaces.FALLBACK_SERVICES,
+            ]:
+                provider_cache[provider] = getattr(c, provider.attr)()
+            else:
+                provider_cache[provider] = list(getattr(c, provider.attr)())
 
         yield provider_cache[provider]
 

rats/cli/_container.py

@@ -55,11 +55,11 @@ class Container(Protocol):
 
         commands = get_class_commands(type(self))
         tates = commands.annotations
+        logger.debug(f"[{type(self)}] commands: {tates}")
 
         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(

rats/logs/__init__.py

@@ -7,16 +7,62 @@ handle configuring the python logging libraries, with a few configuration option
 !!! warning
     We expose the logging functionality through a [rats.apps.AppContainer][] in order to leverage
     the built in plugin system to give users the ability to adjust the default settings, but this
-    entire application should be lightweight and should not contain very complex logic, avoiding
-    logic that is very time consuming or has a chance of failing with confusing errors.
+    application should be lightweight and should not contain very complex logic, avoiding logic
+    that is very time consuming or has a chance of failing with confusing errors.
+
+## Verbosity Env Variables
+
+To help develop modules, logging output can be configured with the `DEBUG_LOGS_*`, `QUIET_LOGS_*`,
+and `LEVEL_LOGS_*` environment variables. The suffix of the environment variables match the module
+name wanting to be configured.
+
+### Module Loggers
+
+Environment variables named `DEBUG_LOGS_*` cause logs from the given module to be shown; the
+`QUIET_LOGS_*` environment variables silence logs emitted by the module; and `LEVEL_LOGS_*` allows
+a specific [logging-level](https://docs.python.org/3/library/logging.html#logging-levels) to be
+used.
+
+```
+$ rats-ci fix
+All checks passed!
+63 files left unchanged
+ran 2 fix commands
+```
+
+```bash
+# Enable DEBUG level logs for the `rats.*` modules
+export DEBUG_LOGS_RATS="1"
+# Enable WARNING level logs for the `rats.projects.*` modules
+export LEVEL_LOGS_RATS_PROJECTS="WARNING"
+# Disable logs for `rats.cli.*` modules
+export QUIET_LOGS_RATS_CLI="1"
+```
+```
+$ rats-ci fix
+2025-05-27 00:49:45 DEBUG    [rats.logs._app:96]: done configuring logging
+All checks passed!
+63 files left unchanged
+ran 2 fix commands
+```
+
+### Root Logger
+
+The root logger can be configured with the `DEBUG_LOGS`, `QUIET_LOGS`, and `LEVEL_LOGS` environment
+variables.
+
+```bash
+# Enable WARNING level logs for all logs
+export LEVEL_LOGS="WARNING"
+```
 
-    If the logging options made available through this module are far from what is desired, instead
-    of adding flags and options to this module, we recommend configuring logging in your own code.
 """
 
 from ._app import AppConfigs, ConfigureApplication
+from ._showwarning import showwarning
 
 __all__ = [
     "AppConfigs",
     "ConfigureApplication",
+    "showwarning",
 ]

rats/logs/_app.py

@@ -1,10 +1,13 @@
 import logging.config
+import os
 import warnings
 from collections.abc import Iterator
 from typing import Any
 
 from rats import apps
 
+from ._showwarning import showwarning
+
 logger = logging.getLogger(__name__)
 LoggerConfigEntry = tuple[str, dict[str, Any]]
 
@@ -61,12 +64,12 @@ class ConfigureApplication(apps.AppContainer, apps.PluginMixin):
                     "colored": {
                         "()": "colorlog.ColoredFormatter",
                         "format": (
-                            "%(log_color)s%(asctime)s %(levelname)-8s [%(name)s][%(lineno)d]: "
+                            "%(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",
+                            "DEBUG": "cyan",
                             "INFO": "green",
                             "WARNING": "yellow",
                             "ERROR": "red,",
@@ -88,9 +91,65 @@ class ConfigureApplication(apps.AppContainer, apps.PluginMixin):
         # enable deprecation warnings by default
         logging.captureWarnings(True)
         warnings.simplefilter("default", DeprecationWarning)
+        # our modified `showwarning` method logs warnings with the module logger that emitted it
+        warnings.showwarning = showwarning
         logger.debug("done configuring logging")
 
     @apps.fallback_group(AppConfigs.LOGGERS)
     def _default_loggers(self) -> Iterator[LoggerConfigEntry]:
-        yield "", {"level": "INFO", "handlers": ["console"]}
-        yield "azure", {"level": "WARNING", "handlers": ["console"]}
+        logger_mapping = {
+            "": "INFO",
+            "azure": "WARNING",
+            "py.warnings": "CRITICAL",
+        }
+        searched_prefixes = [
+            "DEBUG_LOGS",
+            "QUIET_LOGS",
+            "LEVEL_LOGS",
+        ]
+        for name in os.environ.keys():
+            env_prefix = name[0:10]
+            if env_prefix not in searched_prefixes:
+                # this isn't a logging config env
+                continue
+
+            # our above prefixes are conveniently all 10 characters
+            # everything after the prefix is the logger name, skip the underscore after the prefix
+            logger_name = name.lower()[11:].replace("_", ".")
+            if logger_name not in logger_mapping:
+                # the default here is ignored
+                logger_mapping[logger_name] = "INFO"
+
+        for name, default in logger_mapping.items():
+            yield self._build_logger_entry(name, default)
+
+    def _build_logger_entry(self, name: str, default: str = "INFO") -> LoggerConfigEntry:
+        # https://docs.python.org/3/library/logging.html#logging-levels
+        valid_levels = [
+            "NOTSET",
+            "DEBUG",
+            "INFO",
+            "WARNING",
+            "ERROR",
+            "CRITICAL",
+        ]
+        suffix = f"_{'_'.join(name.split('.')).upper()}" if name != "" else ""
+
+        debug_env_name = f"DEBUG_LOGS{suffix}"
+        quiet_env_name = f"QUIET_LOGS{suffix}"
+        level_env_name = f"LEVEL_LOGS{suffix}"
+        if os.environ.get(level_env_name):
+            # user specified exactly what log level is wanted for this module
+            lvl = os.environ[level_env_name].upper()
+            if lvl not in valid_levels:
+                raise ValueError(f"invalid log level specified: {level_env_name}={lvl}")
+            return name, {"level": lvl, "handlers": ["console"], "propagate": False}
+        elif os.environ.get(debug_env_name):
+            # show as many logs as possible
+            return name, {"level": "DEBUG", "handlers": ["console"], "propagate": False}
+        elif os.environ.get(quiet_env_name):
+            # only show critical logs when QUIET_LOGS is enabled
+            return name, {"level": "CRITICAL", "handlers": ["console"], "propagate": False}
+        else:
+            # set default logging to INFO
+            return name, {"level": default, "handlers": ["console"], "propagate": False}

rats/logs/_showwarning.py

@@ -0,0 +1,51 @@
+import logging
+import sys
+import warnings
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def showwarning(
+    message: Warning | str,
+    category: type[Warning],
+    filename: str,
+    lineno: int,
+    file: str | None = None,
+    line: str | None = None,
+) -> None:
+    """
+    Handler that logs warnings using the module logger from the module that emitted the warning.
+
+    ```python
+    import warnings
+    from rats.logs import showwarning
+
+    warnings.showwarning = showwarning
+    warnings.warn("This is a custom warning", UserWarning)
+    ```
+
+    Args:
+        message: The warning message instance or string.
+        category: The category of the warning (e.g., [DeprecationWarning][], [UserWarning][]).
+        filename: The path to the file where the warning originated.
+        lineno: The line number in the file where the warning originated.
+        file: Ignored. Included for compatibility with the standard warnings.showwarning signature.
+        line: The line of source code to be included in the warning message, if available.
+    """
+    if file is not None:
+        raise ValueError(file)
+
+    formatted_message = warnings.formatwarning(message, category, filename, lineno, line)
+
+    for _module_name, module in sys.modules.items():
+        module_path = getattr(module, "__file__", None)
+        if module_path and Path(filename).is_file() and Path(module_path).samefile(filename):
+            module_name = _module_name
+            break
+    else:
+        # unsure what module to use, but we can default to "py.warnings" like the original handler
+        module_name = "py.warnings"
+
+    source_logger = logging.getLogger(module_name)
+    source_logger.warning(formatted_message)

rats_apps-0.11.1.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.3
+Name: rats-apps
+Version: 0.11.1
+Summary: research analysis tools for building applications
+License: MIT
+Keywords: pipelines,machine learning,research
+Author: Elon Portugaly
+Author-email: elonp@microsoft.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click
+Requires-Dist: colorlog
+Requires-Dist: dataclass-wizard
+Requires-Dist: pyyaml
+Requires-Dist: typing-extensions
+Project-URL: Documentation, https://microsoft.github.io/rats
+Project-URL: Repository, https://github.com/microsoft/rats
+Description-Content-Type: text/markdown
+
+---
+title: introduction
+---
+
+The `rats-apps` package helps create applications; a small set of modules that eliminate the most
+common boilerplate code when creating applications of any kind. We do this mainly by providing a
+set of libraries to define service containers, and using the service containers to hide the
+complexity of creating services–like authentication, storage, or database clients–from other parts
+of the system, allowing developers to focus on the business logic of the application. Often referred
+to as [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection), we use our
+service containers to separate the concerns of constructing objects and using them.
+
+## Installation
+
+Use `pip` or your favorite packaging tool to install the package from PyPI.
+
+```bash
+pip install rats-apps
+```
+
+## What is an application?
+
+Let's start with a standard python script, and slowly migrate it to be a rats application in order
+to explain a few main details. Creating a `__main__.py` file in a package makes it executable.
+After the common python boilerplate code is added, this is typically what we find in the wild:
+
+=== ":material-language-python: ~/code/src/foo/\_\_main\_\_.py"
+    ```python
+    def main() -> None:
+        print("hello, world")
+
+
+    if __name__ == "__main__":
+        main()
+    ```
+
+=== ":material-console: ~/code"
+    ```bash
+    python -m foo
+    ```
+
+Using this pattern, we can define our application with a small modification, turning our `main()`
+function into a runnable rats application, and then running it:
+
+=== ":material-language-python: ~/code/src/foo/\_\_main\_\_.py"
+    ```python
+    from rats import apps
+
+
+    def main() -> None:
+        print("hello, world")
+
+
+    if __name__ == "__main__":
+        apps.run(apps.App(main))
+    ```
+
+!!! info
+    The [rats.apps.App][] class is used to quickly turn a script entry point–`Callable[[], None]`
+    –into an object with an `execute()` method, defined by our [rats.apps.Executable][]
+    interface.
+
+## Application Containers & Plugins
+
+We can start to leverage [rats.apps][] to make our application easy to extend. Let's replace our use
+of the [rats.apps.App][] wrapper and move our `main()` function into a class. Using the
+[rats.apps.AppContainer][] and [rats.apps.PluginMixin][] classes, we finish adapting our example
+to be a rats application.
+
+=== ":material-language-python: ~/code/src/foo/\_\_main\_\_.py"
+
+    ```python
+        from rats import apps
+
+
+        class Application(apps.AppContainer, apps.PluginMixin):
+            def execute() -> None:
+                print("hello, world")
+
+
+        if __name__ == "__main__":
+            apps.run_plugin(Application)
+    ```
+
+!!! info
+    If you're making these changes to an existing code base, you should be able to run things to
+    validate that everything still works as it did before. Your `main()` function is now in
+    the `execute()` method of your new `Application` class, but none of the behavior of your
+    application should have been affected.
+
+Now that we have a fully defined rats application; we can use [rats.apps.Container][] instances to
+make services available to our application while remaining decoupled from the details of how these
+services are initialized. A common use case for this is to give our team access to the azure
+storage clients without needing to specify the authentication details; allowing us to ensure our
+application is functional in many compute environments.
+
+=== ":material-language-python: ~/code/src/foo/\_\_init\_\_.py"
+
+    ```python
+        from ._plugin import PluginContainer
+
+        __all__ = ["PluginContainer"]
+    ```
+
+=== ":material-language-python: ~/code/src/foo/\_\_main\_\_.py"
+
+    ```python
+        from rats import apps
+        import foo
+
+
+        class Application(apps.AppContainer, apps.PluginMixin):
+
+            def execute() -> None:
+                blob_client = self._app.get(foo.BLOB_SERVICE_ID)
+                print(f"hello, world. loaded blob client: {blob_client}")
+
+            @apps.container()
+            def _plugins(self) -> apps.Container:
+                return foo.PluginContainer(self._app)
+
+
+        if __name__ == "__main__":
+            apps.run_plugin(Application)
+    ```
+
+=== ":material-language-python: ~/code/src/foo/_plugin.py"
+
+    ```python
+        from rats import apps
+        from azure.storage.blob import BlobServiceClient
+
+        BLOB_SERVICE_ID = apps.ServiceId[BlobServiceClient]("blob-client")
+
+
+        class PluginContainer(apps.Container, apps.PluginMixin):
+
+            @apps.service(BLOB_SERVICE_ID)
+            def _blob_client(self) -> BlobServiceClient:
+                credential = DefaultAzureCredential()
+                return BlobServiceClient(
+                    account_url=f"https://example.blob.core.windows.net/",
+                    credential=credential,
+                )
+    ```
+
+!!! success
+    Following these patterns, we can make services available to others with plugin containers; and
+    we can combine these containers to create applications. The [rats.apps][] module has additional
+    libraries to help define different types of applications, designed to help your solutions
+    evolve as ideas mature. Our first runnable example was a single instance of the
+    [rats.apps.AppContainer][] interface with an `execute()` method; but a larger project might
+    have a few modules providing different aspects of the application's needs by sharing a set of
+    service ids and a plugin container.
+
+## Installable Plugins
+
+We use the standard [Entry Points](https://packaging.python.org/en/latest/specifications/entry-points/)
+mechanism to allow authors to make their application extensible. These plugins are instances of
+[rats.apps.Container][] and loaded into applications like our previous examples.
+
+=== ":material-file-settings: ~/code/pyproject.toml"
+    ```toml
+    [tool.poetry.plugins."foo.plugins"]
+    "foo" = "foo:PluginContainer"
+    ```
+
+=== ":material-language-python: ~/code/src/foo/\_\_main\_\_.py"
+    ```python
+        from rats import apps
+        import foo
+
+
+        class Application(apps.AppContainer, apps.PluginMixin):
+
+            def execute() -> None:
+                blob_client = self._app.get(foo.BLOB_SERVICE_ID)
+                print(f"hello, world. loaded blob client: {blob_client}")
+
+            @apps.container()
+            def _plugins(self) -> apps.Container:
+                return apps.PythonEntryPointContainer("foo.plugins")
+
+
+        if __name__ == "__main__":
+            apps.run_plugin(Application)
+    ```
+
+!!! success
+    We used [rats.app] to define an application, and used a service provided by a plugin container
+    that is loaded through a python entry point. You can create a script entry in your
+    `pyproject.toml` file to expose your application through a terminal command:
+
+    === ":material-language-python: ~/code/src/foo/\_\_init\_\_.py"
+        ```python
+            from ._app import Application, main
+            from ._plugin import PluginContainer
+
+
+            __all__ = [
+                "Application",
+                "main",
+                "PluginContainer",
+            ]
+        ```
+    === ":material-file-settings: ~/code/pyproject.toml"
+        ```toml
+            [tool.poetry.plugins."foo.plugins"]
+            "foo" = "foo:PluginContainer"
+
+            [tool.poetry.scripts]
+            foo = "foo:main"
+        ```
+

{rats_apps-0.11.0.dev20250521180658.dist-info → rats_apps-0.11.1.dist-info}/RECORD

@@ -9,9 +9,9 @@ rats/app_context/_context.py,sha256=S7D8NLefZJI4MDEpYKdenfNsemus4bUlQCG-gd3U3g8,
 rats/app_context/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rats/apps/__init__.py,sha256=6B5qQvzx1xlRrNRY4QJi6GEywuQ1MoW454kC4nO2Yqg,2084
 rats/apps/_annotations.py,sha256=6M_M7K8haNVda0Tx02EpFf3s9EjnWYacNMjTIkNEdRU,4617
-rats/apps/_app_containers.py,sha256=Wen5nMJdhOVa6mGHeEm7paXo1RXsNrgNRUbS0SWd9X0,7026
+rats/apps/_app_containers.py,sha256=1rtq92rOGvCbroQmDgOM24jxxcNNFQHy65fBLO5LIXo,6920
 rats/apps/_composite_container.py,sha256=FdpmH_xIly6LxNZrA_nZCznukptjVLXttXTMtf_tnv8,695
-rats/apps/_container.py,sha256=sYISCG-qVzl-bsBwX_CAWEP9gtXCnG-Jls3l8IKb4DQ,7208
+rats/apps/_container.py,sha256=N8qR0oBLi03xZvPfc8SxaSci0oVYfX_rftzfaBkTSfQ,7415
 rats/apps/_executables.py,sha256=hXExNmAnuPU1KJXihNw1jEDAQpMlQ9E9_aPV8tpGbOY,1347
 rats/apps/_ids.py,sha256=T8Onrj79t8NPfBMQBk0xI6fIWDKF0m2JfFNrdtXAbWg,353
 rats/apps/_mains.py,sha256=2Q97mNk1cBzYROc_pJcm57EEeHmwRbXOWpfYXH37qcA,995
@@ -26,12 +26,13 @@ rats/cli/__main__.py,sha256=WeldAKjA3Kmz9ZRnZVd3G8Ud66Y_gSRDLIPNE1JyhV0,1418
 rats/cli/_annotations.py,sha256=-B2Y1bYjPbeTNTBMZzMdAU92qu9AyutKHN_NdFy-xhA,2964
 rats/cli/_click_app.py,sha256=Jvs6OqNC4Yoe6kbc2tCzjzUieNFa1n_zwXPsdo971Wc,1450
 rats/cli/_command.py,sha256=kyU3UqqF9aiTTaFvlQFBKDLXvArQS1QgjoQqlMbKzok,597
-rats/cli/_container.py,sha256=FIQBqi9PTNpE2P52qkfGET51BczdD-JvcWXLTjCNPDI,3512
+rats/cli/_container.py,sha256=BoZLOu-eT4SzweNwMepWHd4PyxQAg--_p-rM7XkQNAA,3529
 rats/cli/_functions.py,sha256=BNmgWVquQUEqJAYsed_l8vLnlLP7u3XC1TDyEFI1AiU,1552
 rats/cli/_plugin.py,sha256=o-pmEqU6mVH3QoRfRBrbG-XRTWCzt6pLKtSV3-5VSx0,1144
 rats/cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rats/logs/__init__.py,sha256=dSO-V2eu2W7w4w7oRau-UOfXXIkyZ2bHB6-kaasbeFM,970
-rats/logs/_app.py,sha256=SoTxk6g84tygOP_346NwXPcG1o6KZLd7lIgayq5vMdc,3239
+rats/logs/__init__.py,sha256=_ZdkBmvW1yr5UOIB_m4OldNsUxK6NTDunNW4mvgQmpI,2115
+rats/logs/_app.py,sha256=EVjSjSaxJIL5LMJZf4yo9EpUBkkavaVXyg42cDsUt3I,5702
+rats/logs/_showwarning.py,sha256=g5Gq0I7GoHgABI4eCobq6xd4NaKuLGJFyK-SCvegDHA,1726
 rats/logs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rats/runtime/__init__.py,sha256=f9aEnynHuePP9OP5XCtB-6nCBvNWWlQQLTzuxFEueoQ,2150
 rats/runtime/__main__.py,sha256=y01yOymsL075poX95pc02sJR1HD0pDNFRZdpOdi0R6Y,79
@@ -54,7 +55,7 @@ rats_e2e/runtime/_data.py,sha256=3d1F_JO2gEOPUjBp_KYMP3TefyneiG_ktlJjdIIYUy8,125
 rats_e2e/runtime/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rats_resources/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rats_resources/runtime/example-context.yaml,sha256=eiLsNFquFfkIpUhxUCQLzLigH21QF2F00fzA_e_aOKk,215
-rats_apps-0.11.0.dev20250521180658.dist-info/METADATA,sha256=dcJpnIbCfQHHsWtD0bjxHQ26671OecfVVNeISRUoJYg,889
-rats_apps-0.11.0.dev20250521180658.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-rats_apps-0.11.0.dev20250521180658.dist-info/entry_points.txt,sha256=Gf6bPwxIVjWd3Xx71upZo7eDJA5cujniLew6fxJMgA4,117
-rats_apps-0.11.0.dev20250521180658.dist-info/RECORD,,
+rats_apps-0.11.1.dist-info/METADATA,sha256=zUanJsEqbI1Z4kibOwJKNmGs5aYYoTe0Bame-D7CIag,8274
+rats_apps-0.11.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+rats_apps-0.11.1.dist-info/entry_points.txt,sha256=Gf6bPwxIVjWd3Xx71upZo7eDJA5cujniLew6fxJMgA4,117
+rats_apps-0.11.1.dist-info/RECORD,,

rats_apps-0.11.0.dev20250521180658.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.3
-Name: rats-apps
-Version: 0.11.0.dev20250521180658
-Summary: research analysis tools for building applications
-License: MIT
-Keywords: pipelines,machine learning,research
-Author: Elon Portugaly
-Author-email: elonp@microsoft.com
-Requires-Python: >=3.10,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: click
-Requires-Dist: colorlog
-Requires-Dist: dataclass-wizard
-Requires-Dist: pyyaml
-Requires-Dist: typing-extensions
-Project-URL: Documentation, https://microsoft.github.io/rats
-Project-URL: Repository, https://github.com/microsoft/rats
-Description-Content-Type: text/markdown
-
-# rats-apps
-...
-