keycycle 0.3.2__py3-none-any.whl

keycycle/multi_client_wrapper.py

@@ -0,0 +1,372 @@
+"""
+Multi-client wrapper for managing multiple providers with rotating API keys.
+
+This module provides the primary interface for keycycle, supporting:
+- Multi-parameter key rotation (api_key + index_id, etc.)
+- Multiple providers in a single wrapper
+- Environment-based configuration with indexed params
+"""
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union
+
+from dotenv import load_dotenv
+
+from .key_rotation.rotation_manager import RotatingKeyManager
+from .config.dataclasses import RateLimits, KeyLimitOverride
+from .config.enums import RateLimitStrategy
+from .config.models import MODEL_LIMITS, PROVIDER_STRATEGIES
+from .core.utils import (
+    KeyEntry,
+    get_key_suffix,
+    load_api_keys as _load_api_keys,
+    normalize_key_limits as _normalize_key_limits,
+)
+from .usage.db_logic import UsageDatabase
+from .adapters.generic_adapter import (
+    create_rotating_client,
+    SyncGenericRotatingClient,
+    AsyncGenericRotatingClient,
+)
+
+T = TypeVar("T")
+
+
+@dataclass
+class ProviderConfig:
+    """Internal config for a registered provider."""
+    default_model: Optional[str] = None
+    limits: Optional[Dict[str, RateLimits]] = None
+    excluded_kwargs: Optional[List[str]] = None
+
+
+@dataclass
+class ProviderEnvConfig:
+    """
+    Configuration for loading a provider from environment variables.
+
+    Attributes:
+        default_model: Default model ID for this provider
+        extra_params: List of extra parameter names to load alongside API keys.
+            For each param, loads {PROVIDER}_{PARAM}_N environment variables.
+        strategy: Rate limit strategy (per-model or global)
+        limits: Custom rate limits per model
+        api_key_param: Name of the API key parameter (default: "api_key")
+        excluded_kwargs: List of kwarg names to exclude from client constructor.
+            Useful for clients that don't accept certain params (e.g., TwelveLabs doesn't accept 'model').
+    """
+    default_model: Optional[str] = None
+    extra_params: Optional[List[str]] = None
+    strategy: RateLimitStrategy = RateLimitStrategy.PER_MODEL
+    limits: Optional[Dict[str, RateLimits]] = None
+    api_key_param: str = "api_key"
+    excluded_kwargs: Optional[List[str]] = None
+
+
+class MultiClientWrapper:
+    """
+    Manages multiple providers with rotating API keys.
+
+    This is the primary wrapper for keycycle, supporting:
+    - Multiple providers in a single instance
+    - Multi-parameter rotation (api_key + other params)
+    - Environment-based configuration
+
+    Example:
+        >>> wrapper = MultiClientWrapper.from_env({
+        ...     "twelvelabs": ProviderEnvConfig(
+        ...         default_model="pegasus-1",
+        ...         extra_params=["index_id"],
+        ...     ),
+        ...     "anthropic": ProviderEnvConfig(
+        ...         default_model="claude-3-sonnet",
+        ...     ),
+        ... })
+        >>> tl_client = wrapper.get_rotating_client("twelvelabs", TwelveLabs)
+        >>> claude_client = wrapper.get_rotating_client("anthropic", Anthropic)
+    """
+
+    MODEL_LIMITS = MODEL_LIMITS
+    PROVIDER_STRATEGIES = PROVIDER_STRATEGIES
+
+    def __init__(self, db_url: Optional[str] = None, db_env_var: str = "TIDB_DB_URL"):
+        """
+        Initialize a MultiClientWrapper.
+
+        Args:
+            db_url: Database URL for usage persistence (optional)
+            db_env_var: Environment variable name for database URL
+        """
+        self.db = UsageDatabase(db_url, db_env_var)
+        self._managers: Dict[str, RotatingKeyManager] = {}
+        self._configs: Dict[str, ProviderConfig] = {}
+        self._key_limits: Dict[str, Dict[str, KeyLimitOverride]] = {}
+
+    def register_provider(
+        self,
+        provider: str,
+        keys: List[KeyEntry],
+        strategy: Optional[RateLimitStrategy] = None,
+        default_model: Optional[str] = None,
+        limits: Optional[Dict[str, RateLimits]] = None,
+        api_key_param: str = "api_key",
+        key_limits: Optional[Dict[Union[int, str], KeyLimitOverride]] = None,
+        **kwargs
+    ) -> "MultiClientWrapper":
+        """
+        Register a provider with its keys.
+
+        Args:
+            provider: Provider name (e.g., "twelvelabs", "anthropic")
+            keys: List of key entries (strings or dicts with params)
+            strategy: Rate limit strategy (defaults to provider's default)
+            default_model: Default model ID
+            limits: Custom rate limits per model
+            api_key_param: Name of the API key parameter
+            key_limits: Per-key rate limit overrides
+            **kwargs: Additional arguments for RotatingKeyManager
+
+        Returns:
+            Self for method chaining
+        """
+        provider = provider.lower()
+
+        # Use provider-specific strategy if not specified
+        if strategy is None:
+            strategy = self.PROVIDER_STRATEGIES.get(provider, RateLimitStrategy.PER_MODEL)
+
+        # Normalize key_limits to suffix-based
+        normalized_key_limits = self._normalize_key_limits_from_entries(keys, key_limits, api_key_param)
+        self._key_limits[provider] = normalized_key_limits
+
+        manager = RotatingKeyManager(
+            api_keys=keys,
+            provider_name=provider,
+            strategy=strategy,
+            db=self.db,
+            api_key_param=api_key_param,
+            limit_resolver=lambda m, k, p=provider: self._resolve_limits(p, m, k),
+            **kwargs
+        )
+        self._managers[provider] = manager
+        self._configs[provider] = ProviderConfig(default_model, limits)
+        return self
+
+    def _normalize_key_limits_from_entries(
+        self,
+        keys: List[KeyEntry],
+        key_limits: Optional[Dict[Union[int, str], KeyLimitOverride]],
+        api_key_param: str = "api_key",
+    ) -> Dict[str, KeyLimitOverride]:
+        """Normalize key_limits to suffix-based lookup."""
+        if not key_limits:
+            return {}
+
+        # Extract primary keys
+        primary_keys = []
+        for entry in keys:
+            if isinstance(entry, str):
+                primary_keys.append(entry)
+            else:
+                primary_keys.append(entry.get(api_key_param, ""))
+
+        return _normalize_key_limits(primary_keys, key_limits)
+
+    def _resolve_limits(
+        self,
+        provider: str,
+        model_id: str,
+        key_suffix: Optional[str] = None
+    ) -> RateLimits:
+        """Resolve rate limits for a provider/model/key combination."""
+        config = self._configs.get(provider)
+        provider_key_limits = self._key_limits.get(provider, {})
+
+        # Check key-specific overrides first
+        if key_suffix and provider_key_limits:
+            override = provider_key_limits.get(key_suffix)
+            if override:
+                if isinstance(override, RateLimits):
+                    return override
+                elif isinstance(override, dict):
+                    if model_id in override:
+                        return override[model_id]
+                    if '__default__' in override:
+                        return override['__default__']
+
+        # Check provider-specific limits from config
+        if config and config.limits and model_id in config.limits:
+            return config.limits[model_id]
+
+        # Fall back to global model limits
+        provider_limits = self.MODEL_LIMITS.get(provider, {})
+        return provider_limits.get(model_id, provider_limits.get('default', RateLimits(10, 100, 1000)))
+
+    def get_rotating_client(
+        self,
+        provider: str,
+        client_class: Type[T],
+        model: Optional[str] = None,
+        api_key_param: Optional[str] = None,
+        is_async: Optional[bool] = None,
+        usage_extractor: Optional[Callable[[Any], int]] = None,
+        estimated_tokens: int = 1000,
+        max_retries: int = 5,
+        model_param: str = "model",
+        excluded_kwargs: Optional[List[str]] = None,
+        **client_kwargs
+    ) -> Union[SyncGenericRotatingClient[T], AsyncGenericRotatingClient[T]]:
+        """
+        Get a rotating client for a registered provider.
+
+        Args:
+            provider: Registered provider name
+            client_class: The client class to wrap
+            model: Model ID (defaults to provider's default_model)
+            api_key_param: Override the API key parameter name
+            is_async: Whether the client is async (auto-detected if None)
+            usage_extractor: Custom function to extract token usage
+            estimated_tokens: Estimated tokens per request
+            max_retries: Max key rotations on rate limit errors
+            model_param: Name of the model parameter in API calls
+            excluded_kwargs: List of kwarg names to exclude from client constructor.
+                Useful for clients that don't accept certain params (e.g., 'model' for TwelveLabs).
+            **client_kwargs: Additional kwargs for client constructor
+
+        Returns:
+            A rotating client wrapper
+
+        Raises:
+            ValueError: If provider is not registered
+        """
+        provider = provider.lower()
+        manager = self._managers.get(provider)
+        if not manager:
+            raise ValueError(f"Provider '{provider}' not registered. Call register_provider() first.")
+
+        config = self._configs[provider]
+        default_model = model or config.default_model or "default"
+
+        # Use the manager's api_key_param if not overridden
+        if api_key_param is None:
+            api_key_param = manager.api_key_param
+
+        # Use config's excluded_kwargs as default if not specified
+        if excluded_kwargs is None:
+            excluded_kwargs = config.excluded_kwargs
+
+        return create_rotating_client(
+            client_class=client_class,
+            manager=manager,
+            limit_resolver=lambda m, k: self._resolve_limits(provider, m, k),
+            default_model=default_model,
+            api_key_param=api_key_param,
+            is_async=is_async,
+            usage_extractor=usage_extractor,
+            estimated_tokens=estimated_tokens,
+            max_retries=max_retries,
+            model_param=model_param,
+            excluded_kwargs=excluded_kwargs,
+            **client_kwargs,
+        )
+
+    def get_manager(self, provider: str) -> RotatingKeyManager:
+        """Get the RotatingKeyManager for a provider."""
+        provider = provider.lower()
+        manager = self._managers.get(provider)
+        if not manager:
+            raise ValueError(f"Provider '{provider}' not registered.")
+        return manager
+
+    @classmethod
+    def from_env(
+        cls,
+        providers: Dict[str, ProviderEnvConfig],
+        env_file: Optional[str] = None,
+        db_url: Optional[str] = None,
+        db_env_var: str = "TIDB_DB_URL",
+    ) -> "MultiClientWrapper":
+        """
+        Create a wrapper from environment variables.
+
+        Args:
+            providers: Dict mapping provider names to their env configs
+            env_file: Path to .env file (optional)
+            db_url: Database URL for usage persistence
+            db_env_var: Environment variable name for database URL
+
+        Returns:
+            Configured MultiClientWrapper instance
+
+        Example:
+            >>> wrapper = MultiClientWrapper.from_env({
+            ...     "twelvelabs": ProviderEnvConfig(
+            ...         default_model="pegasus-1",
+            ...         extra_params=["index_id"],
+            ...     ),
+            ...     "anthropic": ProviderEnvConfig(
+            ...         default_model="claude-3-sonnet",
+            ...     ),
+            ... })
+
+        Environment variables format:
+            NUM_TWELVELABS=2
+            TWELVELABS_API_KEY_1=key1
+            TWELVELABS_INDEX_ID_1=idx_abc
+            TWELVELABS_API_KEY_2=key2
+            TWELVELABS_INDEX_ID_2=idx_xyz
+        """
+        instance = cls(db_url=db_url, db_env_var=db_env_var)
+
+        for provider, config in providers.items():
+            keys = cls.load_api_keys(
+                provider,
+                env_file=env_file,
+                extra_params=config.extra_params,
+                api_key_param=config.api_key_param,
+            )
+            instance.register_provider(
+                provider=provider,
+                keys=keys,
+                default_model=config.default_model,
+                strategy=config.strategy,
+                limits=config.limits,
+                api_key_param=config.api_key_param,
+            )
+            # Store excluded_kwargs from env config
+            if config.excluded_kwargs:
+                instance._configs[provider.lower()].excluded_kwargs = config.excluded_kwargs
+        return instance
+
+    @staticmethod
+    def load_api_keys(
+        provider: str,
+        env_file: Optional[str] = None,
+        extra_params: Optional[List[str]] = None,
+        api_key_param: str = "api_key",
+    ) -> List[KeyEntry]:
+        """
+        Load keys from environment variables with indexed pattern.
+
+        Args:
+            provider: Provider name (e.g., "twelvelabs")
+            env_file: Path to .env file (optional)
+            extra_params: List of extra param names to load
+            api_key_param: Name for the API key in returned dicts
+
+        Returns:
+            List of key entries
+
+        Environment variables format:
+            NUM_{PROVIDER}=N
+            {PROVIDER}_API_KEY_1, {PROVIDER}_API_KEY_2, ...
+            {PROVIDER}_{PARAM}_1, {PROVIDER}_{PARAM}_2, ... (for each extra_param)
+        """
+        return _load_api_keys(provider, env_file, extra_params, api_key_param)
+
+    def stop(self) -> None:
+        """Stop all managers and flush logs."""
+        for manager in self._managers.values():
+            manager.stop()

