zpdatafetch 2.3.1__tar.gz → 2.3.2__tar.gz

{zpdatafetch-2.3.1/src/zpdatafetch.egg-info → zpdatafetch-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zpdatafetch
-Version: 2.3.1
+Version: 2.3.2
 Summary: A package for fetching data from Zwiftpower and Zwiftracing.app
 Author-email: Doug Morris <doug@mhost.com>
 License-Expression: MIT
@@ -704,7 +704,8 @@ status = ZRRider().rate_limiter.get_status() if hasattr(ZRRider(), 'rate_limiter
 
 #### Async Rate Limiting
 
-Async operations also respect rate limits with automatic throttling:
+Async operations also respect rate limits with automatic throttling. As with
+the sync API, the tier can be set globally and per call:
 
 ```python
 import anyio
@@ -717,12 +718,23 @@ async def main():
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to standard limits
 
-    # Premium tier
-    async with AsyncZR_obj(premium=True) as zr:
+    # Premium tier - set globally (applies to existing and new instances)
+    AsyncZR_obj.set_premium_mode(True)
+    async with AsyncZR_obj() as zr:
         rider = AsyncZRRider()
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to premium limits
 
+    # Premium tier - per call
+    async with AsyncZR_obj() as zr:
+        await zr.fetch_json('/public/riders/12345', premium=True)
+
+    # Premium tier - per instance
+    async with AsyncZR_obj(premium=True) as zr:
+        rider = AsyncZRRider()
+        rider.set_session(zr)
+        await rider.fetch(12345)
+
 anyio.run(main)
 ```
 

{zpdatafetch-2.3.1 → zpdatafetch-2.3.2}/README.md

@@ -675,7 +675,8 @@ status = ZRRider().rate_limiter.get_status() if hasattr(ZRRider(), 'rate_limiter
 
 #### Async Rate Limiting
 
-Async operations also respect rate limits with automatic throttling:
+Async operations also respect rate limits with automatic throttling. As with
+the sync API, the tier can be set globally and per call:
 
 ```python
 import anyio
@@ -688,12 +689,23 @@ async def main():
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to standard limits
 
-    # Premium tier
-    async with AsyncZR_obj(premium=True) as zr:
+    # Premium tier - set globally (applies to existing and new instances)
+    AsyncZR_obj.set_premium_mode(True)
+    async with AsyncZR_obj() as zr:
         rider = AsyncZRRider()
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to premium limits
 
+    # Premium tier - per call
+    async with AsyncZR_obj() as zr:
+        await zr.fetch_json('/public/riders/12345', premium=True)
+
+    # Premium tier - per instance
+    async with AsyncZR_obj(premium=True) as zr:
+        rider = AsyncZRRider()
+        rider.set_session(zr)
+        await rider.fetch(12345)
+
 anyio.run(main)
 ```
 

{zpdatafetch-2.3.1 → zpdatafetch-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "zpdatafetch"
-version = "2.3.1"
+version = "2.3.2"
 description = "A package for fetching data from Zwiftpower and Zwiftracing.app"
 readme = "README.md"
 requires-python = ">=3.10"

{zpdatafetch-2.3.1 → zpdatafetch-2.3.2/src/zpdatafetch.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zpdatafetch
-Version: 2.3.1
+Version: 2.3.2
 Summary: A package for fetching data from Zwiftpower and Zwiftracing.app
 Author-email: Doug Morris <doug@mhost.com>
 License-Expression: MIT
@@ -704,7 +704,8 @@ status = ZRRider().rate_limiter.get_status() if hasattr(ZRRider(), 'rate_limiter
 
 #### Async Rate Limiting
 
-Async operations also respect rate limits with automatic throttling:
+Async operations also respect rate limits with automatic throttling. As with
+the sync API, the tier can be set globally and per call:
 
 ```python
 import anyio
@@ -717,12 +718,23 @@ async def main():
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to standard limits
 
-    # Premium tier
-    async with AsyncZR_obj(premium=True) as zr:
+    # Premium tier - set globally (applies to existing and new instances)
+    AsyncZR_obj.set_premium_mode(True)
+    async with AsyncZR_obj() as zr:
         rider = AsyncZRRider()
         rider.set_session(zr)
         await rider.fetch(12345)  # Auto-throttled to premium limits
 
+    # Premium tier - per call
+    async with AsyncZR_obj() as zr:
+        await zr.fetch_json('/public/riders/12345', premium=True)
+
+    # Premium tier - per instance
+    async with AsyncZR_obj(premium=True) as zr:
+        rider = AsyncZRRider()
+        rider.set_session(zr)
+        await rider.fetch(12345)
+
 anyio.run(main)
 ```
 

{zpdatafetch-2.3.1 → zpdatafetch-2.3.2}/src/zrdatafetch/async_zr.py

@@ -4,7 +4,7 @@ This module provides async/await compatible interfaces for the Zwiftracing API,
 allowing for concurrent requests and better performance in async applications.
 """
 
-from typing import Any
+from typing import Any, ClassVar
 
 import anyio
 import httpx2
@@ -36,11 +36,38 @@ class AsyncZR_obj:
   Attributes:
     _base_url: Base URL for Zwiftracing API
     _client: httpx2.AsyncClient instance
+    _premium_mode: Class-level setting for premium tier rate limits
   """
 
   _base_url: str = 'https://api.zwiftracing.app/api'
   _shared_client: httpx2.AsyncClient | None = None
   _owns_client: bool = False
+  _premium_mode: ClassVar[bool] = False  # Default to standard tier
+
+  # ----------------------------------------------------------------------------
+  @classmethod
+  def set_premium_mode(cls, premium: bool) -> None:
+    """Set the global premium tier rate limit mode.
+
+    Applies to all async instances, including ones already created: the
+    effective tier is recomputed on each request.
+
+    Args:
+      premium: True for premium tier (higher limits), False for standard tier
+    """
+    cls._premium_mode = premium
+    tier = 'premium' if premium else 'standard'
+    logger.info(f'Rate limit tier set to: {tier}')
+
+  # ----------------------------------------------------------------------------
+  @classmethod
+  def get_premium_mode(cls) -> bool:
+    """Get the current premium tier mode setting.
+
+    Returns:
+      True if premium tier is enabled, False for standard tier
+    """
+    return cls._premium_mode
 
   # ----------------------------------------------------------------------------
   def __init__(
@@ -59,7 +86,11 @@ class AsyncZR_obj:
     """
     self._client: httpx2.AsyncClient | None = None
     self._owns_client = not shared_client
-    self.rate_limiter = RateLimiter(tier='premium' if premium else 'standard')
+    self._premium = premium
+    use_premium = premium or self._premium_mode
+    self.rate_limiter = RateLimiter(
+      tier='premium' if use_premium else 'standard',
+    )
 
     if shared_client and AsyncZR_obj._shared_client is None:
       logger.debug('Creating shared async HTTP client for connection pooling')
@@ -107,6 +138,7 @@ class AsyncZR_obj:
     method: str = 'GET',
     max_retries: int = 3,
     backoff_factor: float = 1.0,
+    premium: bool = False,
     **kwargs: Any,
   ) -> httpx2.Response:
     """Fetch endpoint with exponential backoff retry logic (async).
@@ -120,6 +152,7 @@ class AsyncZR_obj:
       method: HTTP method (default: 'GET')
       max_retries: Maximum number of retry attempts (default: 3)
       backoff_factor: Multiplier for exponential backoff (default: 1.0)
+      premium: Force premium tier for this request (default: False)
       **kwargs: Additional arguments to pass to httpx client method
 
     Returns:
@@ -132,6 +165,12 @@ class AsyncZR_obj:
       await self.init_client()
     assert self._client is not None
 
+    # Resolve effective tier: per-call, per-instance, then class-level mode
+    use_premium = premium or self._premium or self._premium_mode
+    desired_tier = 'premium' if use_premium else 'standard'
+    if self.rate_limiter.tier != desired_tier:
+      self.rate_limiter.set_tier(desired_tier)
+
     # Check rate limits before attempting request
     endpoint_type = RateLimiter.get_endpoint_type(method, endpoint)
     await self.rate_limiter.wait_if_needed(endpoint_type)
@@ -222,6 +261,7 @@ class AsyncZR_obj:
     endpoint: str,
     method: str = 'GET',
     max_retries: int = 3,
+    premium: bool = False,
     **kwargs: Any,
   ) -> str:
     """Fetch JSON data from Zwiftracing endpoint, return raw string (async).
@@ -234,6 +274,9 @@ class AsyncZR_obj:
       endpoint: API endpoint path (e.g., '/public/riders/123')
       method: HTTP method ('GET' or 'POST'). Default: 'GET'
       max_retries: Maximum number of retry attempts for transient errors
+      premium: Force premium tier rate limits for this request
+        (default: False). The effective tier is also taken from the instance
+        and the class-level mode set by set_premium_mode().
       **kwargs: Additional arguments passed to httpx request method
         (e.g., headers, params, json, etc.)
 
@@ -264,6 +307,7 @@ class AsyncZR_obj:
         endpoint,
         method=method,
         max_retries=max_retries,
+        premium=premium,
         **kwargs,
       )
 

{zpdatafetch-2.3.1 → zpdatafetch-2.3.2}/src/zrdatafetch/cli.py

@@ -25,6 +25,7 @@ from shared.cli import (
 )
 from shared.validation import ValidationError, parse_datetime_to_epoch
 from zrdatafetch import (
+  AsyncZR_obj,
   Config,
   ZRResultFetch,
   ZRRiderFetch,
@@ -112,6 +113,7 @@ Module for fetching Zwiftracing data using the Zwiftracing API
   # Set premium tier mode if requested
   if args.premium:
     ZR_obj.set_premium_mode(True)
+    AsyncZR_obj.set_premium_mode(True)
 
   # Handle --sync flag (enable synchronous mode)
   if args.sync: