trd-utils 0.0.6__tar.gz → 0.0.8__tar.gz

{trd_utils-0.0.6 → trd_utils-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: trd_utils
-Version: 0.0.6
+Version: 0.0.8
 Summary: Common Basic Utils for Python3. By ALiwoto.
 Keywords: utils,trd_utils,basic-utils,common-utils
 Author: ALiwoto

{trd_utils-0.0.6 → trd_utils-0.0.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "trd_utils"
-version = "0.0.6"
+version = "0.0.8"
 description = "Common Basic Utils for Python3. By ALiwoto."
 authors = ["ALiwoto <aminnimaj@gmail.com>"]
 packages = [

trd_utils-0.0.8/trd_utils/__init__.py

@@ -0,0 +1,3 @@
+
+__version__ = "0.0.8"
+

{trd_utils-0.0.6 → trd_utils-0.0.8}/trd_utils/exchanges/blofin/blofin_client.py

@@ -1,3 +1,4 @@
+import asyncio
 from decimal import Decimal
 import json
 import logging
@@ -10,6 +11,8 @@ from pathlib import Path
 from trd_utils.exchanges.blofin.blofin_types import (
     BlofinApiResponse,
     CmsColorResponse,
+    CopyTraderAllOrderHistory,
+    CopyTraderAllOrderList,
     CopyTraderInfoResponse,
     CopyTraderOrderHistoryResponse,
     CopyTraderOrderListResponse,
@@ -89,9 +92,9 @@ class BlofinClient(ExchangeBase):
 
     async def get_copy_trader_order_list(
         self,
-        from_param: int,
-        limit_param: 0,
         uid: int,
+        from_param: int = 0,
+        limit_param: int = 20,
     ) -> CopyTraderOrderListResponse:
         payload = {
             "from": from_param,
@@ -106,11 +109,60 @@ class BlofinClient(ExchangeBase):
             model=CopyTraderOrderListResponse,
         )
     
+    async def get_copy_trader_all_order_list(
+        self,
+        uid: int,
+        from_param: int = 0,
+        chunk_limit: int = 20,
+        sleep_delay: int = 0.5,
+    ) -> CopyTraderAllOrderList:
+        if chunk_limit < 1:
+            raise ValueError("chunk_limit parameter has to be more than 1")
+
+        result = CopyTraderAllOrderList(
+            code=200,
+            data=[],
+            total_count=0,
+        )
+        current_id_from = from_param
+        while True:
+            total_ignored = 0
+            current_result = await self.get_copy_trader_order_list(
+                uid=uid,
+                from_param=current_id_from,
+                limit_param=chunk_limit,
+            )
+            if not current_result or not isinstance(current_result, CopyTraderOrderListResponse) or \
+                not current_result.data:
+                return result
+            
+            if current_result.data[0].id == current_id_from:
+                if len(current_result.data) < 2:
+                    return result
+                current_result.data = current_result.data[1:]
+                total_ignored += 1
+            elif current_id_from:
+                raise ValueError(
+                    "Expected first array to have the same value as from_param: "
+                    f"current_id_from: {current_id_from}; but was: {current_result.data[0].id}"
+                )
+            
+            current_id_from = current_result.data[-1].id
+            result.data.extend(current_result.data)
+            result.total_count += len(current_result.data)
+            if len(current_result.data) < chunk_limit - total_ignored:
+                # the trader doesn't have any more open orders
+                return result
+            if result.total_count > len(current_result.data) and sleep_delay:
+                # we don't want to sleep after 1 request only
+                await asyncio.sleep(sleep_delay)
+
+
     async def get_copy_trader_order_history(
         self,
-        from_param: int,
-        limit_param: 0,
         uid: int,
+        from_param: int = 0,
+        limit_param: int = 20,
     ) -> CopyTraderOrderHistoryResponse:
         payload = {
             "from": from_param,
@@ -125,6 +177,54 @@ class BlofinClient(ExchangeBase):
             model=CopyTraderOrderHistoryResponse,
         )
 
+    async def get_copy_trader_all_order_history(
+        self,
+        uid: int,
+        from_param: int = 0,
+        chunk_limit: int = 20,
+        sleep_delay: int = 0.5,
+    ) -> CopyTraderAllOrderHistory:
+        if chunk_limit < 1:
+            raise ValueError("chunk_limit parameter has to be more than 1")
+
+        result = CopyTraderAllOrderHistory(
+            code=200,
+            data=[],
+            total_count=0,
+        )
+        current_id_from = from_param
+        while True:
+            total_ignored = 0
+            current_result = await self.get_copy_trader_order_history(
+                uid=uid,
+                from_param=current_id_from,
+                limit_param=chunk_limit,
+            )
+            if not current_result or not isinstance(current_result, CopyTraderOrderHistoryResponse) or \
+                not current_result.data:
+                return result
+            
+            if current_result.data[0].id == current_id_from:
+                if len(current_result.data) < 2:
+                    return result
+                current_result.data = current_result.data[1:]
+                total_ignored += 1
+            elif current_id_from:
+                raise ValueError(
+                    "Expected first array to have the same value as from_param: "
+                    f"current_id_from: {current_id_from}; but was: {current_result.data[0].id}"
+                )
+            
+            current_id_from = current_result.data[-1].id
+            result.data.extend(current_result.data)
+            result.total_count += len(current_result.data)
+            if len(current_result.data) < chunk_limit - total_ignored:
+                # the trader doesn't have any more orders history
+                return result
+            if result.total_count > len(current_result.data) and sleep_delay:
+                # we don't want to sleep after 1 request only
+                await asyncio.sleep(sleep_delay)
+
     # endregion
     ###########################################################
     # region client helper methods

{trd_utils-0.0.6 → trd_utils-0.0.8}/trd_utils/exchanges/blofin/blofin_types.py

@@ -139,6 +139,11 @@ class CopyTraderSingleOrderInfo(BaseModel):
 class CopyTraderOrderListResponse(BlofinApiResponse):
     data: list[CopyTraderSingleOrderInfo] = None
 
+class CopyTraderAllOrderList(CopyTraderOrderListResponse):
+    total_count: int = None
 
 class CopyTraderOrderHistoryResponse(BlofinApiResponse):
     data: list[CopyTraderSingleOrderInfo] = None
+
+class CopyTraderAllOrderHistory(CopyTraderOrderHistoryResponse):
+    total_count: int = None

{trd_utils-0.0.6 → trd_utils-0.0.8}/trd_utils/types_helper/__init__.py

@@ -1,4 +1,6 @@
 from .base_model import BaseModel
 
 
-__all__ = ["BaseModel"]
+__all__ = [
+    BaseModel,
+]

{trd_utils-0.0.6 → trd_utils-0.0.8}/trd_utils/types_helper/base_model.py

@@ -1,3 +1,4 @@
+from decimal import Decimal
 import json
 from typing import (
     Union,
@@ -46,6 +47,85 @@ def is_any_type(target_type: type) -> bool:
     return target_type == Any or target_type is type(None)
 
 
+# TODO: add support for max_depth for this...
+def value_to_normal_obj(value):
+    """
+    Converts a custom value, to a corresponding "normal object" which can be used
+    in dict.
+    """
+    if isinstance(value, BaseModel):
+        return value.to_dict()
+
+    if isinstance(value, list):
+        results = []
+        for current in value:
+            results.append(value_to_normal_obj(current))
+        return results
+
+    if isinstance(value, (int, str)) or value is None:
+        return value
+
+    if isinstance(value, Decimal):
+        return str(value)
+
+    if isinstance(value, dict):
+        result = {}
+        for inner_key, inner_value in value.items():
+            result[inner_key] = value_to_normal_obj(inner_value)
+
+        return result
+
+    raise TypeError(f"unsupported type provided: {type(value)}")
+
+
+def generic_obj_to_value(
+    expected_type: type,
+    expected_type_args: tuple[type],
+    value: Any,
+):
+    """
+    Converts a normal JSON-compatible "object" to a customized python value.
+    """
+    if not expected_type_args:
+        expected_type_args = get_type_args(expected_type)
+
+    if isinstance(value, list):
+        result = []
+        for current in value:
+            result.append(generic_obj_to_value(
+                expected_type=expected_type_args[0],
+                expected_type_args=expected_type_args[1:],
+                value=current,
+            ))
+        return result
+
+    expected_type_name = getattr(expected_type, "__name__", None)
+    if expected_type_name == "dict" and isinstance(value, dict):
+        result = {}
+        for inner_key, inner_value in value.items():
+            result[expected_type_args[0](inner_key)] = generic_obj_to_value(
+                expected_type=expected_type_args[1],
+                expected_type_args=expected_type_args[1:],
+                value=inner_value,
+            )
+        return result
+
+    if isinstance(value, dict) and issubclass(expected_type, BaseModel):
+        if len(expected_type_args) > 1:
+            raise ValueError(
+                "unsupported operation: at this time we cannot have"
+                " expected type args at all...",
+            )
+        return expected_type(**value)
+
+    if not expected_type_args:
+        if isinstance(value, expected_type):
+            return value
+        return expected_type(value)
+
+    raise TypeError(f"unsupported type: {type(value)}")
+
+
 class UltraList(list):
     def __getattr__(self, attr):
         if len(self) == 0:
@@ -104,31 +184,44 @@ class BaseModel:
                 except Exception:
                     pass
 
-            is_optional_type = getattr(expected_type, "_name", None) == "Optional"
+            expected_type_args = get_type_args(expected_type)
+            expected_type_name = getattr(expected_type, "__name__", None)
+            is_optional_type = expected_type_name == "Optional"
+            is_dict_type = expected_type_name == "dict"
             # maybe in the future we can have some other usages for is_optional_type
             # variable or something like that.
             if is_optional_type:
                 try:
-                    expected_type = get_type_args(expected_type)[0]
+                    expected_type = expected_type_args[0]
                 except Exception:
                     # something went wrong, just ignore and continue
                     expected_type = Any
 
+            if value is None:
+                # just skip...
+                pass
+            elif isinstance(value, dict) and is_dict_type:
+                value = generic_obj_to_value(
+                    expected_type=expected_type,
+                    expected_type_args=expected_type_args,
+                    value=value,
+                )
+
             # Handle nested models
-            if isinstance(value, dict) and issubclass(expected_type, BaseModel):
+            elif isinstance(value, dict) and issubclass(expected_type, BaseModel):
                 value = expected_type(**value)
 
             elif isinstance(value, list):
-                type_args = get_type_args(expected_type)
-                if not type_args:
+                if not expected_type_args:
                     # if it's Any, it means we shouldn't really care about the type
                     if expected_type != Any:
                         value = expected_type(value)
                 else:
-                    # Handle list of nested models
-                    nested_type = type_args[0]
-                    if issubclass(nested_type, BaseModel):
-                        value = [nested_type(**item) for item in value]
+                    value = generic_obj_to_value(
+                        expected_type=expected_type,
+                        expected_type_args=expected_type_args,
+                        value=value,
+                    )
 
                 if ULTRA_LIST_ENABLED and isinstance(value, list):
                     value = convert_to_ultra_list(value)
@@ -159,3 +252,30 @@ class BaseModel:
         else:
             data = json_data
         return cls(**data)
+
+    def serialize(
+        self,
+        separators=(",", ":"),
+        ensure_ascii=True,
+        sort_keys=True,
+    ) -> bytes:
+        return json.dumps(
+            obj=self.to_dict(),
+            ensure_ascii=ensure_ascii,
+            separators=separators,
+            sort_keys=sort_keys,
+        )
+
+    def to_dict(self) -> dict:
+        annotations = get_my_field_types(self)
+        result_dict = {}
+        for key, _ in annotations.items():
+            if not isinstance(key, str):
+                continue
+
+            if key.startswith("__"):
+                # ignore private attributes
+                continue
+
+            result_dict[key] = value_to_normal_obj(getattr(self, key))
+        return result_dict

trd_utils-0.0.6/trd_utils/__init__.py

@@ -1,3 +0,0 @@
-
-__version__ = "0.0.6"
-