trd-utils 0.0.57__py3-none-any.whl

trd_utils/types_helper/base_model.py

@@ -0,0 +1,350 @@
+import datetime
+from decimal import Decimal
+import json
+from typing import (
+    Union,
+    Any,
+    get_args as get_type_args,
+)
+
+import dateutil.parser
+
+from trd_utils.date_utils.datetime_helpers import dt_from_ts, dt_to_ts
+from trd_utils.html_utils.html_formats import camel_to_snake
+from trd_utils.types_helper.model_config import ModelConfig
+from trd_utils.types_helper.ultra_list import convert_to_ultra_list, UltraList
+from trd_utils.types_helper.utils import AbstractModel, get_my_field_types, is_type_optional
+
+# Whether to use ultra-list instead of normal python list or not.
+# This might be convenient in some cases, but it is not recommended
+# to use it in production code because of the performance overhead.
+ULTRA_LIST_ENABLED: bool = False
+
+# Whether to also set the camelCase attribute names for the model.
+# This is useful when the API returns camelCase attribute names
+# and you want to use them as is in the model; by default, the
+# attribute names are converted to snake_case.
+SET_CAMEL_ATTR_NAMES = False
+
+# The _model_config is a special field which cannot get serialized
+# nor can it get deserialized.
+SPECIAL_FIELDS = [
+    "_model_config",
+]
+
+def new_list(original: Any = None) -> list:
+    if original is None:
+        original = []
+    elif not isinstance(original, list):
+        original = [original]
+
+    if ULTRA_LIST_ENABLED:
+        return UltraList(original)
+
+    return original
+
+
+def is_base_model_type(expected_type: type) -> bool:
+    return (
+        expected_type is not None
+        and expected_type != Any
+        and issubclass(expected_type, BaseModel)
+    )
+
+
+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, omit_none: bool = False):
+    """
+    Converts a custom value, to a corresponding "normal object" which can be used
+    in dict.
+    """
+    if isinstance(value, BaseModel):
+        return value.to_dict(
+            omit_none=omit_none,
+        )
+
+    if isinstance(value, list):
+        results = new_list()
+        for current in value:
+            results.append(
+                value_to_normal_obj(
+                    value=current,
+                    omit_none=omit_none,
+                )
+            )
+        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():
+            normalized_value = value_to_normal_obj(
+                value=inner_value,
+                omit_none=omit_none,
+            )
+            if normalized_value is None and omit_none:
+                continue
+
+            result[inner_key] = normalized_value
+
+        return result
+
+    if isinstance(value, datetime.datetime):
+        return dt_to_ts(value)
+
+    raise TypeError(f"unsupported type provided: {type(value)}")
+
+
+def convert_to_expected_type(
+    expected_type: type,
+    value: Any,
+    default_value=None,
+):
+    try:
+        return expected_type(value)
+    except Exception:
+        if value == "":
+            try:
+                return expected_type()
+            except Exception:
+                return default_value
+        return default_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 = new_list()
+        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 is_base_model_type(expected_type=expected_type):
+        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 value is None or isinstance(value, expected_type):
+            return value
+        return convert_to_expected_type(
+            expected_type=expected_type,
+            value=value,
+        )
+
+    raise TypeError(f"unsupported type: {type(value)}")
+
+
+class BaseModel(AbstractModel):
+    _model_config: ModelConfig = None
+
+    def __init__(self, **kwargs):
+        if not self._model_config:
+            self._model_config = ModelConfig()
+
+        annotations = get_my_field_types(self)
+        for key, value in kwargs.items():
+            corrected_key = key
+            if key not in annotations:
+                # key does not exist, try converting it to snake_case
+                corrected_key = camel_to_snake(key)
+                if corrected_key not in annotations:
+                    # just ignore and continue
+                    annotations[key] = Any
+                    annotations[corrected_key] = Any
+
+            if corrected_key in SPECIAL_FIELDS or (
+                self._model_config.ignored_fields
+                and corrected_key in self._model_config.ignored_fields
+            ):
+                continue
+
+            expected_type = annotations[corrected_key]
+            if hasattr(self, "_get_" + corrected_key + "_type"):
+                try:
+                    overridden_type = getattr(self, "_get_" + corrected_key + "_type")(
+                        kwargs
+                    )
+                    if overridden_type:
+                        expected_type = overridden_type
+                except Exception:
+                    pass
+
+            expected_type_args = get_type_args(expected_type)
+            expected_type_name = getattr(expected_type, "__name__", None)
+            is_optional_type = is_type_optional(expected_type)
+            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 = 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
+            elif isinstance(value, dict) and is_base_model_type(
+                expected_type=expected_type
+            ):
+                value = expected_type(**value)
+
+            elif isinstance(value, list):
+                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:
+                    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)
+            elif expected_type is datetime.datetime:
+                try:
+                    if isinstance(value, str):
+                        if value.isdigit():
+                            value = dt_from_ts(int(value))
+                        else:
+                            value = dateutil.parser.parse(value)
+                    elif isinstance(value, int):
+                        value = dt_from_ts(value)
+                except Exception as ex:
+                    raise ValueError(
+                        f"Failed to parse the string as datetime: {value}"
+                        f" Are you sure it's in correct format? inner error: {ex}"
+                    )
+
+            # Type checking
+            elif not (is_any_type(expected_type) or isinstance(value, expected_type)):
+                try:
+                    value = convert_to_expected_type(
+                        expected_type=expected_type,
+                        value=value,
+                    )
+                except Exception:
+                    raise TypeError(
+                        f"Field {corrected_key} must be of type {expected_type},"
+                        + f" but it's {type(value)}"
+                    )
+
+            setattr(self, corrected_key, value)
+            if SET_CAMEL_ATTR_NAMES and key != corrected_key:
+                setattr(self, key, value)
+
+        # Check if all required fields are present
+        # for field in self.__annotations__:
+        #     if not hasattr(self, field):
+        #         raise ValueError(f"Missing required field: {field}")
+
+    @classmethod
+    def deserialize(
+        cls,
+        json_data: Union[str, dict],
+        parse_float=Decimal,
+    ):
+        if isinstance(json_data, str):
+            data = json.loads(
+                json_data,
+                parse_float=parse_float,
+            )
+        else:
+            data = json_data
+        return cls(**data)
+
+    def serialize(
+        self,
+        separators=(",", ":"),
+        ensure_ascii: bool = True,
+        sort_keys: bool = True,
+        omit_none: bool = False,
+    ) -> bytes:
+        return json.dumps(
+            obj=self.to_dict(
+                omit_none=omit_none,
+            ),
+            ensure_ascii=ensure_ascii,
+            separators=separators,
+            sort_keys=sort_keys,
+        )
+
+    def to_dict(
+        self,
+        omit_none: bool = False,
+    ) -> dict:
+        annotations = get_my_field_types(self)
+        result_dict = {}
+        for key, _ in annotations.items():
+            if not isinstance(key, str) or key in SPECIAL_FIELDS:
+                continue
+
+            if key.startswith("__") or key.startswith(f"_{self.__class__.__name__}__"):
+                # ignore private attributes
+                continue
+
+            if (
+                self._model_config.ignored_fields
+                and key in self._model_config.ignored_fields
+            ):
+                continue
+
+            normalized_value = value_to_normal_obj(
+                value=getattr(self, key),
+                omit_none=omit_none,
+            )
+            if normalized_value is None and omit_none:
+                continue
+
+            result_dict[key] = normalized_value
+        return result_dict

