apitally 0.4.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

apitally/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.1"
+__version__ = "0.6.0"

apitally/client/asyncio.py

@@ -2,20 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import sys
 import time
 from functools import partial
-from typing import Any, Dict, Optional, Tuple, Type
+from typing import Any, Dict, Optional, Tuple
 
 import backoff
 import httpx
 
-from apitally.client.base import (
-    MAX_QUEUE_TIME,
-    REQUEST_TIMEOUT,
-    ApitallyClientBase,
-    ApitallyKeyCacheBase,
-)
+from apitally.client.base import MAX_QUEUE_TIME, REQUEST_TIMEOUT, ApitallyClientBase
 from apitally.client.logging import get_logger
 
 
@@ -31,19 +25,8 @@ retry = partial(
 
 
 class ApitallyClient(ApitallyClientBase):
-    def __init__(
-        self,
-        client_id: str,
-        env: str,
-        sync_api_keys: bool = False,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
-    ) -> None:
-        super().__init__(
-            client_id=client_id,
-            env=env,
-            sync_api_keys=sync_api_keys,
-            key_cache_class=key_cache_class,
-        )
+    def __init__(self, client_id: str, env: str) -> None:
+        super().__init__(client_id=client_id, env=env)
         self._stop_sync_loop = False
         self._sync_loop_task: Optional[asyncio.Task[Any]] = None
         self._requests_data_queue: asyncio.Queue[Tuple[float, Dict[str, Any]]] = asyncio.Queue()
@@ -62,8 +45,6 @@ class ApitallyClient(ApitallyClientBase):
                 time_start = time.perf_counter()
                 async with self.get_http_client() as client:
                     tasks = [self.send_requests_data(client)]
-                    if self.sync_api_keys:
-                        tasks.append(self.get_keys(client))
                     if not self._app_info_sent and not first_iteration:
                         tasks.append(self.send_app_info(client))
                     await asyncio.gather(*tasks)
@@ -113,24 +94,11 @@ class ApitallyClient(ApitallyClientBase):
         for item in failed_items:
             self._requests_data_queue.put_nowait(item)
 
-    async def get_keys(self, client: httpx.AsyncClient) -> None:
-        if response_data := await self._get_keys(client):  # Response data can be None if backoff gives up
-            self.handle_keys_response(response_data)
-            self._keys_updated_at = time.time()
-        elif self.key_registry.salt is None:  # pragma: no cover
-            logger.critical("Initial Apitally API key sync failed")
-            # Exit because the application will not be able to authenticate requests
-            sys.exit(1)
-        elif (self._keys_updated_at is not None and time.time() - self._keys_updated_at > MAX_QUEUE_TIME) or (
-            self._keys_updated_at is None and time.time() - self._started_at > MAX_QUEUE_TIME
-        ):
-            logger.error("Apitally API key sync has been failing for more than 1 hour")
-
     @retry(raise_on_giveup=False)
     async def _send_app_info(self, client: httpx.AsyncClient, payload: Dict[str, Any]) -> None:
         logger.debug("Sending app info")
         response = await client.post(url="/info", json=payload, timeout=REQUEST_TIMEOUT)
-        if response.status_code == 404 and "Client ID" in response.text:
+        if response.status_code == 404:
             self.stop_sync_loop()
             logger.error(f"Invalid Apitally client ID {self.client_id}")
         else:
@@ -143,10 +111,3 @@ class ApitallyClient(ApitallyClientBase):
         logger.debug("Sending requests data")
         response = await client.post(url="/requests", json=payload)
         response.raise_for_status()
-
-    @retry(raise_on_giveup=False)
-    async def _get_keys(self, client: httpx.AsyncClient) -> Dict[str, Any]:
-        logger.debug("Updating API keys")
-        response = await client.get(url="/keys")
-        response.raise_for_status()
-        return response.json()

apitally/client/base.py

@@ -1,17 +1,14 @@
 from __future__ import annotations
 
-import json
 import os
 import re
 import threading
 import time
-from abc import ABC, abstractmethod
+from abc import ABC
 from collections import Counter
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from hashlib import scrypt
+from dataclasses import dataclass
 from math import floor
-from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union, cast
+from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, cast
 from uuid import UUID, uuid4
 
 from apitally.client.logging import get_logger
@@ -30,24 +27,18 @@ INITIAL_SYNC_INTERVAL_DURATION = 3600
 TApitallyClient = TypeVar("TApitallyClient", bound="ApitallyClientBase")
 
 
-class ApitallyClientBase:
+class ApitallyClientBase(ABC):
     _instance: Optional[ApitallyClientBase] = None
     _lock = threading.Lock()
 
-    def __new__(cls, *args, **kwargs) -> ApitallyClientBase:
+    def __new__(cls: Type[TApitallyClient], *args, **kwargs) -> TApitallyClient:
         if cls._instance is None:
             with cls._lock:
                 if cls._instance is None:
                     cls._instance = super().__new__(cls)
-        return cls._instance
+        return cast(TApitallyClient, cls._instance)
 
-    def __init__(
-        self,
-        client_id: str,
-        env: str,
-        sync_api_keys: bool = False,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
-    ) -> None:
+    def __init__(self, client_id: str, env: str) -> None:
         if hasattr(self, "client_id"):
             raise RuntimeError("Apitally client is already initialized")  # pragma: no cover
         try:
@@ -59,23 +50,13 @@ class ApitallyClientBase:
 
         self.client_id = client_id
         self.env = env
-        self.sync_api_keys = sync_api_keys
         self.instance_uuid = str(uuid4())
         self.request_counter = RequestCounter()
         self.validation_error_counter = ValidationErrorCounter()
-        self.key_registry = KeyRegistry()
-        self.key_cache = key_cache_class(client_id=client_id, env=env) if key_cache_class is not None else None
 
         self._app_info_payload: Optional[Dict[str, Any]] = None
         self._app_info_sent = False
         self._started_at = time.time()
-        self._keys_updated_at: Optional[float] = None
-
-        if self.key_cache is not None and (key_data := self.key_cache.retrieve()):
-            try:
-                self.handle_keys_response(json.loads(key_data), cache=False)
-            except (json.JSONDecodeError, TypeError, KeyError):  # pragma: no cover
-                logger.exception("Failed to load API keys from cache")
 
     @classmethod
     def get_instance(cls: Type[TApitallyClient]) -> TApitallyClient:
@@ -104,42 +85,13 @@ class ApitallyClientBase:
     def get_requests_payload(self) -> Dict[str, Any]:
         requests = self.request_counter.get_and_reset_requests()
         validation_errors = self.validation_error_counter.get_and_reset_validation_errors()
-        api_key_usage = self.key_registry.get_and_reset_usage_counts() if self.sync_api_keys else {}
         return {
             "instance_uuid": self.instance_uuid,
             "message_uuid": str(uuid4()),
             "requests": requests,
             "validation_errors": validation_errors,
-            "api_key_usage": api_key_usage,
         }
 
-    def handle_keys_response(self, response_data: Dict[str, Any], cache: bool = True) -> None:
-        self.key_registry.salt = response_data["salt"]
-        self.key_registry.update(response_data["keys"])
-
-        if cache and self.key_cache is not None:
-            self.key_cache.store(json.dumps(response_data, check_circular=False, allow_nan=False))
-
-
-class ApitallyKeyCacheBase(ABC):
-    def __init__(self, client_id: str, env: str) -> None:
-        self.client_id = client_id
-        self.env = env
-
-    @property
-    def cache_key(self) -> str:
-        return f"apitally:keys:{self.client_id}:{self.env}"
-
-    @abstractmethod
-    def store(self, data: str) -> None:
-        """Store the key data in cache as a JSON string."""
-        pass  # pragma: no cover
-
-    @abstractmethod
-    def retrieve(self) -> str | bytes | bytearray | None:
-        """Retrieve the stored key data from the cache as a JSON string."""
-        pass  # pragma: no cover
-
 
 @dataclass(frozen=True)
 class RequestInfo:
@@ -243,8 +195,8 @@ class ValidationErrorCounter:
                         method=method.upper(),
                         path=path,
                         loc=tuple(str(loc) for loc in error["loc"]),
-                        type=error["type"],
                         msg=error["msg"],
+                        type=error["type"],
                     )
                     self.error_counts[validation_error] += 1
                 except (KeyError, TypeError):  # pragma: no cover