keycycle/usage/__init__.py

@@ -0,0 +1,6 @@
+from .db_logic import UsageDatabase
+from .usage_logger import AsyncUsageLogger
+__all__ = [
+    "UsageDatabase",
+    "AsyncUsageLogger"
+]

keycycle/usage/db_logic.py

@@ -0,0 +1,98 @@
+import os
+import time
+from typing import Optional, List
+from sqlalchemy import (
+    create_engine, select, and_, Table, Column,
+    Integer, String, Float, MetaData, Index, delete,
+    URL
+)
+
+from ..core.utils import get_key_suffix
+from ..config.constants import SECONDS_PER_DAY
+
+
+# --- DATABASE LAYER ---
+
+class UsageDatabase:
+    """Handles Online persistence for API usage"""
+    def __init__(self, db_url: Optional[str] = None, db_env_var: str = "TIDB_DB_URL"):
+        self.db_url = db_url or os.getenv(db_env_var)
+        if not self.db_url:
+            raise ValueError(f"Database URL not provided and {db_env_var} not set.")
+        self.engine = create_engine(
+            self.db_url,
+            pool_recycle = 300   
+        )
+        self._init_db()
+
+    def _init_db(self):
+        metadata = MetaData()
+        self.usage_logs = Table(
+            'usage_logs',
+            metadata,
+            Column('id', Integer, primary_key=True),
+            Column('provider', String(100)),
+            Column('model', String(100)),
+            Column('api_key_suffix', String(50)),
+            Column('timestamp', Float),
+            Column('tokens', Integer),
+
+            Index('idx_key_usage', 'provider', 'api_key_suffix', 'timestamp'),
+            Index('idx_cleanup', 'timestamp'),
+            Index('idx_model_reporting', 'provider', 'model', 'timestamp')
+        )
+        metadata.create_all(self.engine)
+
+    def load_history(self, provider: str, api_key: str, seconds_lookback: int) -> List[tuple[str, float, int]]:
+        """Load history SPECIFIC to this Provider + Model combination"""
+        suffix = get_key_suffix(api_key)
+        cutoff = time.time() - seconds_lookback
+
+        stmt = (
+            select(
+                self.usage_logs.c.model,
+                self.usage_logs.c.timestamp,
+                self.usage_logs.c.tokens,
+            )
+            .where(
+                and_(
+                    self.usage_logs.c.provider == provider,
+                    self.usage_logs.c.api_key_suffix == suffix,
+                    self.usage_logs.c.timestamp > cutoff,
+                )
+            )
+            .order_by(self.usage_logs.c.timestamp.asc())
+        )
+
+        with self.engine.connect() as conn:
+            return conn.execute(stmt).all()
+
+    def load_provider_history(self, provider: str, seconds_lookback: int):
+        """Optimization: Load everything for the provider in ONE call"""
+        cutoff = time.time() - seconds_lookback
+
+        stmt = (
+            select(
+                self.usage_logs.c.api_key_suffix,
+                self.usage_logs.c.model,
+                self.usage_logs.c.timestamp,
+                self.usage_logs.c.tokens,
+            )
+            .where(
+                self.usage_logs.c.provider == provider,
+                self.usage_logs.c.timestamp > cutoff,
+            )
+        )
+
+        with self.engine.connect() as conn:
+            return conn.execute(stmt).all()
+
+    def prune_old_records(self, days_retention: int = 3) -> None:
+        """Delete records older than retention period to keep DB small (3 days)"""
+        cutoff = time.time() - (days_retention * SECONDS_PER_DAY)
+        with self.engine.connect() as conn:
+            conn.execute(
+                delete(self.usage_logs).where(
+                self.usage_logs.c.timestamp < cutoff
+            ))
+            conn.commit()

keycycle/usage/usage_logger.py

@@ -0,0 +1,89 @@
+import atexit
+import logging
+import queue
+import threading
+import time
+from typing import Optional
+
+from .db_logic import UsageDatabase
+from ..config.log_config import default_logger
+from ..config.constants import USAGE_LOG_BATCH_SIZE
+from ..core.utils import get_key_suffix
+
+# --- ASYNC LOGGER ---
+class AsyncUsageLogger:
+    """Decouples Turso DB writes from the main thread using batching."""
+    def __init__(self, db: UsageDatabase, logger: Optional[logging.Logger] = None):
+        self.db = db
+        self.queue = queue.Queue()
+        self._stop_event = threading.Event()
+        self._thread = threading.Thread(target=self._writer_loop, daemon=True)
+        self._thread.start()
+        atexit.register(self.stop)
+
+        self.logger = logger or default_logger
+
+    def log(self, provider: str, model: str, api_key: str, tokens: int):
+        self.queue.put((provider, model, api_key, time.time(), tokens))
+
+    def _writer_loop(self):
+        batch = []
+        insert_stmt = self.db.usage_logs.insert()
+
+        while not self._stop_event.is_set() or not self.queue.empty(): #always empty queue
+            try:
+                record = self.queue.get(timeout=1.0)
+                # Parse record for batch formatting
+                provider, model, full_key, ts, tokens = record
+                suffix = get_key_suffix(full_key)
+                batch.append({
+                    "provider": provider,
+                    "model": model,
+                    "api_key_suffix": suffix,
+                    "timestamp": ts,
+                    "tokens": tokens
+                })
+                
+                # Drain queue up to USAGE_LOG_BATCH_SIZE items to batch write
+                while len(batch) < USAGE_LOG_BATCH_SIZE:
+                    try:
+                        r = self.queue.get_nowait()
+                        p, m, k, t, tok = r
+                        s = get_key_suffix(k)
+                        batch.append({
+                            "provider": p,
+                            "model": m,
+                            "api_key_suffix": s,
+                            "timestamp": t,
+                            "tokens": tok
+                        })
+                    except queue.Empty:
+                        break
+                
+                if batch:
+                    with self.db.engine.connect() as conn:
+                        conn.execute(insert_stmt, batch)
+                        conn.commit()
+                    batch.clear()
+                
+            except queue.Empty:
+                continue
+            except Exception as e:
+                # print(f"Logging thread error: {e}")
+                self.logger.exception("Logging thread error", exc_info=e)
+                time.sleep(2)
+        
+        if batch:
+            try:
+                with self.db.engine.connect() as conn:
+                    conn.execute(insert_stmt, batch)
+                    conn.commit()
+            except Exception as e:
+                self.logger.exception("Logging thread error on exit", exc_info=e)
+                
+    def stop(self):
+        self._stop_event.set()
+        if self._thread.is_alive():
+            self._thread.join(timeout=10)
+            if self._thread.is_alive():
+                self.logger.warning("AsyncUsageLogger thread did not exit cleanly within timeout.")

keycycle/utils.py

@@ -0,0 +1,27 @@
+import importlib
+
+def get_agno_model_class(provider: str):
+    """
+    Dynamically maps a provider string to the actual Agno model class.
+    """
+    p_low = provider.lower()
+
+    overrides = {
+        "openai": "OpenAI",
+        "google": "Gemini",
+        "gemini": "Gemini",
+        "azure": "AzureOpenAI",
+        "aws": "Bedrock",
+        "openrouter": "OpenRouter",
+        "moonshot": "MoonShot"
+    }
+
+    class_name = overrides.get(p_low, p_low.capitalize())
+
+    module_path = "google" if p_low in ["google", "gemini"] else p_low
+    
+    try:
+        module = importlib.import_module(f"agno.models.{module_path}")
+        return getattr(module, class_name)
+    except (ImportError, AttributeError) as e:
+        raise ValueError(f"Agno class '{class_name}' not found for provider '{provider}': {e}")

keycycle-0.3.2.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: keycycle
+Version: 0.3.2
+Summary: A thread-safe key rotation and rate limiting manager for API keys.
+Author-email: William Jin <jinwilliam.jin@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: python-dotenv
+Requires-Dist: sqlalchemy
+Requires-Dist: pymysql
+Requires-Dist: rich
+Requires-Dist: PyYAML
+Provides-Extra: openai
+Requires-Dist: openai; extra == "openai"
+Provides-Extra: agno
+Requires-Dist: agno; extra == "agno"
+Provides-Extra: cohere
+Requires-Dist: cohere; extra == "cohere"
+Provides-Extra: cerebras
+Requires-Dist: cerebras-cloud-sdk; extra == "cerebras"
+Provides-Extra: groq
+Requires-Dist: groq; extra == "groq"
+Provides-Extra: openrouter
+Requires-Dist: openrouter; extra == "openrouter"
+Provides-Extra: all
+Requires-Dist: openai; extra == "all"
+Requires-Dist: agno; extra == "all"
+Requires-Dist: cohere; extra == "all"
+Requires-Dist: cerebras-cloud-sdk; extra == "all"
+Requires-Dist: groq; extra == "all"
+Requires-Dist: openrouter; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=7.4.0; extra == "test"
+Requires-Dist: pytest-cov>=4.1.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.2.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: keycycle[test]; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"

