apikey-gateway 1.1.1__py3-none-any.whl

apikey_gateway/__init__.py

@@ -0,0 +1,48 @@
+"""API Key Gateway - Professional API key validation library"""
+
+# Public API exports
+from .gateway import APIKeyGateway, gateway
+from .decorators import apikey_login
+from .helpers import (
+    add_apikey_gateway_middleware,
+    retry_on_exception,
+    fetch_valid_public_keys,
+    compute_public_key,
+    validate_api_key,
+    CACHE_TTL_SECONDS,
+    API_KEY_CACHE,
+    PH
+)
+
+# Middleware-related exports
+try:
+    from .middleware import APIKeyGatewayMiddleware, FASTAPI_AVAILABLE
+    __all__ = [
+        'APIKeyGateway',
+        'gateway',
+        'apikey_login',
+        'add_apikey_gateway_middleware',
+        'APIKeyGatewayMiddleware',
+        'FASTAPI_AVAILABLE',
+        'retry_on_exception',
+        'fetch_valid_public_keys',
+        'compute_public_key',
+        'validate_api_key',
+        'CACHE_TTL_SECONDS',
+        'API_KEY_CACHE',
+        'PH'
+    ]
+except ImportError:
+    __all__ = [
+        'APIKeyGateway',
+        'gateway',
+        'apikey_login',
+        'add_apikey_gateway_middleware',
+        'retry_on_exception',
+        'fetch_valid_public_keys',
+        'compute_public_key',
+        'validate_api_key',
+        'CACHE_TTL_SECONDS',
+        'API_KEY_CACHE',
+        'PH'
+    ]

apikey_gateway/decorators.py

@@ -0,0 +1,65 @@
+"""Decorators for API key validation"""
+
+import argparse
+import sys
+import os
+
+
+def apikey_login(func=None, *, public_keys_url=None, service=None, verbose=True):
+    """
+    Decorator that adds API key validation to a function.
+
+    :param func: The function to decorate (required if using as decorator without params)
+    :param public_keys_url: Optional URL to fetch valid public keys from (defaults to the official URL)
+    :param service: The service name to validate the API key against (required)
+    :param verbose: Whether to print verbose messages (default: True)
+    """
+    # Check if service parameter is provided
+    if func is None:
+        # If we're in the parameterized decorator mode, we'll check service later
+        pass
+    elif service is None:
+        raise ValueError("service parameter is required for apikey_login decorator")
+
+    # Handle both decorator with and without parameters
+    if func is None:
+        # Return a new decorator with the provided parameters
+        return lambda f: apikey_login(f, public_keys_url=public_keys_url, service=service, verbose=verbose)
+
+    def wrapper(*args, **kwargs):
+        # Create argument parser
+        parser = argparse.ArgumentParser(add_help=False)  # Don't add help to avoid conflict
+        parser.add_argument(
+            '-a', '--apikey',
+            required=False,
+            help='Your API secret key (fallbacks to AKGATEWAY_API_KEY env var)'
+        )
+
+        # Save original argv to restore later
+        original_argv = sys.argv.copy()
+
+        # Parse only API key arguments
+        args_parsed, remaining_args = parser.parse_known_args()
+
+        # Get API key from command line or environment variable
+        secret_key = args_parsed.apikey or os.environ.get('AKGATEWAY_API_KEY')
+
+        # If no API key provided, raise an error
+        if not secret_key:
+            parser.error('API key is required. Use -a/--apikey or set AKGATEWAY_API_KEY environment variable')
+
+        # Replace sys.argv with remaining args (excluding API key) for the wrapped function
+        sys.argv = [sys.argv[0]] + remaining_args
+
+        try:
+            # Use the gateway singleton to validate the API key
+            from .gateway import gateway
+            gateway.validate_api_key(secret_key, service, public_keys_url=public_keys_url, verbose=verbose)
+
+            # If validation passes, call the decorated function
+            return func(*args, **kwargs)
+        finally:
+            # Always restore original argv
+            sys.argv = original_argv
+
+    return wrapper

apikey_gateway/gateway.py

