trd-utils 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

trd_utils/__init__.py

@@ -1,3 +1,3 @@
 
-__version__ = "0.0.5"
+__version__ = "0.0.7"
 

trd_utils/types_helper/__init__.py

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

trd_utils/types_helper/base_model.py

@@ -1,9 +1,10 @@
+from decimal import Decimal
 import json
 from typing import (
     Union,
     get_type_hints,
     Any,
-    get_args as get_type_args
+    get_args as get_type_args,
 )
 
 from trd_utils.html_utils.html_formats import camel_to_snake
@@ -19,6 +20,7 @@ ULTRA_LIST_ENABLED: bool = False
 # attribute names are converted to snake_case.
 SET_CAMEL_ATTR_NAMES = False
 
+
 def get_my_field_types(cls):
     type_hints = {}
     for current_cls in cls.__class__.__mro__:
@@ -27,24 +29,110 @@ def get_my_field_types(cls):
         type_hints.update(get_type_hints(current_cls))
     return type_hints
 
+
 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 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:
             return None
         return UltraList([get_real_attr(item, attr) for item in self])
 
+
 def convert_to_ultra_list(value: Any) -> UltraList:
     if not value:
         return UltraList()
@@ -61,7 +149,7 @@ def convert_to_ultra_list(value: Any) -> UltraList:
             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)))
@@ -70,6 +158,7 @@ def convert_to_ultra_list(value: Any) -> UltraList:
     except Exception:
         return value
 
+
 class BaseModel:
     def __init__(self, **kwargs):
         annotations = get_my_field_types(self)
@@ -83,62 +172,79 @@ class BaseModel:
                     # just ignore and continue
                     annotations[key] = Any
                     annotations[corrected_key] = Any
-            
+
             expected_type = annotations[corrected_key]
             if hasattr(self, "_get_" + corrected_key + "_type"):
                 try:
-                    overridden_type = getattr(self, "_get_" + corrected_key + "_type")(kwargs)
+                    overridden_type = getattr(self, "_get_" + corrected_key + "_type")(
+                        kwargs
+                    )
                     if overridden_type:
                         expected_type = overridden_type
                 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)
-            
+
             # Type checking
-            elif expected_type != Any and not isinstance(value, expected_type):
+            elif not (is_any_type(expected_type) or isinstance(value, expected_type)):
                 try:
                     value = expected_type(value)
                 except Exception:
-                    raise TypeError(f"Field {corrected_key} must be of type {expected_type}," +
-                                    f" but it's {type(value)}")
-            
+                    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]):
         if isinstance(json_data, str):
@@ -147,3 +253,29 @@ class BaseModel:
             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.5.dist-info → trd_utils-0.0.7.dist-info}/METADATA

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

{trd_utils-0.0.5.dist-info → trd_utils-0.0.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-trd_utils/__init__.py,sha256=r1FyIVMcj4G09lxuES6Tc50rbc-_eR52L74_l10QWJY,24
+trd_utils/__init__.py,sha256=T3fa9wcYqXeAC8vAZ1EjWWLpXmx9tFj9SvTgGPKVr4Y,24
 trd_utils/cipher/__init__.py,sha256=V05KNuzQwCic-ihMVHlC8sENaJGc3I8MCb4pg4849X8,1765
 trd_utils/common_utils/float_utils.py,sha256=W-jv7nzjl88xwGB6gsEXmDDhF6DseOrrVT2qx7OvyCo,266
 trd_utils/exchanges/__init__.py,sha256=SQJt5cIXh305miWuDumkOLZHzqDUyOqSmlhTT9Xc9RY,180
@@ -15,9 +15,9 @@ trd_utils/html_utils/html_formats.py,sha256=unKsvOiiDmYTTaM0DYZEUNLEUzWQKKrqASJX
 trd_utils/tradingview/__init__.py,sha256=H0QYb-O5qvy7qC3yswtlcSWLmeBnaS6oJ3JtjvmaV_Y,154
 trd_utils/tradingview/tradingview_client.py,sha256=g_eWYaCRQAL8Kvd-r6AnAdbH7Jha6C_GAyCuxh-RQUU,3917
 trd_utils/tradingview/tradingview_types.py,sha256=z21MXPVdWHAduEl3gSeMIRhxtBN9yK-jPYHfZSMIbSA,6144
-trd_utils/types_helper/__init__.py,sha256=SB9_5bQkuxV059AKC4cXYwsLPT3lM4LOu2m8LpMhZlQ,60
-trd_utils/types_helper/base_model.py,sha256=08P5GatIjLoBGVudF7dcKDpibLqcpUeqE-zLRh1FjEE,5617
-trd_utils-0.0.5.dist-info/LICENSE,sha256=J1EP2xt87RjjmsTV1jTjHDQMLIM9FjdwEftTpw8hyv4,1067
-trd_utils-0.0.5.dist-info/METADATA,sha256=oD-HdWY6g30VIE623ZCBQf_8d0fcsMtXBcJVuEpotoc,1094
-trd_utils-0.0.5.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-trd_utils-0.0.5.dist-info/RECORD,,
+trd_utils/types_helper/__init__.py,sha256=VlEXDzOyn6fYH-dE86EGJ6u_el08QvdyOtJkj-0EAVA,65
+trd_utils/types_helper/base_model.py,sha256=diowqH_nh21HDUki_0nbrEtZd8IxGCpwrN8yCVN8QDE,9311
+trd_utils-0.0.7.dist-info/LICENSE,sha256=J1EP2xt87RjjmsTV1jTjHDQMLIM9FjdwEftTpw8hyv4,1067
+trd_utils-0.0.7.dist-info/METADATA,sha256=Yy5-Rg6vMAN1W-ExlW6CJRa23Jzvebv9dvc0j4KEvNw,1094
+trd_utils-0.0.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+trd_utils-0.0.7.dist-info/RECORD,,