osbot-utils 2.77.0__py3-none-any.whl → 2.79.0__py3-none-any.whl

osbot_utils/helpers/Dict_To_Attr.py

@@ -1,6 +1,3 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-
 class Dict_To_Attr:
     def __init__(self, dictionary):
         for key, value in dictionary.items():

osbot_utils/helpers/transformers/Dict__To__Toml.py

@@ -0,0 +1,211 @@
+from typing                                                           import Dict, Any, List, Set, Tuple, Union
+from osbot_utils.type_safe.Type_Safe                                  import Type_Safe
+from osbot_utils.type_safe.type_safe_core.decorators.type_safe        import type_safe
+
+
+class Dict__To__Toml(Type_Safe):
+
+    @type_safe
+    def convert(self, data: Dict[str, Any]                                          # Dictionary to convert to TOML
+                ) -> str:                                                           # Returns TOML formatted string
+        toml_str = ""
+
+        # First, process top-level simple values
+        toml_str += self._process_simple_values(data, indent_level=0)
+
+        # Process top-level arrays of simple types
+        toml_str += self._process_simple_arrays(data, indent_level=0)
+
+        # Process top-level dictionaries as sections
+        toml_str += self._process_sections(data, parent_key="")
+
+        # Process arrays of tables
+        toml_str += self._process_array_of_tables(data, parent_key="")
+
+        return toml_str
+
+    @type_safe
+    def _format_string_value(self, value: str                                      # String to format
+                            ) -> str:                                              # Returns formatted TOML string
+        """Format a string value for TOML output"""
+        # For TOML basic strings, we need to handle:
+        # 1. If string contains single quotes, use double quotes
+        # 2. If string contains double quotes but no single quotes, use single quotes
+        # 3. If string contains both, use triple quotes (multi-line literal)
+
+        has_single = "'" in value
+        has_double = '"' in value
+        has_newline = '\n' in value or '\r' in value
+
+        # Use triple quotes for complex strings (multilineelif has_single: or with both quote types)
+        if has_newline or (has_single and has_double):
+            # Use multi-line literal string (triple single quotes)
+            # This preserves the exact content without escaping
+            return f"'''\n{value}'''"
+        elif has_single:
+            # Use double quotes and escape any double quotes
+            escaped = value.replace('"', '\\"')
+            return f'"{escaped}"'
+        else:
+            # Use single quotes (default) - no escaping needed
+            return f"'{value}'"
+
+    @type_safe
+    def _process_simple_values(self, data        : Dict[str, Any]        ,          # Data to process
+                                     indent_level : int           = 0                # Current indentation level
+                               ) -> str:                                            # Returns TOML for simple values
+        toml_str = ""
+        indent   = "    " * indent_level
+
+        for key, value in data.items():
+            if not isinstance(value, (dict, list, tuple, set)):
+                if isinstance(value, str):
+                    toml_str += f"{indent}{key} = {self._format_string_value(value)}\n"
+                elif isinstance(value, bool):
+                    toml_str += f"{indent}{key} = {str(value).lower()}\n"
+                elif value is not None:
+                    toml_str += f"{indent}{key} = {value}\n"
+
+        return toml_str
+
+    @type_safe
+    def _process_simple_arrays(self, data        : Dict[str, Any]        ,          # Data to process
+                                    indent_level : int           = 0                # Current indentation level
+                              ) -> str:                                             # Returns TOML for simple arrays
+        toml_str = ""
+        indent   = "    " * indent_level
+
+        for key, value in data.items():
+            if isinstance(value, (list, tuple, set)):
+                if not value:                                                       # Empty collection
+                    toml_str += f"{indent}{key} = []\n"
+                elif not any(isinstance(item, dict) for item in value):            # No dict items
+                    toml_str += f"{indent}{key} = [\n"
+                    for item in value:
+                        if isinstance(item, str):
+                            toml_str += f"{indent}    {self._format_string_value(item)},\n"
+                        elif isinstance(item, bool):
+                            toml_str += f"{indent}    {str(item).lower()},\n"
+                        elif item is not None:
+                            toml_str += f"{indent}    {item},\n"
+                    toml_str += f"{indent}]\n"
+
+        return toml_str
+
+    @type_safe
+    def _process_sections(self, data       : Dict[str, Any]       ,                 # Data to process
+                               parent_key : str            = ""                    # Parent section key
+                         ) -> str:                                                  # Returns TOML sections
+        toml_str = ""
+
+        for key, value in data.items():
+            if isinstance(value, dict):
+                section_key = f"{parent_key}.{key}" if parent_key else key
+                toml_str   += f"[{section_key}]\n"
+                toml_str   += self._process_section_content(value, section_key)
+
+        return toml_str
+
+    @type_safe
+    def _process_section_content(self, section_data : Dict[str, Any]      ,         # Section data to process
+                                       section_key  : str                           # Current section key
+                                ) -> str:                                           # Returns section content
+        toml_str = ""
+        indent   = "    "
+
+        # Process simple values in section
+        for key, value in section_data.items():
+            if isinstance(value, str):
+                toml_str += f"{indent}{key} = {self._format_string_value(value)}\n"
+            elif isinstance(value, bool):
+                toml_str += f"{indent}{key} = {str(value).lower()}\n"
+            elif isinstance(value, (int, float)) and value is not None:
+                toml_str += f"{indent}{key} = {value}\n"
+            elif isinstance(value, (list, tuple, set)) and not value:
+                toml_str += f"{indent}{key} = []\n"
+            elif isinstance(value, (list, tuple, set)):
+                if not any(isinstance(item, dict) for item in value):
+                    toml_str += f"{indent}{key} = [\n"
+                    for item in value:
+                        if isinstance(item, str):
+                            toml_str += f"{indent}{indent}{self._format_string_value(item)},\n"
+                        elif isinstance(item, bool):
+                            toml_str += f"{indent}{indent}{str(item).lower()},\n"
+                        elif item is not None:
+                            toml_str += f"{indent}{indent}{item},\n"
+                    toml_str += f"{indent}]\n"
+
+        # Process arrays of tables within sections (NEW)
+        for key, value in section_data.items():
+            if isinstance(value, (list, tuple, set)):
+                if value and all(isinstance(item, dict) for item in value):
+                    for item in value:
+                        toml_str += f"[[{section_key}.{key}]]\n"
+                        for item_key, item_value in item.items():
+                            if isinstance(item_value, str):
+                                toml_str += f"{indent}{item_key} = {self._format_string_value(item_value)}\n"
+                            elif isinstance(item_value, bool):
+                                toml_str += f"{indent}{item_key} = {str(item_value).lower()}\n"
+                            elif isinstance(item_value, (int, float)) and item_value is not None:
+                                toml_str += f"{indent}{item_key} = {item_value}\n"
+
+        # Process nested dictionaries
+        for key, value in section_data.items():
+            if isinstance(value, dict):
+                nested_key = f"{section_key}.{key}"
+                toml_str  += f"[{nested_key}]\n"
+                toml_str  += self._process_section_content(value, nested_key)
+
+        return toml_str
+
+    @type_safe
+    def _process_array_of_tables(self, data       : Dict[str, Any]       ,          # Data to process
+                                       parent_key : str            = ""             # Parent section key
+                                ) -> str:                                           # Returns array of tables
+        toml_str = ""
+
+        for key, value in data.items():
+            if isinstance(value, (list, tuple, set)):
+                if value and all(isinstance(item, dict) for item in value):
+                    for item in value:
+                        section_key = f"{parent_key}.{key}" if parent_key else key
+                        toml_str   += f"[[{section_key}]]\n"
+                        toml_str   += self._process_table_item(item, section_key)
+
+        return toml_str
+
+    @type_safe
+    def _process_table_item(self, item        : Dict[str, Any]        ,             # Table item to process
+                                  section_key : str                                 # Current section key
+                           ) -> str:                                               # Returns formatted table item
+        toml_str = ""
+        indent   = "    "
+
+        # Process simple values in table item
+        for key, value in item.items():
+            if isinstance(value, str):
+                toml_str += f"{indent}{key} = {self._format_string_value(value)}\n"
+            elif isinstance(value, bool):
+                toml_str += f"{indent}{key} = {str(value).lower()}\n"
+            elif isinstance(value, (int, float)) and value is not None:
+                toml_str += f"{indent}{key} = {value}\n"
+            elif isinstance(value, (list, tuple, set)) and not value:
+                toml_str += f"{indent}{key} = []\n"
+            elif isinstance(value, (list, tuple, set)):
+                if not any(isinstance(sub_item, dict) for sub_item in value):
+                    toml_str += f"{indent}{key} = [\n"
+                    for sub_item in value:
+                        if isinstance(sub_item, str):
+                            toml_str += f"{indent}{indent}{self._format_string_value(sub_item)},\n"
+                        else:
+                            toml_str += f"{indent}{indent}{sub_item},\n"
+                    toml_str += f"{indent}]\n"
+
+        # Process nested dicts in table items
+        for key, value in item.items():
+            if isinstance(value, dict):
+                nested_section = f"{section_key}.{key}"
+                toml_str      += f"[{nested_section}]\n"
+                toml_str      += self._process_section_content(value, nested_section)
+
+        return toml_str

osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py

@@ -1,3 +1,4 @@
+import collections
 import inspect                                                                                                                       # For function introspection
 from enum                                                                     import Enum
 from typing                                                                   import get_args, get_origin, Union, List, Any, Dict    # For type hinting utilities
@@ -105,14 +106,32 @@ class Type_Safe__Method:
         if not isinstance(param_value, list):                                         # Check if value is a list
             raise ValueError(f"Parameter '{param_name}' expected a list but got {type(param_value)}")  # Raise error if not list
 
-        item_type = get_args(expected_type)[0]                                          # Get list item type
-        if get_origin(item_type) is not None:                                           # Handle the case when item_type is a subscripted type (which is not supported at the moment)
+        item_type = get_args(expected_type)[0]                                        # Get list item type
+        item_origin = get_origin(item_type)                                           # Get origin of item type
+
+        if item_origin is dict or item_origin is Dict:                                # Handle Dict[K, V] items
+            key_type, value_type = get_args(item_type)                                # Extract key and value types
+            for i, item in enumerate(param_value):                                    # Validate each dict in list
+                if not isinstance(item, dict):                                        # Check item is a dict
+                    raise ValueError(f"List item at index {i} expected dict but got {type(item)}")  # Raise error if not dict
+                for k, v in item.items():                                             # Validate dict contents
+                    if not isinstance(k, key_type):                                   # Check key type
+                        raise ValueError(f"Dict key '{k}' at index {i} expected type {key_type}, but got {type(k)}")  # Raise error for invalid key
+                    if not isinstance(v, value_type):                                 # Check value type
+                        raise ValueError(f"Dict value for key '{k}' at index {i} expected type {value_type}, but got {type(v)}")  # Raise error for invalid value
+        elif item_origin is collections.abc.Callable:                                 # Handle Callable[[...], ...] items
+            for i, item in enumerate(param_value):                                    # Validate each callable in list
+                if not callable(item):                                                # Check item is callable
+                    raise ValueError(f"List item at index {i} expected callable but got {type(item)}")  # Raise error if not callable
+                # Note: Full signature validation would require is_callable_compatible method
+        elif item_origin is not None:                                                 # Handle other subscripted types
             raise NotImplementedError(f"Validation for list items with subscripted type"
                                       f" '{item_type}' is not yet supported "
-                                      f"in parameter '{param_name}'.")                  # todo: add support for checking for subscripted types
-        for i, item in enumerate(param_value):                                          # Check each list item
-            if not isinstance(item, item_type):                                         # Validate item type
-                raise ValueError(f"List item at index {i} expected type {item_type}, but got {type(item)}")  # Raise error for invalid item
+                                      f"in parameter '{param_name}'.")                # todo: add support for checking for subscripted types
+        else:                                                                         # Handle non-subscripted types
+            for i, item in enumerate(param_value):                                    # Check each list item
+                if not isinstance(item, item_type):                                   # Validate item type
+                    raise ValueError(f"List item at index {i} expected type {item_type}, but got {type(item)}")  # Raise error for invalid item
 
     def validate_type_parameter(self, param_name: str, param_value: Any, expected_type: Any):           # Validate a Type[T] parameter
         if not isinstance(param_value, type):