@@ -0,0 +1,245 @@
+"""Core API key gateway logic for validation and caching"""
+
+import argparse
+import urllib.request
+import urllib.error
+import json
+import os
+import time
+from functools import wraps
+from argon2 import PasswordHasher
+from argon2.exceptions import HashingError
+
+
+class APIKeyGateway:
+    """Core API key gateway logic for validation and caching"""
+
+    def __init__(self):
+        self.PH = PasswordHasher(
+            memory_cost=65536,
+            time_cost=3,
+            parallelism=4,
+            hash_len=32,
+            salt_len=16
+        )
+
+        # Cache to store valid API key-service pairs
+        # Format: {(secret_key, service): expiration_time}
+        self.API_KEY_CACHE = {}
+
+        # Cache TTL: 1 day (86400 seconds)
+        self.CACHE_TTL_SECONDS = 86400
+
+        # Default URL using JSONBin.io
+        self.DEFAULT_URL = "https://api.jsonbin.io/v3/b/691ec6a543b1c97be9b8ea6d"
+
+    @staticmethod
+    def retry_on_exception(exceptions, max_retries=3, delay=0.5, backoff=1):
+        """
+        Decorator that retries a function on specific exceptions.
+        """
+        def decorator(func):
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                verbose = kwargs.get('verbose', True)
+                func_kwargs = {k: v for k, v in kwargs.items() if k != 'verbose'}
+                retries = 0
+                while retries <= max_retries:
+                    try:
+                        return func(*args, **func_kwargs)
+                    except exceptions as e:
+                        retries += 1
+                        if retries > max_retries:
+                            if verbose:
+                                print(f"   All {max_retries} retry attempts failed. Exception: {e}")
+                            raise
+                        wait_time = delay * (backoff ** (retries - 1))
+                        if verbose:
+                            print(f"   Retry {retries}/{max_retries} in {wait_time:.2f} seconds due to: {type(e).__name__}: {e}")
+                        time.sleep(wait_time)
+                return None  # This line should never be reached
+            return wrapper
+        return decorator
+
+    @retry_on_exception(
+        urllib.error.URLError,
+        max_retries=3,
+        delay=0.5,
+        backoff=1  # constant delay, not exponential
+    )
+    def fetch_valid_public_keys(self, url, verbose=True, jsonbin_api_key=None):
+        """Fetch the list of valid public keys from the specified URL."""
+        try:
+            # Set proper headers for JSONBin.io API
+            headers = {
+                'accept': 'application/json',
+            }
+
+            # Add JSONBin API key if available (parameter takes precedence over env var)
+            jsonbin_api_key = jsonbin_api_key or os.environ.get('JSONBIN_API_KEY')
+            if jsonbin_api_key:
+                headers['X-Access-Key'] = jsonbin_api_key
+
+            # Create a request object with the headers
+            req = urllib.request.Request(url, headers=headers)
+
+            # Set timeout to avoid hanging (10 seconds)
+            with urllib.request.urlopen(req, timeout=10) as response:
+                data = json.loads(response.read().decode('utf-8'))
+
+            # JSONBin API wraps the data in a 'record' field
+            if isinstance(data, dict) and 'record' in data:
+                data = data['record']
+                all_keys = []
+
+                # Expected structure: {service: {key_id: public_key, ...}}
+                for service_name, service_data in data.items():
+                    if isinstance(service_data, dict):
+                        # Service has multiple API keys
+                        for key_id, public_key in service_data.items():
+                            all_keys.append({
+                                "service": service_name,
+                                "public_key": public_key
+                            })
+                    else:
+                        # Service has a single API key
+                        all_keys.append({
+                            "service": service_name,
+                            "public_key": service_data
+                        })
+                return all_keys
+            raise RuntimeError(f"Unexpected response structure from JSONBin API: {data}")
+        except urllib.error.HTTPError as e:
+            if e.code == 401:
+                # 401 Unauthorized typically means missing or invalid API key
+                jsonbin_api_key = os.environ.get('JSONBIN_API_KEY')
+                if not jsonbin_api_key:
+                    raise RuntimeError("Failed to fetch valid public keys from jsonbin.io: JSONBIN_API_KEY environment variable is missing")
+                else:
+                    raise RuntimeError(f"Failed to fetch valid public keys from jsonbin.io: Invalid API key provided (HTTP 401). Check your JSONBIN_API_KEY environment variable.")
+            raise RuntimeError(f"Failed to fetch valid public keys from jsonbin.io: HTTP {e.code} error - {e.reason}")
+        except urllib.error.URLError:
+            # Re-raise URLError so the retry decorator can handle it
+            raise
+        except Exception as e:
+            # Wrap all other exceptions in RuntimeError
+            raise RuntimeError(f"Failed to fetch valid public keys: {e}")
+
+    def compute_public_key(self, secret_key):
+        """Compute the public key from the secret key using argon2id."""
+        try:
+            return self.PH.hash(secret_key)
+        except HashingError as e:
+            raise RuntimeError(f"Failed to compute public key: {e}")
+
+    def validate_api_key(self, secret_key, service, public_keys_url=None, verbose=True, jsonbin_api_key=None):
+        """Validate an API key for a specific service"""
+        # Fast fail validations
+        if not secret_key:
+            raise PermissionError("API key validation failed: API key cannot be empty")
+
+        # Check if secret key has correct length
+        expected_length = 43  # Based on test secret key: LVYYllZk6xLIRoGVfGK9A78Dl1ehJbZOpRo6JoF2LAM
+        if len(secret_key) != expected_length:
+            raise PermissionError(f"API key validation failed: API key must be {expected_length} characters long")
+
+        # Check cache first
+        cache_key = (secret_key, service)
+        current_time = time.time()
+
+        if cache_key in self.API_KEY_CACHE:
+            expiration_time = self.API_KEY_CACHE[cache_key]
+            if current_time < expiration_time:
+                # Cache hit: key-service pair is still valid
+                if verbose:
+                    print(f"✓ API key validation passed (cached until {time.ctime(expiration_time)})")
+                return True
+
+        # Cache miss or expired: proceed with full validation
+        if verbose:
+            print(f"⟳ Checking API key validity for service '{service}'...")
+
+        # Fetch valid public keys
+        url = public_keys_url or self.DEFAULT_URL
+        if verbose:
+            print("   Checking public keys from remote server...")
+
+        all_valid_keys = self.fetch_valid_public_keys(url, verbose=verbose, jsonbin_api_key=jsonbin_api_key)
+
+        # Filter keys by the specified service
+        valid_public_keys = [key['public_key'] for key in all_valid_keys if key['service'] == service]
+
+        # Check if service exists
+        if not valid_public_keys:
+            # Check if the service name exists in the fetched keys
+            available_services = set(key['service'] for key in all_valid_keys)
+            if service not in available_services:
+                # Find similar service names to suggest
+                def levenshtein_distance(s1, s2):
+                    """Compute the Levenshtein distance between two strings"""
+                    if len(s1) < len(s2):
+                        return levenshtein_distance(s2, s1)
+                    if len(s2) == 0:
+                        return len(s1)
+
+                    previous_row = range(len(s2) + 1)
+                    for i, c1 in enumerate(s1):
+                        current_row = [i + 1]
+                        for j, c2 in enumerate(s2):
+                            insertions = previous_row[j + 1] + 1
+                            deletions = current_row[j] + 1
+                            substitutions = previous_row[j] + (0 if c1 == c2 else 1)
+                            current_row.append(min(insertions, deletions, substitutions))
+                        previous_row = current_row
+                    return previous_row[-1]
+
+                # Suggest services with Levenshtein distance <= 2
+                similar_services = sorted(
+                    [s for s in available_services if levenshtein_distance(service.lower(), s.lower()) <= 2],
+                    key=lambda s: levenshtein_distance(service.lower(), s.lower())
+                )
+
+                if similar_services:
+                    raise PermissionError(
+                        f"API key validation failed: Service '{service}' does not exist. Did you mean: {', '.join(similar_services)}?"
+                    )
+                else:
+                    raise PermissionError(
+                        f"API key validation failed: Service '{service}' does not exist."
+                    )
+
+        # Compute public key from secret key
+        try:
+            computed_public_key = self.compute_public_key(secret_key)
+        except RuntimeError as e:
+            raise RuntimeError(f"API key validation failed: {e}")
+
+        # Check if any of the valid public keys match the secret key
+        valid = False
+        for public_key in valid_public_keys:
+            try:
+                if self.PH.verify(public_key, secret_key):
+                    valid = True
+                    break
+            except Exception:
+                # If verification fails for any reason, try next one
+                continue
+
+        if not valid:
+            raise PermissionError(
+                "API key validation failed: API key is not correct for the specified service. Please apply for a valid API key from yanru@cyanru.com"
+            )
+
+        # Update cache with valid key-service pair
+        self.API_KEY_CACHE[cache_key] = current_time + self.CACHE_TTL_SECONDS
+        expiration_time = self.API_KEY_CACHE[cache_key]
+
+        if verbose:
+            print(f"✓ API key validation passed for service '{service}'")
+            print(f"   Caching result until {time.ctime(expiration_time)}")
+
+        return True
+
+
+# Create singleton instance
+gateway = APIKeyGateway()

apikey_gateway/helpers.py

@@ -0,0 +1,71 @@
+"""Helper functions for the API key gateway"""
+
+from .gateway import gateway
+
+
+# Expose some constants and helper functions for backward compatibility
+CACHE_TTL_SECONDS = gateway.CACHE_TTL_SECONDS
+API_KEY_CACHE = gateway.API_KEY_CACHE
+PH = gateway.PH
+
+
+def retry_on_exception(exceptions, max_retries=3, delay=0.5, backoff=1):
+    """
+    Decorator that retries a function on specific exceptions.
+
+    :param exceptions: Tuple of exceptions to retry on
+    :param max_retries: Maximum number of retries (default: 3)
+    :param delay: Initial delay between retries in seconds (default: 0.5)
+    :param backoff: Factor by which delay increases each retry (default: 1 for constant delay)
+    """
+    from .gateway import APIKeyGateway
+    return APIKeyGateway.retry_on_exception(exceptions, max_retries, delay, backoff)
+
+
+def fetch_valid_public_keys(url, verbose=True):
+    """Fetch the list of valid public keys from the specified URL."""
+    return gateway.fetch_valid_public_keys(url, verbose=verbose)
+
+
+def compute_public_key(secret_key):
+    """Compute the public key from the secret key using argon2id."""
+    return gateway.compute_public_key(secret_key)
+
+
+def validate_api_key(secret_key, service, public_keys_url=None, verbose=True, jsonbin_api_key=None):
+    """Validate an API key for a specific service"""
+    return gateway.validate_api_key(secret_key, service, public_keys_url=public_keys_url, verbose=verbose, jsonbin_api_key=jsonbin_api_key)
+
+
+def add_apikey_gateway_middleware(
+    app,
+    service: str,
+    public_keys_url: str | None = None,
+    api_key_headers: list[str] | None = None,
+    jsonbin_api_key_header: str | None = None,
+    verbose: bool = True
+):
+    """
+    Convenience function to add APIKeyGatewayMiddleware to a FastAPI app.
+
+    :param app: FastAPI app instance
+    :param service: Service name to validate against
+    :param public_keys_url: Custom URL for public keys
+    :param api_key_headers: List of headers to check for API key
+    :param jsonbin_api_key_header: Header name to check for JSONBin API key (default: X-JSONBIN-API-KEY)
+    :param verbose: Verbose logging
+    """
+    from .middleware import APIKeyGatewayMiddleware, FASTAPI_AVAILABLE
+
+    if not FASTAPI_AVAILABLE:
+        raise RuntimeError("FastAPI is not installed. Please install it with 'pip install fastapi'.")
+
+    # Add middleware directly to the app
+    app.add_middleware(
+        APIKeyGatewayMiddleware,
+        service=service,
+        public_keys_url=public_keys_url,
+        api_key_headers=api_key_headers,
+        jsonbin_api_key_header=jsonbin_api_key_header,
+        verbose=verbose
+    )

