wiz-trader 0.34.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

wiz_trader/__init__.py

@@ -3,6 +3,6 @@
 from .quotes import QuotesClient
 from .apis import WizzerClient
 
-__version__ = "0.34.0"
+__version__ = "0.35.0"
 
 __all__ = ["QuotesClient", "WizzerClient"]

wiz_trader/apis/client.py

@@ -160,6 +160,13 @@ class WizzerClient:
   WEIGHTAGE_SCHEME_FLOAT_ADJUSTED_MARKET_CAP_WEIGHTED = "float_adjusted_market_cap_weighted"
   WEIGHTAGE_SCHEME_FUNDAMENTAL_WEIGHTED = "fundamental_weighted"
   WEIGHTAGE_SCHEME_CUSTOM_WEIGHTED = "custom_weighted"
+  
+  # KV data type constants
+  KV_TYPE_STRING = "string"
+  KV_TYPE_BOOLEAN = "boolean"
+  KV_TYPE_NUMBER = "number"
+  KV_TYPE_ARRAY = "array"
+  KV_TYPE_OBJECT = "object"
 
   # URIs to various API endpoints
   _routes = {
@@ -209,7 +216,17 @@ class WizzerClient:
     
     # Screener API endpoints
     "screener.run": "/datahub/screener",
-    "screener.fields": "/datahub/screener/metadata"
+    "screener.fields": "/datahub/screener/metadata",
+    
+    # KV store endpoints
+    "kv.create": "/kv/{strategy_id}/{key}",
+    "kv.get": "/kv/{strategy_id}/{key}",
+    "kv.update": "/kv/{strategy_id}/{key}",
+    "kv.patch": "/kv/{strategy_id}/{key}",
+    "kv.delete": "/kv/{strategy_id}/{key}",
+    "kv.list": "/kv/{strategy_id}",
+    "kv.keys": "/kv/{strategy_id}/keys",
+    "kv.delete_all": "/kv/{strategy_id}/all"
   }
   
   def __init__(
@@ -1794,3 +1811,426 @@ class WizzerClient:
       if hasattr(e.response, 'text'):
         logger.error("Response content: %s", e.response.text)
       raise
+
+  # ===== KV STORE METHODS =====
+
+  def create_kv(self, key: str, value: Any, ttl: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Create a new key-value pair.
+    
+    Args:
+        key (str): The key for the KV pair.
+        value (Any): The value to store (any JSON-serializable type).
+        ttl (Optional[int]): Time to live in seconds. If provided, the key will expire after this duration.
+    
+    Returns:
+        Dict[str, Any]: Response containing key, value, type, ttl, createdAt, updatedAt.
+        
+    Example Response:
+        {
+            "key": "state",
+            "value": {"positions": 30},
+            "type": "object", 
+            "ttl": 100,
+            "createdAt": "2023-10-01T10:00:00Z",
+            "updatedAt": "2023-10-01T10:00:00Z"
+        }
+    
+    Raises:
+        ValueError: If key is empty or invalid.
+        requests.RequestException: If key already exists (409 Conflict) or API request fails.
+    
+    Example:
+        client.create_kv(key="portfolio_state", value={"positions": 30}, ttl=3600)
+    """
+    if not key or not key.strip():
+      raise ValueError("Key cannot be empty or whitespace")
+    
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.create"].format(strategy_id=strategy_info["id"], key=key)
+    
+    # Build request payload
+    data = {"value": value}
+    if ttl is not None:
+      data["ttl"] = ttl
+    
+    logger.debug("Creating KV pair: key=%s, type=%s, ttl=%s", key, type(value).__name__, ttl)
+    return self._make_request("POST", endpoint, json=data)
+
+  def get_kv(self, key: str) -> Dict[str, Any]:
+    """
+    Retrieve a key-value pair.
+    
+    Args:
+        key (str): The key to retrieve.
+    
+    Returns:
+        Dict[str, Any]: Response containing value, type, and optional ttl.
+        
+    Example Response:
+        {
+            "value": {"positions": 30},
+            "type": "object",
+            "ttl": 85
+        }
+    
+    Raises:
+        ValueError: If key is empty or invalid.
+        requests.RequestException: If key not found (404) or API request fails.
+    
+    Example:
+        data = client.get_kv("portfolio_state")
+        positions = data["value"]["positions"]
+    """
+    if not key or not key.strip():
+      raise ValueError("Key cannot be empty or whitespace")
+    
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.get"].format(strategy_id=strategy_info["id"], key=key)
+    
+    logger.debug("Retrieving KV pair: key=%s", key)
+    return self._make_request("GET", endpoint)
+
+  def update_kv(self, key: str, value: Any, ttl: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Update (replace) an existing key-value pair completely.
+    
+    Args:
+        key (str): The key to update.
+        value (Any): The new value to store (any JSON-serializable type).
+        ttl (Optional[int]): New time to live in seconds.
+    
+    Returns:
+        Dict[str, Any]: Response containing key, value, type, ttl, createdAt, updatedAt.
+        
+    Example Response:
+        {
+            "key": "state",
+            "value": {"positions": 50, "orders": 10},
+            "type": "object",
+            "ttl": 200,
+            "createdAt": "2023-10-01T10:00:00Z", 
+            "updatedAt": "2023-10-01T10:30:00Z"
+        }
+    
+    Raises:
+        ValueError: If key is empty or invalid.
+        requests.RequestException: If key not found (404) or API request fails.
+    
+    Example:
+        client.update_kv(key="portfolio_state", value={"positions": 50}, ttl=1800)
+    """
+    if not key or not key.strip():
+      raise ValueError("Key cannot be empty or whitespace")
+    
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.update"].format(strategy_id=strategy_info["id"], key=key)
+    
+    # Build request payload
+    data = {"value": value}
+    if ttl is not None:
+      data["ttl"] = ttl
+    
+    logger.debug("Updating KV pair: key=%s, type=%s, ttl=%s", key, type(value).__name__, ttl)
+    return self._make_request("PUT", endpoint, json=data)
+
+  def patch_kv(self, key: str, value: Optional[Any] = None, ttl: Optional[int] = None) -> Dict[str, Any]:
+    """
+    Partially update a key-value pair.
+    
+    For OBJECT types: merges the new value with existing value.
+    For other types (STRING, NUMBER, BOOLEAN, ARRAY): replaces the value entirely.
+    
+    Args:
+        key (str): The key to patch.
+        value (Optional[Any]): New value or partial value to merge.
+        ttl (Optional[int]): New time to live in seconds.
+        
+    Note: At least one of value or ttl must be provided.
+    
+    Returns:
+        Dict[str, Any]: Response containing key, value, type, ttl, createdAt, updatedAt.
+        
+    Example Response (for object merge):
+        {
+            "key": "state", 
+            "value": {"positions": 30, "orders": 5, "last_update": "2023-10-01"},  # Merged
+            "type": "object",
+            "ttl": 150,
+            "createdAt": "2023-10-01T10:00:00Z",
+            "updatedAt": "2023-10-01T10:15:00Z"
+        }
+    
+    Raises:
+        ValueError: If key is empty, invalid, or no parameters provided.
+        requests.RequestException: If key not found (404) or API request fails.
+    
+    Example:
+        # For objects - merges with existing
+        client.patch_kv(key="portfolio_state", value={"last_update": "2023-10-01"})
+        
+        # For non-objects - replaces entirely
+        client.patch_kv(key="counter", value=42)
+        
+        # Update only TTL
+        client.patch_kv(key="session", ttl=1800)
+    """
+    if not key or not key.strip():
+      raise ValueError("Key cannot be empty or whitespace")
+    
+    if value is None and ttl is None:
+      raise ValueError("At least one of value or ttl must be provided")
+    
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.patch"].format(strategy_id=strategy_info["id"], key=key)
+    
+    # Build request payload
+    data = {}
+    if value is not None:
+      data["value"] = value
+    if ttl is not None:
+      data["ttl"] = ttl
+    
+    logger.debug("Patching KV pair: key=%s, has_value=%s, has_ttl=%s", key, value is not None, ttl is not None)
+    return self._make_request("PATCH", endpoint, json=data)
+
+  def delete_kv(self, key: str) -> Dict[str, Any]:
+    """
+    Delete a key-value pair.
+    
+    Args:
+        key (str): The key to delete.
+    
+    Returns:
+        Dict[str, Any]: Success confirmation.
+        
+    Example Response:
+        {
+            "success": True,
+            "message": "Key deleted successfully"
+        }
+    
+    Raises:
+        ValueError: If key is empty or invalid.
+        requests.RequestException: If key not found (404) or API request fails.
+    
+    Example:
+        response = client.delete_kv("old_config")
+        if response["success"]:
+            print("Key deleted successfully")
+    """
+    if not key or not key.strip():
+      raise ValueError("Key cannot be empty or whitespace")
+    
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.delete"].format(strategy_id=strategy_info["id"], key=key)
+    
+    logger.debug("Deleting KV pair: key=%s", key)
+    return self._make_request("DELETE", endpoint)
+
+  def get_all_kvs(self, page_no: int = 1, paginate: bool = False) -> List[Dict[str, Any]]:
+    """
+    Get all key-value pairs with their complete data.
+    
+    Args:
+        page_no (int): Page number for pagination (default: 1).
+        paginate (bool): If True, automatically fetch all pages (default: False).
+    
+    Returns:
+        List[Dict[str, Any]]: List of all KV pairs with complete data.
+        
+    Example Response:
+        [
+            {
+                "key": "portfolio_state",
+                "value": {"positions": 30},
+                "type": "object",
+                "ttl": 100,
+                "createdAt": "2023-10-01T10:00:00Z",
+                "updatedAt": "2023-10-01T10:00:00Z"
+            },
+            {
+                "key": "environment",
+                "value": "production",
+                "type": "string", 
+                "createdAt": "2023-10-01T09:00:00Z",
+                "updatedAt": "2023-10-01T09:00:00Z"
+            },
+            {
+                "key": "trade_count",
+                "value": 42,
+                "type": "number",
+                "createdAt": "2023-10-01T08:00:00Z",
+                "updatedAt": "2023-10-01T08:30:00Z"
+            }
+        ]
+    
+    Example:
+        # Get first page only
+        kvs = client.get_all_kvs()
+        
+        # Get all pages automatically
+        all_kvs = client.get_all_kvs(paginate=True)
+    """
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.list"].format(strategy_id=strategy_info["id"])
+    
+    if paginate:
+      return self._paginate_kv_requests(endpoint, "get_all_kvs")
+    else:
+      params = {"pageNo": page_no}
+      logger.debug("Fetching all KVs page %d", page_no)
+      return self._make_request("GET", endpoint, params=params)
+
+  def get_kv_keys(self, page_no: int = 1, paginate: bool = False) -> List[Dict[str, Any]]:
+    """
+    Get all keys with metadata (without values for memory efficiency).
+    
+    Args:
+        page_no (int): Page number for pagination (default: 1).
+        paginate (bool): If True, automatically fetch all pages (default: False).
+    
+    Returns:
+        List[Dict[str, Any]]: List of keys with metadata (no values).
+        
+    Example Response:
+        [
+            {
+                "key": "portfolio_state",
+                "type": "object",
+                "ttl": 100,
+                "createdAt": "2023-10-01T10:00:00Z",
+                "updatedAt": "2023-10-01T10:00:00Z"
+            },
+            {
+                "key": "environment", 
+                "type": "string",
+                "createdAt": "2023-10-01T09:00:00Z",
+                "updatedAt": "2023-10-01T09:00:00Z"
+            },
+            {
+                "key": "trade_count",
+                "type": "number",
+                "createdAt": "2023-10-01T08:00:00Z",
+                "updatedAt": "2023-10-01T08:30:00Z"
+            }
+        ]
+    
+    Example:
+        # Get keys for first page
+        keys = client.get_kv_keys()
+        
+        # Get all keys across all pages
+        all_keys = client.get_kv_keys(paginate=True)
+        
+        # Check what keys exist
+        for key_info in all_keys:
+            print(f"Key: {key_info['key']}, Type: {key_info['type']}")
+    """
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.keys"].format(strategy_id=strategy_info["id"])
+    
+    if paginate:
+      return self._paginate_kv_requests(endpoint, "get_kv_keys")
+    else:
+      params = {"pageNo": page_no}
+      logger.debug("Fetching KV keys page %d", page_no)
+      return self._make_request("GET", endpoint, params=params)
+
+  def _paginate_kv_requests(self, endpoint: str, operation: str) -> List[Dict[str, Any]]:
+    """
+    Internal method to handle pagination for KV list operations.
+    
+    Args:
+        endpoint (str): API endpoint.
+        operation (str): Operation name for logging.
+        
+    Returns:
+        List[Dict[str, Any]]: Combined results from all pages.
+    """
+    all_items = []
+    page_no = 1
+    total_count = None
+    page_size = 20  # KV API uses 20 items per page
+    
+    while True:
+      params = {"pageNo": page_no}
+      logger.debug("Fetching %s page %d", operation, page_no)
+      
+      try:
+        url = f"{self.base_url}{endpoint}"
+        response = requests.request(
+          method="GET",
+          url=url,
+          headers=self.headers,
+          params=params
+        )
+        response.raise_for_status()
+        
+        # Get items from the current page
+        items = response.json()
+        all_items.extend(items)
+        
+        # Check if we need to fetch more pages
+        if total_count is None and "X-Total-Count" in response.headers:
+          try:
+            total_count = int(response.headers["X-Total-Count"])
+            logger.debug("Total %s count: %d", operation, total_count)
+          except (ValueError, TypeError):
+            logger.warning("Could not parse X-Total-Count header for %s", operation)
+            break
+        
+        # If we've fetched all items or there are no more pages, stop
+        if not items or len(all_items) >= total_count or total_count is None:
+          break
+        
+        # Move to the next page
+        page_no += 1
+        
+      except requests.RequestException as e:
+        logger.error("API request failed during %s pagination: %s", operation, e, exc_info=True)
+        if hasattr(e.response, 'text'):
+          logger.error("Response content: %s", e.response.text)
+        raise
+    
+    logger.info("Fetched %d items in total for %s", len(all_items), operation)
+    return all_items
+  
+  # Add this method to the WizzerClient class
+  def delete_all_kv(self) -> Dict[str, Any]:
+    """
+    Delete all key-value pairs for the current strategy.
+    
+    This method removes all KV pairs associated with the client's strategy.
+    Use with caution as this operation cannot be undone.
+    
+    Returns:
+        Dict[str, Any]: Response containing success status, count of deleted items, and message.
+        
+    Example Response:
+        {
+            "success": True,
+            "deleted": 15,
+            "message": "Successfully deleted 15 key-value pairs"
+        }
+    
+    Raises:
+        requests.RequestException: If API request fails.
+    
+    Example:
+        response = client.delete_all_kv()
+        print(f"Deleted {response['deleted']} key-value pairs")
+    """
+    # Get strategy information
+    strategy_info = self._get_strategy()
+    endpoint = self._routes["kv.delete_all"].format(strategy_id=strategy_info["id"])
+    
+    logger.debug("Deleting all KV pairs for strategy: %s", strategy_info["id"])
+    return self._make_request("DELETE", endpoint)

{wiz_trader-0.34.0.dist-info → wiz_trader-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiz_trader
-Version: 0.34.0
+Version: 0.35.0
 Summary: A Python SDK for connecting to the Wizzer.
 Home-page: https://bitbucket.org/wizzer-tech/quotes_sdk.git
 Author: Pawan Wagh
@@ -3663,3 +3663,243 @@ results = client.run_screener(
     limit=10
 )
 ```
+
+## KV Store Integration
+
+The WizzerClient includes comprehensive Key-Value (KV) store functionality for persistent data management. This feature allows you to store configuration data, state information, user preferences, and other persistent data associated with your trading strategies.
+
+### Supported Data Types
+
+The KV store supports all JSON-serializable data types:
+
+- **STRING**: Text values (`"production"`, `"user123"`)
+- **NUMBER**: Integer and float values (`42`, `150.25`)
+- **BOOLEAN**: True/false values (`True`, `False`)
+- **ARRAY**: Lists of values (`["AAPL", "GOOGL", "MSFT"]`)
+- **OBJECT**: Dictionaries/objects (`{"positions": 30, "cash": 50000}`)
+
+### Available Constants
+
+```python
+client.KV_TYPE_STRING   # "string"
+client.KV_TYPE_NUMBER   # "number" 
+client.KV_TYPE_BOOLEAN  # "boolean"
+client.KV_TYPE_ARRAY    # "array"
+client.KV_TYPE_OBJECT   # "object"
+```
+
+### Core CRUD Operations
+
+#### Create Key-Value Pair
+
+```python
+# Store different data types
+client.create_kv("environment", "production")
+client.create_kv("trade_count", 42)
+client.create_kv("is_active", True)
+client.create_kv("symbols", ["AAPL", "GOOGL", "MSFT"])
+
+# Store complex configuration with TTL (expires in 1 hour)
+config = {
+    "risk_level": "medium",
+    "max_positions": 10,
+    "stop_loss_pct": 0.05,
+    "take_profit_pct": 0.15
+}
+client.create_kv("strategy_config", config, ttl=3600)
+```
+
+#### Retrieve Key-Value Pair
+
+```python
+# Get a single KV pair
+data = client.get_kv("strategy_config")
+print(data["value"])          # The stored object
+print(data["type"])           # "object"
+print(data["ttl"])            # Remaining time to live (if set)
+
+# Access nested values
+risk_level = data["value"]["risk_level"]  # "medium"
+```
+
+#### Update Key-Value Pair (Complete Replacement)
+
+```python
+# Complete replacement of existing key
+new_config = {"risk_level": "high", "max_positions": 5}
+client.update_kv("strategy_config", new_config, ttl=1800)
+```
+
+#### Patch Key-Value Pair (Partial Update)
+
+```python
+# For objects - merges with existing data
+client.patch_kv("strategy_config", {"last_updated": "2024-01-15"})
+
+# For non-objects - replaces entirely  
+client.patch_kv("trade_count", 50)
+
+# Update only TTL
+client.patch_kv("strategy_config", ttl=7200)
+```
+
+#### Delete Key-Value Pair
+
+```python
+response = client.delete_kv("old_config")
+if response["success"]:
+    print("Key deleted successfully")
+```
+
+### List Operations
+
+#### Get All KV Pairs (with values)
+
+```python
+# Get first page (20 items)
+kvs = client.get_all_kvs(page_no=1)
+
+# Get all pages automatically
+all_kvs = client.get_all_kvs(paginate=True)
+
+for kv in all_kvs:
+    print(f"Key: {kv['key']}")
+    print(f"Type: {kv['type']}")
+    print(f"Value: {kv['value']}")
+```
+
+#### Get Keys Only (memory efficient)
+
+```python
+# Get all keys without values (faster for large datasets)
+keys = client.get_kv_keys(paginate=True)
+
+for key_info in keys:
+    print(f"Key: {key_info['key']}, Type: {key_info['type']}")
+    if 'ttl' in key_info:
+        print(f"  TTL: {key_info['ttl']} seconds remaining")
+```
+
+### Advanced Usage Examples
+
+#### Strategy Configuration Management
+
+```python
+# Store strategy parameters
+params = {
+    "moving_average_period": 20,
+    "rsi_oversold": 30,
+    "rsi_overbought": 70,
+    "position_size": 0.02
+}
+client.create_kv("strategy_params", params)
+
+# Update specific parameters using patch (merges with existing)
+client.patch_kv("strategy_params", {"moving_average_period": 50})
+```
+
+#### State Persistence
+
+```python
+# Save current portfolio state
+portfolio_state = {
+    "cash_balance": 50000,
+    "open_positions": 5,
+    "daily_pnl": 1250.75,
+    "last_updated": "2024-01-15T15:30:00Z"
+}
+client.create_kv("portfolio_state", portfolio_state, ttl=3600)
+
+# Update state periodically
+client.patch_kv("portfolio_state", {
+    "daily_pnl": 1500.25,
+    "last_updated": "2024-01-15T16:00:00Z"
+})
+```
+
+#### Feature Flags
+
+```python
+# Enable/disable features dynamically
+features = {
+    "advanced_charts": True,
+    "paper_trading": True,
+    "options_trading": False,
+    "algo_trading": True
+}
+client.create_kv("feature_flags", features)
+
+# Toggle a feature
+client.patch_kv("feature_flags", {"options_trading": True})
+```
+
+#### Data Caching with TTL
+
+```python
+# Cache market data with short TTL (5 minutes)
+market_status = {
+    "nse_open": True,
+    "bse_open": True,
+    "last_checked": "2024-01-15T09:15:00Z"
+}
+client.create_kv("market_status", market_status, ttl=300)
+```
+
+### Object Merge Behavior
+
+For OBJECT type data, the `patch_kv` method performs intelligent merging:
+
+```python
+# Initial object
+client.create_kv("user_prefs", {
+    "theme": "dark",
+    "notifications": True,
+    "language": "en"
+})
+
+# Patch merges new fields with existing ones
+client.patch_kv("user_prefs", {
+    "notifications": False,  # Updates existing field
+    "timezone": "UTC"        # Adds new field
+})
+
+# Result: {"theme": "dark", "notifications": False, "language": "en", "timezone": "UTC"}
+```
+
+### Delete All KV Pairs
+
+The `delete_all_kv` method allows you to remove all key-value pairs for a strategy at once:
+
+```python
+# Delete all KV pairs for the current strategy
+response = client.delete_all_kv()
+print(f"Deleted {response['deleted']} key-value pairs")
+
+# Example response:
+# {
+#     "success": True,
+#     "deleted": 15,
+#     "message": "Successfully deleted 15 key-value pairs"
+# }
+
+# Common usage - reset strategy state before reinitialization
+def reset_strategy_state():
+    """Reset all persistent state for the strategy."""
+    # Clear all existing KV pairs
+    result = client.delete_all_kv()
+    print(f"Cleared {result['deleted']} KV pairs")
+    
+    # Reinitialize with default configuration
+    client.create_kv("config", {
+        "mode": "production",
+        "risk_percentage": 0.02,
+        "max_positions": 10
+    })
+    client.create_kv("state", {
+        "initialized": True,
+        "start_time": datetime.now().isoformat()
+    })
+    print("Strategy state reset successfully")
+
+# Use with caution - this operation cannot be undone!
+```

wiz_trader-0.35.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+wiz_trader/__init__.py,sha256=mvDJsObXpYGcnLwfpMITtZeAouMb_YHNW0Tqse0V0bg,183
+wiz_trader/apis/__init__.py,sha256=6sUr1nzmplNdld0zryMrQSt0jHT2GhOiFYgKKVHzk8U,133
+wiz_trader/apis/client.py,sha256=znwlyDIHbaiQuDqxp7pn1NPiiYB99oA74JWt4AiLkBg,80088
+wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
+wiz_trader/quotes/client.py,sha256=aZ5LVlrj0mKfgHgFxERmk2HDZraB6RMaormTOMlqWZc,14915
+wiz_trader-0.35.0.dist-info/METADATA,sha256=0aBskcZN4xpphpCtQMO9oAYIjwgboe9nmcpcywuKrXg,144695
+wiz_trader-0.35.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wiz_trader-0.35.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
+wiz_trader-0.35.0.dist-info/RECORD,,

wiz_trader-0.34.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-wiz_trader/__init__.py,sha256=Bd8yqFEqK9MNrzHUVgrbEntlyIHZhArgA6AZT9SEFjY,183
-wiz_trader/apis/__init__.py,sha256=6sUr1nzmplNdld0zryMrQSt0jHT2GhOiFYgKKVHzk8U,133
-wiz_trader/apis/client.py,sha256=WzsKxrNi9T-xbtXWBT2J41bJ-sz0KsGFYV5Oyddo3gg,65487
-wiz_trader/quotes/__init__.py,sha256=RF9g9CNP6bVWlmCh_ad8krm3-EWOIuVfLp0-H9fAeEM,108
-wiz_trader/quotes/client.py,sha256=aZ5LVlrj0mKfgHgFxERmk2HDZraB6RMaormTOMlqWZc,14915
-wiz_trader-0.34.0.dist-info/METADATA,sha256=OAi5g0xbSdp9bc-F1Fgl7d8oMRIsfimTohtJ0oA-FX0,138653
-wiz_trader-0.34.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wiz_trader-0.34.0.dist-info/top_level.txt,sha256=lnYS_g8LlA6ryKYnvY8xIQ6K2K-xzOsd-99AWgnW6VY,11
-wiz_trader-0.34.0.dist-info/RECORD,,