keycycle 0.3.0__tar.gz → 0.3.2__tar.gz

{keycycle-0.3.0 → keycycle-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keycycle
-Version: 0.3.0
+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

{keycycle-0.3.0 → keycycle-0.3.2}/keycycle/adapters/openai_adapter.py

@@ -43,6 +43,7 @@ PROVIDER_BASE_URLS = {
     "groq": "https://api.groq.com/openai/v1",
     "cohere": "https://api.cohere.ai/compatibility/v1",
     "moonshot": "https://api.moonshot.ai/v1",
+    "mistral": "https://api.mistral.ai/v1",
 }
 
 class BaseRotatingClient:

keycycle-0.3.2/keycycle/config/models/mistral.yaml

@@ -0,0 +1,13 @@
+# Mistral API rate limits (dummy high limits, same posture as moonshot.yaml)
+# Base URL: https://api.mistral.ai/v1 (OpenAI-compatible chat completions)
+# Not independently researched against Mistral's published tier limits yet --
+# a single key (NUM_MISTRAL=1, no rotation benefit) makes local throttling
+# low-value for now; Mistral's own 429s still surface and rotate normally.
+
+default:
+  requests_per_minute: 10000
+  requests_per_hour: 100000
+  requests_per_day: 1000000
+  tokens_per_minute: 10000000
+  tokens_per_hour: 100000000
+  tokens_per_day: 1000000000

{keycycle-0.3.0 → keycycle-0.3.2}/keycycle/config/models.py

@@ -16,6 +16,7 @@ class ModelDict(TypedDict):
     openrouter: Any
     cohere: Any
     moonshot: Any
+    mistral: Any
 
 PROVIDER_STRATEGIES: ModelDict = {
     'cerebras': RateLimitStrategy.PER_MODEL,
@@ -23,7 +24,8 @@ PROVIDER_STRATEGIES: ModelDict = {
     'gemini': RateLimitStrategy.PER_MODEL,
     'openrouter': RateLimitStrategy.GLOBAL,
     'cohere': RateLimitStrategy.PER_MODEL,
-    'moonshot': RateLimitStrategy.PER_MODEL
+    'moonshot': RateLimitStrategy.PER_MODEL,
+    'mistral': RateLimitStrategy.PER_MODEL
 }
 
 # Load Cohere tiers first to handle the env var logic
@@ -44,7 +46,8 @@ MODEL_LIMITS: ModelDict = {
         # Same for every model
         'default': COHERE_TIERS.get(os.getenv('COHERE_TIER', 'free').lower(), COHERE_TIERS['free'])
     },
-    'moonshot': load_rate_limits_from_yaml(os.path.join(MODELS_DIR, 'moonshot.yaml'))
+    'moonshot': load_rate_limits_from_yaml(os.path.join(MODELS_DIR, 'moonshot.yaml')),
+    'mistral': load_rate_limits_from_yaml(os.path.join(MODELS_DIR, 'mistral.yaml'))
 }
 
 OPENROUTER_MODELS = load_openrouter_models(os.path.join(MODELS_DIR, 'openrouter_models.yaml'))

{keycycle-0.3.0 → keycycle-0.3.2}/keycycle/core/utils.py

@@ -313,26 +313,59 @@ def load_api_keys(
         env_path = Path.cwd() / ".env"
     load_dotenv(dotenv_path=env_path, override=True)
 
-    num_keys_var = f"NUM_{provider.upper()}"
-    num_keys = os.getenv(num_keys_var)
-    if not num_keys:
+    provider_upper = provider.upper()
+    num_keys_var = f"NUM_{provider_upper}"
+    num_keys_raw = os.getenv(num_keys_var)
+    if not num_keys_raw:
         raise ValueError(f"Environment variable '{num_keys_var}' not found.")
     try:
-        num_keys = int(num_keys)
+        expected_count = int(num_keys_raw)
     except ValueError:
-        raise ValueError(f"'{num_keys_var}' must be an integer, got: {num_keys}")
+        raise ValueError(f"'{num_keys_var}' must be an integer, got: {num_keys_raw}")
+
+    # NUM_{PROVIDER} is AUTHORITATIVE (0.3.2, reverting 0.3.1's scan-all):
+    # the fleet convention is that the first NUM indices (sorted ascending)
+    # are the sanctioned live keys, and keys parked at higher indices beyond
+    # a numbering gap are dead or spare on purpose -- loading them would put
+    # known-bad keys back into rotation. Gaps INSIDE the sanctioned range
+    # are tolerated (a retired key's index can be missing); the loader takes
+    # the first NUM indices that actually exist and warns if it comes up
+    # short, but never loads past NUM keys.
+    key_pattern = re.compile(rf"^{re.escape(provider_upper)}_API_KEY_(\d+)$")
+    found: Dict[int, str] = {}
+    for env_name, value in os.environ.items():
+        match = key_pattern.match(env_name)
+        if match and value:
+            found[int(match.group(1))] = value
+
+    if not found:
+        raise ValueError(f"Missing API key: {provider_upper}_API_KEY_1")
+
+    all_indices = sorted(found)
+    indices = all_indices[:expected_count]
+    excluded = all_indices[expected_count:]
+    if excluded:
+        logging.getLogger(__name__).info(
+            "%s: %s=%d -- using the first %d key indices %s; excluding %d "
+            "parked key(s) at indices %s (dead/spare by convention).",
+            provider_upper, num_keys_var, expected_count, len(indices), indices,
+            len(excluded), excluded,
+        )
+    if len(indices) < expected_count:
+        logging.getLogger(__name__).warning(
+            "%s: only %d API key(s) found (indices %s) but %s=%d -- the "
+            "declared count is stale. Using the %d key(s) actually found.",
+            provider_upper, len(indices), indices, num_keys_var, expected_count,
+            len(indices),
+        )
 
     keys: List[KeyEntry] = []
-    for i in range(1, num_keys + 1):
-        key_var = f"{provider.upper()}_API_KEY_{i}"
-        key = os.getenv(key_var)
-        if not key:
-            raise ValueError(f"Missing API key: {key_var}")
-
+    for i in indices:
+        key = found[i]
         if extra_params:
             key_dict: Dict[str, Any] = {api_key_param: key}
             for param in extra_params:
-                val = os.getenv(f"{provider.upper()}_{param.upper()}_{i}")
+                val = os.getenv(f"{provider_upper}_{param.upper()}_{i}")
                 if val:
                     key_dict[param] = val
             keys.append(key_dict)

{keycycle-0.3.0 → keycycle-0.3.2}/keycycle.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keycycle
-Version: 0.3.0
+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

{keycycle-0.3.0 → keycycle-0.3.2}/keycycle.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ keycycle/config/models/cerebras.yaml
 keycycle/config/models/cohere.yaml
 keycycle/config/models/gemini.yaml
 keycycle/config/models/groq.yaml
+keycycle/config/models/mistral.yaml
 keycycle/config/models/moonshot.yaml
 keycycle/config/models/openrouter.yaml
 keycycle/config/models/openrouter_models.yaml

{keycycle-0.3.0 → keycycle-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "keycycle"
-version = "0.3.0"
+version = "0.3.2"
 authors = [
   { name="William Jin", email="jinwilliam.jin@gmail.com" },
 ]

{keycycle-0.3.0 → keycycle-0.3.2}/tests/test_multi_client_wrapper.py

@@ -330,6 +330,53 @@ class TestLoadApiKeysStatic(unittest.TestCase):
 
         self.assertIn("Missing API key", str(ctx.exception))
 
+    @patch.dict(os.environ, {
+        # The fleet convention (0.3.2): the first NUM indices are the
+        # sanctioned live keys; keys parked at higher indices beyond a gap
+        # are dead or spare ON PURPOSE (mirrors William's GROQ fleet:
+        # 1..24 live, 37..46 parked dead). NUM is authoritative.
+        "NUM_GAPPY": "24",
+        **{f"GAPPY_API_KEY_{i}": f"key-{i}" for i in range(1, 25)},
+        **{f"GAPPY_API_KEY_{i}": f"key-{i}" for i in range(37, 47)},
+    })
+    @patch('keycycle.multi_client_wrapper.load_dotenv')
+    def test_load_keys_num_caps_out_parked_keys(self, mock_dotenv):
+        """Only the first NUM sorted indices load; parked keys stay out."""
+        keys = MultiClientWrapper.load_api_keys("gappy")
+
+        self.assertEqual(len(keys), 24)
+        self.assertEqual(keys[0], "key-1")
+        self.assertEqual(keys[-1], "key-24")
+
+    @patch.dict(os.environ, {
+        # A gap INSIDE the sanctioned range is tolerated: index 2 retired,
+        # NUM still says 3, so the loader takes the first 3 that exist
+        # (1, 3, 4) rather than crashing or stopping at the gap.
+        "NUM_HOLEY": "3",
+        "HOLEY_API_KEY_1": "key-1",
+        "HOLEY_API_KEY_3": "key-3",
+        "HOLEY_API_KEY_4": "key-4",
+        "HOLEY_API_KEY_9": "key-9",
+    })
+    @patch('keycycle.multi_client_wrapper.load_dotenv')
+    def test_load_keys_tolerates_gap_inside_sanctioned_range(self, mock_dotenv):
+        keys = MultiClientWrapper.load_api_keys("holey")
+        self.assertEqual(keys, ["key-1", "key-3", "key-4"])
+
+    @patch.dict(os.environ, {
+        "NUM_SPARSE": "5",
+        "SPARSE_API_KEY_1": "key-1",
+        "SPARSE_API_KEY_3": "key-3",
+    })
+    @patch('keycycle.multi_client_wrapper.load_dotenv')
+    def test_load_keys_logs_warning_on_count_mismatch(self, mock_dotenv):
+        """A mismatch between NUM_{PROVIDER} and keys found is logged loudly."""
+        with self.assertLogs('keycycle.core.utils', level='WARNING') as ctx:
+            keys = MultiClientWrapper.load_api_keys("sparse")
+
+        self.assertEqual(keys, ["key-1", "key-3"])
+        self.assertTrue(any("NUM_SPARSE" in msg for msg in ctx.output))
+
 
 class TestKwargFiltering(unittest.TestCase):
     """Test the kwarg filtering functionality (introspection + manual exclusion)."""