game-api-client 0.1.0__tar.gz → 0.1.2__tar.gz

{game_api_client-0.1.0 → game_api_client-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: game-api-client
-Version: 0.1.0
+Version: 0.1.2
 Summary: Python client library for GAME trading API
 License: MIT
 Keywords: api,trading,game,client
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: pydantic (>=2.10.0,<3.0.0)
@@ -131,6 +132,8 @@ GAME_API_VERIFY_SSL=false
   - `market_zone`: Market zone like "10YCH-SWISSGRIDZ" (optional)
 - `get_latest_ltp()` - Get latest LTP per contract across all zones
   - Returns dict mapping `contract_id -> {price, volume, timestamp, market_zones, latest_zone}`
+- `get_latest_available_ltp(duration=None)` - Get the newest LTP compatible with available cross-border capacity
+  - Falls back to the next eligible trade and uses the Swiss LTP when no cross-border capacity is available
 
 ### Order Management
 - `get_orders(direction=None)` - Get orders with optional filter
@@ -143,7 +146,10 @@ GAME_API_VERIFY_SSL=false
   - `order_id`: Order ID (handles both string and numeric formats)
 
 ### Spot Data
-- `get_spot_data()` - Get spot market data
+- `get_spot_data(area_name=None, date_from=None, date_to=None, limit=None)` - Get spot market data
+  - `area_name`: Area name, such as `CH-SGD` (optional; API default: `CH-SGD`)
+  - `date_from`, `date_to`: Date range in `YYYY-MM-DD` format (optional)
+  - `limit`: Maximum number of results (optional; API default: `500`)
 - `get_spot_status()` - Get spot API status
 
 ## Usage Examples

{game_api_client-0.1.0 → game_api_client-0.1.2}/README.md

@@ -103,6 +103,8 @@ GAME_API_VERIFY_SSL=false
   - `market_zone`: Market zone like "10YCH-SWISSGRIDZ" (optional)
 - `get_latest_ltp()` - Get latest LTP per contract across all zones
   - Returns dict mapping `contract_id -> {price, volume, timestamp, market_zones, latest_zone}`
+- `get_latest_available_ltp(duration=None)` - Get the newest LTP compatible with available cross-border capacity
+  - Falls back to the next eligible trade and uses the Swiss LTP when no cross-border capacity is available
 
 ### Order Management
 - `get_orders(direction=None)` - Get orders with optional filter
@@ -115,7 +117,10 @@ GAME_API_VERIFY_SSL=false
   - `order_id`: Order ID (handles both string and numeric formats)
 
 ### Spot Data
-- `get_spot_data()` - Get spot market data
+- `get_spot_data(area_name=None, date_from=None, date_to=None, limit=None)` - Get spot market data
+  - `area_name`: Area name, such as `CH-SGD` (optional; API default: `CH-SGD`)
+  - `date_from`, `date_to`: Date range in `YYYY-MM-DD` format (optional)
+  - `limit`: Maximum number of results (optional; API default: `500`)
 - `get_spot_status()` - Get spot API status
 
 ## Usage Examples

{game_api_client-0.1.0 → game_api_client-0.1.2}/game_client.py

@@ -4,10 +4,12 @@ Simple GAME API Client
 A minimal client for the GAME trading API.
 """
 
+from __future__ import annotations
+
 import logging
 import time
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from datetime import datetime
+from typing import Any
 
 import httpx
 
@@ -17,8 +19,6 @@ logger = logging.getLogger(__name__)
 class GameAPIError(Exception):
     """Base exception for GAME API errors"""
 
-    pass
-
 
 # Valid order states
 VALID_ORDER_STATES = ["displayed", "hidden"]
@@ -31,9 +31,8 @@ def get_default_tz_offset_hours() -> int:
     Mirrors the frontend's getCurrentTimezoneOffset() logic.
     Returns 1 for CET, 2 for CEST, 0 for UTC.
     """
-    now = datetime.now()
-    utc_now = datetime.now(timezone.utc)
-    offset_seconds = (now - utc_now.replace(tzinfo=None)).total_seconds()
+    local_offset = datetime.now().astimezone().utcoffset()
+    offset_seconds = local_offset.total_seconds() if local_offset else 0
     offset_hours = round(offset_seconds / 3600)
     return max(0, min(2, offset_hours))
 
@@ -62,8 +61,8 @@ class GameAPI:
         self.verify_ssl = verify_ssl
         self.timeout = timeout
         self.personal_token = token
-        self._access_token: Optional[str] = None
-        self._token_expires_at: Optional[float] = None
+        self._access_token: str | None = None
+        self._token_expires_at: float | None = None
 
         if not token:
             raise GameAPIError("Personal token is required")
@@ -116,8 +115,8 @@ class GameAPI:
         self,
         method: str,
         endpoint: str,
-        params: Optional[Dict[str, Any]] = None,
-        json_data: Optional[Dict[str, Any]] = None,
+        params: dict[str, Any] | None = None,
+        json_data: dict[str, Any] | None = None,
     ) -> Any:
         """Make an authenticated request to the API"""
         url = f"{self.base_url}/api/v1{endpoint}"
