minor-utils 0.1.1__tar.gz → 0.2.0.dev1__tar.gz

minor_utils-0.2.0.dev1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: minor_utils
+Version: 0.2.0.dev1
+Summary: Utils compilation for easier work
+Author-email: CyberAxolotl <minor.gleb@outlook.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

{minor_utils-0.1.1 → minor_utils-0.2.0.dev1}/minor_utils/__init__.py

@@ -4,10 +4,12 @@ __author__ = "Gleb Minor"
 __license__ = "MIT"
 
 from .formatter import Formatter
+from .func_manager import Manager
 from .errors import MissingStringError, InvalidArgumentError, FormatAlreadyExistsError, AliasAlreadyExistsError, DefaultFormatModificationError
 
 __all__ = [
     "Formatter",
+    "Manager",
     "MissingStringError",
     "InvalidArgumentError",
     "FormatAlreadyExistsError",

{minor_utils-0.1.1 → minor_utils-0.2.0.dev1}/minor_utils/formatter.py

@@ -5,7 +5,6 @@ from .errors import DefaultFormatModificationError, MissingStringError, InvalidA
 
 class Formatter:
 #--------(Format functions)--------
-
     @staticmethod
     def cap(s):
         """Capitalize the first character of the string and make the rest lowercase."""
@@ -89,7 +88,6 @@ class Formatter:
     enabled_formats = list(formats.keys()) + list(format_aliases.keys())
 
 #--------(Formatter function)--------
-
     @classmethod
     def get_callable(cls, string_format):
         if string_format in cls.format_aliases:
@@ -109,7 +107,9 @@ class Formatter:
             )
         
         return func
+#--------
 
+#--------
     @classmethod
     def formatting(cls,
         string: str,
@@ -144,6 +144,7 @@ class Formatter:
             output = output[::-1]
 
         return output
+#--------
     
 #--------(Pipeline API)--------
     @classmethod
@@ -159,12 +160,13 @@ class Formatter:
         for fmt in formats:
             string = cls.formatting(string, fmt, inverse=inversed, reverse=reversed)
         return string
+#--------
 
 #--------(Registry API)--------
     @classmethod
     def add_format(cls, func=None, name=None, *aliases):
         def decorator(f):
-            cls.validate_format_function(f)
+            cls.__validate_format_function(f)
 
             format_name = (
                 name
@@ -205,10 +207,12 @@ class Formatter:
             return decorator
         
         return decorator(func)
+#--------
     
+#--------
     @classmethod
     def replace_format(cls, name, func):
-        cls.validate_format_function(func)
+        cls.__validate_format_function(func)
 
         if not cls.is_existing_format(name):
             raise InvalidArgumentError(
@@ -221,7 +225,9 @@ class Formatter:
             )
 
         cls.formats[name] = func
+#--------
 
+#--------
     @classmethod
     def remove_format(cls, name):
         if not cls.is_existing_format(name):
@@ -236,13 +242,17 @@ class Formatter:
 
         cls.formats.pop(name, None)
         cls.custom_formats.pop(name, None)
+#--------
 
+#--------
     @classmethod
     def reset_formats(cls):
         cls.clear_aliases()
         cls.clear_custom_formats()
         cls.formats = cls.default_formats.copy()
+#--------
 
+#--------
     @classmethod
     def restore_format(cls, name):
         if name not in cls.default_formats:
@@ -259,14 +269,18 @@ class Formatter:
         cls.custom_formats.pop(name, None)
         if name not in cls.enabled_formats:
             cls.enabled_formats.append(name)
+#--------
 
+#--------
     @classmethod
     def clear_formats(cls):
         cls.formats.clear()
         cls.custom_formats.clear()
         cls.enabled_formats.clear()
         cls.format_aliases.clear()
+#--------
 
+#--------
     @classmethod
     def clear_default_formats(cls):
         for name in list(cls.default_formats):
@@ -276,7 +290,9 @@ class Formatter:
                 cls.enabled_formats.remove(name)
 
             cls.formats.pop(name, None)
+#--------
 
+#--------
     @classmethod
     def clear_custom_formats(cls):
         for name in list(cls.custom_formats):
@@ -288,11 +304,15 @@ class Formatter:
             cls.formats.pop(name, None)
 
         cls.custom_formats.clear()
+#--------
 
+#--------
     @classmethod
     def get_formats(cls):
         return cls.formats
+#--------
     
+#--------
     @classmethod
     def get_default_formats(cls):
         return {
@@ -300,15 +320,21 @@ class Formatter:
             for name in cls.formats
             if name in cls.default_formats
         }
+#--------
     
+#--------
     @classmethod
     def get_custom_formats(cls):
         return cls.custom_formats
+#--------
 
+#--------
     @classmethod
     def get_builtin_formats(cls):
         return cls.default_formats
+#--------
 
+#--------
     @classmethod
     def get_format_function(cls, name):
         if not cls.is_existing_format(name):
@@ -317,7 +343,9 @@ class Formatter:
             )
 
         return cls.formats[name]
+#--------
 
+#--------
     @classmethod
     def names_of(cls, func):
         names = []
@@ -329,7 +357,9 @@ class Formatter:
         raise InvalidArgumentError(
             f"Format {func.__name__} not found."
         )
+#--------
 
+#--------
     @classmethod
     def get_format_info(cls, name):
         if not cls.is_existing_format(name):
@@ -344,11 +374,15 @@ class Formatter:
             "function": func,
             "doc": func.__doc__
         }