keycycle-0.3.2.dist-info/RECORD

@@ -0,0 +1,37 @@
+keycycle/__init__.py,sha256=IRm7jD151rZk8KsdzF5527n7ve4NRPlYDGEp0z371Kk,1357
+keycycle/legacy_multi_provider_wrapper.py,sha256=u_8EW1eE8XfF84MBHKKK3KYQuPpPxdf4XFO4KPtLz8U,28820
+keycycle/multi_client_wrapper.py,sha256=vnCU2Tz3Tv75vMm-mALIZgj_SuLd-e2eozRLSW30NUo,13767
+keycycle/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+keycycle/utils.py,sha256=4nNzR35AG73HfaEdjIoct1yYhBYtHO58tLUJTupeaLQ,811
+keycycle/adapters/__init__.py,sha256=YclnV2JDpRBDaE5htVChjkSgbx_6o6xFK-pBDfNIxWk,540
+keycycle/adapters/generic_adapter.py,sha256=3iWAlMlvmZg83YP8I23ORzX0hzbD996oQK6GXffMJqg,25984
+keycycle/adapters/openai_adapter.py,sha256=CoarZIHfzVLdVfj1PBXoj46lFw8SX_itg0_RXeV9PEk,16133
+keycycle/config/__init__.py,sha256=ZTqtkbw3PBBc-tc4uvjhQkgpU6azATP7cmdBCQ5HHVw,483
+keycycle/config/constants.py,sha256=YBTedy-pDo1KTAKsTwot93dVdYh0b8Rbfoyd4LlpoAc,856
+keycycle/config/dataclasses.py,sha256=l-8wEixdd7eVIyXvblt2BFW93q7d36R_OxM7vYoY54Y,8769
+keycycle/config/enums.py,sha256=J8taDqXN0hT9-mBv8alihCmDoNRGtZuKtFMa87AOBvI,184
+keycycle/config/loader.py,sha256=cei34gYic0rz9PAdIE1LSbx6i8Xhg_I4Mb-fp2DlpcA,2008
+keycycle/config/log_config.py,sha256=tVVOwH4uekrdACOp1I-6NfOs0dxQ9ToBGg0X7vmQ344,1488
+keycycle/config/models.py,sha256=SLfJ8Myedpar7AcP118WLjQDN5MeU_8y3TLs5t3r1sI,1924
+keycycle/config/models/cerebras.yaml,sha256=frD4wiIUw4LaAmpDglS-zuJElTd7_wUxUX682ykcr_0,1441
+keycycle/config/models/cohere.yaml,sha256=itL2P0rwGHMBZh0vZJ9OOgBres-FTE1zKp8cpm3I2VU,268
+keycycle/config/models/gemini.yaml,sha256=vjc1bm_hPhGNj9dieFJTIcDpSAMNcsOvtpjfBi7SjV8,1505
+keycycle/config/models/groq.yaml,sha256=r-2-BqCloxK7O74t3Zq71ieJyP_zT1j8YCHS09CxqtI,3624
+keycycle/config/models/mistral.yaml,sha256=SHDDVHnU1LQyqBD2XaNP4ixWBfzWzzQ0-MPO_xfeTcA,563
+keycycle/config/models/moonshot.yaml,sha256=wUcsAwIU9hwYOrPqXdutBVR3q2Y93rZ_Yz3Fc6x9-pQ,1493
+keycycle/config/models/openrouter.yaml,sha256=hI0EZc2KR4YtCzJ7NubYNL-f5rux1y-NvxuYzgy_Fds,82
+keycycle/config/models/openrouter_models.yaml,sha256=qd43vjFAKh-9Uz2aeSvOqQtTD4bDbKBmc0AOrzJ02VM,2936
+keycycle/core/__init__.py,sha256=l7c_73JyYb9ao6MfcF360VnpEAWRWUq0dgASMEqF6_s,905
+keycycle/core/backoff.py,sha256=SkvJzXF0ZbUrdjbwOZk6csCbcz3QwKlwgRQYQ4rpcd8,2209
+keycycle/core/exceptions.py,sha256=TTzvsFvPv2aW38hGrxnEGwZQxLQ8o6eqMSwJy8vI3z0,2814
+keycycle/core/utils.py,sha256=KfHIyl0RbO2oLbV_0-Fs8ZmGPGH8QZYV8cZt04CXlWY,16085
+keycycle/key_rotation/__init__.py,sha256=Gk9Yk-Dkbw_OlUqQZbzGhJlkkIKRHb42hd0f_RE09vo,173
+keycycle/key_rotation/rotating_mixin.py,sha256=nh53FWb9uAAWQ6_yJMGaChlhOG3BOvIixxRksRv1zyg,17465
+keycycle/key_rotation/rotation_manager.py,sha256=sT6LKEZ_bz_kQdVP6Ie9J3AcpRYTEk7JkHvK1qRyVUQ,9388
+keycycle/usage/__init__.py,sha256=y7lJv-9VSpUPWU5cC-LznS1c4vR8Kec_SHKR7ZTpfAQ,136
+keycycle/usage/db_logic.py,sha256=Kd7tWKzr6kqJIPq3AATF2y4T5JAH31Ko7WhSgSOcQs4,3386
+keycycle/usage/usage_logger.py,sha256=TfTmD37xwKZpqeqzxhNNThX_UhA8NG3QtTyfBrBXuw0,3351
+keycycle-0.3.2.dist-info/METADATA,sha256=wm5OFHZfH2-NFro_32tRnG03T_ZQTVTlH6ANv-MVl4A,1593
+keycycle-0.3.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+keycycle-0.3.2.dist-info/top_level.txt,sha256=Vfq7VDf-qh5oxQpTVd4qKB0m5CTpO9LscJ-oGu30DvA,9
+keycycle-0.3.2.dist-info/RECORD,,

keycycle-0.3.2.dist-info/WHEEL

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

keycycle-0.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+keycycle