@@ -267,69 +219,3 @@ class ValidationErrorCounter:
                 )
             self.error_counts.clear()
         return data
-
-
-@dataclass(frozen=True)
-class KeyInfo:
-    key_id: int
-    api_key_id: int
-    name: str = ""
-    scopes: List[str] = field(default_factory=list)
-    expires_at: Optional[datetime] = None
-
-    @property
-    def is_expired(self) -> bool:
-        return self.expires_at is not None and self.expires_at < datetime.now()
-
-    def has_scopes(self, scopes: Union[List[str], str]) -> bool:
-        if isinstance(scopes, str):
-            scopes = [scopes]
-        if not isinstance(scopes, list):
-            raise ValueError("scopes must be a string or a list of strings")
-        return all(scope in self.scopes for scope in scopes)
-
-    @classmethod
-    def from_dict(cls, data: Dict[str, Any]) -> KeyInfo:
-        return cls(
-            key_id=data["key_id"],
-            api_key_id=data["api_key_id"],
-            name=data.get("name", ""),
-            scopes=data.get("scopes", []),
-            expires_at=(
-                datetime.now() + timedelta(seconds=data["expires_in_seconds"])
-                if data["expires_in_seconds"] is not None
-                else None
-            ),
-        )
-
-
-class KeyRegistry:
-    def __init__(self) -> None:
-        self.salt: Optional[str] = None
-        self.keys: Dict[str, KeyInfo] = {}
-        self.usage_counts: Counter[int] = Counter()
-        self._lock = threading.Lock()
-
-    def get(self, api_key: str) -> Optional[KeyInfo]:
-        hash = self.hash_api_key(api_key.strip())
-        with self._lock:
-            key = self.keys.get(hash)
-            if key is None or key.is_expired:
-                return None
-            self.usage_counts[key.api_key_id] += 1
-        return key
-
-    def hash_api_key(self, api_key: str) -> str:
-        if self.salt is None:
-            raise RuntimeError("Apitally API keys not initialized")
-        return scrypt(api_key.encode(), salt=bytes.fromhex(self.salt), n=256, r=4, p=1, dklen=32).hex()
-
-    def update(self, keys: Dict[str, Dict[str, Any]]) -> None:
-        with self._lock:
-            self.keys = {hash: KeyInfo.from_dict(data) for hash, data in keys.items()}
-
-    def get_and_reset_usage_counts(self) -> Dict[int, int]:
-        with self._lock:
-            data = dict(self.usage_counts)
-            self.usage_counts.clear()
-        return data

apitally/client/threading.py

@@ -2,21 +2,15 @@ from __future__ import annotations
 
 import logging
 import queue
-import sys
 import time
 from functools import partial
 from threading import Event, Thread
-from typing import Any, Callable, Dict, Optional, Tuple, Type
+from typing import Any, Callable, Dict, Optional, Tuple
 
 import backoff
 import requests
 
-from apitally.client.base import (
-    MAX_QUEUE_TIME,
-    REQUEST_TIMEOUT,
-    ApitallyClientBase,
-    ApitallyKeyCacheBase,
-)
+from apitally.client.base import MAX_QUEUE_TIME, REQUEST_TIMEOUT, ApitallyClientBase
 from apitally.client.logging import get_logger
 
 
@@ -48,19 +42,8 @@ except NameError:
 
 
 class ApitallyClient(ApitallyClientBase):