osbot_utils/utils/Toml.py

@@ -1,29 +1,11 @@
 import sys
-from osbot_utils.utils.Files   import file_create, file_contents
-from osbot_utils.utils.Objects import dict_to_obj
-
-
-def dict_to_toml(data, indent_level=0):
-    toml_str = ""
-    indent = " " * (indent_level * 4)
-
-    for key, value in data.items():
-        if isinstance(value, dict):
-            toml_str += f"{indent}[{key}]\n"
-            toml_str += dict_to_toml(value, indent_level + 1)
-        elif isinstance(value, (list, tuple, set)):
-            toml_str += f"{indent}{key} = [\n"
-            for item in value:
-                toml_str += f"{indent}    {repr(item)},\n"
-            toml_str += f"{indent}]\n"
-        elif isinstance(value, str):
-            toml_str += f"{indent}{key} = '{value}'\n"
-        elif isinstance(value, bool):
-            toml_str += f"{indent}{key} = {str(value).lower()}\n"
-        else:
-            toml_str += f"{indent}{key} = {value}\n"
-
-    return toml_str
+from osbot_utils.helpers.transformers.Dict__To__Toml import Dict__To__Toml
+from osbot_utils.utils.Files                         import file_create, file_contents
+from osbot_utils.utils.Objects                       import dict_to_obj
+
+
+def dict_to_toml(data):
+    return Dict__To__Toml().convert(data)                                                 # Singleton instance for convenience
 
 def toml_dict_to_file(toml_file, data):
     str_toml = dict_to_toml(data)