+#--------
 
+#--------
     @classmethod
     def get_format_doc(cls, name):
         return cls.get_format_function(name).__doc__
+#--------
 
+#--------
     @classmethod
     def rename_format(cls, old_name, new_name):
         if not cls.is_existing_format(old_name):
@@ -386,15 +420,21 @@ class Formatter:
 
         for alias in aliases:
             cls.format_aliases[alias] = func
+#--------
 
+#--------
     @classmethod
     def has_format(cls, name):
         return cls.is_existing_format(name)
-    
+#--------
+
+#--------
     @classmethod
     def has_alias(cls, name):
         return cls.is_existing_alias(name)
+#--------
 
+#--------
     @classmethod
     def disable(cls, name):
         if not cls.is_existing_format(name):
@@ -410,21 +450,25 @@ class Formatter:
 
         if name in cls.enabled_formats:
             cls.enabled_formats.remove(name)
+#--------
 
+#--------
     @classmethod
     def enable(cls, name):
         if not cls.is_existing_format(name):
             raise InvalidArgumentError(
                 f"Unable to enable format: format '{name}' does not exist."
             )
-        
+
         aliases = list(cls.aliases_of(name))
         if not cls.is_enabled(name):
             cls.enabled_formats.append(name)
         for alias in aliases:
             if not cls.is_enabled(alias):
                 cls.enabled_formats.append(alias)
+#--------
 
+#--------
     @classmethod
     def toggle(cls, name):
         if not cls.is_existing_format(name):
@@ -445,12 +489,13 @@ class Formatter:
             for alias in aliases:
                 if alias not in cls.enabled_formats:
                     cls.enabled_formats.append(alias)
+#--------
 
+#--------
     @classmethod
     def is_enabled(cls, name):
         return name in cls.enabled_formats
-        
-    
+#--------
 
 #--------(Validation API)--------
     @classmethod
@@ -461,21 +506,28 @@ class Formatter:
                 "Input string is empty or contains only whitespace."
             )
         return s
+#--------
 
+#--------
     @classmethod
     def is_existing_format(cls, name):
         return name in cls.formats
-    
+#--------
+ 
+#--------    
     @classmethod
     def is_existing_alias(cls, name):
         return name in cls.format_aliases
+#--------
 
+#--------
     @classmethod
-    def validate_format_function(cls, func):
+    def __validate_format_function(cls, func):
         sig = signature(func)
 
         if len(sig.parameters) != 1:
             raise InvalidArgumentError("Format function must accept exactly one argument.")
+#--------
 
 #--------(Alias API)--------
 
@@ -501,7 +553,9 @@ class Formatter:
 
         if alias_name not in cls.enabled_formats:
             cls.enabled_formats.append(alias_name)
+#--------
 
+#--------
     @classmethod
     def del_alias(cls, alias_name):
         if not cls.is_existing_alias(alias_name):
@@ -513,7 +567,9 @@ class Formatter:
             cls.enabled_formats.remove(alias_name)
 
         del cls.format_aliases[alias_name]
+#--------
 