trd_utils/types_helper/decorators.py

@@ -0,0 +1,20 @@
+
+from typing import Type, TypeVar
+
+from trd_utils.types_helper.model_config import ModelConfig
+from trd_utils.types_helper.utils import AbstractModel
+
+
+T = TypeVar('T', bound=AbstractModel)
+
+def ignore_json_fields(fields: list[str]):
+    def wrapper(cls: Type[T]) -> Type[T]:
+        config = getattr(cls, "_model_config", None)
+        if not config:
+            config = ModelConfig()
+        
+        config.ignored_fields = fields.copy()
+        setattr(cls, "_model_config", config)
+        return cls
+    return wrapper
+

trd_utils/types_helper/model_config.py

@@ -0,0 +1,6 @@
+
+
+class ModelConfig:
+    ignored_fields: list[str] = None
+
+

trd_utils/types_helper/ultra_list.py

@@ -0,0 +1,39 @@
+
+from typing import Any
+from trd_utils.types_helper.utils import get_my_field_types, get_real_attr
+
+
+class UltraList(list):
+    def __getattr__(self, attr):
+        if len(self) == 0:
+            return None
+        return UltraList([get_real_attr(item, attr) for item in self])
+
+
+def convert_to_ultra_list(value: Any = None) -> UltraList:
+    if not value:
+        return UltraList()
+
+    # Go through all fields of the value and convert them to
+    # UltraList if they are lists
+
+    try:
+        if isinstance(value, list):
+            return UltraList([convert_to_ultra_list(item) for item in value])
+        elif isinstance(value, dict):
+            return {k: convert_to_ultra_list(v) for k, v in value.items()}
+        elif isinstance(value, tuple):
+            return tuple(convert_to_ultra_list(v) for v in value)
+        elif isinstance(value, set):
+            return {convert_to_ultra_list(v) for v in value}
+
+        for attr, attr_value in get_my_field_types(value).items():
+            if isinstance(attr_value, list):
+                setattr(value, attr, convert_to_ultra_list(getattr(value, attr)))
+
+        return value
+    except Exception:
+        return value
+
+
+

