osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/graphs/mgraph/MGraph__Edge.py

@@ -0,0 +1,27 @@
+from osbot_utils.base_classes.Kwargs_To_Self        import Kwargs_To_Self
+from osbot_utils.graphs.mermaid.Mermaid__Node import LINE_PADDING, Mermaid__Node
+from osbot_utils.graphs.mgraph.MGraph__Node   import MGraph__Node
+from osbot_utils.utils.Str import safe_str
+
+
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,17 @@
+import random
+
+from osbot_utils.utils.Files import file_exists, file_extension, pickle_load_from_file
+
+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/CPrint.py

@@ -0,0 +1,98 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+
+# note these attributes will be replaced by methods by CPrint. This is done like this in order to:
+#     - Have code complete on CPrint
+#     - not have the write the code for each of the methods
+#     - have a good and logical place to capture the ID of the color
+
+class Colors:
+    black           = "30"
+    blue            = "34"
+    cyan            = "36"
+    grey            = "38;5;15"
+    green           = "32"
+    none            = "0"
+    magenta         = "35"
+    red             = "31"
+    white           = "38;5;15"
+    yellow          = "33"
+    bright_black    = "90"
+    bright_red      = "91"
+    bright_green    = "92"
+    bright_yellow   = "93"
+    bright_blue     = "94"
+    bright_magenta  = "95"
+    bright_cyan     = "96"
+    bright_white    = "97"
+    dark_red        = "38;5;124"            # see https://github.com/fidian/ansi for a full list
+
+
+class CPrint(Colors, Kwargs_To_Self):
+    apply_colors   : bool = True
+    auto_new_line  : bool = True
+    auto_print     : bool = True
+    clear_on_print : bool = True
+    current_line   : str
+    lines          : list
+
+    def __getattribute__(self, name):                                                       # this will replace the attributes defined in colors with methods that will call add_to_current_line with the params provided
+        if name != '__getattribute__' and hasattr(Colors, name):                                                           # if name is one of the colors defined in Colors
+            def method(*args, **kwargs):                                                    # create a method to replace the attribute
+                return self.add_with_color(name, *args, **kwargs)                     # pass the data to add_with_color
+            return method
+        return super().__getattribute__(name)                                               # if the attribute name is not one of the attributes defined in colors, restore the normal behaviour of __getattribute__
+
+    def add_with_color(self, color_name, *args, **kwargs):
+        color_code = getattr(Colors, color_name)                                            # capture the color from the Colors class
+        self.add_to_current_line(color_code, *args, **kwargs)                         # add the color code to the current line
+        return self
+
+    def add_to_current_line(self, color_code, *args, **kwargs):
+        args             = [str(arg) for arg in args]                                           # Convert all non-string arguments to strings
+        text             = "".join(args)                                                        # Concatenate all arguments without a space (to have beter support for multi-prints per line)
+        if self.apply_colors:
+            color_start      = f"\033[{color_code}m"                                            # ANSI color code start and end
+            color_end        = "\033[0m"
+            kwargs['end']    = ''                                                               # remove the default print end (which is \n)
+
+            text_with_colors = f"{color_start}{text}{color_end}"
+            self.current_line += text_with_colors
+        else:
+            self.current_line += text
+        self.apply_config_options()
+        return self
+
+    def apply_config_options(self):
+        if self.auto_new_line:
+            self.flush()
+        if self.auto_print:
+            self.print()
+
+    def flush(self):
+        if self.current_line:
+            self.lines.append(self.current_line)
+        self.current_line = ''
+        return self
+
+    def lines_str(self):
+        lines_str = ''
+        for line in self.lines:
+            lines_str += line + '\n'
+        return lines_str
+
+    def new_line(self):
+        self.flush()
+        self.lines.append('')
+        self.apply_config_options()
+        return self
+
+    def print(self):
+        self.flush()
+        for line in self.lines:
+            print(line)
+        if self.clear_on_print:
+            self.lines = []
+        return self
+
+

osbot_utils/helpers/Dict_To_Attr.py

@@ -0,0 +1,7 @@
+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():
+            setattr(self, key, value)

osbot_utils/helpers/Local_Cache.py