+#--------
     @classmethod
     def del_aliases_of(cls, existing_name):
         if not cls.is_existing_format(existing_name):
@@ -532,14 +588,18 @@ class Formatter:
                 cls.enabled_formats.remove(alias)
 
             del cls.format_aliases[alias]
+#--------
 
+#--------
     @classmethod
     def clear_aliases(cls):
         for alias in list(cls.format_aliases):
             if alias in cls.enabled_formats:
                 cls.enabled_formats.remove(alias)
             del cls.format_aliases[alias]
+#--------
 
+#--------
     @classmethod
     def aliases_of(cls, existing_name):
         if not cls.is_existing_format(existing_name):
@@ -552,7 +612,10 @@ class Formatter:
             for name, func in cls.format_aliases.items()
             if func is cls.formats[existing_name] and name != existing_name
         }
+#--------
 
+#--------
     @classmethod
     def get_all_aliases(cls):
         return cls.format_aliases
+#--------

minor_utils-0.2.0.dev1/minor_utils/func_manager.py

@@ -0,0 +1,326 @@
+# Errors
+from .errors import InvalidArgumentError
+
+class Manager:
+    managers = {}
+    counter = 0
+
+#--------
+    def __init__(self, name=None):
+
+        self.__name = (
+            name
+            if name is not None
+            else "Manager"
+        )
+
+        self.__funcs = []
+
+        self.id = Manager.counter
+        Manager.counter += 1
+        Manager.managers[self.id] = self
+#--------
+
+#--------(Registration API)--------
+    def add_func(self, func=None, name=None, *args, **kwargs):
+        def decorator(f, *args, **kwargs):
+            self.__validate_func(func, *args, **kwargs)
+
+            if not self.validate_name(name):
+                raise InvalidArgumentError(f"Invalid function name '{name}'. Function names must be valid identifiers.")
+
+            func_name = (
+                name
+                if name is not None
+                else f.__name__
+            )
+
+            if self.is_existing_func(func_name):
+                raise InvalidArgumentError(f"Function '{func_name}' already exists in manager {self.__name}.")
+            
+            self.__funcs.append(func_name, f)
+
+            return f
+        
+        if func is None:
+            return decorator
+        
+        return decorator(func)
+    
+    def del_func(self, name):
+        if not self.is_existing_func(name):
+            raise InvalidArgumentError(f"Function '{name}' does not exist in manager {self.__name}.")
+        
+        try:
+            func_id = int(name)
+            del self.__funcs[func_id]
+        except (ValueError, TypeError):
+            for i, (func_name, _) in enumerate(self.__funcs):
+                    if func_name == name:
+                        del self.__funcs[i]
+                        break
+    
+#--------
+
+#--------(Lookup API)--------
+    def get_func(self, name):
+        if not self.is_existing_func(name):
+            raise InvalidArgumentError(f"Function '{name}' does not exist in manager {self.__name}.")
+        
+        try:
+            func_id = int(name)
+            return self.__funcs[func_id][1]
+        except (ValueError, TypeError):
+            for func_name, func in self.__funcs:
+                    if func_name == name:
+                        return func
+#--------
+
+#--------
+    def find_func(self, name):
+        if not self.is_existing_func(name):
+            return None
+        
+        try:
+            func_id = int(name)
+            return self.__funcs[func_id][1]
+        except (ValueError, TypeError):
+            for func_name, func in self.__funcs:
+                    if func_name == name:
+                        return func
+#--------
+
+#--------
+    def get_funcs(self):
+        return [func for _, func in self.__funcs]
+#--------
+
+#--------
+    def get_info(self, name = None):
+        if name is None:
+                return self.__funcs.copy()
+        else:
+            func = self.get_func(name)
+            return [func] if func is not None else []
+#--------
+
+#--------
+    def find_info(self, name = None):
+        if name is None:
+                return self.__funcs.copy()
+        else:
+            func = self.find_func(name)
+            return [func] if func is not None else []
+#--------
+
+#--------
+    def get_func_id(self, name):
+        if not self.is_existing_func(name):
+            raise InvalidArgumentError(f"Function '{name}' does not exist in manager {self.__name}.")
+        
+        try:
+            func_id = int(name)
+            return func_id
+        except (ValueError, TypeError):
+            for i, (func_name, _) in enumerate(self.__funcs):
+                    if func_name == name:
+                        return i
+#--------
+
+#--------
+    def get_func_name(self, name):
+        if not self.is_existing_func(name):
+            raise InvalidArgumentError(f"Function '{name}' does not exist in manager {self.__name}.")
+        
+        try:
+            func_id = int(name)
+            return self.__funcs[func_id][0]
+        except (ValueError, TypeError):
+            for func_name, _ in self.__funcs:
+                    if func_name == name:
+                        return func_name
+#--------
+
+#--------
+    def get_ids(self):
+        return list(range(len(self.__funcs)))
+#--------
+
+#--------
+    def get_names(self):
+        return [func_name for func_name, _ in self.__funcs]
+#--------
+
+#--------
+    def info_to_string(self, name = None):
+        funcs = self.get_info(name)
+        output = ""
+        for i, (func_name, func) in enumerate(funcs):
+            output += (
+                f"--------\n"
+                f"ID = {i}\n"
+                f"Name = {func_name}\n"
+                f"Function = {func.__name__}\n"
+            )
+        output += "--------\n"
+        return output
+#--------
+
+#--------(Config API)--------
+    def compile_config(self, config=None):
+        ids = list(range(len(self.__funcs)))
+
+        if config is None:
+            return ids
+        
+        env = {"ids": ids}
+        result = []
+
+        for expr in config:
+            if isinstance(expr, int):
+                result.append(expr)
+                continue
+
+            value = eval(expr, {}, env)
+            if isinstance(value, int):
+                result.append(value)
+            elif isinstance(value, (list, tuple)):
+                result.extend(value)
+            else:
+                raise InvalidArgumentError(f"Invalid config expression '{expr}'. Config expressions must evaluate to an integer or a list/tuple of integers.")
+        
+        return result
+#--------
+
+#--------
+    def sample_menu(self):
+        menu = "--------Commands (ID: Name)--------\n" + "Note: commands are executed only by their IDs, not names.\n"
+        for i, func_name in enumerate(self.get_names()):
+            menu += f"{i}: {func_name}\n"
+        menu += "-1: Exit\n" + "-"*16 + "\n"
+        return menu
+#--------
+
+#--------
+    def sample_not_found_func(self, name):
+        if not self.is_id(name):
+            return f"Functions must be called by their IDs, not names. '{name}' is not an ID."
+        
+        if not self.is_existing_func(name):
+            return f"Function '{name}' not found in manager {self.__name}."
+#--------
+
+#--------(Execution API)--------
+    def call_func(self, name, *args, safe = False, **kwargs):
+        if safe:
+            try:
+                return self.get_func(name)(*args, **kwargs)
+            except Exception as e:
+                print(f"Error occurred while calling function '{name}': {e}")
+                return None
+        else:
+            return self.get_func(name)(*args, **kwargs)
+#--------
+
+#--------
+    def run(self, *, config = None, arguments = None, safe = False):
+        order = self.compile_config(config)
+
+        if arguments is None:
+            arguments = [([], {}) for _ in self.__funcs]
+
+        if len(arguments) != len(self.__funcs):
+            raise InvalidArgumentError(f"Invalid arguments list. The number of argument sets must match the number of functions in the manager ({len(self.__funcs)}).")
+        
+        results = []
+
+        for func_id in order:
+            args, kwargs = arguments[func_id]
+
+            result = self.call_func(func_id, safe = safe, *args, **kwargs)
+            results.append(result)
+
+        return results
+#--------
+
+#--------
+    def run_manual(self, *, arguments = None, safe = False, menu = None):
+        if menu is None:
+            menu = self.sample_menu()
+        else:
+            menu = str(menu) + "\n"
+        
+        invalid_index_message = self.sample_not_found_func("{name}")
+        
+        if arguments is None:
+            arguments = [([], {}) for _ in self.__funcs]
+
+        if len(arguments) != len(self.__funcs):
+            raise InvalidArgumentError(f"Invalid arguments list. The number of argument sets must match the number of functions in the manager ({len(self.__funcs)}).")
+        
+        results = {}
+
+        while True:
+            print(menu)
+            choice = input("> ").strip()
+
+            if choice == "-1":
+                return results
+            
+            if not self.is_id(choice) or not self.is_existing_func(choice):
+                print(invalid_index_message.format(name=choice))
+                continue
+            
+            func_id = int(choice)
+            args, kwargs = arguments[func_id]
+
+            result = self.call_func(func_id, *args, safe = safe, **kwargs)
+            results.setdefault(func_id, []).append(result)
+#--------
+
+# --------(Validation API)--------
+    def is_existing_func(self, name):
+        try:
+            func_id = int(name)
+            return 0 <= func_id < len(self.__funcs)
+        except (ValueError, TypeError):
+            if not self.validate_name(name):
+                raise InvalidArgumentError(f"Invalid function identifier '{name}'. '{name}' must be a name or an integer index.")
+            
+            for func_name, _ in self.__funcs:
+                if func_name == name:
+                    return True
+            return False
+#--------
+
+#--------
+    def is_id(self, name):
+        try:
+            func_id = int(name)
+            return True
+        except (ValueError, TypeError):
+            return False
+#--------
+
+#--------
+    def is_name(self, name):
+        if self.validate_name(name):
+            return True
+        return False
+#--------
+    
+#--------
+    @classmethod
+    def __validate_func(cls, func, *args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            raise InvalidArgumentError(f"Function '{func.__name__}' raised an error:\n{str(e)}") from e
+#--------
+
+#--------
+    @staticmethod
+    def validate_name(name):
+        name = str(name).strip()
+        return name.isidentifier()
+#--------

minor_utils-0.2.0.dev1/minor_utils.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: minor_utils
+Version: 0.2.0.dev1
+Summary: Utils compilation for easier work
+Author-email: CyberAxolotl <minor.gleb@outlook.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown

{minor_utils-0.1.1 → minor_utils-0.2.0.dev1}/minor_utils.egg-info/SOURCES.txt

@@ -1,8 +1,8 @@
-README.md
 pyproject.toml
 minor_utils/__init__.py
 minor_utils/errors.py
 minor_utils/formatter.py
+minor_utils/func_manager.py
 minor_utils.egg-info/PKG-INFO
 minor_utils.egg-info/SOURCES.txt
 minor_utils.egg-info/dependency_links.txt

{minor_utils-0.1.1 → minor_utils-0.2.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "minor_utils"
-version = "0.1.1"
+version = "0.2.0dev1"
 description = "Utils compilation for easier work"
 authors = [{name = "CyberAxolotl", email = "minor.gleb@outlook.com"}]
 license = "MIT"

minor_utils-0.1.1/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: minor_utils
-Version: 0.1.1
-Summary: Utils compilation for easier work
-Author-email: CyberAxolotl <minor.gleb@outlook.com>
-License-Expression: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
-# minor-utils
-
-Utility library for formatting and helper functions.
-
-## Installation
-
-```bash
-pip install minor-utils
-```
-
-## Note
-
-The project is NOT final! It will be updated, new content will be added. There might be some bugs and information about the project is incomplete. You can use it now, but be careful. I recommend not to use it right now and wait untill it is finished.
-
-## Where can I find it?
-
-It is uploaded on PyPI
-Link:
-https://pypi.org/project/minor-utils/

minor_utils-0.1.1/README.md

@@ -1,19 +0,0 @@
-# minor-utils
-
-Utility library for formatting and helper functions.
-
-## Installation
-
-```bash
-pip install minor-utils
-```
-
-## Note
-
-The project is NOT final! It will be updated, new content will be added. There might be some bugs and information about the project is incomplete. You can use it now, but be careful. I recommend not to use it right now and wait untill it is finished.
-
-## Where can I find it?
-
-It is uploaded on PyPI
-Link:
-https://pypi.org/project/minor-utils/

minor_utils-0.1.1/minor_utils.egg-info/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: minor_utils
-Version: 0.1.1
-Summary: Utils compilation for easier work
-Author-email: CyberAxolotl <minor.gleb@outlook.com>
-License-Expression: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-
-# minor-utils
-
-Utility library for formatting and helper functions.
-
-## Installation
-
-```bash
-pip install minor-utils
-```
-
-## Note
-
-The project is NOT final! It will be updated, new content will be added. There might be some bugs and information about the project is incomplete. You can use it now, but be careful. I recommend not to use it right now and wait untill it is finished.
-
-## Where can I find it?
-
-It is uploaded on PyPI
-Link:
-https://pypi.org/project/minor-utils/