apitally 0.6.3__py3-none-any.whl → 0.7.1__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.6.3"
+__version__ = "0.7.1"

apitally/common.py

@@ -0,0 +1,31 @@
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from typing import Dict, Optional
+
+
+def get_versions(*packages, app_version: Optional[str] = None) -> Dict[str, str]:
+    versions = _get_common_package_versions()
+    for package in packages:
+        versions[package] = _get_package_version(package)
+    if app_version:
+        versions["app"] = app_version
+    return {n: v for n, v in versions.items() if v is not None}
+
+
+def _get_common_package_versions() -> Dict[str, Optional[str]]:
+    return {
+        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
+        "apitally": _get_package_version("apitally"),
+        "uvicorn": _get_package_version("uvicorn"),
+        "hypercorn": _get_package_version("hypercorn"),
+        "daphne": _get_package_version("daphne"),
+        "gunicorn": _get_package_version("gunicorn"),
+        "uwsgi": _get_package_version("uwsgi"),
+    }
+
+
+def _get_package_version(name: str) -> Optional[str]:
+    try:
+        return version(name)
+    except PackageNotFoundError:
+        return None

apitally/django.py

@@ -1,26 +1,29 @@
 from __future__ import annotations
 
+import contextlib
 import json
-import sys
+import re
 import time
 from dataclasses import dataclass
-from importlib.metadata import PackageNotFoundError, version
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+from importlib import import_module
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Union
 
 from django.conf import settings
-from django.core.exceptions import ViewDoesNotExist
-from django.test import RequestFactory
-from django.urls import Resolver404, URLPattern, URLResolver, get_resolver, resolve
+from django.urls import URLPattern, URLResolver, get_resolver
 from django.utils.module_loading import import_string
 
+from apitally.client.logging import get_logger
 from apitally.client.threading import ApitallyClient
+from apitally.common import get_versions
 
 
 if TYPE_CHECKING:
     from django.http import HttpRequest, HttpResponse
+    from ninja import NinjaAPI
 
 
 __all__ = ["ApitallyMiddleware"]
+logger = get_logger(__name__)
 
 
 @dataclass
@@ -28,8 +31,8 @@ class ApitallyMiddlewareConfig:
     client_id: str
     env: str
     app_version: Optional[str]
-    openapi_url: Optional[str]
     identify_consumer_callback: Optional[Callable[[HttpRequest], Optional[str]]]
+    urlconfs: List[Optional[str]]
 
 
 class ApitallyMiddleware:
@@ -37,21 +40,31 @@ class ApitallyMiddleware:
 
     def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
         self.get_response = get_response
+        self.drf_available = _check_import("rest_framework")
+        self.drf_endpoint_enumerator = None
+        self.ninja_available = _check_import("ninja")
+        self.callbacks = set()
+
         if self.config is None:
             config = getattr(settings, "APITALLY_MIDDLEWARE", {})
             self.configure(**config)
             assert self.config is not None
-        views = _extract_views_from_url_patterns(get_resolver().url_patterns)
-        self.view_lookup = {
-            view.pattern: view for view in reversed(_extract_views_from_url_patterns(get_resolver().url_patterns))
-        }
+
+        if self.drf_available:
+            from rest_framework.schemas.generators import EndpointEnumerator
+
+            self.drf_endpoint_enumerator = EndpointEnumerator()
+            if None not in self.config.urlconfs:
+                self.callbacks.update(_get_drf_callbacks(self.config.urlconfs))
+        if self.ninja_available and None not in self.config.urlconfs:
+            self.callbacks.update(_get_ninja_callbacks(self.config.urlconfs))
+
         self.client = ApitallyClient(client_id=self.config.client_id, env=self.config.env)
         self.client.start_sync_loop()
         self.client.set_app_info(
             app_info=_get_app_info(
-                views=views,
                 app_version=self.config.app_version,
-                openapi_url=self.config.openapi_url,
+                urlconfs=self.config.urlconfs,
             )
         )
 
@@ -61,212 +74,236 @@ class ApitallyMiddleware:
         client_id: str,
         env: str = "dev",
         app_version: Optional[str] = None,
-        openapi_url: Optional[str] = None,
         identify_consumer_callback: Optional[str] = None,