-    def __init__(
-        self,
-        client_id: str,
-        env: str,
-        sync_api_keys: bool = False,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
-    ) -> None:
-        super().__init__(
-            client_id=client_id,
-            env=env,
-            sync_api_keys=sync_api_keys,
-            key_cache_class=key_cache_class,
-        )
+    def __init__(self, client_id: str, env: str) -> None:
+        super().__init__(client_id=client_id, env=env)
         self._thread: Optional[Thread] = None
         self._stop_sync_loop = Event()
         self._requests_data_queue: queue.Queue[Tuple[float, Dict[str, Any]]] = queue.Queue()
@@ -80,8 +63,6 @@ class ApitallyClient(ApitallyClientBase):
                     now = time.time()
                     if (now - last_sync_time) >= self.sync_interval:
                         with requests.Session() as session:
-                            if self.sync_api_keys:
-                                self.get_keys(session)
                             if not self._app_info_sent and last_sync_time > 0:  # not on first sync
                                 self.send_app_info(session)
                             self.send_requests_data(session)
@@ -127,24 +108,11 @@ class ApitallyClient(ApitallyClientBase):
         for item in failed_items:
             self._requests_data_queue.put_nowait(item)
 
-    def get_keys(self, session: requests.Session) -> None:
-        if response_data := self._get_keys(session):  # Response data can be None if backoff gives up
-            self.handle_keys_response(response_data)
-            self._keys_updated_at = time.time()
-        elif self.key_registry.salt is None:  # pragma: no cover
-            logger.critical("Initial Apitally API key sync failed")
-            # Exit because the application will not be able to authenticate requests
-            sys.exit(1)
-        elif (self._keys_updated_at is not None and time.time() - self._keys_updated_at > MAX_QUEUE_TIME) or (
-            self._keys_updated_at is None and time.time() - self._started_at > MAX_QUEUE_TIME
-        ):
-            logger.error("Apitally API key sync has been failing for more than 1 hour")
-
     @retry(raise_on_giveup=False)
     def _send_app_info(self, session: requests.Session, payload: Dict[str, Any]) -> None:
         logger.debug("Sending app info")
         response = session.post(url=f"{self.hub_url}/info", json=payload, timeout=REQUEST_TIMEOUT)
-        if response.status_code == 404 and "Client ID" in response.text:
+        if response.status_code == 404:
             self.stop_sync_loop()
             logger.error(f"Invalid Apitally client ID {self.client_id}")
         else:
@@ -157,10 +125,3 @@ class ApitallyClient(ApitallyClientBase):
         logger.debug("Sending requests data")
         response = session.post(url=f"{self.hub_url}/requests", json=payload, timeout=REQUEST_TIMEOUT)
         response.raise_for_status()
-
-    @retry(raise_on_giveup=False)
-    def _get_keys(self, session: requests.Session) -> Dict[str, Any]:
-        logger.debug("Updating API keys")
-        response = session.get(url=f"{self.hub_url}/keys", timeout=REQUEST_TIMEOUT)
-        response.raise_for_status()
-        return response.json()

apitally/django.py

@@ -5,7 +5,7 @@ import sys
 import time
 from dataclasses import dataclass
 from importlib.metadata import PackageNotFoundError, version
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
 
 from django.conf import settings
 from django.core.exceptions import ViewDoesNotExist
@@ -13,7 +13,6 @@ from django.test import RequestFactory
 from django.urls import URLPattern, URLResolver, get_resolver, resolve
 from django.utils.module_loading import import_string
 
-from apitally.client.base import ApitallyKeyCacheBase, KeyInfo
 from apitally.client.threading import ApitallyClient
 
 
@@ -29,10 +28,8 @@ class ApitallyMiddlewareConfig:
     client_id: str
     env: str
     app_version: Optional[str]
-    sync_api_keys: bool
     openapi_url: Optional[str]
     identify_consumer_callback: Optional[Callable[[HttpRequest], Optional[str]]]
-    key_cache_class: Optional[Type[ApitallyKeyCacheBase]]
 
 
 class ApitallyMiddleware:
@@ -45,12 +42,7 @@ class ApitallyMiddleware:
             self.configure(**config)
             assert self.config is not None
         self.views = _extract_views_from_url_patterns(get_resolver().url_patterns)
-        self.client = ApitallyClient(
-            client_id=self.config.client_id,
-            env=self.config.env,
-            sync_api_keys=self.config.sync_api_keys,
-            key_cache_class=self.config.key_cache_class,
-        )
+        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(
@@ -66,21 +58,17 @@ class ApitallyMiddleware:
         client_id: str,
         env: str = "dev",
         app_version: Optional[str] = None,
-        sync_api_keys: bool = False,
         openapi_url: Optional[str] = None,
         identify_consumer_callback: Optional[str] = None,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
     ) -> None:
         cls.config = ApitallyMiddlewareConfig(
             client_id=client_id,
             env=env,
             app_version=app_version,
-            sync_api_keys=sync_api_keys,
             openapi_url=openapi_url,
             identify_consumer_callback=import_string(identify_consumer_callback)
             if identify_consumer_callback
             else None,
-            key_cache_class=key_cache_class,
         )
 
     def __call__(self, request: HttpRequest) -> HttpResponse:
@@ -130,8 +118,6 @@ class ApitallyMiddleware:
             consumer_identifier = self.config.identify_consumer_callback(request)
             if consumer_identifier is not None:
                 return str(consumer_identifier)
-        if hasattr(request, "auth") and isinstance(request.auth, KeyInfo):
-            return f"key:{request.auth.key_id}"
         return None
 
 

apitally/django_ninja.py

@@ -1,84 +1,4 @@
-from __future__ import annotations
+from apitally.django import ApitallyMiddleware
 
-from typing import TYPE_CHECKING, Callable, List, Optional
 
