abstract-utilities 0.2.2.424__tar.gz → 0.2.2.613__tar.gz

{abstract_utilities-0.2.2.424 → abstract_utilities-0.2.2.613}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.424
+Version: 0.2.2.613
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.424 → abstract_utilities-0.2.2.613}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_utilities',
-    version='0.2.2.424',
+    version='0.2.2.613',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description='abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.',

{abstract_utilities-0.2.2.424 → abstract_utilities-0.2.2.613}/src/abstract_utilities/__init__.py

@@ -1,10 +1,6 @@
-import re,threading,os,shutil,requests,asyncio,time,subprocess,json,glob,sys,logging
-from datetime import timedelta
-from datetime import datetime
-from typing import *
+from .imports import *
 from .hash_utils import *
 ##from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
-
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,
@@ -40,42 +36,8 @@ from .json_utils import (unified_json_loader,
                          )
 from .read_write_utils import (read_from_file,
                                write_to_file)
-from .path_utils import (get_file_create_time,
-                         get_files,
-                         get_folders,
-                         path_join,
-                         mkdirs,
-                         split_text,
-                         get_all_item_paths,
-                         get_directory_items,
-                         get_files,
-                         get_folders,
-                         break_down_find_existing,
-                         get_directory_items,
-                         get_directory_files,
-                         get_all_item_paths,
-                         get_all_file_paths,
-                         get_directory,
-                         create_directory,
-                         initialize_file,
-                         join_path,
-                         is_last_itter,
-                         path_join,
-                         is_file,
-                         is_dir,
-                         is_path,
-                         get_all_directories,
-                         get_all_files,
-                         get_all_items,
-                         collate_text_docs,
-                         get_dirlist,
-                         get_content,
-                         is_directory_in_paths,
-                         make_dirs,
-                         remove_directory,
-                         remove_path,
-
-                         )
+from .directory_utils import *
+from .path_utils import *
 from .file_utils import *
 from .list_utils import (get_highest_value_obj,
                          make_list,
@@ -95,7 +57,7 @@ from .time_utils import (get_time_stamp,
                          parse_timestamp,
                          get_time_now_iso,
                          is_valid_time)
-from .string_clean import (eatInner,
+from .string_utils import (eatInner,
                            eatAll,
                            eatOuter,
                            url_join,
@@ -140,7 +102,7 @@ from .compare_utils import (create_new_name,
                             best_match)
 from .thread_utils import ThreadManager
 from .history_utils import HistoryManager
-from .abstract_classes import *
+
 from .parse_utils import (num_tokens_from_string,
                           chunk_source_code,
                           chunk_any_to_tokens,
@@ -150,6 +112,10 @@ from .parse_utils import (num_tokens_from_string,
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
-from .class_utils import alias,get_class_inputs,get_set_attr
+from .class_utils import *
 from .ssh_utils import *
 from .env_utils import *
+from .path_utils import *
+from .file_utils import *
+from .string_utils import *
+from .import_utils import *

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/__init__.py

@@ -0,0 +1,7 @@
+from .imports import *
+from .abstract_classes import *
+from .caller_utils import *
+from .class_utils import *
+from .function_utils import *
+from .module_utils import *
+from .global_utils import *

{abstract_utilities-0.2.2.424/src/abstract_utilities → abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils}/abstract_classes.py

@@ -1,10 +1,11 @@
-import inspect
+from .imports import *
 class SingletonMeta(type):
     _instances = {}
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:
             cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
         return cls._instances[cls]
+
 def get_inputs(cls, *args, **kwargs):
     """
     Dynamically construct a dataclass instance from args and kwargs,

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/caller_utils.py

@@ -0,0 +1,54 @@
+from .imports import *
+
+def get_initial_caller() -> str:
+    """
+    Return the TRUE original caller: the entrypoint script that launched the program.
+    """
+    main_mod = sys.modules.get('__main__')
+    
+    # interactive environments (REPL) may have no __file__
+    if not main_mod or not hasattr(main_mod, '__file__'):
+        return None
+
+    return os.path.realpath(main_mod.__file__)
+def get_initial_caller_dir() -> str:
+    """
+    Return the directory of the TRUE original entrypoint script.
+    """
+    caller = get_initial_caller()
+    return os.path.dirname(caller) if caller else None
+
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/class_utils.py

@@ -0,0 +1,109 @@
+"""
+Sheet: Class Utilities
+
+Module: class_utils.py
+Part of: abstract_utilities module
+Author: putkoff
+Date: 05/31/2023
+Version: 0.1.2
+
+This module contains utility functions tailored for handling classes, objects, and modules. It encapsulates operations like:
+1. Fetching and checking object types.
+2. Manipulating global variables.
+3. Checking object membership in a module.
+4. Inspecting function signatures and their arguments within a module.
+5. Calling functions with supplied arguments.
+6. Converting layout definitions into components.
+7. Retrieving attributes and methods of a module.
+
+Function Overview:
+------------------
+- get_type_list: Get a list of common Python types.
+- remove_key: Remove a specified key from a dictionary.
+- get_module_obj: Retrieve an object from a given module.
+- spec_type_mod: Check if an object has a specific type.
+- get_type_mod: Retrieve the type name of a given object.
+- is_module_obj: Check if an object is part of a module.
+- inspect_signature: Fetch the signature of a specified function.
+- get_parameter_defaults: Fetch the default parameter values for a function.
+- convert_layout_to_components: Convert a layout definition to its component representation.
+- get_dir: List all attributes and methods of a module.
+- get_proper_args: Call a function using either positional or keyword arguments.
+- get_fun: Parse a dictionary to retrieve a function and call it.
+- if_none_change: Replace a None object with a default value.
+- call_functions: Call a specified function or method using provided arguments.
+- process_args: Evaluate and process nested function calls in arguments.
+- has_attribute: Check if a function exists in a module.
+- mk_fun: Print a statement indicating the existence of a function in a module.
+
+Dependencies:
+-------------
+- inspect
+- json
+
+Each function is furnished with its own docstring that elaborates on its purpose, expected inputs, and outputs.
+
+"""
+from .imports import *
+
+
+def inspect_signature(instance: any, function: str):
+    """
+    Inspects the signature of a function.
+
+    Args:
+        instance (any): The instance containing the function.
+        function (str): The name of the function to inspect.
+
+    Returns:
+        inspect.Signature: The signature of the function.
+    """
+    return inspect.signature(get_module_obj(instance, function))
+
+def get_parameter_defaults(module, function):
+    """
+    Retrieves the default parameter values of a function.
+
+    Args:
+        module: The module instance.
+        function (str): The name of the function.
+
+    Returns:
+        dict: A dictionary containing the parameter names and their default values.
+    """
+    signature = inspect_signature(module, function)
+    if signature is None:
+        return {}
+    return json.dumps(remove_key({param_name: param.default if param.default != inspect.Parameter.empty else None for param_name, param in signature.parameters.items()}, 'icon'))
+
+def convert_layout_to_components(instance: any = None, component: str = 'function', js: dict = {}):
+    """
+    Converts a layout to components.
+
+    Args:
+        instance (any, optional): The instance containing the components. Defaults to None.
+        component (str, optional): The name of the component. Defaults to 'function'.
+        js (dict, optional): The dictionary of component properties. Defaults to an empty dictionary.
+
+    Returns:
+        any: The result of the component conversion.
+    """
+    jsN = json.loads(get_parameter_defaults(instance, component))
+    keys = list(js.keys())
+    for key in jsN:
+        if key in js:
+            jsN[key] = js[key]
+    return call_functions_hard(instance, component, **jsN)
+def get_class_inputs(cls, *args, **kwargs):
+    fields = list(cls.__annotations__.keys())
+    values = {}
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)
+    return cls(**values)
+

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/function_utils.py

@@ -0,0 +1,153 @@
+from .imports import *
+def get_proper_args(function,args:(dict or list)={}):
+    """Call a function with either positional or keyword arguments based on the provided args type."""
+    return function(*args) if isinstance(args, list) else function(**args)
+def process_args(args):
+    """
+    Processes the arguments for a function, replacing nested function calls with their results.
+
+    Args:
+        args (dict): A dictionary of arguments. 
+
+    Returns:
+        dict: A dictionary of processed arguments.
+    """
+    for key, value in args.items():
+        # check if value is a dict and has a 'type' key with value 'get'
+        if isinstance(value, dict) and value.get('type') == 'get':
+            function_name = value.get('name',None)
+            function_args = value.get('args', {})
+            instance = value.get('instance',None)
+            glob = value.get('global',globals())
+            # call the function and replace the arg with its result
+            args[key] = call_functions(function_name, function_args, instance, glob)
+    return args
+def get_fun(js):
+    """
+    Retrieves and calls a function with the given parameters.
+
+    Args:
+        js (dict): A dictionary that contains function details, including name, arguments, instance (optional), and global scope (optional).
+
+    Returns:
+        any: The result of the function call.
+    """
+    # Get function details
+    function_name = js.get('name',None)
+    if function_name is None:
+        return None
+    function_args = js.get('args', {})
+    instance = js.get('instance',None)
+    glob = js.get('global',globals())
+    # Process arguments
+    function_args = process_args(function_args)
+    # If instance is not None, get the function from the instance, else get from globals
+    if instance is not None:
+        function = getattr(instance, function_name)
+    else:
+        function = glob[function_name]
+    # Get function's valid parameter keys
+    sig = inspect.signature(function)
+    valid_keys = sig.parameters.keys()
+    # Filter arguments to only those accepted by the function
+    filtered_args = {k: v for k, v in function_args.items() if k in valid_keys}
+    return call_functions(function_name, filtered_args, instance, glob)
+def call_functions(function_name: str, args: dict = {}, instance=None, glob:(dict or bool)=globals()):
+    """
+    Calls a function or a method with the given arguments.
+
+    Args:
+        function_name (str): The name of the function.
+        args (dict, optional): A dictionary of arguments to pass to the function. Defaults to None.
+        instance (optional): The instance on which to call the method. Defaults to None.
+        glob (optional): The global scope from which to retrieve the function. Defaults to globals().
+
+    Returns:
+        any: The result of the function or method call.
+    """
+    glob = if_none_change(glob,globals())
+    args = if_none_change(args,{})
+    if instance is not None:
+        # Calls method on instance
+        method = getattr(instance, function_name)
+        return get_proper_args(method,args)
+    else:
+        # Calls function from globals
+        return get_proper_args(glob[function_name],args)
+def get_all_functions_for_instance(instance):
+    """
+    Retrieves all callable methods/functions of an object instance.
+
+    Args:
+        instance: The object instance for which to retrieve methods/functions.
+
+    Returns:
+        list: A list of method/function names that are callable on the given instance.
+    """
+    return [method for method in dir(instance) if callable(getattr(instance, method))]
+def get_all_params(instance, function_name):
+    """
+    Retrieves information about the parameters of a callable method/function of an instance.
+
+    Args:
+        instance: The object instance containing the method.
+        function_name (str): The name of the method/function to inspect.
+
+    Returns:
+        dict: A dictionary containing parameter information, including names, defaults, kinds, and required parameters.
+    """
+    # Use getattr() to get the method by name
+    method = getattr(instance, function_name, None)
+    
+    if callable(method):
+        # Now you have the method, and you can inspect it
+        func_signature = inspect.signature(method)
+        parameters = func_signature.parameters
+        
+        params = {"names": [], "defaults": [], "kinds": [], "required": []}
+        
+        for param_name, param in parameters.items():
+            params["names"].append(param_name)
+            params["defaults"].append(param.default)
+            params["kinds"].append(param.kind)
+            
+            if param.default == inspect._empty:
+                params["required"].append(param_name)
+        
+        return params
+    else:
+        print(f"{function_name} is not a callable method of the instance.")
+        return None 
+def mk_fun(module,function):
+    """
+    Checks if a function exists in a given module.
+
+    Args:
+        module: The module in which to look for the function.
+        function: The function to check.
+
+    Prints a statement indicating whether the function exists.
+    """
+    if has_attribute(module,function):
+      print(f"The function {function} exists.")
+    else:
+      print(f"The function {function} does not exist.")
+def alias(*aliases):
+    """
+    Decorator to create multiple names for a function.
+    
+    Args:
+        *aliases: Names to assign to the function.
+    
+    Returns:
+        callable: Decorated function.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        # Assign aliases in the module's globals
+        for name in aliases:
+            globals()[name] = func
+        return wrapper
+    return decorator

{abstract_utilities-0.2.2.424/src/abstract_utilities → abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils}/global_utils.py

@@ -1,3 +1,22 @@
+import importlib, sys,os
+from .caller_utils import get_initial_caller
+def file_to_module_name(path):
+    path = os.path.realpath(path)
+    # Find a path that exists in sys.path
+    for base in sys.path:
+        base = os.path.realpath(base)
+        if path.startswith(base):
+            rel = os.path.relpath(path, base)
+            mod = os.path.splitext(rel)[0]
+            return mod.replace(os.sep, ".")
+    # fallback (never should be used)
+    return os.path.splitext(os.path.basename(path))[0]
+def get_globals_from_path(module_path: str=None):
+    module_path = module_path or get_initial_caller()
+    module_name = file_to_module_name(module_path)
+    if module_name not in sys.modules:
+        importlib.import_module(module_name)
+    return sys.modules[module_name].__dict__
 def global_registry(name:str,glob:dict):
     global_ledger = if_none_default(string='global_ledger',glob=globals(),default={"registry_names":[],"registry_index":[]})
     if name not in global_ledger['registry_names']:
@@ -31,26 +50,22 @@ def return_globals() -> dict:
         dict: The global variables dictionary.
     """
     return globals()
-def change_glob(var: str, val: any, glob: dict = return_globals()) -> any:
-    """
-    Changes the value of a global variable.
-
-    Args:
-        var (str): The name of the global variable.
-        val (any): The new value.
-        glob (dict, optional): The dictionary of global variables. Defaults to the current globals.
-
-    Returns:
-        any: The new value of the variable.
-    """
+def get_true_globals():
+    return sys.modules['__main__'].__dict__
+def change_glob(var: str, val: any, glob: dict = None) -> any:
+    if glob is None:
+        glob = get_true_globals()
     glob[var] = val
     return val
-def get_globes(string:str='',glob:dict=return_globals()):
-    if string in glob:
-        return glob[string]
-def if_none_default(string:str, default:any,glob:dict=return_globals()):
-    piece = get_globes(string=string,glob=glob)
-    if piece is None:
-        piece = default
-    return change_glob(var=string,val=piece,glob=glob)
 
+def get_globes(string: str='', glob: dict=None):
+    if glob is None:
+        glob = get_true_globals()
+    return glob.get(string)
+def if_none_default(string: str, default: any, glob: dict=None, typ=None):
+    if glob is None:
+        glob = get_true_globals()
+    piece = get_globes(string=string, glob=glob)
+    if piece is None or (typ and not isinstance(piece, typ)):
+        piece = default
+    return change_glob(var=string, val=piece, glob=glob)

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from ...imports import inspect,os,json,functools,inspect,glob,sys
+from typing import *

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/imports/utils.py

@@ -0,0 +1,40 @@
+from .imports import *
+def remove_key(js: dict, key: any) -> dict:
+    """Remove a key from a dictionary. If the key is not present,
+    no action is taken."""
+    js.pop(key, None)
+    return js
+def if_none_change(obj, default):
+    """Return a default value if the provided object is None."""
+    if obj == None:
+        obj = default
+    return obj
+def has_attribute(module, function):
+    """Check if a specific function exists in a given module."""
+    try:
+        bool_it = hasattr(module, function)
+    except:
+        bool_it =None
+    return bool_it
+def get_type_list() -> list:
+    """Get a list of common Python types."""
+    return ['None','str','int','float','bool','list','tuple','set','dict','frozenset','bytearray','bytes','memoryview','range','enumerate','zip','filter','map','property','slice','super','type','Exception','object']
+def get_set_attr(parent,attr_name,value=None,valueFunc=None,default=False,*args,**kwargs):
+    attr_value = getattr(parent,attr_name,default)
+    if attr_value == False:
+        if value is None and valueFunc is not None:
+            value = valueFunc(*args,**kwargs)
+        setattr(parent,attr_name,value)
+        attr_value = getattr(parent,attr_name,default)
+    return attr_value
+def get_dir(mod):
+    """
+    Retrieves the directory of a module.
+
+    Args:
+        mod: The module.
+
+    Returns:
+        list: The list of attributes and methods in the module.
+    """
+    return dir(mod)

abstract_utilities-0.2.2.613/src/abstract_utilities/class_utils/module_utils.py

@@ -0,0 +1,63 @@
+from .imports import *
+def get_module_obj(instance: any, obj: any):
+    """
+    Retrieves an object from a module.
+
+    Args:
+        instance (any): The module instance.
+        obj (any): The object to retrieve.
+
+    Returns:
+        any: The retrieved object.
+    """
+    return getattr(instance, obj)
+
+def spec_type_mod(obj: any, st: str) -> bool:
+    """
+    Checks if an object has a specific type.
+
+    Args:
+        obj (any): The object to check.
+        st (str): The specific type to check.
+
+    Returns:
+        bool: True if the object has the specified type, False otherwise.
+    """
+    if obj.__class__.__name__ == st:
+        return True
+    return False
+
+def get_type_mod(obj: any) -> str:
+    """
+    Retrieves the type of an object.
+
+    Args:
+        obj (any): The object to get the type of.
+
+    Returns:
+        str: The type of the object.
+    """
+    type_ls = get_types_list()
+    for k in range(len(type_ls)):
+        typ = str(type_ls[k])
+        if spec_type_mod(obj, typ):
+            return typ
+    return "NoneType"
+
+def is_module_obj(instance: any, obj: str) -> bool:
+    """
+    Checks if an object is part of a module.
+
+    Args:
+        instance (any): The module instance.
+        obj (str): The name of the object to check.
+
+    Returns:
+        bool: True if the object is part of the module, False otherwise.
+    """
+    try:
+        if get_type_mod(getattr(instance, obj)) in [None, 'NoneType']:
+            return False
+        return True
+    except:
+        return False

{abstract_utilities-0.2.2.424/src/abstract_utilities/cmd_utils/imports → abstract_utilities-0.2.2.613/src/abstract_utilities/directory_utils}/__init__.py

@@ -1 +1,2 @@
 from .imports import *
+from .src import *

abstract_utilities-0.2.2.613/src/abstract_utilities/directory_utils/imports/__init__.py

@@ -0,0 +1,2 @@
+from .imports import *
+from .module_imports import *

abstract_utilities-0.2.2.613/src/abstract_utilities/directory_utils/imports/imports.py

@@ -0,0 +1 @@
+from ...imports import os,shlex

abstract_utilities-0.2.2.613/src/abstract_utilities/directory_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...safe_utils import safe_join
+from ...ssh_utils import is_file

abstract_utilities-0.2.2.613/src/abstract_utilities/directory_utils/src/__init__.py

@@ -0,0 +1,4 @@
+from .directory_utils import *
+from .name_utils import *
+from .utils import *
+from .size_utils import *