trd_utils/types_helper/utils.py

@@ -0,0 +1,40 @@
+from typing import (
+    get_type_hints,
+)
+
+class AbstractModel:
+    pass
+
+def is_type_optional(target: type) -> bool:
+    if getattr(target, "__name__", None) == "Optional":
+        # e.g: my_field: Optional[str] = None
+        return True
+    
+    target_args = getattr(target, "__args__", None)
+    if target_args and len(target_args) > 1 and target_args[1] is type(None):
+        # e.g: my_field: Decimal | None = None
+        return True
+    
+    return False
+
+def get_real_attr(cls, attr_name):
+    if cls is None:
+        return None
+
+    if isinstance(cls, dict):
+        return cls.get(attr_name, None)
+
+    if hasattr(cls, attr_name):
+        return getattr(cls, attr_name)
+
+    return None
+
+def get_my_field_types(cls):
+    type_hints = {}
+    for current_cls in cls.__class__.__mro__:
+        if current_cls is object or current_cls is AbstractModel:
+            break
+        type_hints.update(get_type_hints(current_cls))
+    return type_hints
+
+

trd_utils-0.0.57.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: trd_utils
+Version: 0.0.57
+Summary: Common Basic Utils for Python3. By ALiwoto.
+License-File: LICENSE
+Keywords: utils,trd_utils,basic-utils,common-utils
+Author: ALiwoto
+Author-email: aminnimaj@gmail.com
+Requires-Python: >=3.7
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: cryptography (>=41.0.7)
+Requires-Dist: httpx (>=0.21.0)
+Requires-Dist: python-dateutil (>=2.9.0.post0)
+Requires-Dist: websockets (>=15.0.1)
+Project-URL: Homepage, https://github.com/ALiwoto/trd_utils
+Description-Content-Type: text/markdown
+
+# Trd Utils
+
+Basic common utils for Python.
+
+## How to run tests
+
+Use this command first:
+
+```bash
+pip install -e .
+```
+
+Then run the tests in vscode.
+