@@ -0,0 +1,111 @@
+from osbot_utils.utils.Misc import list_set
+from osbot_utils.utils.Dev import pprint
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.utils.Files    import current_temp_folder, path_combine, create_folder, safe_file_name, file_exists, file_delete
+from osbot_utils.utils.Json import json_save_file, json_load_file
+
+
+class Local_Cache:
+
+    DEFAULT_CACHES_NAME = "_cache_data"
+
+    def __init__(self, cache_name, caches_name=None):
+        self.caches_name = caches_name or Local_Cache.DEFAULT_CACHES_NAME
+        self.cache_name = safe_file_name(cache_name)
+        self._data      = None
+
+    def add(self, key, value):
+        self.data()[key] = value
+        self.save()
+        return self
+
+    def add_data(self, items):
+        data = self.data()
+        for key, value in items.items():
+            data[key] = value
+        self.save()
+        return self
+
+    def cache_delete(self):
+        return file_delete(self.path_cache_file())
+
+    def cache_exists(self):
+        return file_exists(self.path_cache_file())
+
+    def create(self):
+        if not self.cache_exists():
+            self.save()
+        return self
+
+    def has_key(self, key):
+        return key in self.keys()
+
+    def save(self):
+        data = self.data() or {}
+        json_save_file(data, self.path_cache_file())
+        return self
+
+    def data(self):
+        if self._data is None:
+            self._data = json_load_file(self.path_cache_file())
+        return self._data
+
+    def get(self, key, default_value=None):
+        return self.data().get(key, default_value)
+
+    def info(self):
+        return { 'caches_name'    : self.caches_name       ,
+                 'cache_name'     : self.cache_name        ,
+                 'path_cache_file': self.path_cache_file() ,
+                 'data_keys'      : list_set(self.data())  }
+
+    def name(self):
+        return self.cache_name
+
+    def print_info(self):
+        pprint(self.info())
+
+    def keys(self):
+        return self.data().keys()
+
+    @cache_on_self
+    def path_root_folder(self):
+        path_root_folder = path_combine(current_temp_folder(), self.caches_name)
+        create_folder(path_root_folder)                          # create if it doesn't exist
+        return path_root_folder
+
+    @cache_on_self
+    def path_cache_file(self):
+        return path_combine(self.path_root_folder(), f"{self.cache_name}.json")
+
+    def set(self, key, value):
+        return self.add(key, value)
+
+    def set_data(self,items):
+        return self.add_data(items)
+
+    def set_all_data(self, data):
+        self._data = data
+        self.save()
+        return self
+
+    def setup(self):
+        self.create()
+        return self
+
+    def remove(self, key):
+        if key in self.keys():
+            del self.data()[key]
+            self.save()
+            return True
+        return False
+
+    def values(self):
+        return self.data().values()
+
+    def __repr__(self):
+        return f"Local_Cache: {self.cache_name}"
+
+    # extra methods alias
+
+    #add = set

osbot_utils/helpers/Local_Caches.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from typing import Dict, List
+from osbot_utils.helpers.Local_Cache import Local_Cache
+from osbot_utils.utils.Files         import current_temp_folder, path_combine,folder_exists, folder_delete
+from osbot_utils.utils.Misc          import random_text
+
+
+class Local_Caches:
+
+    DEFAULT_NAME = "_cache_data"                # todo: see if this is still being used
+
+    def __init__(self, caches_name=None):
+        self.caches_name = caches_name or random_text("local_caches")
+
+    def caches(self) -> Dict[str, Local_Cache]:
+        cache_names = self.existing_cache_names()
+        caches = {}
+        for cache_name in cache_names:
+            caches[cache_name] = self.cache(cache_name)
+        return caches
+
+    def delete(self) -> bool:
+        for cache_name, cache in self.caches().items():
+            cache.cache_delete()
+        return folder_delete(self.path_local_caches())
+
+    #
+    #@cache_on_self
+    def cache(self, cache_name) -> Local_Cache:
+        local_cache = Local_Cache(cache_name=cache_name, caches_name=self.caches_name)
+        local_cache.setup()
+        return local_cache
+
+    def exists(self) -> bool:
+        return folder_exists(self.path_local_caches())
+
+    def empty(self) -> bool:
+        return len(self.caches()) == 0
+
+    def existing_cache_names(self) -> List[str]:
+        cache_names = []
+        for f in self.path_local_caches().iterdir():
+            if f.is_file():
+                cache_name = f.name.replace('.json', '')
+                cache_names.append(cache_name)
+        return cache_names
+
+    #@cache_on_self
+    def path_local_caches(self) -> Path:
+        return Path(path_combine(current_temp_folder(), self.caches_name))
+
+    def setup(self):
+        self.path_local_caches().mkdir(parents=True, exist_ok=True)
+        return self