apitally 0.13.0a1__py3-none-any.whl → 0.14.0rc1__py3-none-any.whl

apitally/litestar.py

@@ -13,12 +13,17 @@ from litestar.handlers import HTTPRouteHandler
 from litestar.plugins import InitPluginProtocol
 from litestar.types import ASGIApp, Message, Receive, Scope, Send
 
-from apitally.client.asyncio import ApitallyClient
-from apitally.client.base import Consumer as ApitallyConsumer
-from apitally.common import get_versions
+from apitally.client.client_asyncio import ApitallyClient
+from apitally.client.consumers import Consumer as ApitallyConsumer
+from apitally.client.request_logging import (
+    BODY_TOO_LARGE,
+    MAX_BODY_SIZE,
+    RequestLoggingConfig,
+)
+from apitally.common import get_versions, parse_int
 
 
-__all__ = ["ApitallyPlugin", "ApitallyConsumer"]
+__all__ = ["ApitallyPlugin", "ApitallyConsumer", "RequestLoggingConfig"]
 
 
 class ApitallyPlugin(InitPluginProtocol):
@@ -26,15 +31,23 @@ class ApitallyPlugin(InitPluginProtocol):
         self,
         client_id: str,
         env: str = "dev",
+        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         filter_openapi_paths: bool = True,
         identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
-        self.client = ApitallyClient(client_id=client_id, env=env)
+        self.client = ApitallyClient(client_id=client_id, env=env, request_logging_config=request_logging_config)
         self.app_version = app_version
         self.filter_openapi_paths = filter_openapi_paths
         self.identify_consumer_callback = identify_consumer_callback
+
         self.openapi_path = "/schema"
+        self.capture_request_body = (
+            self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body
+        )
+        self.capture_response_body = (
+            self.client.request_logger.config.enabled and self.client.request_logger.config.log_response_body
+        )
 
     def on_app_init(self, app_config: AppConfig) -> AppConfig:
         app_config.on_startup.append(self.on_startup)
@@ -67,23 +80,39 @@ class ApitallyPlugin(InitPluginProtocol):
     def middleware_factory(self, app: ASGIApp) -> ASGIApp:
         async def middleware(scope: Scope, receive: Receive, send: Send) -> None:
             if scope["type"] == "http" and scope["method"] != "OPTIONS":
+                timestamp = time.time()
                 request = Request(scope)
+                request_size = parse_int(request.headers.get("Content-Length"))
+                request_body = b""
+                request_body_too_large = request_size is not None and request_size > MAX_BODY_SIZE
                 response_status = 0
                 response_time = 0.0
                 response_headers = Headers()
                 response_body = b""
-                response_size = 0
+                response_body_too_large = False
+                response_size: Optional[int] = None
                 response_chunked = False
                 start_time = time.perf_counter()
 
+                async def receive_wrapper() -> Message:
+                    nonlocal request_body, request_body_too_large
+                    message = await receive()
+                    if message["type"] == "http.request" and self.capture_request_body and not request_body_too_large:
+                        request_body += message.get("body", b"")
+                        if len(request_body) > MAX_BODY_SIZE:
+                            request_body_too_large = True
+                            request_body = b""
+                    return message
+
                 async def send_wrapper(message: Message) -> None:
                     nonlocal \
                         response_time, \
                         response_status, \
                         response_headers, \
                         response_body, \
-                        response_size, \
-                        response_chunked
+                        response_body_too_large, \
+                        response_chunked, \
+                        response_size
                     if message["type"] == "http.response.start":
                         response_time = time.perf_counter() - start_time
                         response_status = message["status"]
@@ -92,20 +121,28 @@ class ApitallyPlugin(InitPluginProtocol):
                             response_headers.get("Transfer-Encoding") == "chunked"
                             or "Content-Length" not in response_headers
                         )
+                        response_size = parse_int(response_headers.get("Content-Length")) if not response_chunked else 0
+                        response_body_too_large = response_size is not None and response_size > MAX_BODY_SIZE
                     elif message["type"] == "http.response.body":
-                        if response_chunked:
+                        if response_chunked and response_size is not None:
                             response_size += len(message.get("body", b""))
-                        if response_status == 400:
+                        if (self.capture_response_body or response_status == 400) and not response_body_too_large:
                             response_body += message.get("body", b"")
+                            if len(response_body) > MAX_BODY_SIZE:
+                                response_body_too_large = True
+                                response_body = b""
                     await send(message)
 