@@ -146,7 +145,7 @@ class GameAPI:
                     try:
                         error_detail = response.json()
                         error_msg += f" - {error_detail.get('detail', 'Unknown error')}"
-                    except Exception:
+                    except (AttributeError, TypeError, ValueError):
                         error_msg += f" - {response.text}"
                     raise GameAPIError(error_msg)
 
@@ -156,14 +155,14 @@ class GameAPI:
             raise GameAPIError(f"Network error: {e}") from e
 
     # Status endpoints
-    async def get_status(self) -> Dict[str, Any]:
+    async def get_status(self) -> dict[str, Any]:
         """Get API status"""
         return await self._make_request("GET", "/status")
 
     # Trades endpoints
     async def get_trades(
-        self, direction: Optional[str] = None, duration: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
+        self, direction: str | None = None, duration: str | None = None
+    ) -> list[dict[str, Any]]:
         """Get trades with optional filtering"""
         params = {}
         if direction:
@@ -173,14 +172,14 @@ class GameAPI:
         return await self._make_request("GET", "/trades", params=params)
 
     # Orders endpoints
-    async def get_orders(self, direction: Optional[str] = None) -> List[Dict[str, Any]]:
+    async def get_orders(self, direction: str | None = None) -> list[dict[str, Any]]:
         """Get orders with optional filtering"""
         params = {}
         if direction:
             params["direction"] = direction
         return await self._make_request("GET", "/orders", params=params)
 
-    async def find_order_by_id(self, order_id: str) -> Optional[Dict[str, Any]]:
+    async def find_order_by_id(self, order_id: str) -> dict[str, Any] | None:
         """
         Find a specific order by its ID (string or numeric)
 
@@ -201,11 +200,11 @@ class GameAPI:
                 ):
                     return order
             return None
-        except Exception as e:
+        except (GameAPIError, AttributeError, TypeError, ValueError) as e:
             logger.error(f"Error finding order {order_id}: {e}")
             return None
 
-    async def create_order(self, order_data: Dict[str, Any]) -> Dict[str, Any]:
+    async def create_order(self, order_data: dict[str, Any]) -> dict[str, Any]:
         """
         Create a new order
 
@@ -238,7 +237,7 @@ class GameAPI:
             self._validate_single_order(order_data, "Single order")
             return await self._make_request("POST", "/orders", json_data=order_data)
 
-    def _validate_single_order(self, order: Dict[str, Any], context: str) -> None:
+    def _validate_single_order(self, order: dict[str, Any], context: str) -> None:
         """Validate a single order's required fields and apply defaults"""
         required_fields = ["side", "price", "volume", "date", "start_time", "end_time"]
         # Optional fields that are passed through to the API
@@ -313,7 +312,7 @@ class GameAPI:
                             f"{context}: 'trader_suffixe' must be 50 characters or less"
                         )
 
-    async def delete_order(self, order_id: str) -> Dict[str, Any]:
+    async def delete_order(self, order_id: str) -> dict[str, Any]:
         """
         Delete an order by ID
 
@@ -344,7 +343,7 @@ class GameAPI:
                     numeric_id = None
 
                     # Method 1: Check for explicit numeric ID field
-                    if "id" in matching_order and matching_order["id"]:
+                    if matching_order.get("id"):
                         numeric_id = str(matching_order["id"])
                     # Method 2: Check order_id_numeric field
                     elif "order_id_numeric" in matching_order:
@@ -393,7 +392,7 @@ class GameAPI:
             return await self._make_request("DELETE", f"/orders/{numeric_id}")
 
     # Market endpoints
-    def _sort_market_data(self, data: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def _sort_market_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
         """
         Sort a market snapshot by contract/timestamp, then by direction,
         placing the "best" price first for each side.
@@ -402,7 +401,7 @@ class GameAPI:
         - buy/bid  : higher price is better -> descending
         """
 
-        def _sort_key(row: Dict[str, Any]):
+        def _sort_key(row: dict[str, Any]):
             contract = row.get("contract") or row.get("timestamp") or ""
             direction = row.get("direction") or ""
             price = row.get("price")
@@ -416,10 +415,10 @@ class GameAPI:
 
     async def get_market_data(
         self,
-        direction: Optional[str] = None,
-        duration: Optional[str] = None,
+        direction: str | None = None,
+        duration: str | None = None,
         sort_by_price: bool = False,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """
         Get market data.
 