-from ninja.security import APIKeyHeader
-
-from apitally.client.asyncio import ApitallyClient
-from apitally.client.base import KeyInfo
-from apitally.django import ApitallyMiddleware as _ApitallyMiddleware
-from apitally.django import DjangoViewInfo
-
-
-if TYPE_CHECKING:
-    from django.http import HttpRequest, HttpResponse
-    from ninja import NinjaAPI
-
-
-__all__ = ["ApitallyMiddleware", "APIKeyAuth", "APIKeyAuthBase", "KeyInfo"]
-
-
-class ApitallyMiddleware(_ApitallyMiddleware):
-    def __init__(self, get_response: Callable[[HttpRequest], HttpResponse]) -> None:
-        super().__init__(get_response)
-        if self.client.sync_api_keys:
-            api = _get_api(self.views)
-            _add_exception_handlers(api)
-
-
-class AuthError(Exception):
-    pass
-
-
-class InvalidAPIKey(AuthError):
-    pass
-
-
-class PermissionDenied(AuthError):
-    pass
-
-
-class APIKeyAuthBase(APIKeyHeader):
-    def __init__(self, scopes: Optional[List[str]] = None) -> None:
-        self.scopes = scopes or []
-
-    def authenticate(self, request: HttpRequest, key: Optional[str]) -> Optional[KeyInfo]:
-        if key is None:
-            return None
-        if self.param_name == "Authorization":
-            scheme, _, api_key = key.partition(" ")
-            if scheme.lower() != "apikey":
-                return None
-        else:
-            api_key = key
-        key_info = ApitallyClient.get_instance().key_registry.get(api_key)
-        if key_info is None:
-            raise InvalidAPIKey()
-        if not key_info.has_scopes(self.scopes):
-            raise PermissionDenied()
-        return key_info
-
-
-class APIKeyAuth(APIKeyAuthBase):
-    param_name = "Authorization"
-    openapi_description = "Provide your API key using the <code>Authorization</code> header and the scheme prefix <code>ApiKey</code>.<br>Example: <pre>Authorization: ApiKey your_api_key_here</pre>"
-
-
-def _get_api(views: List[DjangoViewInfo]) -> NinjaAPI:
-    try:
-        return next(
-            (view.func.__self__.api for view in views if view.is_ninja_path_view and hasattr(view.func, "__self__"))
-        )
-    except StopIteration:  # pragma: no cover
-        raise RuntimeError("Could not find NinjaAPI instance")
-
-
-def _add_exception_handlers(api: NinjaAPI) -> None:
-    def on_invalid_api_key(request: HttpRequest, exc) -> HttpResponse:
-        return api.create_response(request, {"detail": "Invalid API key"}, status=403)
-
-    def on_permission_denied(request: HttpRequest, exc) -> HttpResponse:
-        return api.create_response(request, {"detail": "Permission denied"}, status=403)
-
-    api.add_exception_handler(InvalidAPIKey, on_invalid_api_key)
-    api.add_exception_handler(PermissionDenied, on_permission_denied)
+__all__ = ["ApitallyMiddleware"]

apitally/django_rest_framework.py

@@ -1,48 +1,4 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, List, Type
-
-from django.conf import settings
-from rest_framework.permissions import BasePermission
-
-from apitally.client.base import KeyInfo
-from apitally.client.threading import ApitallyClient
 from apitally.django import ApitallyMiddleware
 
 
-if TYPE_CHECKING:
-    from rest_framework.request import Request
-    from rest_framework.views import APIView
-
-
-__all__ = ["ApitallyMiddleware", "HasAPIKey", "HasAPIKeyWithScopes", "KeyInfo"]
-
-
-class HasAPIKey(BasePermission):  # type: ignore[misc]
-    required_scopes: List[str] = []
-
-    def has_permission(self, request: Request, view: APIView) -> bool:
-        custom_header = getattr(settings, "APITALLY_CUSTOM_API_KEY_HEADER", None)
-        header = request.headers.get("Authorization" if custom_header is None else custom_header)
-        if not header:
-            return False
-        if custom_header is None:
-            scheme, _, api_key = header.partition(" ")
-            if scheme.lower() != "apikey":
-                return False
-        else:
-            api_key = header
-        key_info = ApitallyClient.get_instance().key_registry.get(api_key)
-        if key_info is None:
-            return False
-        if self.required_scopes and not key_info.has_scopes(self.required_scopes):
-            return False
-        request.auth = key_info
-        return True
-
-
-def HasAPIKeyWithScopes(scopes: List[str]) -> Type[HasAPIKey]:
-    class _HasAPIKeyWithScopes(HasAPIKey):  # type: ignore[misc]
-        required_scopes = scopes
-
-    return _HasAPIKeyWithScopes
+__all__ = ["ApitallyMiddleware"]

apitally/fastapi.py

@@ -1,77 +1,4 @@
-from typing import Optional
-
-from fastapi.exceptions import HTTPException
-from fastapi.openapi.models import APIKey, APIKeyIn
-from fastapi.requests import Request
-from fastapi.security import SecurityScopes
-from fastapi.security.base import SecurityBase
-from fastapi.security.utils import get_authorization_scheme_param
-from starlette.status import HTTP_401_UNAUTHORIZED, HTTP_403_FORBIDDEN
-
-from apitally.client.asyncio import ApitallyClient
-from apitally.client.base import KeyInfo
 from apitally.starlette import ApitallyMiddleware
 
 
-__all__ = ["ApitallyMiddleware", "APIKeyAuth", "KeyInfo", "api_key_auth"]
-
-
-class APIKeyAuth(SecurityBase):
-    def __init__(self, *, custom_header: Optional[str] = None, auto_error: bool = True) -> None:
-        self.model: APIKey
-        if custom_header is None:
-            self.model = APIKey(
-                **{"in": APIKeyIn.header},  # type: ignore[arg-type]
-                name="Authorization",
-                description="Provide your API key using the <code>Authorization</code> header and the scheme prefix <code>ApiKey</code>.<br>Example: <pre>Authorization: ApiKey your_api_key_here</pre>",
-            )
-            self.scheme_name = "Authorization header with ApiKey scheme"
-        else:
-            self.model = APIKey(
-                **{"in": APIKeyIn.header},  # type: ignore[arg-type]
-                name=custom_header,
-                description=f"Provide your API key using the <code>{custom_header}</code> header.<br>Example: <pre>{custom_header}: your_api_key_here</pre>",
-            )
-            self.scheme_name = f"{custom_header} header"
-        self.auto_error = auto_error
-
-    async def __call__(self, request: Request, security_scopes: SecurityScopes) -> Optional[KeyInfo]:
-        header = request.headers.get(self.model.name)
-        if self.model.name == "Authorization":
-            scheme, api_key = get_authorization_scheme_param(header)
-            if not header or scheme.lower() != "apikey":
-                if self.auto_error:
-                    raise HTTPException(
-                        status_code=HTTP_401_UNAUTHORIZED,
-                        detail="Not authenticated" if not header else "Invalid authorization scheme",
-                        headers={"WWW-Authenticate": "ApiKey"},
-                    )
-                else:
-                    return None  # pragma: no cover
-        elif not header:
-            if self.auto_error:
-                raise HTTPException(
-                    status_code=HTTP_403_FORBIDDEN,
-                    detail="Missing API key",
-                )
-            else:
-                return None  # pragma: no cover
-        else:
-            api_key = header
-        key_info = ApitallyClient.get_instance().key_registry.get(api_key)
-        if key_info is None and self.auto_error:
-            raise HTTPException(
-                status_code=HTTP_403_FORBIDDEN,
-                detail="Invalid API key",
-            )
-        if key_info is not None and self.auto_error and not key_info.has_scopes(security_scopes.scopes):
-            raise HTTPException(
-                status_code=HTTP_403_FORBIDDEN,
-                detail="Permission denied",
-            )
-        if key_info is not None:
-            request.state.key_info = key_info
-        return key_info
-
-
-api_key_auth = APIKeyAuth()
+__all__ = ["ApitallyMiddleware"]

apitally/flask.py

@@ -2,17 +2,15 @@ from __future__ import annotations
 
 import sys
 import time
-from functools import wraps
 from importlib.metadata import version
 from threading import Timer
-from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple, Type
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Tuple
 
-from flask import Flask, g, make_response, request
+from flask import Flask, g
 from werkzeug.datastructures import Headers
 from werkzeug.exceptions import NotFound
 from werkzeug.test import Client
 
-from apitally.client.base import ApitallyKeyCacheBase, KeyInfo
 from apitally.client.threading import ApitallyClient
 
 
@@ -21,7 +19,7 @@ if TYPE_CHECKING:
     from werkzeug.routing.map import Map
 
 
-__all__ = ["ApitallyMiddleware", "require_api_key"]
+__all__ = ["ApitallyMiddleware"]
 
 
 class ApitallyMiddleware:
@@ -31,20 +29,13 @@ class ApitallyMiddleware:
         client_id: str,
         env: str = "dev",
         app_version: Optional[str] = None,
-        sync_api_keys: bool = False,
         openapi_url: Optional[str] = None,
         filter_unhandled_paths: bool = True,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
     ) -> None:
         self.app = app
         self.wsgi_app = app.wsgi_app
         self.filter_unhandled_paths = filter_unhandled_paths
-        self.client = ApitallyClient(
-            client_id=client_id,
-            env=env,
-            sync_api_keys=sync_api_keys,
-            key_cache_class=key_cache_class,
-        )
+        self.client = ApitallyClient(client_id=client_id, env=env)
         self.client.start_sync_loop()
         self.delayed_set_app_info(app_version, openapi_url)
 
@@ -103,40 +94,7 @@ class ApitallyMiddleware:
             return environ["PATH_INFO"], False
 
     def get_consumer(self) -> Optional[str]:
-        if "consumer_identifier" in g:
-            return str(g.consumer_identifier)
-        if "key_info" in g and isinstance(g.key_info, KeyInfo):
-            return f"key:{g.key_info.key_id}"
-        return None
-
-
-def require_api_key(func=None, *, scopes: Optional[List[str]] = None, custom_header: Optional[str] = None):
-    def decorator(func):
-        @wraps(func)
-        def wrapped_func(*args, **kwargs):
-            api_key: Optional[str]
-            if custom_header is None:
-                authorization = request.headers.get("Authorization")
-                if authorization is None:
-                    return make_response("Not authenticated", 401, {"WWW-Authenticate": "ApiKey"})
-                scheme, _, api_key = authorization.partition(" ")
-                if scheme.lower() != "apikey":
-                    return make_response("Unsupported authentication scheme", 401, {"WWW-Authenticate": "ApiKey"})
-            else:
-                api_key = request.headers.get(custom_header)
-                if api_key is None:
-                    return make_response("Missing API key", 403)
-            key_info = ApitallyClient.get_instance().key_registry.get(api_key)
-            if key_info is None:
-                return make_response("Invalid API key", 403)
-            if scopes is not None and not key_info.has_scopes(scopes):
-                return make_response("Permission denied", 403)
-            g.key_info = key_info
-            return func(*args, **kwargs)
-
-        return wrapped_func
-
-    return decorator if func is None else decorator(func)
+        return str(g.consumer_identifier) if "consumer_identifier" in g else None
 
 
 def _get_app_info(app: Flask, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> Dict[str, Any]:

apitally/litestar.py

@@ -0,0 +1,186 @@
+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
+from litestar.config.app import AppConfig
+from litestar.connection import Request
+from litestar.datastructures import Headers
+from litestar.enums import ScopeType
+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
+
+
+__all__ = ["ApitallyPlugin"]
+
+
+class ApitallyPlugin(InitPluginProtocol):
+    def __init__(
+        self,
+        client_id: str,
+        env: str = "dev",
+        app_version: Optional[str] = None,
+        filter_openapi_paths: bool = True,
+        identify_consumer_callback: Optional[Callable[[Request], Optional[str]]] = None,
+    ) -> None:
+        self.client = ApitallyClient(client_id=client_id, env=env)
+        self.app_version = app_version
+        self.filter_openapi_paths = filter_openapi_paths
+        self.identify_consumer_callback = identify_consumer_callback
+        self.openapi_path: Optional[str] = None
+
+    def on_app_init(self, app_config: AppConfig) -> AppConfig:
+        app_config.on_startup.append(self.on_startup)
+        app_config.middleware.append(self.middleware_factory)
+        return app_config
+
+    def on_startup(self, app: Litestar) -> None:
+        openapi_config = app.openapi_config or DEFAULT_OPENAPI_CONFIG
+        self.openapi_path = openapi_config.openapi_controller.path
+
+        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),
+            "client": "python:litestar",
+        }
+        self.client.set_app_info(app_info)
+        self.client.start_sync_loop()
+
+    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":
+                request = Request(scope)
+                response_status = 0
+                response_time = 0.0
+                response_headers = Headers()
+                response_body = b""
+                start_time = time.perf_counter()
+
+                async def send_wrapper(message: Message) -> None:
+                    nonlocal response_time, response_status, response_headers, response_body
+                    if message["type"] == "http.response.start":
+                        response_time = time.perf_counter() - start_time
+                        response_status = message["status"]
+                        response_headers = Headers(message["headers"])
+                    elif message["type"] == "http.response.body" and response_status == 400:
+                        response_body += message["body"]
+                    await send(message)
+
+                await app(scope, receive, send_wrapper)
+                self.add_request(
+                    request=request,
+                    response_status=response_status,
+                    response_time=response_time,
+                    response_headers=response_headers,
+                    response_body=response_body,
+                )
+            else:
+                await app(scope, receive, send)  # pragma: no cover
+
+        return middleware
+
+    def add_request(
+        self,
+        request: Request,
+        response_status: int,
+        response_time: float,
+        response_headers: Headers,
+        response_body: bytes,
+    ) -> None:
+        if response_status < 100 or not request.route_handler.paths:
+            return  # pragma: no cover
+        path = self.get_path(request)
+        if path is None or self.filter_path(path):
+            return
+        consumer = self.get_consumer(request)
+        self.client.request_counter.add_request(
+            consumer=consumer,
+            method=request.method,
+            path=path,
+            status_code=response_status,
+            response_time=response_time,
+            request_size=request.headers.get("Content-Length"),
+            response_size=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,
+                        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
+                        ],
+                    )
+
+    def get_path(self, request: Request) -> Optional[str]:
+        path: List[str] = []
+        for layer in request.route_handler.ownership_layers:
+            if isinstance(layer, HTTPRouteHandler):
+                if len(layer.paths) == 0:
+                    return None  # pragma: no cover
+                path.append(list(layer.paths)[0].lstrip("/"))
+            else:
+                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:
+            return path == self.openapi_path or path.startswith(self.openapi_path + "/")
+        return False  # pragma: no cover
+
+    def get_consumer(self, request: Request) -> Optional[str]:
+        if hasattr(request.state, "consumer_identifier"):
+            return str(request.state.consumer_identifier)
+        if self.identify_consumer_callback is not None:
+            consumer_identifier = self.identify_consumer_callback(request)
+            if consumer_identifier is not None:
+                return str(consumer_identifier)
+        return None
+
+
+def _get_openapi(app: Litestar) -> str:
+    schema = app.openapi_schema.to_schema()
+    return json.dumps(schema)
+
+
+def _get_routes(app: Litestar) -> List[Dict[str, str]]:
+    return [
+        {"method": method, "path": route.path}
+        for route in app.routes
+        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

@@ -5,28 +5,11 @@ import json
 import sys
 import time
 from importlib.metadata import PackageNotFoundError, version
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
 
 from httpx import HTTPStatusError
-from starlette.authentication import (
-    AuthCredentials,
-    AuthenticationBackend,
-    AuthenticationError,
-    BaseUser,
-)
 from starlette.concurrency import iterate_in_threadpool
 from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.requests import HTTPConnection
 from starlette.routing import BaseRoute, Match, Router
 from starlette.schemas import EndpointInfo, SchemaGenerator
 from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR
@@ -34,7 +17,6 @@ from starlette.testclient import TestClient
 from starlette.types import ASGIApp
 
 from apitally.client.asyncio import ApitallyClient
-from apitally.client.base import ApitallyKeyCacheBase, KeyInfo
 
 
 if TYPE_CHECKING:
@@ -43,7 +25,7 @@ if TYPE_CHECKING:
     from starlette.responses import Response
 
 
-__all__ = ["ApitallyMiddleware", "APIKeyAuth"]
+__all__ = ["ApitallyMiddleware"]
 
 
 class ApitallyMiddleware(BaseHTTPMiddleware):
@@ -53,20 +35,13 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
         client_id: str,
         env: str = "dev",
         app_version: Optional[str] = None,
-        sync_api_keys: bool = False,
         openapi_url: Optional[str] = "/openapi.json",
         filter_unhandled_paths: bool = True,
         identify_consumer_callback: Optional[Callable[[Request], Optional[str]]] = None,
-        key_cache_class: Optional[Type[ApitallyKeyCacheBase]] = None,
     ) -> None:
         self.filter_unhandled_paths = filter_unhandled_paths
         self.identify_consumer_callback = identify_consumer_callback
-        self.client = ApitallyClient(
-            client_id=client_id,
-            env=env,
-            sync_api_keys=sync_api_keys,
-            key_cache_class=key_cache_class,
-        )
+        self.client = ApitallyClient(client_id=client_id, env=env)
         self.client.start_sync_loop()
         self.delayed_set_app_info(app_version, openapi_url)
         _register_shutdown_handler(app, self.client.handle_shutdown)
