osbot-utils 1.92.0__py3-none-any.whl → 1.94.0__py3-none-any.whl

osbot_utils/base_classes/Type_Safe.py

@@ -3,7 +3,7 @@
 
 import sys
 import types
-from osbot_utils.utils.Objects                          import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
+from osbot_utils.utils.Objects import default_value         # todo: remove test mocking requirement for this to be here (instead of on the respective method)
 
 # Backport implementations of get_origin and get_args for Python 3.7
 if sys.version_info < (3, 8):                                           # pragma: no cover
@@ -95,8 +95,12 @@ class Type_Safe:
         if value is not None:
             if type(value) is dict:
                 value = convert_dict_to_value_from_obj_annotation(self, name, value)
-            if type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
+            elif type(value) in [int, str]:                                                   # for now only a small number of str and int classes are supported (until we understand the full implications of this)
                 value = convert_to_value_from_obj_annotation (self, name, value)
+            else:
+                origin = get_origin(value)
+                if origin is not None:
+                    value = origin
             check_1 = value_type_matches_obj_annotation_for_attr      (self, name, value)
             check_2 = value_type_matches_obj_annotation_for_union_and_annotated(self, name, value)
             if (check_1 is False and check_2 is None  or
@@ -169,7 +173,7 @@ class Type_Safe:
                                 #todo: fix type safety bug that I believe is caused here
                                 if obj_is_type_union_compatible(var_type, IMMUTABLE_TYPES) is False:                # if var_type is not something like Optional[Union[int, str]]
                                     if type(var_type) not in IMMUTABLE_TYPES:
-                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Kwargs_To_Self, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
+                                        exception_message = f"variable '{var_name}' is defined as type '{var_type}' which is not supported by Type_Safe, with only the following immutable types being supported: '{IMMUTABLE_TYPES}'"
                                         raise ValueError(exception_message)
             if include_base_classes is False:
                 break
@@ -304,6 +308,19 @@ class Type_Safe:
                 setattr(self, key, value)
         return self
 
+    def deserialize_type__using_value(self, value):
+        if value:
+            try:
+                module_name, type_name = value.rsplit('.', 1)
+                if module_name == 'builtins' and type_name == 'NoneType':                       # Special case for NoneType (which serialises as builtins.* , but it actually in types.* )
+                    value = types.NoneType
+                else:
+                    module = __import__(module_name, fromlist=[type_name])
+                    value = getattr(module, type_name)
+            except (ValueError, ImportError, AttributeError) as e:
+                raise ValueError(f"Could not reconstruct type from '{value}': {str(e)}")
+        return value
+
     def deserialize_dict__using_key_value_annotations(self, key, value):
         from osbot_utils.base_classes.Type_Safe__Dict import Type_Safe__Dict
 
@@ -353,7 +370,9 @@ class Type_Safe:
                             raise ValueError(f"Attribute '{key}' not found in '{self.__class__.__name__}'")
                         else:
                             continue
-                    if obj_is_attribute_annotation_of_type(self, key, dict):                                # handle the case when the value is a dict
+                    if obj_attribute_annotation(self, key) == type:                                         # Handle type objects
+                        value = self.deserialize_type__using_value(value)
+                    elif obj_is_attribute_annotation_of_type(self, key, dict):                                # handle the case when the value is a dict
                         value = self.deserialize_dict__using_key_value_annotations(key, value)
                     elif obj_is_attribute_annotation_of_type(self, key, list):                              # handle the case when the value is a list
                         attribute_annotation = obj_attribute_annotation(self, key)                          # get the annotation for this variable
@@ -423,15 +442,17 @@ def serialize_to_dict(obj):
         return obj
     elif isinstance(obj, Enum):
         return obj.name
+    elif isinstance(obj, type):
+        return f"{obj.__module__}.{obj.__name__}"                                   # save the full type name
     elif isinstance(obj, list) or isinstance(obj, List):
         return [serialize_to_dict(item) for item in obj]
     elif isinstance(obj, dict):
         return {key: serialize_to_dict(value) for key, value in obj.items()}
     elif hasattr(obj, "__dict__"):
-        data = {}                                           # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
+        data = {}                                                                   # todo: look at a more advanced version which saved the type of the object, for example with {'__type__': type(obj).__name__}
         for key, value in obj.__dict__.items():
-            if key.startswith('__') is False:               # don't process internal variables (for example the ones set by @cache_on_self)
-                data[key] = serialize_to_dict(value)        # Recursive call for complex types
+            if key.startswith('__') is False:                                       # don't process internal variables (for example the ones set by @cache_on_self)
+                data[key] = serialize_to_dict(value)                                # Recursive call for complex types
         return data
     else:
         raise TypeError(f"Type {type(obj)} not serializable")

osbot_utils/helpers/Safe_Id.py

@@ -1,8 +1,10 @@
 from osbot_utils.utils.Misc import random_id_short
 from osbot_utils.utils.Str  import safe_id
 
+SAFE_ID__MAX_LENGTH = 512
+
 class Safe_Id(str):
-    def __new__(cls, value=None, max_length=36):
+    def __new__(cls, value=None, max_length=SAFE_ID__MAX_LENGTH):
         if value is None:
             value = safe_id(random_id_short('safe-id'))
         sanitized_value = safe_id(value, max_length=max_length)

osbot_utils/utils/Json.py

@@ -193,6 +193,7 @@ json_save_file_gz            = Json.save_file_gz
 json_save_file_pretty_gz     = Json.save_file_pretty_gz
 json_save_tmp_file           = Json.json_save_tmp_file
 str_to_json                  = Json.loads
+str_from_json                = json_dumps
 
 load_file_json               = json_load_file
 load_file_json_gz            = json_load_file_gz

osbot_utils/utils/Objects.py

@@ -359,8 +359,6 @@ def obj_attribute_annotation(target, attr_name):
 
 def obj_is_attribute_annotation_of_type(target, attr_name, expected_type):
     attribute_annotation = obj_attribute_annotation(target, attr_name)
-    #attribute_type       = type(attribute_annotation)
-    #return attribute_type is expected_type
     if expected_type is attribute_annotation:
         return True
     if expected_type is type(attribute_annotation):

osbot_utils/utils/Str.py

@@ -9,17 +9,17 @@ REGEX__ANSI_ESCAPE_PATTERN = re.compile(r'\x1b\[[0-9;]*m')
 REGEX__SAFE_ID_REGEX       = re.compile(r'[^a-zA-Z0-9_-]')
 
 def ansi_text_visible_length(ansi_text):
-    if type(ansi_text) is str:
+    if isinstance(ansi_text, str):
         ansi_escape = re.compile(REGEX__ANSI_ESCAPE_PATTERN)           # This regex matches the escape sequences used for text formatting
         visible_text = ansi_escape.sub('', ansi_text)       # Remove the escape sequences
         return len(visible_text)                                # Return the length of the remaining text
 
 def ansi_to_text(ansi_text: str):
-    if type(ansi_text) is str:
+    if isinstance(ansi_text, str):
         return REGEX__ANSI_ESCAPE_PATTERN.sub('', ansi_text)
 
 def ansis_to_texts(ansis_texts: list):                          # todo: find a better name for this method :)
-    if type(ansis_texts) is list:
+    if isinstance(ansis_texts, list):
         return [ansi_to_text(ansi_text) for ansi_text in ansis_texts]
     return []
 
@@ -42,7 +42,7 @@ def safe_id(value, max_length=36):
         value = str(value)
 
     if len(value) > max_length:
-        raise ValueError(f"Invalid ID: The ID must not exceed 36 characters (was {len(value)}).")
+        raise ValueError(f"Invalid ID: The ID must not exceed {max_length} characters (was {len(value)}).")
 
     sanitized_value = REGEX__SAFE_ID_REGEX.sub('_', value)
 
@@ -98,7 +98,7 @@ def str_cap_snake_case(snake_str):
 
 
 def trim(target):
-    if type(target) is str:
+    if isinstance(target, str):
         return target.strip()
     return ""
 

osbot_utils/version

@@ -1 +1 @@
-v1.92.0
+v1.94.0

{osbot_utils-1.92.0.dist-info → osbot_utils-1.94.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: osbot_utils
-Version: 1.92.0
+Version: 1.94.0
 Summary: OWASP Security Bot - Utils
 Home-page: https://github.com/owasp-sbot/OSBot-Utils
 License: MIT
@@ -23,7 +23,7 @@ Description-Content-Type: text/markdown
 
 Powerful Python util methods and classes that simplify common apis and tasks.
 
-![Current Release](https://img.shields.io/badge/release-v1.92.0-blue)
+![Current Release](https://img.shields.io/badge/release-v1.94.0-blue)
 [![codecov](https://codecov.io/gh/owasp-sbot/OSBot-Utils/graph/badge.svg?token=GNVW0COX1N)](https://codecov.io/gh/owasp-sbot/OSBot-Utils)
 
 

{osbot_utils-1.92.0.dist-info → osbot_utils-1.94.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ osbot_utils/__init__.py,sha256=DdJDmQc9zbQUlPVyTJOww6Ixrn9n4bD3ami5ItQfzJI,16
 osbot_utils/base_classes/Cache_Pickle.py,sha256=kPCwrgUbf_dEdxUz7vW1GuvIPwlNXxuRhb-H3AbSpII,5884
 osbot_utils/base_classes/Kwargs_To_Disk.py,sha256=HHoy05NC_w35WcT-OnSKoSIV_cLqaU9rdjH0_KNTM0E,1096
 osbot_utils/base_classes/Kwargs_To_Self.py,sha256=weFNsBfBNV9W_qBkN-IdBD4yYcJV_zgTxBRO-ZlcPS4,141
-osbot_utils/base_classes/Type_Safe.py,sha256=D1SzaB3Km-UrlucCE3boL5_dbTQBDn1-s1URbehRl8w,27754
+osbot_utils/base_classes/Type_Safe.py,sha256=XzJd1tOEFFT67ycg5QaiXv5pFeWD8Fq4YDVQGGVYAjc,28990
 osbot_utils/base_classes/Type_Safe__Base.py,sha256=CFPYe8_i5vvTLyc7s8CXbY4n_dY6sqVfBY8w9Vo77ZA,5468
 osbot_utils/base_classes/Type_Safe__Dict.py,sha256=sfZcukhXUd9TS0PQpAk-gGLfZUJSC6BtMh6jF4Fn8Jw,1107
 osbot_utils/base_classes/Type_Safe__List.py,sha256=pXDzJJttpEQQ9oTdsw7BykMB4VIX2rZzi1ZrnCzMZ8M,650
@@ -37,28 +37,6 @@ osbot_utils/decorators/methods/type_safe.py,sha256=WtoDTRPcFV-EgSaNEawMj2plVq-zR
 osbot_utils/fluent/Fluent_Dict.py,sha256=nZ2z91s39sU2a-TLYpBirRoWgDXHrs0tQ9Bi_ZdKeW0,481
 osbot_utils/fluent/Fluent_List.py,sha256=PfDDC9sm16CFnNQ8gkhCEsmKcZp8iyQ0YBpSHvYssG8,1089
 osbot_utils/fluent/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-osbot_utils/graphs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/graphs/mermaid/Mermaid.py,sha256=G7--iIKm2C1z-tEB1qLNopwoW3_w4oR7Oq7-yA460mM,3164
-osbot_utils/graphs/mermaid/Mermaid__Edge.py,sha256=jwHxHJEAA49aO28T8nnJFxOfpWAZZaWKNT_krG1fwkQ,1893
-osbot_utils/graphs/mermaid/Mermaid__Graph.py,sha256=FRw17efZrdcKyXDKsyb1C8nswIAmljiUAyiF0FHIL4M,2854
-osbot_utils/graphs/mermaid/Mermaid__Node.py,sha256=j_AVfR3hnKAJH2Z3d17djvU7MfQP8B70Lh7Jv6y0tTs,3322
-osbot_utils/graphs/mermaid/Mermaid__Renderer.py,sha256=-5h_Xkaq3boKVWzPYPG_kUoe0SOlR0Tm4zVEXJ70wUk,2289
-osbot_utils/graphs/mermaid/configs/Mermaid__Edge__Config.py,sha256=PaypnkaDQQhNBIxZqnAB5bxuJAZWh3SQtmHUPfIcDCQ,212
-osbot_utils/graphs/mermaid/configs/Mermaid__Node__Config.py,sha256=KZWd_uiIm-QIz_wPSDfXfWAWU_A2yxzMeq-h5wldVjQ,465
-osbot_utils/graphs/mermaid/configs/Mermaid__Render__Config.py,sha256=JGQR6kdiTQh45zFZYvqdEDMghFIWLnVYMZsdukYtGyw,216
-osbot_utils/graphs/mermaid/examples/Mermaid_Examples__FlowChart.py,sha256=BFlQ1C-DkmVxSWJKUQC8lFVxu26znHvgaXy50QkYVZY,2220
-osbot_utils/graphs/mermaid/models/Mermaid__Diagram_Direction.py,sha256=m52zJ3bkHuF-Fq29CK3yAlX9RFi5_VQwqQGKaT1XRR4,141
-osbot_utils/graphs/mermaid/models/Mermaid__Diagram__Type.py,sha256=QWPjpZ8Y77K3l8v481TK_UzbkxmSkIHDfOxc-P405TM,799
-osbot_utils/graphs/mermaid/models/Mermaid__Node__Shape.py,sha256=_su5S8nYqg5qpXmWvKFZ05ZT5zLjTZP3sVIhc2hNpgg,1813
-osbot_utils/graphs/mgraph/MGraph.py,sha256=1Iu2CM9IHxoJxjmABsBqDvi8l09LINLDE9_b53Dz4kM,2218
-osbot_utils/graphs/mgraph/MGraph__Config.py,sha256=oFTj9eP92HolaOSyk-7tpsPVFZLMIcTH-O-mx93nTiA,204
-osbot_utils/graphs/mgraph/MGraph__Data.py,sha256=oLaKmxUOXoQbhdUxa_VW_QZA0tAETgRMzP3pvslppHw,5746
-osbot_utils/graphs/mgraph/MGraph__Edge.py,sha256=sS9LojdWZ8AISD0d8gdY6HgcyPM956roHmEkzhM_TQg,785
-osbot_utils/graphs/mgraph/MGraph__Node.py,sha256=KnUnD918hu5ifjbW_v7AVAAzxjHi5iuA4rluvDGOaPg,893
-osbot_utils/graphs/mgraph/MGraph__Random_Graphs.py,sha256=MDCmnrv7QcGXJeZDYc4y5Wth6ysB0hHzn1DqfocxtIs,964
-osbot_utils/graphs/mgraph/MGraph__Serializer.py,sha256=pLgKsJuo1x8S22m6TCLd3bvFLrBo6sTrq1AkknkOA18,1475
-osbot_utils/graphs/mgraph/MGraphs.py,sha256=TIv1CEsUiPIVxll3AuGLhEVBY4YRzZu_rpEz3Tzrph8,532
-osbot_utils/graphs/mgraph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/CFormat.py,sha256=1_XvqGwgU6qC97MbzcKF0o7s9mCXpU5Kq9Yf-1ixUwY,6808
 osbot_utils/helpers/CPrint.py,sha256=ztKPNmT8BGxeyPXSQKRs63PqqbgxKDz_BiZmzFMup9g,1413
 osbot_utils/helpers/Dependency_Manager.py,sha256=79YRYnVfchewq8iSMJ5dzwW2D5u8chWcIqYE-G9YrSo,1337
@@ -72,7 +50,7 @@ osbot_utils/helpers/Python_Audit.py,sha256=shpZlluJwqJBAlad6xN01FkgC1TsQ48RLvR5Z
 osbot_utils/helpers/Random_Guid.py,sha256=COu9hcP51vzjk-ErECTFFaOWuOmW0eGJyMu8HXhaRXQ,382
 osbot_utils/helpers/Random_Guid_Short.py,sha256=YP_k5OLuYvXWGU2OEnQHk_OGViBQofTWKm3pUdQaJao,404
 osbot_utils/helpers/Random_Seed.py,sha256=14btja8LDN9cMGWaz4fCNcMRU_eyx49gas-_PQvHgy4,634
-osbot_utils/helpers/Safe_Id.py,sha256=iwIrWXfSARyr6JkihNhh1soOdjeCGVf3wkXSkSP8zDw,402
+osbot_utils/helpers/Safe_Id.py,sha256=0wPGd9eLzaOCYTSg9yEOal1kPsc8OI9khHkqEw9VQOM,446
 osbot_utils/helpers/Str_ASCII.py,sha256=PRqyu449XnKrLn6b9Miii1Hv-GO5OAa1UhhgvlRcC2M,704
 osbot_utils/helpers/Timestamp_Now.py,sha256=k3-SUGYx2jLTXvgZYeECqPRJhVxqWPmW7co1l6r12jk,438
 osbot_utils/helpers/Type_Registry.py,sha256=Ajk3SyMSKDi2g9SJYUtTgg7PZkAgydaHcpbGuEN3S94,311
@@ -261,7 +239,6 @@ osbot_utils/helpers/ssh/TestCase__SSH.py,sha256=MD8sq0_kI4f6pEmEO0cLq2mQOhIqbP45
 osbot_utils/helpers/ssh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 osbot_utils/helpers/trace/Trace_Call.py,sha256=O_y6cncgneYrj3ARDMz-o9Yi1LjsESibUqkGFAg0Jk0,8886
 osbot_utils/helpers/trace/Trace_Call__Config.py,sha256=UAjdsDEqsPBBsu-h4_QKYL4UMukJmQYBBWGYTmSKS40,3361
-osbot_utils/helpers/trace/Trace_Call__Graph.py,sha256=HCrXRKQI42DIQxxyFLcaosWiOcUyoITbeV17ICdXcXM,1156
 osbot_utils/helpers/trace/Trace_Call__Handler.py,sha256=9EQyIiGB6r3UURyNgEXHPOCmZNOejM0UJNW9c_MjpNU,12650
 osbot_utils/helpers/trace/Trace_Call__Print_Lines.py,sha256=cy7zLv0_JNxdOIQPfZk6J9bv6AkIW6O643w0ykClXbw,4820
 osbot_utils/helpers/trace/Trace_Call__Print_Traces.py,sha256=2LGeWMGP1uhSojGMmJmL3bH2B5LFIlfYEqEPNqoyKJw,8628
@@ -323,24 +300,24 @@ osbot_utils/utils/Files.py,sha256=yxteAcyhDcUy1_r9Eihx80V16lV_UAE6cvoOe2Dc7DU,23
 osbot_utils/utils/Functions.py,sha256=0E6alPJ0fJpBiJgFOWooCOi265wSRyxxXAJ5CELBnso,3498
 osbot_utils/utils/Http.py,sha256=Cm_-b2EgxKoQJ47ThZp-dgHCdeGv4UcCNLfTOH94-7s,7790
 osbot_utils/utils/Int.py,sha256=PmlUdU4lSwf4gJdmTVdqclulkEp7KPCVUDO6AcISMF4,116
-osbot_utils/utils/Json.py,sha256=0DZGlCU7Nqte5n0r7ctPXFybqA5MRfSrTz5zuK_6UFk,7095
+osbot_utils/utils/Json.py,sha256=0t7Hwefx8bg4JiZVr-xIbWP3BAk6_ZsnY7iV5pnRLDQ,7137
 osbot_utils/utils/Json_Cache.py,sha256=mLPkkDZN-3ZVJiDvV1KBJXILtKkTZ4OepzOsDoBPhWg,2006
 osbot_utils/utils/Lists.py,sha256=tPz5x5s3sRO97WZ_nsxREBPC5cwaHrhgaYBhsrffTT8,5599
 osbot_utils/utils/Misc.py,sha256=H_xexJgiTxB3jDeDiW8efGQbO0Zuy8MM0iQ7qXC92JI,17363
-osbot_utils/utils/Objects.py,sha256=FVX0CyVY2g1iXIL4UA1dFzgbsA-GYrJ_cYlxosGxTdo,21713
+osbot_utils/utils/Objects.py,sha256=nsheXk2t4sRQVJStsKYDgCj8wF3knQ8X1AtLO1M4SlM,21614
 osbot_utils/utils/Png.py,sha256=V1juGp6wkpPigMJ8HcxrPDIP4bSwu51oNkLI8YqP76Y,1172
 osbot_utils/utils/Process.py,sha256=lr3CTiEkN3EiBx3ZmzYmTKlQoPdkgZBRjPulMxG-zdo,2357
 osbot_utils/utils/Python_Logger.py,sha256=tx8N6wRKL3RDHboDRKZn8SirSJdSAE9cACyJkxrThZ8,12792
 osbot_utils/utils/Regex.py,sha256=MtHhk69ax7Nwu4CQZK7y4KXHZ6VREwEpIchuioB168c,960
 osbot_utils/utils/Status.py,sha256=Yq4s0TelXgn0i2QjCP9V8mP30GabXp_UL-jjM6Iwiw4,4305
-osbot_utils/utils/Str.py,sha256=Y05F46m6s3_H7KoPdeasc1LRaU7R4YifIbsHNQYDEeg,3275
+osbot_utils/utils/Str.py,sha256=KQVfh0o3BxJKVm24yhAhgIGH5QYfzpP1G-siVv2zQws,3301
 osbot_utils/utils/Threads.py,sha256=lnh4doZWYUIoWBZRU_780QPeAIKGDh7INuqmU8Fzmdc,3042
 osbot_utils/utils/Toml.py,sha256=Rxl8gx7mni5CvBAK-Ai02EKw-GwtJdd3yeHT2kMloik,1667
 osbot_utils/utils/Version.py,sha256=Ww6ChwTxqp1QAcxOnztkTicShlcx6fbNsWX5xausHrg,422
 osbot_utils/utils/Zip.py,sha256=pR6sKliUY0KZXmqNzKY2frfW-YVQEVbLKiyqQX_lc-8,14052
 osbot_utils/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-osbot_utils/version,sha256=HcQJfW9qetpTTCAJA7zp8wAdYNIGH7zJcl-GVVPylC4,8
-osbot_utils-1.92.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-osbot_utils-1.92.0.dist-info/METADATA,sha256=BD8zNKY7lu6bJuUASVxE_R_j2ywMvZj6t32oFGOn9Sw,1317
-osbot_utils-1.92.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-osbot_utils-1.92.0.dist-info/RECORD,,
+osbot_utils/version,sha256=_0FgKn2Budr8baj8RE7pf68-C8Yvew0utOg1014PVtc,8
+osbot_utils-1.94.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+osbot_utils-1.94.0.dist-info/METADATA,sha256=v3Ivesk54q4PsxGFrjpS-7clJ6b6tkX_-vhJkZ-ZZp4,1317
+osbot_utils-1.94.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+osbot_utils-1.94.0.dist-info/RECORD,,

osbot_utils/graphs/mermaid/Mermaid.py

@@ -1,75 +0,0 @@
-from osbot_utils.graphs.mermaid.Mermaid__Renderer                   import Mermaid__Renderer
-from osbot_utils.graphs.mermaid.Mermaid__Edge                       import Mermaid__Edge
-from osbot_utils.graphs.mermaid.Mermaid__Graph                      import Mermaid__Graph
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram_Direction   import Diagram__Direction
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram__Type       import Diagram__Type
-from osbot_utils.utils.Python_Logger                                import Python_Logger
-from osbot_utils.base_classes.Kwargs_To_Self                        import Kwargs_To_Self
-
-class Mermaid(Kwargs_To_Self):
-    graph             : Mermaid__Graph
-    renderer          : Mermaid__Renderer
-    logger            : Python_Logger
-
-    # todo add support for storing the data in sqlite so that the search for existing nodes is efficient
-    def add_edge(self, from_node_key, to_node_key, label=None,attributes=None):
-        nodes_by_id = self.graph.data().nodes__by_key()
-        from_node   = nodes_by_id.get(from_node_key)
-        to_node     = nodes_by_id.get(to_node_key)
-        if not from_node:
-            from_node = self.add_node(key=from_node_key)
-        if not to_node:
-            to_node = self.add_node(key=to_node_key)
-
-        # todo: add back the protection/detection that we get from MGraph class of allow_circle_edges and allow_duplicate_edges
-        mermaid_edge = Mermaid__Edge(from_node=from_node, to_node=to_node, label=label, attributes=attributes)
-        self.graph.edges.append(mermaid_edge)
-        return mermaid_edge
-
-    def add_directive(self, directive):
-        self.renderer.config.directives.append(directive)
-        return self
-
-    def add_node(self, **kwargs):
-        return self.graph.add_node(**kwargs)
-
-    def code(self):
-        return self.renderer.code(self.nodes(), self.edges())
-
-    def code_markdown(self):
-        #self.code_create()
-        self.code()
-        rendered_lines = self.renderer.mermaid_code
-        markdown = ['#### Mermaid Graph',
-                    "```mermaid"        ,
-                    *rendered_lines     ,
-                    "```"               ]
-
-        return '\n'.join(markdown)
-
-    def edges(self):
-        return self.graph.edges
-
-    def print_code(self):
-        print(self.code())
-
-    def nodes(self):
-        return self.graph.nodes
-
-    def set_direction(self, direction):
-        if isinstance(direction, Diagram__Direction):
-            self.renderer.diagram_direction = direction
-        elif isinstance(direction, str) and direction in Diagram__Direction.__members__:
-            self.renderer.diagram_direction = Diagram__Direction[direction]
-        return self                             # If the value can't be set (not a valid name), do nothing
-
-    def set_diagram_type(self, diagram_type):
-        if isinstance(diagram_type, Diagram__Type):
-            self.renderer.diagram_type = diagram_type
-
-    def save(self, target_file=None):
-        file_path = target_file or '/tmp/mermaid.md'
-
-        with open(file_path, 'w') as file:
-            file.write(self.code_markdown())
-        return file_path

osbot_utils/graphs/mermaid/Mermaid__Edge.py

@@ -1,49 +0,0 @@
-from osbot_utils.graphs.mermaid.Mermaid__Node import LINE_PADDING, Mermaid__Node
-from osbot_utils.graphs.mermaid.configs.Mermaid__Edge__Config import Mermaid__Edge__Config
-from osbot_utils.graphs.mgraph.MGraph__Edge import MGraph__Edge
-#from osbot_utils.graphs.mgraph.views.mermaid.Mermaid__Node import Mermaid__Node
-from osbot_utils.utils.Str import safe_str
-
-
-class Mermaid__Edge(MGraph__Edge):
-    config    : Mermaid__Edge__Config
-    from_node : Mermaid__Node
-    to_node   : Mermaid__Node
-
-    # def __init__(self, **kwargs):
-    #     super().__init__(**kwargs)
-
-    # def __init__(self, **kwargs):
-    #     super().__init__(**kwargs)
-    #     self.convert_nodes()
-    #
-    def edge_mode(self, edge_mode):
-        self.config.edge_mode = edge_mode
-        return self
-
-    def edge_mode__lr_using_pipe(self):
-        return self.edge_mode('lr_using_pipe')
-
-    def output_node_from(self, value=True):
-        self.config.output_node_from = value
-        return self
-
-    def output_node_to(self, value=True):
-        self.config.output_node_to = value
-        return self
-
-    def render_edge(self):
-        from_node_key = safe_str(self.from_node.key)
-        to_node_key   = safe_str(self.to_node  .key)
-        if self.config.output_node_from:
-            from_node_key =  self.from_node.render_node(include_padding=False) #f'{edge.from_node.key}["{edge.from_node.label}"]'
-        if self.config.output_node_to:
-            to_node_key   = self.to_node.render_node(include_padding=False   ) #f'{edge.to_node  .key}["{edge.to_node  .label}"]'
-        if self.config.edge_mode == 'lr_using_pipe':
-            link_code      = f'-->|{self.label}|'
-        elif self.label:
-            link_code      = f'--"{self.label}"-->'
-        else:
-            link_code      = '-->'
-        edge_code      = f'{LINE_PADDING}{from_node_key} {link_code} {to_node_key}'
-        return edge_code

osbot_utils/graphs/mermaid/Mermaid__Graph.py

@@ -1,95 +0,0 @@
-from typing import List
-
-from osbot_utils.graphs.mgraph.MGraph__Edge import MGraph__Edge
-from osbot_utils.graphs.mgraph.MGraph__Node import MGraph__Node
-from osbot_utils.graphs.mermaid.Mermaid__Edge import Mermaid__Edge
-from osbot_utils.graphs.mermaid.Mermaid__Node import Mermaid__Node
-from osbot_utils.graphs.mgraph.MGraph import MGraph
-
-
-class Mermaid__Graph(MGraph):
-    edges        : List[Mermaid__Edge]
-    mermaid_code : List
-    nodes        : List[Mermaid__Node]
-
-    # def __init__(self, mgraph=None):
-    #     super().__init__()
-    #     if mgraph is None:
-    #         mgraph = MGraph()
-    #     self.__dict__ = mgraph.__dict__
-    #     self.convert_nodes().convert_edges()
-
-    # def cast(self, source):
-    #     self.__dict__ = source.__dict__
-    #     return self
-
-    # def add_edge(self, **kwargs):
-    #     #new_edge = super().add_edge(*args, **kwargs)
-    #     mermaid_edge = Mermaid__Edge(**kwargs)
-    #     self.edges.append(mermaid_edge)
-    #     return mermaid_edge
-    #
-    def add_node(self, **kwargs):
-        new_node    = MGraph__Node(**kwargs)
-        mermaid_node = Mermaid__Node().merge_with(new_node)
-        self.nodes.append(mermaid_node)
-        return mermaid_node
-
-    #
-    #
-    # def add_line(self, line):
-    #     self.mermaid_code.append(line)
-    #     return line
-    #
-    # def code(self):
-    #     self.code_create()
-    #     return '\n'.join(self.mermaid_code)
-    #
-    # def code_create(self):
-    #     with self as _:
-    #         _.reset_code()
-    #         _.add_line('graph LR')
-    #         for node in _.nodes:
-    #             _.add_line(node.code())
-    #         _.add_line('')
-    #         for edge in _.edges:
-    #             _.add_line(edge.code())
-    #     return self
-    #
-    # def code_markdown(self):
-    #     self.code_create()
-    #     markdown = ['# Mermaid Graph',
-    #                 "```mermaid" ,
-    #                 *self.mermaid_code,
-    #                 "```"]
-    #
-    #     return '\n'.join(markdown)
-    #
-    # def convert_edges(self):
-    #     new_edges = []
-    #     for edge in self.edges:
-    #         new_edges.append(Mermaid__Edge().cast(edge))
-    #     self.edges = new_edges
-    #     return self
-    #
-    # def convert_nodes(self):
-    #     new_nodes = []
-    #     for node in self.nodes:
-    #         mermaid_node = Mermaid__Node().cast(node)
-    #         new_nodes.append(mermaid_node)
-    #     self.nodes = new_nodes
-    #     return self
-    #
-    # def reset_code(self):
-    #     self.mermaid_code = []
-    #     return self
-    #
-    # def save(self, target_file=None):
-    #     file_path = target_file or '/tmp/mermaid.md'
-    #
-    #     with open(file_path, 'w') as file:
-    #         file.write(self.code_markdown())
-    #     return file_path
-    #
-    # def print_code(self):
-    #     print(self.code())

osbot_utils/graphs/mermaid/Mermaid__Node.py

@@ -1,69 +0,0 @@
-from enum import Enum
-
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.graphs.mermaid.configs.Mermaid__Node__Config import Mermaid__Node__Config
-from osbot_utils.graphs.mermaid.models.Mermaid__Node__Shape import Mermaid__Node__Shape
-from osbot_utils.graphs.mgraph.MGraph__Node import MGraph__Node
-from osbot_utils.utils.Str import safe_str
-
-LINE_PADDING = '    '
-
-class Mermaid__Node(MGraph__Node):
-
-    config : Mermaid__Node__Config
-
-    def render_node(self, include_padding=True):
-        left_char, right_char = self.config.node_shape.value
-
-        if self.config.markdown:
-            label = f'`{self.label}`'
-        else:
-            label = self.label
-
-
-        if self.config.show_label is False:
-            node_code = f'{self.key}'
-        else:
-            if self.config.wrap_with_quotes is False:
-                node_code = f'{self.key}{left_char}{label}{right_char}'
-            else:
-                node_code = f'{self.key}{left_char}"{label}"{right_char}'
-
-        if include_padding:
-            node_code = f'{LINE_PADDING}{node_code}'
-        return node_code
-
-    def markdown(self, value=True):
-        self.config.markdown = value
-        return self
-
-    def shape(self, shape=None):
-        self.config.node_shape = Mermaid__Node__Shape.get_shape(shape)
-        return self
-
-
-    def shape_asymmetric        (self): self.config.node_shape = Mermaid__Node__Shape.asymmetric        ; return self
-    def shape_circle            (self): self.config.node_shape = Mermaid__Node__Shape.circle            ; return self
-    def shape_cylindrical       (self): self.config.node_shape = Mermaid__Node__Shape.cylindrical       ; return self
-    def shape_default           (self): self.config.node_shape = Mermaid__Node__Shape.default           ; return self
-    def shape_double_circle     (self): self.config.node_shape = Mermaid__Node__Shape.double_circle     ; return self
-    def shape_hexagon           (self): self.config.node_shape = Mermaid__Node__Shape.hexagon           ; return self
-    def shape_parallelogram     (self): self.config.node_shape = Mermaid__Node__Shape.parallelogram     ; return self
-    def shape_parallelogram_alt (self): self.config.node_shape = Mermaid__Node__Shape.parallelogram_alt ; return self
-    def shape_stadium           (self): self.config.node_shape = Mermaid__Node__Shape.stadium           ; return self
-    def shape_subroutine        (self): self.config.node_shape = Mermaid__Node__Shape.subroutine        ; return self
-    def shape_rectangle         (self): self.config.node_shape = Mermaid__Node__Shape.rectangle         ; return self
-    def shape_rhombus           (self): self.config.node_shape = Mermaid__Node__Shape.rhombus           ; return self
-    def shape_round_edges       (self): self.config.node_shape = Mermaid__Node__Shape.round_edges       ; return self
-    def shape_trapezoid         (self): self.config.node_shape = Mermaid__Node__Shape.trapezoid         ; return self
-    def shape_trapezoid_alt     (self): self.config.node_shape = Mermaid__Node__Shape.trapezoid_alt     ; return self
-
-
-
-    def wrap_with_quotes(self, value=True):
-        self.config.wrap_with_quotes = value
-        return self
-
-    def show_label(self, value=True):
-        self.config.show_label = value
-        return self

osbot_utils/graphs/mermaid/Mermaid__Renderer.py

@@ -1,56 +0,0 @@
-from typing import List
-
-from osbot_utils.base_classes.Kwargs_To_Self                        import Kwargs_To_Self
-from osbot_utils.graphs.mermaid.configs.Mermaid__Render__Config import Mermaid__Render__Config
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram_Direction   import Diagram__Direction
-from osbot_utils.graphs.mermaid.models.Mermaid__Diagram__Type       import Diagram__Type
-
-
-class Mermaid__Renderer(Kwargs_To_Self):
-    config            : Mermaid__Render__Config
-    mermaid_code      : List
-    diagram_direction : Diagram__Direction = Diagram__Direction.LR
-    diagram_type      : Diagram__Type      = Diagram__Type.graph
-
-
-    def add_line(self, line):
-        self.mermaid_code.append(line)
-        return line
-
-    def code(self, nodes, edges):
-        self.code_create(nodes, edges)
-        return '\n'.join(self.mermaid_code)
-
-    def code_create(self, nodes, edges, recreate=False):
-        with self as _:
-            if recreate:                            # if recreate is True, reset the code
-                _.reset_code()
-            elif self.mermaid_code:                 # if the code has already been created, don't create it
-                return self                         #   todo: find a better way to do this, namely around the concept of auto detecting (on change) when the recreation needs to be done (vs being able to use the previously calculated data)
-            for directive in _.config.directives:
-                _.add_line(f'%%{{{directive}}}%%')
-            _.add_line(self.graph_header())
-            if self.config.add_nodes:
-                for node in nodes:
-                    node_code = node.render_node()
-                    _.add_line(node_code)
-            if self.config.line_before_edges:
-                _.add_line('')
-            for edge in edges:
-                edge_code = edge.render_edge()
-                _.add_line(edge_code)
-        return self
-
-
-
-    def graph_header(self):
-        # if type(self.diagram_type.value) is str:
-        #     value = self.diagram_type.value
-        # else:
-        #     value = self.diagram_type.name
-        value = self.diagram_type.name
-        return f'{value} {self.diagram_direction.name}'
-
-    def reset_code(self):
-        self.mermaid_code = []
-        return self

osbot_utils/graphs/mermaid/configs/Mermaid__Edge__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-
-class Mermaid__Edge__Config(Kwargs_To_Self):
-    edge_mode        : str
-    output_node_from : bool = False
-    output_node_to   : bool = False

osbot_utils/graphs/mermaid/configs/Mermaid__Node__Config.py

@@ -1,9 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self                       import Kwargs_To_Self
-from osbot_utils.graphs.mermaid.models.Mermaid__Node__Shape import Mermaid__Node__Shape
-
-
-class Mermaid__Node__Config(Kwargs_To_Self):
-    markdown         : bool
-    node_shape       : Mermaid__Node__Shape = Mermaid__Node__Shape.default
-    show_label       : bool = True
-    wrap_with_quotes : bool = True               # todo: add support for only using quotes when needed

osbot_utils/graphs/mermaid/configs/Mermaid__Render__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-
-class Mermaid__Render__Config(Kwargs_To_Self):
-    add_nodes         : bool = True
-    directives        : list
-    line_before_edges : bool = True

osbot_utils/graphs/mermaid/examples/Mermaid_Examples__FlowChart.py

@@ -1,98 +0,0 @@
-# from https://mermaid.js.org/syntax/flowchart.html
-class Mermain_Examples__FlowChart:
-    example_1__a_node_default = """
-flowchart LR
-    id
-    """
-    example_2__a_node_with_text = """
-flowchart LR
-    id1[This is the text in the box]    
-    """
-
-    example_3__a_node_with_unicode_text = """
-flowchart LR
-    id["This ❤ Unicode"]    
-    """
-    example_4__a_node_with_markdown_formatting = """
-%%{init: {"flowchart": {"htmlLabels": false}} }%%
-flowchart LR
-    markdown["`This **is** _Markdown_`"]
-    newLines["`Line1
-    Line 2
-    Line 3`"]
-    markdown --> newLines 
-    """
-
-    example_5__direction__from_top_to_bottom  = """
-flowchart TD
-    Start --> Stop    
-    """
-
-    example_6__direction__from_left_to_right  = """
-flowchart LR
-    Start --> Stop    
-    """
-    example_7__node_shapes_a_node_with_round_edges  = """
-flowchart LR
-    id1(This is the text in the box)
-    """
-
-    example_8__node_shapes_a_stadium_shaped_node  = """
-flowchart LR
-    id1([This is the text in the box])
-    """
-
-    example_9__node_shapes_a_node_in_a_subroutine ="""
-flowchart LR
-    id1[[This is the text in the box]]
-    """
-
-    example_10__node_shapes_a_node_in_a_cylindrical_shape ="""
-flowchart LR
-    id1[(Database)]
-    """
-
-    example_11__node_shapes_a_node_in_the_form_of_a_circle = """
-flowchart LR
-    id1((This is the text in the circle))
-    """
-
-    example_12__node_shapes_a_node_in_an_asymmetric_shape = """
-flowchart LR
-    id1>This is the text in the box]
-    """
-
-    example_13__node_shapes_a_node_rhombus = """
-flowchart LR
-    id1{This is the text in the box}
-    """
-
-    example_14__node_shapes_a_hexagon_node = """
-flowchart LR
-    id1{{This is the text in the box}}
-    """
-
-    example_15__node_shapes_parallelogram = """
-flowchart TD
-    id1[/This is the text in the box/]
-    """
-
-    example_16__node_shapes_parallelogram_alt = r"""
-flowchart TD
-    id1[\This is the text in the box\]
-    """
-
-    example_17__node_shapes_trapezoid = r"""
-flowchart TD
-    A[/Christmas\]
-    """
-
-    example_18__node_shapes_trapezoid_alt = r"""
-flowchart TD
-    B[\Go shopping/]
-    """
-
-    example_19__node_shapes_double_circle = """
-flowchart TD
-    id1(((This is the text in the circle)))
-    """

osbot_utils/graphs/mermaid/models/Mermaid__Diagram_Direction.py

@@ -1,9 +0,0 @@
-from enum import Enum, auto
-
-
-class Diagram__Direction(Enum):
-    BT = auto()
-    LR = auto()
-    TB = auto()
-    TD = auto()
-    RL = auto()

osbot_utils/graphs/mermaid/models/Mermaid__Diagram__Type.py

@@ -1,16 +0,0 @@
-from enum import Enum
-
-class Diagram__Type(Enum):
-    class_diagram                = "class_diagram"
-    entity_relationship_diagram  = "entity_relationship_diagram"
-    flowchart                    = "flowchart"
-    gantt                        = "gantt"
-    git_graph                    = "git_graph"
-    graph                        = "graph"
-    mermaid_map                  = "mermaid_map"
-    mindmap                      = "mindmap"
-    pie_chart                    = "pie_chart"
-    requirement_diagram          = "requirement_diagram"
-    sequence_diagram             = "sequenceDiagram"             # these are different from the others
-    state_diagram                = "stateDiagram-v2"             # these are different from the others
-    user_journey                 = "user_journey"

osbot_utils/graphs/mermaid/models/Mermaid__Node__Shape.py

@@ -1,30 +0,0 @@
-from __future__ import annotations
-from enum import Enum
-
-
-class Mermaid__Node__Shape(Enum):
-    asymmetric          = ('>'  ,  ']'  )        # Asymmetric
-    circle              = ('((' ,  '))' )        # Circle, used for endpoints or start/end points
-    cylindrical         = ('[(' ,  ')]' )        # Cylindrical
-    default             = ('['  ,  ']'  )        # Rectangle
-    double_circle       = ('(((',  ')))')        # Double Circle
-    round_edges         = ('('  ,  ')'  )        # Stadium shape, used for processes or operations
-    rhombus             = ('{'  ,  '}'  )        # Rhombus, often synonymous with diamond in diagramming contexts
-    hexagon             = ('{{' ,  '}}' )        # Hexagon, used for preparation or complex processing
-    parallelogram       = ('[/' ,  '/]' )        # Parallelogram, used for input/output
-    parallelogram_alt   = ('[\\',  '\\]')        # Alternative parallelogram, also used for input/output
-    rectangle           = ('['  ,  ']'  )        # Rectangle, used for process
-    stadium             = ('([' ,  '])' )        # Stadium
-    subroutine          = ('[[',   ']]' )        # Subroutine
-    trapezoid           = ('[/' , r'\]' )        # Trapezoid, used for manual operations             # todo: figure out why this line is throwing the compile error of: SyntaxWarning: invalid escape sequence '\]'
-    trapezoid_alt       = ('[\\',  '/]' )        # Inverted trapezoid, also used for manual operations
-
-    @staticmethod
-    def get_shape(value = None) -> Mermaid__Node__Shape:
-        if isinstance(value, Mermaid__Node__Shape):
-            return value
-        if type(value) is str:
-            for shape in Mermaid__Node__Shape:
-                if value == shape.name:
-                    return shape
-        return Mermaid__Node__Shape.default

osbot_utils/graphs/mgraph/MGraph.py

@@ -1,55 +0,0 @@
-from typing import List
-
-from osbot_utils.utils.Misc import random_text, lower
-from osbot_utils.base_classes.Kwargs_To_Self   import Kwargs_To_Self
-from osbot_utils.graphs.mgraph.MGraph__Config  import MGraph__Config
-from osbot_utils.graphs.mgraph.MGraph__Edge    import MGraph__Edge
-from osbot_utils.graphs.mgraph.MGraph__Node    import MGraph__Node
-
-
-# todo add support for storing the data in sqlite so that we get the ability to search nodes and edges
-class MGraph(Kwargs_To_Self):
-    config : MGraph__Config
-    edges  : List[MGraph__Edge]
-    key    : str
-    nodes  : List[MGraph__Node]
-
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        if not self.key:
-            self.key = random_text("mgraph", lowercase=True)                 # make sure there is always a key
-
-    def add_edge(self, from_node, to_node, label=None,attributes=None):
-        if self.config.allow_circle_edges is False:
-            if from_node == to_node:
-                return None
-        if self.config.allow_duplicate_edges is False:                          # todo: figure out if there is a more efficient way to do this
-            for edge in self.edges:
-                if edge.from_node == from_node and edge.to_node == to_node:
-                    return None
-        new_edge = MGraph__Edge(from_node=from_node, to_node=to_node, label=label, attributes=attributes)
-        self.edges.append(new_edge)
-        return new_edge
-
-    def add_node(self, key=None, label=None, attributes=None):
-        new_node = MGraph__Node(key=key, label=label, attributes=attributes)
-        self.nodes.append(new_node)
-        return new_node
-
-    def data(self):
-        from osbot_utils.graphs.mgraph.MGraph__Data import MGraph__Data
-        return MGraph__Data(mgraph=self)
-
-    # def save(self, format='pickle'):
-    #     if format == 'pickle':
-    #         return pickle_save_to_file(self)
-
-    #todo: add save that return saved object
-    # def save(self):
-    #     from osbot_utils.graphs.mgraph.MGraph__Serializer import MGraph__Serializer        # due to circular dependency
-    #     return MGraph__Serializer(mgraph=self).save()
-
-    def print(self):
-        print()
-        return self.data().print()

osbot_utils/graphs/mgraph/MGraph__Config.py

@@ -1,7 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-class MGraph__Config(Kwargs_To_Self):
-
-    allow_circle_edges    : bool
-    allow_duplicate_edges : bool
-    graph_title           : str

osbot_utils/graphs/mgraph/MGraph__Data.py

@@ -1,139 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.graphs.mgraph.MGraph        import MGraph
-from osbot_utils.helpers.Print_Table         import Print_Table
-
-
-class MGraph__Data(Kwargs_To_Self):
-
-    mgraph : MGraph
-
-    def graph_data(self):
-        nodes_data = self.nodes_data()
-        edges_data = self.edges_data()
-        graph_data = {'nodes': nodes_data, 'edges': edges_data}
-        return graph_data
-
-    def edges(self):
-        return self.mgraph.edges
-
-    def edges_data(self):
-        edges_data = []
-        for edge in self.edges():
-            edges_data.append(edge.data())
-        return edges_data
-
-    def nodes(self):
-        return self.mgraph.nodes
-
-    def nodes_data(self):
-        nodes_data = []
-        for node in self.nodes():
-            nodes_data.append(node.data())
-        return nodes_data
-
-
-    def nodes__by_key(self):
-        by_key = {}
-        for node in self.nodes():
-            by_key[node.key] = node
-        return by_key
-
-    def nodes__keys(self):
-        return [node.key for node in self.nodes()]
-
-    def nodes_edges(self):
-        nodes__edges = {}
-        for node in self.nodes():
-            nodes__edges[node.key] = []
-        for edge in self.edges():
-            from_key = edge.from_node.key
-            if from_key in nodes__edges:                                        # todo: add a better way to handle this, which is a weird situation, look also at a better way to do this assigment
-                nodes__edges[from_key].append(edge.to_node.key)
-        for node_key, edges_keys in nodes__edges.items():
-            nodes__edges[node_key] = sorted(edges_keys)
-        return nodes__edges
-
-    # def map_paths(self, key, paths, all_paths, nodes_edges):
-    #     key_edges = nodes_edges[key]
-    #     new_paths = []
-    #
-    #     for edge_key in key_edges:
-    #         for path in paths:
-    #             if edge_key in path:
-    #                 if path not in all_paths:
-    #                     all_paths.append(path)
-    #             else:
-    #                 new_path = [*path, edge_key]
-    #                 new_paths.append(new_path)
-    #                 self.map_paths(edge_key, new_paths, all_paths, nodes_edges)
-    #                 if new_path not in all_paths:
-    #                     all_paths.append(new_path)
-        # if new_paths:
-        #     return new_paths
-
-            # for edge_key in key_edges:
-            #     self.map_paths(edge_key, paths, nodes_edges)
-        return paths
-
-    # def nodes__find_all_paths(self):
-    #     key         = self.nodes__keys()[0]
-    #     nodes_edges = self.nodes_edges()
-    #     #for key in self.nodes__keys():
-    #     all_paths = []
-    #     paths = [[key]]
-    #     self.map_paths(key, paths,all_paths,  nodes_edges)
-    #     pprint(all_paths)
-
-    def print(self):
-        with Print_Table() as _:
-            _.set_title(self.mgraph.config.graph_title)
-            for node_key, edges_keys in self.nodes_edges().items():
-                row = {'key': node_key,  'edges': edges_keys}
-                _.add_data(row)
-            _.set_order('key', 'edges')
-            _.print()
-
-    def print_adjacency_matrix(self):
-        adjacency_matrix = self.nodes_edges__adjacency_matrix()
-        node_keys        = sorted(self.nodes__keys())
-        with Print_Table() as _:
-            for row in adjacency_matrix:
-                _.add_data(row)
-            _.set_order('key', *node_keys)
-            _.print()
-
-
-    def node_edges__to_from(self):
-        # Initialize a dictionary to hold the edges to and from for each node
-        node_connections = { node_key: {'edges_to': [], 'edges_from': []} for node_key in self.nodes_edges().keys() }
-
-
-        for node_key, edges_keys in self.nodes_edges().items():                 # Fill 'edges_to' and 'edges_from' for each node
-            node_connections[node_key]['edges_from'].extend(edges_keys)         # 'edges_from' are the outgoing edges from 'node_key'
-
-            for edge_key in edges_keys:                                         # 'edges_to' are the incoming edges to the nodes in 'edges_keys'
-                if edge_key in node_connections:                                # Check if the edge_key represents a valid node
-                    node_connections[edge_key]['edges_to'].append(node_key)
-
-        return node_connections
-
-    def nodes_edges__adjacency_matrix(self):
-        nodes_edges = self.nodes_edges()                                                    # Retrieve the nodes and their edges
-        node_keys = sorted(nodes_edges.keys())                                              # Get a sorted list of unique node keys
-        node_indices = {node_key: index for index, node_key in enumerate(node_keys)}        # Create a mapping of node keys to their respective indices
-        size = len(node_keys)                                                               # Initialize a square matrix with empty strings
-        matrix = [['' for _ in range(size)] for _ in range(size)]
-
-        for node_key, edges_keys in nodes_edges.items():                                    # Fill the matrix with 'X' if there is an edge between two nodes
-            for edge_key in edges_keys:                                                     # Find the matrix positions based on node indices
-                row_index = node_indices[node_key]
-                col_index = node_indices[edge_key]
-                matrix[row_index][col_index] = 'X'
-
-        table_data = []
-        for i, row in enumerate(matrix):
-            row_data = {'key': node_keys[i]}
-            row_data.update({node_keys[j]: row[j] for j in range(size)})
-            table_data.append(row_data)
-        return table_data
-

osbot_utils/graphs/mgraph/MGraph__Edge.py

@@ -1,24 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self  import Kwargs_To_Self
-from osbot_utils.graphs.mgraph.MGraph__Node   import MGraph__Node
-
-class MGraph__Edge(Kwargs_To_Self):
-    attributes : dict
-    from_node  : MGraph__Node
-    label      : str
-    to_node    : MGraph__Node
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-    # def __repr__(self):
-    #     return self.__str__()
-
-    def __str__(self):
-        return f'[Graph Edge] from "{self.from_node.key}" to "{self.to_node.key}" '
-
-    # def cast(self, source):
-    #     self.__dict__ = source.__dict__
-    #     return self
-
-    def data(self):
-        return self.__locals__()             # todo: see if there is a better way to do this (specialy as the edge objects gets more features and attributes)

osbot_utils/graphs/mgraph/MGraph__Node.py

@@ -1,32 +0,0 @@
-from osbot_utils.utils.Misc                     import random_id
-from osbot_utils.base_classes.Kwargs_To_Self    import Kwargs_To_Self
-
-
-class MGraph__Node(Kwargs_To_Self):
-    attributes : dict
-    key        : str
-    label      : str
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        if not self.key:
-            self.key = random_id()
-        if not self.label:
-            self.label = self.key
-
-    def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
-        return f'[Graph Node] {self.key}'
-
-    def data(self):
-        return self.__locals__()             # todo: see if there is a better way to do this (specialy as the node objects gets more features and attributes)
-
-    def set_key(self, value: str):
-        self.key = value
-        return self
-
-    def set_label(self, value: str):
-        self.label = value
-        return self

osbot_utils/graphs/mgraph/MGraph__Random_Graphs.py

@@ -1,27 +0,0 @@
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-
-from osbot_utils.graphs.mgraph.MGraph import MGraph
-from osbot_utils.graphs.mgraph.MGraph__Config import MGraph__Config
-from osbot_utils.utils.Misc import random_int
-
-
-class MGraph__Random_Graphs(Kwargs_To_Self):
-    config     : MGraph__Config
-    graph_key : str
-
-    def new_graph(self):
-        return MGraph(config=self.config, key=self.graph_key)
-
-    def with_x_nodes_and_y_edges(self, x=10, y=20):
-        MGraph = self.new_graph()
-        if x >0  and y > 0 :
-            for i in range(x):
-                MGraph.add_node(label=f'node_{i}')
-            for i in range(y):
-                from_node_id = random_int(max=x) - 1
-                to_node_id   = random_int(max=x) - 1
-                from_node    = MGraph.nodes[from_node_id]
-                to_node      = MGraph.nodes[to_node_id  ]
-                MGraph.add_edge(from_node=from_node, to_node=to_node)
-
-        return MGraph

osbot_utils/graphs/mgraph/MGraph__Serializer.py

@@ -1,42 +0,0 @@
-from enum                                    import Enum, auto
-from osbot_utils.utils.Str                   import safe_str
-from osbot_utils.helpers.Local_Cache         import Local_Cache
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.graphs.mgraph.MGraph        import MGraph
-
-
-class Serialization_Mode(Enum):
-    JSON    = auto()
-    PICKLE  = auto()
-
-class MGraph__Serializer(Kwargs_To_Self):
-
-    caches_name : str                = 'mgraph_tests'
-    mode        : Serialization_Mode = Serialization_Mode.PICKLE
-
-    local_cache : Local_Cache                                           # todo, refactor this into an MGraph__Storage__Disk class
-    key         : str
-    mgraph      : MGraph
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self.key         = safe_str(f'serialiser_for__{self.mgraph.key}')
-
-        self.local_cache = Local_Cache(cache_name=self.key, caches_name=self.caches_name)
-
-
-    def save(self):
-        if self.mode == Serialization_Mode.JSON:
-            return self.save_to_json()
-        if self.mode == Serialization_Mode.PICKLE:
-            return self.save_to_pickle()
-
-    def save_to_json(self):
-        graph_data = self.mgraph.data().graph_data()
-        #pprint(graph_data)
-        self.local_cache.set('graph_data', graph_data)
-        return True
-
-    def save_to_pickle(self):
-        #obj_info(self.local_cache)
-        return '...pickle save - to be implemented...'

osbot_utils/graphs/mgraph/MGraphs.py

@@ -1,12 +0,0 @@
-from osbot_utils.graphs.mgraph.MGraph__Random_Graphs import MGraph__Random_Graphs
-
-class MGraphs:
-
-    def new__random(self, config=None, graph_key=None, x_nodes=10, y_edges=20):
-        return MGraph__Random_Graphs(config=config, graph_key=graph_key).with_x_nodes_and_y_edges(x=x_nodes, y=y_edges)
-
-    # todo : implement based on multiple save a load methods
-    # def load(self, file_path):
-    #     if file_exists(file_path):
-    #         if file_extension(file_path):
-    #             return pickle_load_from_file(file_path)

osbot_utils/helpers/trace/Trace_Call__Graph.py

@@ -1,26 +0,0 @@
-from osbot_utils.graphs.mermaid.Mermaid__Graph import Mermaid__Graph
-from osbot_utils.utils.Dev import pprint
-
-from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
-from osbot_utils.helpers.trace.Trace_Call import Trace_Call
-
-# todo: reimplement this class when Mermaid__Graph has been updated to new version
-class Trace_Call__Graph(Trace_Call):
-
-    def create(self):
-        mermaid_graph = Mermaid__Graph()
-        self.trace_call_handler.stack.root_node.func_name = 'trace_root'
-        for trace in self.trace_call_handler.traces():
-            node_key   = trace.func_name
-            class_name = trace.module.split('.')[-1]
-            node_label = f'`**{trace.func_name}**\n*{class_name}*`'
-            mermaid_graph.add_node(key=node_key, label=node_label)
-
-        nodes__by_key = mermaid_graph.data().nodes__by_key()
-
-        for trace in self.trace_call_handler.traces():
-            from_node = nodes__by_key[trace.func_name]
-            for child in trace.children:
-                to_node = nodes__by_key[child.func_name]
-                mermaid_graph.add_edge(from_node=from_node, to_node=to_node)
-        return mermaid_graph