ksxt 0.0.10__py3-none-any.whl → 1.0.1__py3-none-any.whl

ksxt/async_/base/async_exchange.py

@@ -1,19 +1,14 @@
 import asyncio
+import time
 import aiohttp
-import json
-import os
-import platform
-import tomllib
 from datetime import datetime
-from pathlib import Path
 from typing import Any, Dict, Literal, Optional
 
-import yarl
 
-from ksxt.async_.base.throttler import Throttler
 from ksxt.base.errors import NotSupportedError
+from ksxt.base.rate_limiter import RateLimiterContext
 from ksxt.base.rest_exchange import RestExchange
-from ksxt.config import CONFIG_DIR
+from ksxt.config import VALID_METHODS
 import ksxt.models
 
 
@@ -23,22 +18,26 @@ class AsyncExchange(RestExchange):
     def __init__(self, config: Dict = None, filename: str = None):
         super().__init__(config, filename)
 
-        self.asyncio_loop = asyncio.get_event_loop()
-        self.session = aiohttp.ClientSession()
-        self.throttle = Throttler({}, self.asyncio_loop)
+        self.asyncio_loop = None
+        self.session: aiohttp.ClientSession = None
 
     async def initialize(self):
         if self.asyncio_loop is None:
             self.asyncio_loop = asyncio.get_event_loop()
-        if self.session is None:
+
+        if self.session is None or (
+            self.session_last_used and (time.time() - self.session_last_used > self.session_lifetime)
+        ):
+            if self.session:
+                await self.session.close()
             self.session = aiohttp.ClientSession()
-        if self.throttle is None:
-            self.throttle = Throttler({}, self.asyncio_loop)
+            self.session_last_used = time.time()
 
     async def close(self):
         if self.session:
             await self.session.close()
             self.session = None
+            self.session_last_used = None
 
     async def __aenter__(self):
         await self.initialize()
@@ -47,49 +46,43 @@ class AsyncExchange(RestExchange):
     async def __aexit__(self, *args):
         await self.close()
 
-    def _get_api_from_file(self, filename: str):
-        if filename is None:
-            tr_config_filename = "tr_dev.json" if self.is_dev else "tr_app.json"
-        else:
-            tr_config_filename = filename
-
-        config_path = os.path.join(CONFIG_DIR, tr_config_filename)
+    async def fetch(self, url, method="GET", headers=None, body=None, params=None):
+        # Ensure that resources are initialized before the request
+        await self.initialize()
 
-        if Path(tr_config_filename).suffix == ".json":
-            with open(
-                config_path,
-                encoding="utf-8",
-            ) as f:
-                c = json.load(f)
-                return {"apis": c[self.name]}
+        method_lower = method.lower()
+        if method_lower not in VALID_METHODS:
+            raise ValueError(f"Invalid HTTP method: {method}")
 
-        elif Path(tr_config_filename).suffix == ".toml":
-            with open(config_path, mode="rb") as f:
-                c = tomllib.load(f)
-                return c
+        session_method = getattr(self.session, method.lower())
 
-    async def fetch(self, url, method="GET", headers=None, body=None, params=None):
-        request_headers = headers
-        request_body = str(body).encode() if body else None
-        request_params = params
+        # TODO : Set rate limiters value when config load
+        api_name = ""
 
-        session_method = getattr(self.session, method.lower())
+        if api_name and api_name in self.rate_limiters:
+            await self.rate_limiters[api_name].async_acquire()
 
         try:
             async with session_method(
                 url,
-                # yarl.URL(url, encoded=True),
-                headers=request_headers,
-                data=request_body,
-                params=request_params,
+                headers=headers,
+                data=str(body).encode() if body else None,
+                params=params,
                 timeout=aiohttp.ClientTimeout(total=int(self.timeout / 1000)),
             ) as response:
                 http_response = await response.text(errors="replace")
                 json_response = self.parse_json(http_response)
                 return json_response
-        except asyncio.TimeoutError as e:
+        except (asyncio.TimeoutError, aiohttp.ClientError) as e:
             details = f"{self.id} {method} {url}"
             raise TimeoutError(details) from e
+        finally:
+            if (
+                api_name
+                and api_name in self.rate_limiters
+                and isinstance(self.rate_limiters[api_name], RateLimiterContext)
+            ):
+                self.rate_limiters[api_name].release()
 
     async def fetch2(
         self, path, security_type, params={}, headers: Optional[Any] = None, body: Optional[Any] = None, config={}