@@ -33,7 +15,6 @@ def toml_dict_from_file(toml_file):
     str_toml = file_contents(toml_file)
     return toml_to_dict(str_toml)
 
-
 def toml_to_dict(str_toml):
     if sys.version_info >= (3, 11):
         import tomllib

osbot_utils/version

@@ -1 +1 @@
-v2.77.0
+v2.79.0

{osbot_utils-2.77.0.dist-info → osbot_utils-2.79.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: osbot_utils
-Version: 2.77.0
+Version: 2.79.0
 Summary: OWASP Security Bot - Utils
 License: MIT
 Author: Dinis Cruz
@@ -21,7 +21,7 @@ Description-Content-Type: text/markdown
 
 # OSBot-Utils
 
-![Current Release](https://img.shields.io/badge/release-v2.77.0-blue)
+![Current Release](https://img.shields.io/badge/release-v2.79.0-blue)
 ![Python](https://img.shields.io/badge/python-3.8+-green)
 ![Type-Safe](https://img.shields.io/badge/Type--Safe-✓-brightgreen)
 ![Caching](https://img.shields.io/badge/Caching-Built--In-orange)

{osbot_utils-2.77.0.dist-info → osbot_utils-2.79.0.dist-info}/RECORD

@@ -33,7 +33,7 @@ osbot_utils/fluent/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVG
 osbot_utils/helpers/CFormat.py,sha256=QviXlx3cQF7Wq6bNQmvWPHknDDMQXg5bh5dsRncrg-U,6805
 osbot_utils/helpers/CPrint.py,sha256=8iCkLaPozi3anzLQ-kPfJTtfLZdOrgpGNJs5UNjGJ9g,1346
 osbot_utils/helpers/Dependency_Manager.py,sha256=79YRYnVfchewq8iSMJ5dzwW2D5u8chWcIqYE-G9YrSo,1337
-osbot_utils/helpers/Dict_To_Attr.py,sha256=NdhXl5mJH7-NaBk213amzc5Nfy3tJgW-N_uYIRE4hoc,208
+osbot_utils/helpers/Dict_To_Attr.py,sha256=OWAChOCTM03ECfL4ME7Y0026ZnfA7OmSTIWYKlW9Jmg,139
 osbot_utils/helpers/Hashicorp_Secrets.py,sha256=e2fWWHK6bubpAm1sw5y8X5kh2Hk5d4JyZCnUovZip5A,4232
 osbot_utils/helpers/Local_Cache.py,sha256=67qmeVXUBhfqLUQhjFBE9Pjt5dcjpQYhqCTGQNWgVSU,3232
 osbot_utils/helpers/Local_Caches.py,sha256=LUeNJX07Ccnp1SIhYvhqqQFVF6r_Ez7bWha8ssomuvY,1957
@@ -306,6 +306,7 @@ osbot_utils/helpers/trace/Trace_Call__Stats.py,sha256=gmiotIrOXe2ssxodzQQ56t8eGT
 osbot_utils/helpers/trace/Trace_Call__View_Model.py,sha256=a40nn6agCEMd2ecsJ93n8vXij0omh0D69QilqwmN_ao,4545
 osbot_utils/helpers/trace/Trace_Files.py,sha256=SNpAmuBlSUS9NyVocgZ5vevzqVaIqoh622yZge3a53A,978
 osbot_utils/helpers/trace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+osbot_utils/helpers/transformers/Dict__To__Toml.py,sha256=x_5_9xwS6ytSVzpr74AJOjYTnrkTCLPb8MoHyRkWuvA,10791
 osbot_utils/helpers/xml/Xml__Attribute.py,sha256=_dIVyp0WHfdv306vAj5bpEtiqKa83MLKRH925rjKa94,145
 osbot_utils/helpers/xml/Xml__Element.py,sha256=NLRdiTsRhqRf0I0ScAdN-tHuSh2qNuKP_tldx7iiSv4,868
 osbot_utils/helpers/xml/Xml__File.py,sha256=ECR4WD57ePyA88uioKVt5GVbWXddM_Y1OsWAJNzAg74,420
@@ -416,7 +417,7 @@ osbot_utils/type_safe/type_safe_core/collections/Type_Safe__Tuple.py,sha256=Kx7C
 osbot_utils/type_safe/type_safe_core/collections/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/decorators/type_safe.py,sha256=wOTMvZBl5hWMz-HuIRZpPBGN0oSbXWd9wH5xxZkfLlA,1796
-osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py,sha256=5Kf6vRrU_SRV88dN7HRtM-OdT2ZeoNVy5KLhbs0Cz0Q,16807
+osbot_utils/type_safe/type_safe_core/methods/Type_Safe__Method.py,sha256=-EHM5goVg-CvVufeMFi_jUSTldpla4FQiq6XO5ZJtUs,18776
 osbot_utils/type_safe/type_safe_core/methods/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/type_safe/type_safe_core/methods/type_safe_property.py,sha256=DcJkOIs6swJtkglsZVKLyFSczCGSJISOVwAmvjCOQvo,1425
 osbot_utils/type_safe/type_safe_core/shared/Type_Safe__Annotations.py,sha256=kabSiRPYPjpMBJxfjDB5AFRTx-hX17tOznZAd_qQID4,1147
@@ -464,12 +465,12 @@ osbot_utils/utils/Regex.py,sha256=MtHhk69ax7Nwu4CQZK7y4KXHZ6VREwEpIchuioB168c,96
 osbot_utils/utils/Status.py,sha256=OjqLwUhHqY-j-JeRN-hIaVZQHPRdyjR7y6i6ujsB-Yc,4287
 osbot_utils/utils/Str.py,sha256=KQVfh0o3BxJKVm24yhAhgIGH5QYfzpP1G-siVv2zQws,3301
 osbot_utils/utils/Threads.py,sha256=YI1T382AtJpHVsa-BK7SycmEYhnkqHIiYyK_5HSmUtw,4329
-osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,1667
+osbot_utils/utils/Toml.py,sha256=grjWkVPIMVkawJ499FVIJKxQp8FJ2wcsd0Z3YIR4drM,1148
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=mG42lgTY0tnm14T3P1-DSAIZKkTiYoO3odZ1aOUdc1I,14394
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=Ee_VvYF0FneCzkUtpqDTXDcXCaviuUXqsJ-W8pEco9k,8
-osbot_utils-2.77.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-2.77.0.dist-info/METADATA,sha256=WX8X7ud_stauh0dxr7wvg7IPLgbn5-0X1Nm993_tUQc,7918
-osbot_utils-2.77.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-osbot_utils-2.77.0.dist-info/RECORD,,
+osbot_utils/version,sha256=LBnSHfeuqdNUDCaJ0l1-HSUQy_-YezgRfKFIWsPg7Q4,8
+osbot_utils-2.79.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-2.79.0.dist-info/METADATA,sha256=EYa9xfe3-uAcOGHcGHDaX0LIrRtztORvnB_PJ8cS-G0,7918
+osbot_utils-2.79.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+osbot_utils-2.79.0.dist-info/RECORD,,