apikey_gateway/middleware.py

@@ -0,0 +1,124 @@
+"""FastAPI middleware for API key gateway validation"""
+
+# Try to import FastAPI types for middleware (optional dependency)
+try:
+    from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+    from starlette.requests import Request
+    from starlette.responses import Response, JSONResponse
+    from fastapi import FastAPI
+    FASTAPI_AVAILABLE = True
+except ImportError:
+    # If FastAPI is not installed, middleware-related functionality will be disabled
+    FASTAPI_AVAILABLE = False
+    # Create mock classes for type hinting
+    class Request:
+        pass
+
+    class Response:
+        pass
+
+    class JSONResponse:
+        pass
+
+    class BaseHTTPMiddleware:
+        pass
+
+    class RequestResponseEndpoint:
+        pass
+
+    class FastAPI:
+        pass
+
+
+class APIKeyGatewayMiddleware(BaseHTTPMiddleware):
+    """
+    FastAPI middleware for API key gateway validation.
+
+    Best practice:
+    - Validates API keys for all incoming requests to protected routes
+    - Extracts API key from configurable headers (default: X-API-Key, Authorization Bearer)
+    - Supports service-specific validation
+    - Handles proper error responses with appropriate status codes
+    """
+
+    def __init__(
+        self,
+        app: FastAPI,
+        service: str,
+        public_keys_url: str | None = None,
+        api_key_headers: list[str] | None = None,
+        jsonbin_api_key_header: str | None = None,
+        verbose: bool = True
+    ):
+        """
+        Initialize the API key gateway middleware.
+
+        :param app: FastAPI app instance
+        :param service: Service name to validate against (required)
+        :param public_keys_url: Custom URL for public keys (defaults to gateway's DEFAULT_URL)
+        :param api_key_headers: List of headers to check for API key (default: X-AKGATEWAY-API-KEY, Authorization Bearer)
+        :param jsonbin_api_key_header: Header name to check for JSONBin API key (default: X-JSONBIN-API-KEY)
+        :param verbose: Verbose logging
+        """
+        super().__init__(app)
+        from .gateway import gateway
+        self.service = service
+        self.public_keys_url = public_keys_url
+        self.api_key_headers = api_key_headers or [
+            "x-akgateway-api-key",
+            "authorization"  # for Bearer token format
+        ]
+        self.jsonbin_api_key_header = jsonbin_api_key_header or "x-jsonbin-api-key"
+        self.verbose = verbose
+        self.gateway_instance = gateway
+
+
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -> Response:
+        """
+        Middleware dispatch method that handles API key validation.
+        """
+        # Extract API key from configured headers
+        headers = request.headers
+
+        # Extract secret API key
+        secret_key = None
+        for header_name in self.api_key_headers:
+            header_value = headers.get(header_name)
+            if header_value:
+                if header_name.lower() == "authorization":
+                    # Handle Bearer token format
+                    if header_value.lower().startswith("bearer "):
+                        secret_key = header_value[7:].strip()
+                        break
+                else:
+                    # Handle direct header value
+                    secret_key = header_value.strip()
+                    break
+
+        # Extract JSONBin API key from header if present
+        jsonbin_api_key = headers.get(self.jsonbin_api_key_header)
+
+        try:
+            # Validate the API key using the gateway instance
+            if secret_key:
+                self.gateway_instance.validate_api_key(
+                    secret_key=secret_key,
+                    service=self.service,
+                    public_keys_url=self.public_keys_url,
+                    verbose=self.verbose,
+                    jsonbin_api_key=jsonbin_api_key
+                )
+            else:
+                # No API key found in headers
+                raise PermissionError("API key validation failed: No API key found in request headers")
+
+            # If validation passes, call the next endpoint
+            response = await call_next(request)
+            return response
+
+        except (PermissionError, RuntimeError) as e:
+            # Return appropriate error response
+            return JSONResponse(
+                status_code=401 if isinstance(e, PermissionError) else 500,
+                content={"error": str(e)}
+            )