+        urlconf: Optional[Union[List[Optional[str]], str]] = None,
     ) -> None:
         cls.config = ApitallyMiddlewareConfig(
             client_id=client_id,
             env=env,
             app_version=app_version,
-            openapi_url=openapi_url,
             identify_consumer_callback=import_string(identify_consumer_callback)
             if identify_consumer_callback
             else None,
+            urlconfs=[urlconf] if urlconf is None or isinstance(urlconf, str) else urlconf,
         )
 
     def __call__(self, request: HttpRequest) -> HttpResponse:
-        view = self.get_view(request)
         start_time = time.perf_counter()
         response = self.get_response(request)
-        if request.method is not None and view is not None and view.is_api_view:
+        response_time = time.perf_counter() - start_time
+        path = self.get_path(request)
+        if request.method is not None and path is not None:
             consumer = self.get_consumer(request)
-            self.client.request_counter.add_request(
-                consumer=consumer,
-                method=request.method,
-                path=view.pattern,
-                status_code=response.status_code,
-                response_time=time.perf_counter() - start_time,
-                request_size=request.headers.get("Content-Length"),
-                response_size=response["Content-Length"]
-                if response.has_header("Content-Length")
-                else (len(response.content) if not response.streaming else None),
-            )
+            try:
+                self.client.request_counter.add_request(
+                    consumer=consumer,
+                    method=request.method,
+                    path=path,
+                    status_code=response.status_code,
+                    response_time=response_time,
+                    request_size=request.headers.get("Content-Length"),
+                    response_size=response["Content-Length"]
+                    if response.has_header("Content-Length")
+                    else (len(response.content) if not response.streaming else None),
+                )
+            except Exception:  # pragma: no cover
+                logger.exception("Failed to log request metadata")
             if (
                 response.status_code == 422
                 and (content_type := response.get("Content-Type")) is not None
                 and content_type.startswith("application/json")
             ):
                 try:
-                    body = json.loads(response.content)
-                    if isinstance(body, dict) and "detail" in body and isinstance(body["detail"], list):
-                        # Log Django Ninja / Pydantic validation errors
-                        self.client.validation_error_counter.add_validation_errors(
-                            consumer=consumer,
-                            method=request.method,
-                            path=view.pattern,
-                            detail=body["detail"],
-                        )
-                except json.JSONDecodeError:  # pragma: no cover
-                    pass
+                    with contextlib.suppress(json.JSONDecodeError):
+                        body = json.loads(response.content)
+                        if isinstance(body, dict) and "detail" in body and isinstance(body["detail"], list):
+                            # Log Django Ninja / Pydantic validation errors
+                            self.client.validation_error_counter.add_validation_errors(
+                                consumer=consumer,
+                                method=request.method,
+                                path=path,
+                                detail=body["detail"],
+                            )
+                except Exception:  # pragma: no cover
+                    logger.exception("Failed to log validation errors")
         return response
 
-    def get_view(self, request: HttpRequest) -> Optional[DjangoViewInfo]:
-        try:
-            resolver_match = resolve(request.path_info)
-            return self.view_lookup.get(resolver_match.route)
-        except Resolver404:  # pragma: no cover
-            return None
+    def get_path(self, request: HttpRequest) -> Optional[str]:
+        if (match := request.resolver_match) is not None:
+            try:
+                if self.callbacks and match.func not in self.callbacks:
+                    return None
+                if self.drf_endpoint_enumerator is not None:
+                    from rest_framework.schemas.generators import is_api_view
+
+                    if is_api_view(match.func):
+                        return self.drf_endpoint_enumerator.get_path_from_regex(match.route)
+                if self.ninja_available:
+                    from ninja.operation import PathView
+
+                    if hasattr(match.func, "__self__") and isinstance(match.func.__self__, PathView):
+                        path = "/" + match.route.lstrip("/")
+                        return re.sub(r"<(?:[^:]+:)?([^>:]+)>", r"{\1}", path)
+            except Exception:  # pragma: no cover
+                logger.exception("Failed to get path for request")
+        return None
 
     def get_consumer(self, request: HttpRequest) -> Optional[str]:
-        if hasattr(request, "consumer_identifier"):
-            return str(request.consumer_identifier)
-        if self.config is not None and self.config.identify_consumer_callback is not None:
-            consumer_identifier = self.config.identify_consumer_callback(request)
-            if consumer_identifier is not None:
-                return str(consumer_identifier)
+        try:
+            if hasattr(request, "consumer_identifier"):
+                return str(request.consumer_identifier)
+            if self.config is not None and self.config.identify_consumer_callback is not None:
+                consumer_identifier = self.config.identify_consumer_callback(request)
+                if consumer_identifier is not None:
+                    return str(consumer_identifier)
+        except Exception:  # pragma: no cover
+            logger.exception("Failed to get consumer identifier for request")
         return None
 
 