-                await app(scope, receive, send_wrapper)
+                await app(scope, receive_wrapper, send_wrapper)
                 self.add_request(
+                    timestamp=timestamp,
                     request=request,
+                    request_body=request_body if not request_body_too_large else BODY_TOO_LARGE,
+                    request_size=request_size,
                     response_status=response_status,
                     response_time=response_time,
                     response_headers=response_headers,
-                    response_body=response_body,
+                    response_body=response_body if not response_body_too_large else BODY_TOO_LARGE,
                     response_size=response_size,
                 )
             else:
@@ -115,64 +152,95 @@ class ApitallyPlugin(InitPluginProtocol):
 
     def add_request(
         self,
+        timestamp: float,
         request: Request,
+        request_body: bytes,
+        request_size: Optional[int],
         response_status: int,
         response_time: float,
         response_headers: Headers,
         response_body: bytes,
-        response_size: int = 0,
+        response_size: Optional[int],
     ) -> None:
-        if response_status < 100 or not request.route_handler.paths:
+        if response_status < 100:
             return  # pragma: no cover
         path = self.get_path(request)
-        if path is None or self.filter_path(path):
+        if self.filter_path(path):
             return
+
         consumer = self.get_consumer(request)
         consumer_identifier = consumer.identifier if consumer else None
         self.client.consumer_registry.add_or_update_consumer(consumer)
-        self.client.request_counter.add_request(
-            consumer=consumer_identifier,
-            method=request.method,
-            path=path,
-            status_code=response_status,
-            response_time=response_time,
-            request_size=request.headers.get("Content-Length"),
-            response_size=response_size or response_headers.get("Content-Length"),
-        )
-        if response_status == 400 and response_body and len(response_body) < 4096:
-            with contextlib.suppress(json.JSONDecodeError):
-                parsed_body = json.loads(response_body)
-                if (
-                    isinstance(parsed_body, dict)
-                    and "detail" in parsed_body
-                    and isinstance(parsed_body["detail"], str)
-                    and "validation" in parsed_body["detail"].lower()
-                    and "extra" in parsed_body
-                    and isinstance(parsed_body["extra"], list)
-                ):
-                    self.client.validation_error_counter.add_validation_errors(
-                        consumer=consumer_identifier,
-                        method=request.method,
-                        path=path,
-                        detail=[
-                            {
-                                "loc": [error.get("source", "body")] + error["key"].split("."),
-                                "msg": error["message"],
-                                "type": "",
-                            }
-                            for error in parsed_body["extra"]
-                            if "key" in error and "message" in error
-                        ],
-                    )
-        if response_status == 500 and "exception" in request.state:
-            self.client.server_error_counter.add_server_error(
+
+        if path is not None:
+            self.client.request_counter.add_request(
                 consumer=consumer_identifier,
                 method=request.method,
                 path=path,
-                exception=request.state["exception"],
+                status_code=response_status,
+                response_time=response_time,
+                request_size=request_size,
+                response_size=response_size,
+            )
+
+            if response_status == 400 and response_body and len(response_body) < 4096:
+                with contextlib.suppress(json.JSONDecodeError):
+                    parsed_body = json.loads(response_body)
+                    if (
+                        isinstance(parsed_body, dict)
+                        and "detail" in parsed_body
+                        and isinstance(parsed_body["detail"], str)
+                        and "validation" in parsed_body["detail"].lower()
+                        and "extra" in parsed_body
+                        and isinstance(parsed_body["extra"], list)
+                    ):
+                        self.client.validation_error_counter.add_validation_errors(
+                            consumer=consumer_identifier,
+                            method=request.method,
+                            path=path,
+                            detail=[
+                                {
+                                    "loc": [error.get("source", "body")] + error["key"].split("."),
+                                    "msg": error["message"],
+                                    "type": "",
+                                }
+                                for error in parsed_body["extra"]
+                                if "key" in error and "message" in error
+                            ],
+                        )
+
+            if response_status == 500 and "exception" in request.state:
+                self.client.server_error_counter.add_server_error(
+                    consumer=consumer_identifier,
+                    method=request.method,
+                    path=path,
+                    exception=request.state["exception"],
+                )
+
+        if self.client.request_logger.enabled:
+            self.client.request_logger.log_request(
+                request={
+                    "timestamp": timestamp,
+                    "method": request.method,
+                    "path": path,
+                    "url": str(request.url),
+                    "headers": [(k, v) for k, v in request.headers.items()],
+                    "size": request_size,
+                    "consumer": consumer_identifier,
+                    "body": request_body,
+                },
+                response={
+                    "status_code": response_status,
+                    "response_time": response_time,
+                    "headers": [(k, v) for k, v in response_headers.items()],
+                    "size": response_size,
+                    "body": response_body,
+                },
             )
 
     def get_path(self, request: Request) -> Optional[str]:
+        if not request.route_handler.paths:
+            return None
         path: List[str] = []
         for layer in request.route_handler.ownership_layers:
             if isinstance(layer, HTTPRouteHandler):
@@ -183,8 +251,8 @@ class ApitallyPlugin(InitPluginProtocol):
                 path.append(layer.path.lstrip("/"))
         return "/" + "/".join(filter(None, path))
 
-    def filter_path(self, path: str) -> bool:
-        if self.filter_openapi_paths and self.openapi_path:
+    def filter_path(self, path: Optional[str]) -> bool:
+        if path is not None and self.filter_openapi_paths and self.openapi_path:
             return path == self.openapi_path or path.startswith(self.openapi_path + "/")
         return False  # pragma: no cover
 

apitally/starlette.py

@@ -4,7 +4,7 @@ import asyncio
 import contextlib
 import json
 import time
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 from warnings import warn
 
 from httpx import HTTPStatusError
@@ -15,12 +15,17 @@ from starlette.schemas import EndpointInfo, SchemaGenerator
 from starlette.testclient import TestClient
 from starlette.types import ASGIApp, Message, Receive, Scope, Send
 
-from apitally.client.asyncio import ApitallyClient
-from apitally.client.base import Consumer as ApitallyConsumer
-from apitally.common import get_versions
+from apitally.client.client_asyncio import ApitallyClient
+from apitally.client.consumers import Consumer as ApitallyConsumer
+from apitally.client.request_logging import (
+    BODY_TOO_LARGE,
+    MAX_BODY_SIZE,
+    RequestLoggingConfig,
+)
+from apitally.common import get_versions, parse_int
 
 
-__all__ = ["ApitallyMiddleware", "ApitallyConsumer"]
+__all__ = ["ApitallyMiddleware", "ApitallyConsumer", "RequestLoggingConfig"]
 
 
 class ApitallyMiddleware:
@@ -29,20 +34,26 @@ class ApitallyMiddleware:
         app: ASGIApp,
         client_id: str,
         env: str = "dev",
+        request_logging_config: Optional[RequestLoggingConfig] = None,
         app_version: Optional[str] = None,
         openapi_url: Optional[str] = "/openapi.json",
-        filter_unhandled_paths: bool = True,
         identify_consumer_callback: Optional[Callable[[Request], Union[str, ApitallyConsumer, None]]] = None,
     ) -> None:
         self.app = app