apikey_gateway-1.1.1.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: apikey-gateway
+Version: 1.1.1
+Summary: A Python library for API key validation
+Project-URL: Homepage, https://github.com/yanrucheng/apikey-gateway
+Project-URL: Bug Tracker, https://github.com/yanrucheng/apikey-gateway/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: argon2-cffi>=25.1.0
+Requires-Dist: pytest>=8.3.5
+
+# API Key Gateway
+
+A Python library that provides an `@apikey_login` decorator to validate API keys with service-aware authentication.
+
+## Features
+
+- **CLI Decorator**: Automatically adds `--apikey/-a` CLI parameter to decorated functions
+- **FastAPI Middleware**: Built-in support for FastAPI applications
+- **Strong Security**: Validates API keys using argon2id hashing algorithm
+- **Service-Aware**: Keys are scoped to specific services
+- **Remote Key Management**: Fetches valid public keys from a remote JSON endpoint
+- **Caching**: Caches valid API key-service pairs for improved performance
+- **Retry Mechanism**: Automatically retries fetching keys on network failures
+- **Flexible Configuration**: Supports custom API key URLs and authentication headers
+
+## Installation
+
+```bash
+uv install apikey-gateway
+```
+
+## Usage
+
+The library supports two usage modes: **CLI Decorator** and **FastAPI Middleware**.
+
+### CLI Decorator
+The `apikey_login` decorator automatically adds `--apikey/-a` CLI parameter to decorated functions.
+
+```python
+from apikey_gateway import apikey_login
+
+@apikey_login(service="media-match")
+def media_app():
+    print("API key validated for media-match service!")
+    # Your media application logic here
+
+@apikey_login(service="analytics")
+def analytics_app():
+    print("API key validated for analytics service!")
+    # Your analytics application logic here
+
+if __name__ == "__main__":
+    media_app()  # or analytics_app()
+```
+
+Run with:
+```bash
+python app.py --apikey your-secret-key
+```
+
+### FastAPI Middleware
+The library provides built-in FastAPI middleware for validating API keys on all requests.
+
+```python
+from fastapi import FastAPI
+from apikey_gateway import add_apikey_gateway_middleware
+
+# Create your FastAPI app
+app = FastAPI(title="My API")
+
+# Add API key validation middleware
+add_apikey_gateway_middleware(
+    app=app,
+    service="my-service",
+    verbose=True
+)
+
+# All endpoints below will require API key validation
+@app.get("/protected/resource")
+def protected_resource():
+    return {"message": "Access granted to protected resource"}
+
+# To run: uvicorn app:app --reload
+```
+
+Test the FastAPI endpoint:
+```bash
+# With X-AKGATEWAY-API-KEY header (default)
+curl -H "X-AKGATEWAY-API-KEY: your-secret-key" http://localhost:8000/protected/resource
+
+# With Authorization Bearer header
+curl -H "Authorization: Bearer your-secret-key" http://localhost:8000/protected/resource
+```
+
+Middleware Features:
+- Automatically checks `X-AKGATEWAY-API-KEY` and `Authorization Bearer` headers
+- Supports custom API key headers
+- Can be configured with a custom public keys URL
+- Supports `X-JSONBIN-API-KEY` header for JSONBin API key authentication
+- Allows customization of both API key header and JSONBin API key header names
+
+## How It Works
+
+### For CLI Applications
+1. The application specifies the `service` name when using the `@apikey_login` decorator
+2. The user provides a secret API key via the `--apikey/-a` CLI parameter
+3. Followed by the same validation steps as FastAPI applications...
+
+### For FastAPI Applications
+1. The application adds the middleware with a specific `service` name
+2. The client provides a secret API key via `X-AKGATEWAY-API-KEY` or `Authorization Bearer` header
+3. Followed by the same validation steps as CLI applications...
+
+### Common Validation Steps
+3. The library computes an argon2id hash (public key) from the secret key
+4. It fetches the list of valid public keys from `https://api.jsonbin.io/v3/b/691ec6a543b1c97be9b8ea6d`
+5. Valid keys are filtered to only those belonging to the specified service
+6. If the computed public key matches any valid service-specific public key, access is granted
+
+## JSON Format
+
+The remote JSON follows a service-aware structure where keys are organized by service name:
+
+### Service-Aware Structure
+```json
+{
+  "service1": {
+    "key_id_1": "argon2id_hash_here",
+    "key_id_2": "another_hash_here"
+  },
+  "service2": "single_key_hash_here"
+}
+```
+
+- Top-level keys are service names
+- Each service can have either multiple keys (as a dictionary) or a single key (as a string)
+- The library automatically handles both formats when fetching keys
+
+## License
+
+MIT