-@dataclass
-class DjangoViewInfo:
-    func: Callable
-    pattern: str
-    name: Optional[str] = None
-
-    @property
-    def is_api_view(self) -> bool:
-        return self.is_rest_framework_api_view or self.is_ninja_path_view
-
-    @property
-    def is_rest_framework_api_view(self) -> bool:
-        try:
-            from rest_framework.views import APIView
-
-            return hasattr(self.func, "view_class") and issubclass(self.func.view_class, APIView)
-        except ImportError:  # pragma: no cover
-            return False
+def _get_app_info(app_version: Optional[str], urlconfs: List[Optional[str]]) -> Dict[str, Any]:
+    app_info: Dict[str, Any] = {}
+    try:
+        app_info["paths"] = _get_paths(urlconfs)
+    except Exception:  # pragma: no cover
+        app_info["paths"] = []
+        logger.exception("Failed to get paths")
+    try:
+        app_info["openapi"] = _get_openapi(urlconfs)
+    except Exception:  # pragma: no cover
+        logger.exception("Failed to get OpenAPI schema")
+    app_info["versions"] = get_versions("django", "djangorestframework", "django-ninja", app_version=app_version)
+    app_info["client"] = "python:django"
+    return app_info
 
-    @property
-    def is_ninja_path_view(self) -> bool:
-        try:
-            from ninja.operation import PathView
 
-            return hasattr(self.func, "__self__") and isinstance(self.func.__self__, PathView)
-        except ImportError:  # pragma: no cover
-            return False
+def _get_openapi(urlconfs: List[Optional[str]]) -> Optional[str]:
+    drf_schema = None
+    ninja_schema = None
+    with contextlib.suppress(ImportError):
+        drf_schema = _get_drf_schema(urlconfs)
+    with contextlib.suppress(ImportError):
+        ninja_schema = _get_ninja_schema(urlconfs)
+    if drf_schema is not None and ninja_schema is None:
+        return json.dumps(drf_schema)
+    elif ninja_schema is not None and drf_schema is None:
+        return json.dumps(ninja_schema)
+    return None  # pragma: no cover
 
-    @property
-    def allowed_methods(self) -> List[str]:
-        if hasattr(self.func, "view_class"):
-            return [method.upper() for method in self.func.view_class().allowed_methods]
-        if self.is_ninja_path_view:
-            assert hasattr(self.func, "__self__")
-            return [method.upper() for operation in self.func.__self__.operations for method in operation.methods]
-        return []  # pragma: no cover
 
+def _get_paths(urlconfs: List[Optional[str]]) -> List[Dict[str, str]]:
+    paths = []
+    with contextlib.suppress(ImportError):
+        paths.extend(_get_drf_paths(urlconfs))
+    with contextlib.suppress(ImportError):
+        paths.extend(_get_ninja_paths(urlconfs))
+    return paths
 
-def _get_app_info(
-    views: List[DjangoViewInfo], app_version: Optional[str] = None, openapi_url: Optional[str] = None
-) -> Dict[str, Any]:
-    app_info: Dict[str, Any] = {}
-    if openapi := _get_openapi(views, openapi_url):
-        app_info["openapi"] = openapi
-    app_info["paths"] = _get_paths(views)
-    app_info["versions"] = _get_versions(app_version)
-    app_info["client"] = "python:django"
-    return app_info
 
+def _get_drf_paths(urlconfs: List[Optional[str]]) -> List[Dict[str, str]]:
+    from rest_framework.schemas.generators import EndpointEnumerator
 
-def _get_paths(views: List[DjangoViewInfo]) -> List[Dict[str, str]]:
+    enumerators = [EndpointEnumerator(urlconf=urlconf) for urlconf in urlconfs]
     return [
-        {"method": method, "path": view.pattern}
-        for view in views
-        if view.is_api_view
-        for method in view.allowed_methods
+        {
+            "method": method.upper(),
+            "path": path,
+        }
+        for enumerator in enumerators
+        for path, method, _ in enumerator.get_api_endpoints()
         if method not in ["HEAD", "OPTIONS"]
     ]
 
 