-        self.filter_unhandled_paths = filter_unhandled_paths
         self.identify_consumer_callback = identify_consumer_callback
-        self.client = ApitallyClient(client_id=client_id, env=env)
+        self.client = ApitallyClient(client_id=client_id, env=env, request_logging_config=request_logging_config)
         self.client.start_sync_loop()
         self._delayed_set_startup_data_task: Optional[asyncio.Task] = None
         self.delayed_set_startup_data(app_version, openapi_url)
         _register_shutdown_handler(app, self.client.handle_shutdown)
 
+        self.capture_request_body = (
+            self.client.request_logger.config.enabled and self.client.request_logger.config.log_request_body
+        )
+        self.capture_response_body = (
+            self.client.request_logger.config.enabled and self.client.request_logger.config.log_response_body
+        )
+
     def delayed_set_startup_data(self, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> None:
         self._delayed_set_startup_data_task = asyncio.create_task(
             self._delayed_set_startup_data(app_version, openapi_url)
@@ -57,24 +68,40 @@ class ApitallyMiddleware:
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         if scope["type"] == "http" and scope["method"] != "OPTIONS":
+            timestamp = time.time()
             request = Request(scope)
+            request_size = parse_int(request.headers.get("Content-Length"))
+            request_body = b""
+            request_body_too_large = request_size is not None and request_size > MAX_BODY_SIZE
             response_status = 0
             response_time: Optional[float] = None
             response_headers = Headers()
             response_body = b""
-            response_size = 0
+            response_body_too_large = False
+            response_size: Optional[int] = None
             response_chunked = False
             exception: Optional[BaseException] = None
             start_time = time.perf_counter()
 
+            async def receive_wrapper() -> Message:
+                nonlocal request_body, request_body_too_large
+                message = await receive()
+                if message["type"] == "http.request" and self.capture_request_body and not request_body_too_large:
+                    request_body += message.get("body", b"")
+                    if len(request_body) > MAX_BODY_SIZE:
+                        request_body_too_large = True
+                        request_body = b""
+                return message
+
             async def send_wrapper(message: Message) -> None:
                 nonlocal \
                     response_time, \
                     response_status, \
                     response_headers, \
                     response_body, \
-                    response_size, \
-                    response_chunked
+                    response_body_too_large, \
+                    response_chunked, \
+                    response_size
                 if message["type"] == "http.response.start":
                     response_time = time.perf_counter() - start_time
                     response_status = message["status"]
@@ -83,15 +110,20 @@ class ApitallyMiddleware:
                         response_headers.get("Transfer-Encoding") == "chunked"
                         or "Content-Length" not in response_headers
                     )
+                    response_size = parse_int(response_headers.get("Content-Length")) if not response_chunked else 0
+                    response_body_too_large = response_size is not None and response_size > MAX_BODY_SIZE
                 elif message["type"] == "http.response.body":
-                    if response_chunked:
+                    if response_chunked and response_size is not None:
                         response_size += len(message.get("body", b""))
-                    if response_status == 422:
+                    if (self.capture_response_body or response_status == 422) and not response_body_too_large:
                         response_body += message.get("body", b"")
+                        if len(response_body) > MAX_BODY_SIZE:
+                            response_body_too_large = True
+                            response_body = b""
                 await send(message)
 
             try:
-                await self.app(scope, receive, send_wrapper)
+                await self.app(scope, receive_wrapper, send_wrapper)
             except BaseException as e:
                 exception = e
                 raise e from None
@@ -99,11 +131,14 @@ class ApitallyMiddleware:
                 if response_time is None:
                     response_time = time.perf_counter() - start_time
                 self.add_request(
+                    timestamp=timestamp,
                     request=request,
+                    request_body=request_body if not request_body_too_large else BODY_TOO_LARGE,
+                    request_size=request_size,
                     response_status=response_status,
                     response_time=response_time,
                     response_headers=response_headers,
-                    response_body=response_body,
+                    response_body=response_body if not response_body_too_large else BODY_TOO_LARGE,
                     response_size=response_size,
                     exception=exception,
                 )
@@ -112,29 +147,34 @@ class ApitallyMiddleware:
 
     def add_request(
         self,
+        timestamp: float,
         request: Request,
+        request_body: bytes,
+        request_size: Optional[int],
         response_status: int,
         response_time: float,
         response_headers: Headers,
         response_body: bytes,
-        response_size: int = 0,
+        response_size: Optional[int],
         exception: Optional[BaseException] = None,
     ) -> None:
-        path_template, is_handled_path = self.get_path_template(request)
-        if is_handled_path or not self.filter_unhandled_paths:
-            consumer = self.get_consumer(request)
-            consumer_identifier = consumer.identifier if consumer else None
-            self.client.consumer_registry.add_or_update_consumer(consumer)
+        path = self.get_path(request)
+
+        consumer = self.get_consumer(request)
+        consumer_identifier = consumer.identifier if consumer else None
+        self.client.consumer_registry.add_or_update_consumer(consumer)
+
+        if path is not None:
             if response_status == 0 and exception is not None:
                 response_status = 500
             self.client.request_counter.add_request(
                 consumer=consumer_identifier,
                 method=request.method,
-                path=path_template,
+                path=path,
                 status_code=response_status,
                 response_time=response_time,
-                request_size=request.headers.get("Content-Length"),
-                response_size=response_size or response_headers.get("Content-Length"),
+                request_size=request_size,
+                response_size=response_size,
             )
             if response_status == 422 and response_body and response_headers.get("Content-Type") == "application/json":
                 with contextlib.suppress(json.JSONDecodeError):
@@ -144,24 +184,45 @@ class ApitallyMiddleware:
                         self.client.validation_error_counter.add_validation_errors(
                             consumer=consumer_identifier,
                             method=request.method,
-                            path=path_template,
+                            path=path,
                             detail=body["detail"],
                         )
             if response_status == 500 and exception is not None:
                 self.client.server_error_counter.add_server_error(
                     consumer=consumer_identifier,
                     method=request.method,
-                    path=path_template,
+                    path=path,
                     exception=exception,
                 )
 
+        if self.client.request_logger.enabled:
+            self.client.request_logger.log_request(
+                request={
+                    "timestamp": timestamp,
+                    "method": request.method,
+                    "path": path,
+                    "url": str(request.url),
+                    "headers": request.headers.items(),
+                    "size": request_size,
+                    "consumer": consumer_identifier,
+                    "body": request_body,
+                },
+                response={
+                    "status_code": response_status,
+                    "response_time": response_time,
+                    "headers": response_headers.items(),
+                    "size": response_size,
+                    "body": response_body,
+                },
+            )
+
     @staticmethod
-    def get_path_template(request: Request) -> Tuple[str, bool]:
+    def get_path(request: Request) -> Optional[str]:
         for route in request.app.routes:
             match, _ = route.matches(request.scope)
             if match == Match.FULL:
-                return route.path, True
-        return request.url.path, False
+                return route.path
+        return None
 
     def get_consumer(self, request: Request) -> Optional[ApitallyConsumer]:
         if hasattr(request.state, "apitally_consumer") and request.state.apitally_consumer:

{apitally-0.13.0a1.dist-info → apitally-0.14.0rc1.dist-info}/METADATA

@@ -1,34 +1,33 @@
 Metadata-Version: 2.3
 Name: apitally
-Version: 0.13.0a1
+Version: 0.14.0rc1
 Summary: Simple API monitoring & analytics for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
-Project-URL: homepage, https://apitally.io
-Project-URL: documentation, https://docs.apitally.io
-Project-URL: source, https://github.com/apitally/apitally-py
+Project-URL: Homepage, https://apitally.io
+Project-URL: Documentation, https://docs.apitally.io
+Project-URL: Repository, https://github.com/apitally/apitally-py
 Author-email: Apitally <hello@apitally.io>
 License: MIT License
-License-File: LICENSE
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Framework :: Django
 Classifier: Framework :: FastAPI
 Classifier: Framework :: Flask
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Internet
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
 Classifier: Topic :: Software Development
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.8
 Requires-Dist: backoff>=2.0.0

apitally-0.14.0rc1.dist-info/RECORD

@@ -0,0 +1,24 @@
+apitally/__init__.py,sha256=ShXQBVjyiSOHxoQJS2BvNG395W4KZfqMxZWBAR0MZrE,22
+apitally/common.py,sha256=Y8MRuTUHFUeQkcDrCLUxnqIPRpYIiW8S43T0QUab-_A,1267
+apitally/django.py,sha256=2Wg89-NpHGm1Yc25DjtDRVdvW8H3ugSslhxPOQKiXXY,16497
+apitally/django_ninja.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
+apitally/django_rest_framework.py,sha256=-CmrwFFRv7thFOUK_OrOSouhHL9bm5sIBNIQlpyE_2c,166
+apitally/fastapi.py,sha256=IfKfgsmIY8_AtnuMTW2sW4qnkya61CAE2vBoIpcc9tk,169
+apitally/flask.py,sha256=Q-3_nrCPkinZ8QERVoa_jiZaEmZoY43oIdj5UGx2tk4,9170
+apitally/litestar.py,sha256=tEaoqRJJNtbijjyrI3ue82ePhZBUk6A2yuXIjlN5oMQ,12951
+apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/starlette.py,sha256=ooXr9StS8gU3y8mfyrscUdMiPIBfYMxX5Y6LfIMYQgA,12370
+apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/client/client_asyncio.py,sha256=cCCtA8Lf-FOfXCstVZEAT3_0bnwH_dU1xe0YzhfLUYU,6691
+apitally/client/client_base.py,sha256=w5AXAbg3hw5Qds5rovCZFtePB9bHNcJsr9l7kDgbroc,3733
+apitally/client/client_threading.py,sha256=lLtr89LXrD2roDeUORJkx7QeQOPQqt162Vo8bSExPh4,7101
+apitally/client/consumers.py,sha256=w_AFQhVgdtJVt7pVySBvSZwQg-2JVqmD2JQtVBoMkus,2626
+apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
+apitally/client/request_logging.py,sha256=Ar7bqeJbQ8gMbIt3j-wWRBH0E3OhWF0hYwiLyrBJdU0,12548
+apitally/client/requests.py,sha256=RdJyvIqQGVHvS-wjpAPUwcO7byOJ6jO8dYqNTU2Furg,3685
+apitally/client/server_errors.py,sha256=axEhOxqV5SWjk0QCZTLVv2UMIaTfqPc81Typ4DXt66A,4646
+apitally/client/validation_errors.py,sha256=6G8WYWFgJs9VH9swvkPXJGuOJgymj5ooWA9OwjUTbuM,1964
+apitally-0.14.0rc1.dist-info/METADATA,sha256=9LAy2ffwdz6zicCpyqYKct_zso_lCtZokjY0USYMc-E,7580
+apitally-0.14.0rc1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+apitally-0.14.0rc1.dist-info/licenses/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.14.0rc1.dist-info/RECORD,,

{apitally-0.13.0a1.dist-info → apitally-0.14.0rc1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any