trd_utils-0.0.57.dist-info/RECORD

@@ -0,0 +1,44 @@
+trd_utils/__init__.py,sha256=Xi63N56I_0mLMvCwn1ROb6iNd47L9-f1CDY-vGa9P9s,25
+trd_utils/cipher/__init__.py,sha256=V05KNuzQwCic-ihMVHlC8sENaJGc3I8MCb4pg4849X8,1765
+trd_utils/common_utils/float_utils.py,sha256=aYPwJ005LmrRhXAngojwvdDdtRgeb1FfR6hKeQ5ndMU,470
+trd_utils/common_utils/wallet_utils.py,sha256=OX9q2fymP0VfIWTRIRBP8W33cfyjLXimxMgPOsZe-3g,727
+trd_utils/date_utils/__init__.py,sha256=Erg_E1TfKWNpiuZFm_NXRjCwoRMfxpPS2-mJK6V4lFM,77
+trd_utils/date_utils/datetime_helpers.py,sha256=euIJBr-6PfJzLScOC9xVXd8Re_Gw5CSBPwtHX9_Il4A,596
+trd_utils/exchanges/README.md,sha256=8egE4IPUQ3_UtiGP6GaCg50xq_dp43aGY_X1lKcO6ok,6812
+trd_utils/exchanges/__init__.py,sha256=IRAEr4DYE8pmnYUoilpUThEhKBQ2TCupDHrhRzvcVXg,674
+trd_utils/exchanges/base_types.py,sha256=Yl9lMvK1f13ZuhWoZRqyjGxaDAjcAbeamK-BSVJB-lA,7498
+trd_utils/exchanges/binance/__init__.py,sha256=Yy9z_cQeECjX05IwTJHpIRmId1aLoo0tQAR8rVTrUx0,223
+trd_utils/exchanges/binance/binance_client.py,sha256=dNY3uki68CkbRgRTwXKu-nS8m0tQwp1ZVa-BsOGbUnQ,13524
+trd_utils/exchanges/binance/binance_types.py,sha256=SyzFDQKynCrtbFNdOt_K_6N6mxcO2HIWK7UzTr3rrIM,3396
+trd_utils/exchanges/blofin/__init__.py,sha256=X4r9o4Nyjla4UeOBG8lrgtnGYO2aErFMKaJ7yQrFasE,76
+trd_utils/exchanges/blofin/blofin_client.py,sha256=QRiCyUewY9KBBaCrLTyg26RNedX58zhFY6NdpEcgO40,13343
+trd_utils/exchanges/blofin/blofin_types.py,sha256=bQx0opCgHwcuC-5TxiVA4VQr17A1x7u7QIMdcIrROAg,4315
+trd_utils/exchanges/bx_ultra/__init__.py,sha256=8Ssy-eOemQR32Nv1-FoPHm87nRqRO4Fm2PU5GHEFKfQ,80
+trd_utils/exchanges/bx_ultra/bx_types.py,sha256=7Ga6IYHQNRDbhWXmS1J0NxpcR9HUJ8ZwQGh-1EvNRqM,36687
+trd_utils/exchanges/bx_ultra/bx_ultra_client.py,sha256=W85CFxSFE5lFqUvNupQf42b5aU81i-SFF23BO22kx4U,40798
+trd_utils/exchanges/bx_ultra/bx_utils.py,sha256=PwapomwDW33arVmKIDj6cL-aP0ptu4BYy_lOCqSAPOo,1392
+trd_utils/exchanges/errors.py,sha256=P_NTuc389XL7rFegomP59BydWmHv8ckiGyNU-_l5qNQ,167
+trd_utils/exchanges/exchange_base.py,sha256=oXiG4Qu4GKRzrMbjZWJkUla6uYV2UrWHtYKWsGo0gjc,9271
+trd_utils/exchanges/hyperliquid/README.md,sha256=-qaxmDt_9NTus2xRuzyFGkKgYDWgWk7ufHVTSkyn3t4,105
+trd_utils/exchanges/hyperliquid/__init__.py,sha256=QhwGRcneGFHREM-MMdYpbcx-aWdsWsu2WznHzx7LaUM,92
+trd_utils/exchanges/hyperliquid/hyperliquid_client.py,sha256=Fcwb5JBgZ3Sw-N_wFEOj-LUwsb7MLcLkPQcrzhHx59Y,10402
+trd_utils/exchanges/hyperliquid/hyperliquid_types.py,sha256=PqrA3ycKpOReGLoJLMc4ZgqbQrU8xxXbshBOIvq9-jo,5186
+trd_utils/exchanges/okx/__init__.py,sha256=OjVpvcwB9mrCTofLt14JRHV2-fMAzGz9-YkJAMwl6dM,67
+trd_utils/exchanges/okx/okx_client.py,sha256=tIYp3RehylP1Ag9IUnqlIdgpavynchzzPka-3W5osxg,7486
+trd_utils/exchanges/okx/okx_types.py,sha256=IkFOfgivcvvIw950jyGHAVfFFGbGqfZcYGfZLWfNLvc,5013
+trd_utils/exchanges/price_fetcher.py,sha256=YHLkM6sCvHGFS_4t188Sl3DczqrarK-1ivGwZEVsom4,1320
+trd_utils/html_utils/__init__.py,sha256=1WWs8C7JszRjTkmzIRLHpxWECHur_DrulTPGIeX88oM,426
+trd_utils/html_utils/html_formats.py,sha256=unKsvOiiDmYTTaM0DYZEUNLEUzWQKKrqASJXvY54kvU,2299
+trd_utils/tradingview/__init__.py,sha256=H0QYb-O5qvy7qC3yswtlcSWLmeBnaS6oJ3JtjvmaV_Y,154
+trd_utils/tradingview/tradingview_client.py,sha256=D6K0Hra6WNua0ATwmK9xNDEzPZTMd-ghtdk-D19A0Mg,3970
+trd_utils/tradingview/tradingview_types.py,sha256=z21MXPVdWHAduEl3gSeMIRhxtBN9yK-jPYHfZSMIbSA,6144
+trd_utils/types_helper/__init__.py,sha256=_yWDkeLdgVUG92CQFyO9uoGsSyMRUq0yYXK3XgUYmDI,214
+trd_utils/types_helper/base_model.py,sha256=bkkKdYoAmBrn0dW55icVJV062DCU38fbxr4NTNw8FTM,11481
+trd_utils/types_helper/decorators.py,sha256=ziQGDKV0RnhMG6gBPAz244Ug3j6ayr0iKXeucAdnXB8,527
+trd_utils/types_helper/model_config.py,sha256=uvyhdGHQZ1A_I5RUbCgzlDk6MxWL6RLV8r0cdVi6nBk,60
+trd_utils/types_helper/ultra_list.py,sha256=pt3GGZ1F0V4DqxVNbfeqQmVkPmkOphaBA6UtA5zOl7U,1184
+trd_utils/types_helper/utils.py,sha256=hJzxI6D1ZSmv4y4wLrv-QW5AvrDU4BARXJmLpB-CTEI,960
+trd_utils-0.0.57.dist-info/METADATA,sha256=OeCDvhODSgzlxtjXhq5v0c2oYLJzfT6U7672MrTRbYk,1252
+trd_utils-0.0.57.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+trd_utils-0.0.57.dist-info/licenses/LICENSE,sha256=J1EP2xt87RjjmsTV1jTjHDQMLIM9FjdwEftTpw8hyv4,1067
+trd_utils-0.0.57.dist-info/RECORD,,

trd_utils-0.0.57.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

trd_utils-0.0.57.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 ALi.w
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.