apikey_gateway-1.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+apikey_gateway/__init__.py,sha256=wik-nyj1clngVzzmK244hzvZqzAyx8oTmB932byH8aU,1207
+apikey_gateway/decorators.py,sha256=7K8khH0t6NOAWNvaVVtOlCWSJBXe8ygK4p7pd8bSYvs,2555
+apikey_gateway/gateway.py,sha256=lNz5Wua3_Jn-kNqBWiMvNxR3Dkta1XPrgSPMzFmRbwg,10533
+apikey_gateway/helpers.py,sha256=91Snz_LZsCOOgpPcQdhZDd9-ZJanYXtKPDtgoME-jdc,2616
+apikey_gateway/middleware.py,sha256=ym-zNMukNkx9kNulYroMCe7F9Dna6BzpxL7gKu5wZt8,4456
+apikey_gateway-1.1.1.dist-info/METADATA,sha256=uuU93HScsmFy0IyGPOw8nzNEnQhZ_STZMVhf49F_f8Q,4709
+apikey_gateway-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+apikey_gateway-1.1.1.dist-info/top_level.txt,sha256=nwreq0PaHh4WpaMOluQ3V5iA1LP8y9GliflzObT7G1I,15
+apikey_gateway-1.1.1.dist-info/RECORD,,

apikey_gateway-1.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

apikey_gateway-1.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+apikey_gateway