@@ -161,52 +136,9 @@ class ApitallyMiddleware(BaseHTTPMiddleware):
             consumer_identifier = self.identify_consumer_callback(request)
             if consumer_identifier is not None:
                 return str(consumer_identifier)
-        if hasattr(request.state, "key_info") and isinstance(key_info := request.state.key_info, KeyInfo):
-            return f"key:{key_info.key_id}"
-        if "user" in request.scope and isinstance(user := request.scope["user"], APIKeyUser):
-            return f"key:{user.key_info.key_id}"
         return None
 
 
-class APIKeyAuth(AuthenticationBackend):
-    def __init__(self, custom_header: Optional[str] = None) -> None:
-        self.custom_header = custom_header
-
-    async def authenticate(self, conn: HTTPConnection) -> Optional[Tuple[AuthCredentials, BaseUser]]:
-        if self.custom_header is None:
-            if "Authorization" not in conn.headers:
-                return None
-            auth = conn.headers["Authorization"]
-            scheme, _, api_key = auth.partition(" ")
-            if scheme.lower() != "apikey":
-                return None
-        elif self.custom_header not in conn.headers:
-            return None
-        else:
-            api_key = conn.headers[self.custom_header]
-        key_info = ApitallyClient.get_instance().key_registry.get(api_key)
-        if key_info is None:
-            raise AuthenticationError("Invalid API key")
-        return AuthCredentials(["authenticated"] + key_info.scopes), APIKeyUser(key_info)
-
-
-class APIKeyUser(BaseUser):
-    def __init__(self, key_info: KeyInfo) -> None:
-        self.key_info = key_info
-
-    @property
-    def is_authenticated(self) -> bool:
-        return True
-
-    @property
-    def display_name(self) -> str:
-        return self.key_info.name
-
-    @property
-    def identity(self) -> str:
-        return str(self.key_info.key_id)
-
-
 def _get_app_info(app: ASGIApp, app_version: Optional[str] = None, openapi_url: Optional[str] = None) -> Dict[str, Any]:
     app_info: Dict[str, Any] = {}
     if openapi_url and (openapi := _get_openapi(app, openapi_url)):