-def _get_openapi(views: List[DjangoViewInfo], openapi_url: Optional[str] = None) -> Optional[str]:
-    openapi_views = [
-        view
-        for view in views
-        if (openapi_url is not None and view.pattern == openapi_url.removeprefix("/"))
-        or (openapi_url is None and view.pattern.endswith("openapi.json") and "<" not in view.pattern)
-    ]
-    if len(openapi_views) == 1:
-        rf = RequestFactory()
-        request = rf.get(openapi_views[0].pattern)
-        response = openapi_views[0].func(request)
-        if response.status_code == 200:
-            return response.content.decode()
-    return None
-
-
-def _extract_views_from_url_patterns(
-    url_patterns: List[Any], base: str = "", namespace: Optional[str] = None
-) -> List[DjangoViewInfo]:
-    # Copied and adapted from django-extensions.
-    # See https://github.com/django-extensions/django-extensions/blob/dd794f1b239d657f62d40f2c3178200978328ed7/django_extensions/management/commands/show_urls.py#L190C34-L190C34
-    views = []
-    for p in url_patterns:
-        if isinstance(p, URLPattern):
-            try:
-                if not p.name:
-                    name = p.name
-                elif namespace:
-                    name = f"{namespace}:{p.name}"
-                else:
-                    name = p.name
-                views.append(DjangoViewInfo(func=p.callback, pattern=base + str(p.pattern), name=name))
-            except ViewDoesNotExist:
-                continue
-        elif isinstance(p, URLResolver):
-            try:
-                patterns = p.url_patterns
-            except ImportError:
-                continue
-            views.extend(
-                _extract_views_from_url_patterns(
-                    patterns,
-                    base + str(p.pattern),
-                    namespace=f"{namespace}:{p.namespace}" if namespace and p.namespace else p.namespace or namespace,
-                )
-            )
-        elif hasattr(p, "_get_callback"):
-            try:
-                views.append(DjangoViewInfo(func=p._get_callback(), pattern=base + str(p.pattern), name=p.name))
-            except ViewDoesNotExist:
-                continue
-        elif hasattr(p, "url_patterns"):
-            try:
-                patterns = p.url_patterns
-            except ImportError:
-                continue
-            views.extend(
-                _extract_views_from_url_patterns(
-                    patterns,
-                    base + str(p.pattern),
-                    namespace=namespace,
-                )
-            )
-    return views
+def _get_drf_callbacks(urlconfs: List[Optional[str]]) -> Set[Callable]:
+    from rest_framework.schemas.generators import EndpointEnumerator
+
+    enumerators = [EndpointEnumerator(urlconf=urlconf) for urlconf in urlconfs]
+    return {callback for enumerator in enumerators for _, _, callback in enumerator.get_api_endpoints()}
+
+
+def _get_drf_schema(urlconfs: List[Optional[str]]) -> Optional[Dict[str, Any]]:
+    from rest_framework.schemas.openapi import SchemaGenerator
+
+    schemas = []
+    with contextlib.suppress(AssertionError):  # uritemplate and inflection must be installed for OpenAPI schema support
+        for urlconf in urlconfs:
+            generator = SchemaGenerator(urlconf=urlconf)
+            schema = generator.get_schema()
+            if schema is not None and len(schema["paths"]) > 0:
+                schemas.append(schema)
+    return None if len(schemas) != 1 else schemas[0]  # type: ignore[return-value]
+
+
+def _get_ninja_paths(urlconfs: List[Optional[str]]) -> List[Dict[str, str]]:
+    endpoints = []
+    for api in _get_ninja_api_instances(urlconfs=urlconfs):
+        schema = api.get_openapi_schema()
+        for path, operations in schema["paths"].items():
+            for method, operation in operations.items():
+                if method not in ["HEAD", "OPTIONS"]:
+                    endpoints.append(
+                        {
+                            "method": method,
+                            "path": path,
+                            "summary": operation.get("summary"),
+                            "description": operation.get("description"),
+                        }
+                    )
+    return endpoints
+
+
+def _get_ninja_callbacks(urlconfs: List[Optional[str]]) -> Set[Callable]:
+    return {
+        path_view.get_view()
+        for api in _get_ninja_api_instances(urlconfs=urlconfs)
+        for _, router in api._routers
+        for path_view in router.path_operations.values()
+    }
 
 
-def _get_versions(app_version: Optional[str]) -> Dict[str, str]:
-    versions = {
-        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        "apitally": version("apitally"),
-        "django": version("django"),
-    }
-    try:
-        versions["djangorestframework"] = version("djangorestframework")
-    except PackageNotFoundError:  # pragma: no cover
-        pass
+def _get_ninja_schema(urlconfs: List[Optional[str]]) -> Optional[Dict[str, Any]]:
+    schemas = []
+    for api in _get_ninja_api_instances(urlconfs=urlconfs):
+        schema = api.get_openapi_schema()
+        if len(schema["paths"]) > 0:
+            schemas.append(schema)
+    return None if len(schemas) != 1 else schemas[0]
+
+
+def _get_ninja_api_instances(
+    urlconfs: Optional[List[Optional[str]]] = None,
+    patterns: Optional[List[Any]] = None,
+) -> Set[NinjaAPI]:
+    from ninja import NinjaAPI
+
+    if urlconfs is None:
+        urlconfs = [None]
+    if patterns is None:
+        patterns = []
+        for urlconf in urlconfs:
+            patterns.extend(get_resolver(urlconf).url_patterns)
+
+    apis: Set[NinjaAPI] = set()
+    for p in patterns:
+        if isinstance(p, URLResolver):
+            if p.app_name != "ninja":
+                apis.update(_get_ninja_api_instances(patterns=p.url_patterns))
+            else:
+                for pattern in p.url_patterns:
+                    if isinstance(pattern, URLPattern) and pattern.lookup_str.startswith("ninja."):
+                        callback_keywords = getattr(pattern.callback, "keywords", {})
+                        if isinstance(callback_keywords, dict):
+                            api = callback_keywords.get("api")
+                            if isinstance(api, NinjaAPI):
+                                apis.add(api)
+                                break
+    return apis
+
+
+def _check_import(name: str) -> bool:
     try:
-        versions["django-ninja"] = version("django-ninja")
-    except PackageNotFoundError:  # pragma: no cover
-        pass
-    if app_version:
-        versions["app"] = app_version
-    return versions
+        import_module(name)
+        return True
+    except ImportError:
+        return False

apitally/flask.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import sys
 import time
-from importlib.metadata import version
 from threading import Timer
 from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple
 
@@ -12,6 +10,7 @@ from werkzeug.exceptions import NotFound
 from werkzeug.test import Client
 
 from apitally.client.threading import ApitallyClient
+from apitally.common import get_versions
 
 
 if TYPE_CHECKING:
@@ -103,7 +102,7 @@ def _get_app_info(app: Flask, app_version: Optional[str] = None, openapi_url: Op
         app_info["openapi"] = openapi
     if paths := _get_paths(app.url_map):
         app_info["paths"] = paths
-    app_info["versions"] = _get_versions(app_version)
+    app_info["versions"] = get_versions("flask", app_version=app_version)
     app_info["client"] = "python:flask"
     return app_info
 
@@ -124,14 +123,3 @@ def _get_openapi(app: WSGIApplication, openapi_url: str) -> Optional[str]:
     if response.status_code != 200:
         return None
     return response.get_data(as_text=True)
-
-
-def _get_versions(app_version: Optional[str]) -> Dict[str, str]:
-    versions = {
-        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        "apitally": version("apitally"),
-        "flask": version("flask"),
-    }
-    if app_version:
-        versions["app"] = app_version
-    return versions

apitally/litestar.py

@@ -1,8 +1,6 @@
 import contextlib
 import json
-import sys
 import time
-from importlib.metadata import version
 from typing import Callable, Dict, List, Optional
 
 from litestar.app import DEFAULT_OPENAPI_CONFIG, Litestar
@@ -15,6 +13,7 @@ from litestar.plugins import InitPluginProtocol
 from litestar.types import ASGIApp, Message, Receive, Scope, Send
 
 from apitally.client.asyncio import ApitallyClient
+from apitally.common import get_versions
 
 
 __all__ = ["ApitallyPlugin"]
@@ -48,7 +47,7 @@ class ApitallyPlugin(InitPluginProtocol):
         app_info = {
             "openapi": _get_openapi(app),
             "paths": [route for route in _get_routes(app) if not self.filter_path(route["path"])],
-            "versions": _get_versions(self.app_version),
+            "versions": get_versions("litestar", app_version=self.app_version),
             "client": "python:litestar",
         }
         self.client.set_app_info(app_info)
@@ -174,14 +173,3 @@ def _get_routes(app: Litestar) -> List[Dict[str, str]]:
         for method in route.methods
         if route.scope_type == ScopeType.HTTP and method != "OPTIONS"
     ]
-
-
-def _get_versions(app_version: Optional[str]) -> Dict[str, str]:
-    versions = {
-        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        "apitally": version("apitally"),
-        "litestar": version("litestar"),
-    }
-    if app_version:
-        versions["app"] = app_version
-    return versions

apitally/starlette.py

@@ -2,9 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import json
-import sys
 import time
-from importlib.metadata import PackageNotFoundError, version
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
 
 from httpx import HTTPStatusError
@@ -17,6 +15,7 @@ from starlette.testclient import TestClient
 from starlette.types import ASGIApp
 
 from apitally.client.asyncio import ApitallyClient
+from apitally.common import get_versions
 
 
 if TYPE_CHECKING:
@@ -145,7 +144,7 @@ def _get_app_info(app: ASGIApp, app_version: Optional[str] = None, openapi_url:
         app_info["openapi"] = openapi
     if endpoints := _get_endpoint_info(app):
         app_info["paths"] = [{"path": endpoint.path, "method": endpoint.http_method} for endpoint in endpoints]
-    app_info["versions"] = _get_versions(app_version)
+    app_info["versions"] = get_versions("fastapi", "starlette", app_version=app_version)
     app_info["client"] = "python:starlette"
     return app_info
 
@@ -179,18 +178,3 @@ def _register_shutdown_handler(app: Union[ASGIApp, Router], shutdown_handler: Ca
         app.add_event_handler("shutdown", shutdown_handler)
     elif hasattr(app, "app"):
         _register_shutdown_handler(app.app, shutdown_handler)
-
-
-def _get_versions(app_version: Optional[str]) -> Dict[str, str]:
-    versions = {
-        "python": f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        "apitally": version("apitally"),
-        "starlette": version("starlette"),
-    }
-    try:
-        versions["fastapi"] = version("fastapi")
-    except PackageNotFoundError:  # pragma: no cover
-        pass
-    if app_version:
-        versions["app"] = app_version
-    return versions

{apitally-0.6.3.dist-info → apitally-0.7.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.6.3
-Summary: API monitoring for REST APIs built with FastAPI, Flask, Django, and Starlette.
+Version: 0.7.1
+Summary: API monitoring for REST APIs built with FastAPI, Flask, Django, Starlette and Litestar.
 Home-page: https://apitally.io
 License: MIT
 Author: Apitally
@@ -21,7 +21,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
 Classifier: Typing :: Typed
-Provides-Extra: django
 Provides-Extra: django-ninja
 Provides-Extra: django-rest-framework
 Provides-Extra: fastapi
@@ -29,15 +28,17 @@ Provides-Extra: flask
 Provides-Extra: litestar
 Provides-Extra: starlette
 Requires-Dist: backoff (>=2.0.0)
-Requires-Dist: django (>=2.2) ; extra == "django" or extra == "django-ninja" or extra == "django-rest-framework"
+Requires-Dist: django (>=2.2) ; extra == "django-ninja" or extra == "django-rest-framework"
 Requires-Dist: django-ninja (>=0.18.0) ; extra == "django-ninja"
 Requires-Dist: djangorestframework (>=3.10.0) ; extra == "django-rest-framework"
 Requires-Dist: fastapi (>=0.87.0) ; extra == "fastapi"
 Requires-Dist: flask (>=2.0.0) ; extra == "flask"
 Requires-Dist: httpx (>=0.22.0) ; extra == "fastapi" or extra == "litestar" or extra == "starlette"
+Requires-Dist: inflection (>=0.5.1) ; extra == "django-rest-framework"
 Requires-Dist: litestar (>=2.0.0) ; extra == "litestar"
-Requires-Dist: requests (>=2.26.0) ; extra == "django" or extra == "django-ninja" or extra == "django-rest-framework" or extra == "flask"
+Requires-Dist: requests (>=2.26.0) ; extra == "django-ninja" or extra == "django-rest-framework" or extra == "flask"
 Requires-Dist: starlette (>=0.21.0,<1.0.0) ; extra == "fastapi" or extra == "starlette"
+Requires-Dist: uritemplate (>=3.0.0) ; extra == "django-rest-framework"
 Project-URL: Documentation, https://docs.apitally.io
 Project-URL: Repository, https://github.com/apitally/python-client
 Description-Content-Type: text/markdown
@@ -52,7 +53,7 @@ Description-Content-Type: text/markdown
 
 <p align="center"><b>API monitoring made easy.</b></p>
 
-<p align="center"><i>Apitally is a simple and affordable API monitoring solution with a focus on data privacy. It is easy to set up and use for new and existing API projects using Python or Node.js.</i></p>
+<p align="center"><i>Apitally is a simple and affordable API monitoring tool with a focus on data privacy.<br>It is super easy to use for API projects in Python or Node.js and never collects sensitive data.</i></p>
 
 <p align="center">🔗 <b><a href="https://apitally.io" target="_blank">apitally.io</a></b></p>
 
@@ -95,8 +96,8 @@ example:
 pip install apitally[fastapi]
 ```
 
-The available extras are: `fastapi`, `starlette`, `flask`, `django` and
-`litestar`.
+The available extras are: `fastapi`, `flask`, `django_rest_framework`,
+`django_ninja`, `starlette` and `litestar`.
 
 ## Usage
 

{apitally-0.6.3.dist-info → apitally-0.7.1.dist-info}/RECORD

@@ -1,18 +1,19 @@
-apitally/__init__.py,sha256=zYiFHqR7JwbvdK9dvKrh-RTNfUqjHUwC4CTcFAPVYLc,22
+apitally/__init__.py,sha256=2KJZDSMOG7KS82AxYOrZ4ZihYxX0wjfUjDsIZh3L024,22
 apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apitally/client/asyncio.py,sha256=uR5JlH37G6gZvAJ7A1gYOGkjn3zjC-4I6avA1fncXHs,4433
 apitally/client/base.py,sha256=E_yUTItAtZWPOx80K3Pm55CNBgF_NZ6RMyXZTnjSV9c,8511
 apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
 apitally/client/threading.py,sha256=ihQzUStrSQFynpqXgFpseAXrHuc5Et1QvG-YHlzqDr8,4831
-apitally/django.py,sha256=PTKRWd--vJucgHPs2XDixIAQkqzOfjToipZfZBbIlNA,10081
+apitally/common.py,sha256=GbVmnXxhRvV30d7CfCQ9r0AeXj14Mv9Jm_Yd1bRWP28,1088
+apitally/django.py,sha256=SHSM00eRsvoJC2d4c4tK6gctKLnxLfrw4LoZ4CWPm4U,12124
 apitally/django_ninja.py,sha256=iMvZd7j04nbOLpJgYxs7tpbsyXlZuhmHjcswXMvyUlU,82
 apitally/django_rest_framework.py,sha256=iMvZd7j04nbOLpJgYxs7tpbsyXlZuhmHjcswXMvyUlU,82
 apitally/fastapi.py,sha256=Q3n2bVREKQ_V_2yCQ48ngPtr-NJxDskpT_l20xhSbpM,85
-apitally/flask.py,sha256=-R0MP72ufO3v0p30JBU9asODWtuOU3FOCl5iY-kTSzw,5099
-apitally/litestar.py,sha256=rOQE0gsqDifwZUw_SGMBB1KIV0oAh3ydiJWnpTTC2sI,7504
+apitally/flask.py,sha256=xxyrHchMiPuEMP3c_Us_niJn9K7x87RDvxD5GtntEvU,4769
+apitally/litestar.py,sha256=Pl1tEbxve3vqrdflWdvZjPFrEVxNIr6NjuQVf4YSpzY,7171
 apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=VlLWOR9rzNlI9IjFbQ86APaWanURerIt52tX6bRGzCo,7814
-apitally-0.6.3.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.6.3.dist-info/METADATA,sha256=GvqjHhr__OPd3vV06AvjIbMPYHMPBmZWtA2dx45_-b4,6610
-apitally-0.6.3.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.6.3.dist-info/RECORD,,
+apitally/starlette.py,sha256=9VKGdNuKPrRcnQv7GeyV5cLa7TpgidxMVnAKSxMsWjI,7345
+apitally-0.7.1.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.7.1.dist-info/METADATA,sha256=SO16kB-1EwZGAm28P4m4E2EMltFfmKUy4uF44X4LB30,6736
+apitally-0.7.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.7.1.dist-info/RECORD,,