@@ -429,7 +428,7 @@ class GameAPI:
             sort_by_price: If True, sort the result so the best offer for each
                 direction comes first (sell ascending, buy descending).
         """
-        params: Dict[str, Any] = {}
+        params: dict[str, Any] = {}
         if direction:
             params["direction"] = direction
         if duration:
@@ -444,9 +443,9 @@ class GameAPI:
 
     async def get_market_best_offers(
         self,
-        duration: Optional[str] = None,
-        top_n: Optional[int] = None,
-    ) -> Dict[str, Dict[str, List[Dict[str, Any]]]]:
+        duration: str | None = None,
+        top_n: int | None = None,
+    ) -> dict[str, dict[str, list[dict[str, Any]]]]:
         """
         Get market offers grouped by contract and direction, best prices first.
 
@@ -468,7 +467,7 @@ class GameAPI:
             }
         """
         data = await self.get_market_data(duration=duration, sort_by_price=True)
-        grouped: Dict[str, Dict[str, List[Dict[str, Any]]]] = {}
+        grouped: dict[str, dict[str, list[dict[str, Any]]]] = {}
         for row in data:
             contract = row.get("contract") or row.get("timestamp") or ""
             direction = row.get("direction") or "unknown"
@@ -483,8 +482,8 @@ class GameAPI:
 
     # LTP (Last Traded Price) endpoints
     async def get_market_ltp(
-        self, market_zone: Optional[str] = None
-    ) -> List[Dict[str, Any]]:
+        self, market_zone: str | None = None
+    ) -> list[dict[str, Any]]:
         """
         Get last traded prices (LTP) for market contracts.
 
@@ -512,7 +511,23 @@ class GameAPI:
             params["market_zone"] = market_zone
         return await self._make_request("GET", "/market/market-ltp", params=params)
 
-    async def get_latest_ltp(self) -> Dict[str, Dict[str, Any]]:
+    async def get_latest_available_ltp(
+        self, duration: str | None = None
+    ) -> list[dict[str, Any]]:
+        """Get the newest LTP compatible with available cross-border capacity.
+
+        The GAME API selects the newest eligible trade per contract, falling
+        back to an older trade when the newest foreign-zone LTP has no
+        bidirectional capacity with Switzerland. CH remains the fallback zone.
+        """
+        params: dict[str, Any] = {}
+        if duration:
+            params["duration"] = duration
+        return await self._make_request(
+            "GET", "/market/latest-ltp", params=params or None
+        )
+
+    async def get_latest_ltp(self) -> dict[str, dict[str, Any]]:
         """
         Get the latest LTP for each contract across all market zones.
 
@@ -545,7 +560,7 @@ class GameAPI:
             return {}
 
         # Group by contract and keep the most recent entry per contract
-        latest_by_contract: Dict[str, Dict[str, Any]] = {}
+        latest_by_contract: dict[str, dict[str, Any]] = {}
 
         for entry in ltp_data:
             contract = entry.get("contract")
@@ -571,21 +586,39 @@ class GameAPI:
                 latest_by_contract[contract]["market_zones"].add(zone)
 
         # Convert sets to lists for JSON serialization
-        result: Dict[str, Dict[str, Any]] = {}
+        result: dict[str, dict[str, Any]] = {}
         for contract, data in latest_by_contract.items():
             result[contract] = {
                 **data,
-                "market_zones": sorted(list(data["market_zones"])),
+                "market_zones": sorted(data["market_zones"]),
             }
 
         return result
 
     # Spot endpoints
-    async def get_spot_data(self) -> List[Dict[str, Any]]:
-        """Get spot data"""
+    async def get_spot_data(
+        self,
+        area_name: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        """Get spot data with optional area, date range, and result limit filters."""
+        params = {
+            key: value
+            for key, value in {
+                "area_name": area_name,
+                "date_from": date_from,
+                "date_to": date_to,
+                "limit": limit,
+            }.items()
+            if value is not None
+        }
+        if params:
+            return await self._make_request("GET", "/spot", params=params)
         return await self._make_request("GET", "/spot")
 
-    async def get_spot_status(self) -> Dict[str, Any]:
+    async def get_spot_status(self) -> dict[str, Any]:
         """Get spot API status"""
         return await self._make_request("GET", "/spot/status")
 
@@ -595,6 +628,6 @@ class GameAPI:
         try:
             await self.get_status()
             return True
-        except Exception as e:
+        except GameAPIError as e:
             logger.error(f"Connection test failed: {e}")
             return False

{game_api_client-0.1.0 → game_api_client-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "game-api-client"
-version = "0.1.0"
+version = "0.1.2"
 description = "Python client library for GAME trading API"
 authors = ["Groupe E <support@groupe-e.ch>"]
 readme = "README.md"
@@ -51,18 +51,18 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.black]
 line-length = 88
-target-version = "0.1.0"
+target-version = "0.1.2"
 
 [tool.ruff]
 line-length = 88
-target-version = "0.1.0"
+target-version = "0.1.2"
 
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "N", "B", "C90"]
 ignore = ["E501", "B008", "N999", "C901"]
 
 [tool.mypy]
-python_version = "0.1.0"
+python_version = "0.1.2"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true