{apitally-0.4.1.dist-info → apitally-0.6.0.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: apitally
-Version: 0.4.1
-Summary: Simple API monitoring and API key management for REST APIs built with FastAPI, Flask, Django, and Starlette.
-Home-page: https://docs.apitally.io
+Version: 0.6.0
+Summary: API monitoring for REST APIs built with FastAPI, Flask, Django, and Starlette.
+Home-page: https://apitally.io
 License: MIT
 Author: Apitally
 Author-email: hello@apitally.io
@@ -21,19 +21,22 @@ 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
 Provides-Extra: flask
+Provides-Extra: litestar
 Provides-Extra: starlette
 Requires-Dist: backoff (>=2.0.0)
-Requires-Dist: django (>=4.0) ; extra == "django-rest-framework" or extra == "django-ninja"
+Requires-Dist: django (>=4.0) ; extra == "django" or extra == "django-ninja" or extra == "django-rest-framework"
 Requires-Dist: django-ninja (>=0.18.0) ; extra == "django-ninja"
 Requires-Dist: djangorestframework (>=3.12.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 == "starlette"
-Requires-Dist: requests (>=2.26.0) ; extra == "django-rest-framework" or extra == "django-ninja" or extra == "flask"
+Requires-Dist: httpx (>=0.22.0) ; extra == "fastapi" or extra == "litestar" or extra == "starlette"
+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: starlette (>=0.21.0,<1.0.0) ; extra == "fastapi" or extra == "starlette"
 Project-URL: Documentation, https://docs.apitally.io
 Project-URL: Repository, https://github.com/apitally/python-client
@@ -47,9 +50,9 @@ Description-Content-Type: text/markdown
   </picture>
 </p>
 
-<p align="center"><b>Your refreshingly simple REST API companion.</b></p>
+<p align="center"><b>API monitoring made easy.</b></p>
 
-<p align="center"><i>Apitally is a simple and affordable API monitoring and API key management 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 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">🔗 <b><a href="https://apitally.io" target="_blank">apitally.io</a></b></p>
 
@@ -71,6 +74,7 @@ frameworks:
 - [Flask](https://docs.apitally.io/frameworks/flask)
 - [Django Ninja](https://docs.apitally.io/frameworks/django-ninja)
 - [Django REST Framework](https://docs.apitally.io/frameworks/django-rest-framework)
+- [Litestar](https://docs.apitally.io/frameworks/litestar)
 
 Learn more about Apitally on our 🌎 [website](https://apitally.io) or check out
 the 📚 [documentation](https://docs.apitally.io).
@@ -79,10 +83,8 @@ the 📚 [documentation](https://docs.apitally.io).
 
 - Middleware for different frameworks to capture metadata about API endpoints,
   requests and responses (no sensitive data is captured)
-- Non-blocking clients that aggregate and send captured data to Apitally and
-  optionally synchronize API key hashes in 1 minute intervals
-- Functions to easily secure endpoints with API key authentication and
-  permission checks
+- Non-blocking clients that aggregate and send captured data to Apitally in
+  regular intervals
 
 ## Install
 
@@ -93,8 +95,8 @@ example:
 pip install apitally[fastapi]
 ```
 
-The available extras are: `fastapi`, `starlette`, `flask`, `django_ninja` and
-`django_rest_framework`.
+The available extras are: `fastapi`, `starlette`, `flask`, `django` and
+`litestar`.
 
 ## Usage
 
@@ -119,24 +121,6 @@ app.add_middleware(
 )
 ```
 
-### Starlette
-
-This is an example of how to add the Apitally middleware to a Starlette
-application. For further instructions, see our
-[setup guide for Starlette](https://docs.apitally.io/frameworks/starlette).
-
-```python
-from starlette.applications import Starlette
-from apitally.starlette import ApitallyMiddleware
-
-app = Starlette(routes=[...])
-app.add_middleware(
-    ApitallyMiddleware,
-    client_id="your-client-id",
-    env="dev",  # or "prod" etc.
-)
-```
-
 ### Flask
 
 This is an example of how to add the Apitally middleware to a Flask application.
@@ -155,17 +139,17 @@ app.wsgi_app = ApitallyMiddleware(
 )
 ```
 
-### Django Ninja
+### Django
 
-This is an example of how to add the Apitally middleware to a Django Ninja
-application. For further instructions, see our
-[setup guide for Django Ninja](https://docs.apitally.io/frameworks/django-ninja).
+This is an example of how to add the Apitally middleware to a Django Ninja or
+Django REST Framework application. For further instructions, see our
+[setup guide for Django](https://docs.apitally.io/frameworks/django).
 
 In your Django `settings.py` file:
 
 ```python
 MIDDLEWARE = [
-    "apitally.django_ninja.ApitallyMiddleware",
+    "apitally.django.ApitallyMiddleware",
     # Other middleware ...
 ]
 APITALLY_MIDDLEWARE = {
@@ -174,30 +158,33 @@ APITALLY_MIDDLEWARE = {
 }
 ```
 
-### Django REST Framework
-
-This is an example of how to add the Apitally middleware to a Django REST
-Framework application. For further instructions, see our
-[setup guide for Django REST Framework](https://docs.apitally.io/frameworks/django-rest-framework).
+### Litestar
 
-In your Django `settings.py` file:
+This is an example of how to add the Apitally plugin to a Litestar application.
+For further instructions, see our
+[setup guide for Litestar](https://docs.apitally.io/frameworks/litestar).
 
 ```python
-MIDDLEWARE = [
-    "apitally.django_rest_framework.ApitallyMiddleware",
-    # Other middleware ...
-]
-APITALLY_MIDDLEWARE = {
-    "client_id": "your-client-id",
-    "env": "dev",  # or "prod" etc.
-}
+from litestar import Litestar
+from apitally.litestar import ApitallyPlugin
+
+app = Litestar(
+    route_handlers=[...],
+    plugins=[
+        ApitallyPlugin(
+            client_id="your-client-id",
+            env="dev",  # or "prod" etc.
+        ),
+    ]
+)
 ```
 
 ## Getting help
 
 If you need help please
 [create a new discussion](https://github.com/orgs/apitally/discussions/categories/q-a)
-on GitHub.
+on GitHub or
+[join our Slack workspace](https://join.slack.com/t/apitally-community/shared_invite/zt-2b3xxqhdu-9RMq2HyZbR79wtzNLoGHrg).
 
 ## License
 

apitally-0.6.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+apitally/__init__.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
+apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/client/asyncio.py,sha256=uR5JlH37G6gZvAJ7A1gYOGkjn3zjC-4I6avA1fncXHs,4433
+apitally/client/base.py,sha256=g-v7_S-ie2DN2HCVtgTlImZGTMXVU9CrKraMZiyM6Ds,8353
+apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
+apitally/client/threading.py,sha256=ihQzUStrSQFynpqXgFpseAXrHuc5Et1QvG-YHlzqDr8,4831
+apitally/django.py,sha256=vL2vBelXis-9d3CDWjKzLsOjdSbBDnZX0v1oDtBvtNM,9943
+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=VgKhbKRjVHVjzdw7PgMxedaOrSB6_ZUo9L4XNr3iRxc,7437
+apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apitally/starlette.py,sha256=VlLWOR9rzNlI9IjFbQ86APaWanURerIt52tX6bRGzCo,7814
+apitally-0.6.0.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
+apitally-0.6.0.dist-info/METADATA,sha256=CbNI6H1gnNT3oPXzM_RxWFksCtwZ7_uT7lunjarMKXA,6610
+apitally-0.6.0.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+apitally-0.6.0.dist-info/RECORD,,

apitally-0.4.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-apitally/__init__.py,sha256=pMtTmSUht-XtbR_7Doz6bsQqopJJd8rZ8I8zy2HwwoA,22
-apitally/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/client/asyncio.py,sha256=A7FEk-VD7YY2UPVBNaI8Roh3e0YLAVpD5iU6wS5067I,5977
-apitally/client/base.py,sha256=iEBFWId-M6_V1roAE4z270iwdZQJ48NZ7trAOSEAUBk,12489
-apitally/client/logging.py,sha256=QMsKIIAFo92PNBUleeTgsrsQa7SEal-oJa1oOHUr1wI,507
-apitally/client/threading.py,sha256=CALCE4AGMMedhR5GpwiPqY4BZIiIu3TrIa-H2dzpxvg,6396
-apitally/django.py,sha256=i2mb7sHes6Q4JE1kdo1BvDBBcGZzuv946e4MDlAE62c,10555
-apitally/django_ninja.py,sha256=TFltgr03FzTnl83sUAXJj7R32u_g9DTZ9p-HuVKs4ZE,2785
-apitally/django_rest_framework.py,sha256=UmJvxxiKGRdaILSbg6jJY_cvAl-mpuPY1pM0FoQ4bg0,1587
-apitally/fastapi.py,sha256=YjnrRis8UG2M6Q3lkwizbtDXU7nPfCA4mebxG8XwveY,3334
-apitally/flask.py,sha256=C3_Uk0XiVyayXURnzKvoG7EAFthA6PeV7mLys22BiO4,6960
-apitally/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apitally/starlette.py,sha256=8PQdvw0h0_rBVziPciMGtHf0vxJ_mlrKOSyFAB7Mr14,9941
-apitally-0.4.1.dist-info/LICENSE,sha256=vbLzC-4TddtXX-_AFEBKMYWRlxC_MN0g66QhPxo8PgY,1065
-apitally-0.4.1.dist-info/METADATA,sha256=J-oAJmEw8L92xjTx3rCZhz7xvZWn4QW5PG9GL9eHhpY,6983
-apitally-0.4.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-apitally-0.4.1.dist-info/RECORD,,