abstract-utilities 0.0.0__tar.gz

abstract_utilities-0.0.0/PKG-INFO

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: abstract_utilities
+Version: 0.0.0

abstract_utilities-0.0.0/abstract_utilities/__init__.py

@@ -0,0 +1,135 @@
+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,
+                         get_value_from_path,
+                         find_paths_to_key,
+                         create_and_read_json,
+                         unified_json_loader,
+                         all_try,
+                         try_json_loads,
+                         get_error_msg,
+                         get_any_key,
+                         get_any_value,
+                         json_key_or_default,
+                         format_json_key_values,
+                         get_all_keys,
+                         update_dict_value,
+                         get_all_key_values,
+                         get_json_data,
+                         safe_json_dumps,
+                         safe_json_loads,
+                         read_from_json,
+                         safe_load_from_json,
+                         safe_load_from_file,
+                         safe_json_reads,
+                         safe_read_from_json,
+                         safe_dump_to_file,
+                         safe_dump_to_json,
+                         safe_write_to_json,
+                         safe_write_to_file,
+                         safe_save_updated_json_data,
+                         get_result_from_data,
+                         flatten_json,
+                         to_json_safe
+                         )
+
+from .directory_utils import *
+from .list_utils import (get_highest_value_obj,
+                         make_list,
+                         safe_list_return,
+                         get_actual_number,
+                         compare_lists,
+                         get_symetric_difference,
+                         list_set,
+                         make_list_it,
+                         get_single_from_list
+                         )
+from .time_utils import (get_time_stamp,
+                         get_sleep,
+                         sleep_count_down,
+                         get_date,
+                         get_current_time_with_delta,
+                         format_timestamp,
+                         timestamp_to_milliseconds,
+                         parse_timestamp,
+                         get_time_now_iso,
+                         is_valid_time)
+from .string_utils import (eatInner,
+                           eatAll,
+                           eatOuter,
+                           url_join,
+                           capitalize
+                           )
+from .type_utils import (make_bool,
+                         T_or_F_obj_eq,
+                         is_number,
+                         makeInt,
+                         str_lower,
+                         confirm_type,
+                         get_all_file_types,
+                         is_media_type,
+                         get_bool_response,
+                         get_mime_type,
+                         get_media_exts,
+                         if_true_get_string,
+                         find_for_string,
+                         is_strings_in_string,
+                         get_alphabet_str,
+                         get_alphabet_upper_str,
+                         get_alphabet_comp_str,
+                         get_numbers,
+                         get_numbers_comp,
+                         is_any_instance,
+                         break_string,
+                         MIME_TYPES,
+                         get_if_None,
+                         derive_media_type,
+                         get_media_map
+                         )
+get_media_types = get_all_types = get_all_file_types
+from .math_utils import (convert_to_percentage,
+                         exponential,
+                         get_percentage,
+                         add_it,
+                         divide_it,
+                         exp_it,
+                         return_0,
+                         zero_buff_int)
+from .compare_utils import (create_new_name,
+                            get_last_comp_list,
+                            get_closest_match_from_list,
+                            get_first_match,
+                            get_all_match,
+                            best_match)
+from .thread_utils import ThreadManager
+from .history_utils import HistoryManager
+
+from .parse_utils import (num_tokens_from_string,
+                          chunk_source_code,
+                          chunk_any_to_tokens,
+                          detect_language_from_text,
+                          chunk_by_language_context,
+                          search_code,
+                          get_within_quotes)
+
+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 *
+from .ssh_utils import *
+from .env_utils import *
+
+from .file_utils import *
+from .string_utils import *
+from .import_utils import *
+from .path_utils import *
+from .read_write_utils import (read_from_file,
+                               write_to_file,
+                               make_dirs,
+                               make_dirs,
+                               copy_files,
+                               make_path,
+                               run_cmd
+                               )

abstract_utilities-0.0.0/abstract_utilities/class_utils/__init__.py

@@ -0,0 +1,6 @@
+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.0.0/abstract_utilities/class_utils/abstract_classes.py

@@ -0,0 +1,175 @@
+from .imports import *
+import inspect
+from dataclasses import fields, is_dataclass, MISSING
+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,
+    filling missing values from defaults in the dataclass.
+    """
+    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)  # default from dataclass
+
+    return cls(**values)
+
+
+
+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,
+    filling missing values from defaults in the dataclass.
+    """
+    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)  # default from dataclass
+
+    return cls(*args,**values)
+def get_input_params(func):
+    sig = inspect.signature(func)
+    return sig.parameters
+def get_args(func, *args,**kwargs):
+    parameters = get_input_params(func)
+    parameters = dict(parameters)
+    for key,value in parameters.items():
+        value = str(value)
+        if value.startswith('**'):
+            kwargs_key = key
+        elif value.startswith('*'):
+            args_key = key
+            kwargs_copy = kwargs.copy()
+            for k_key,k_value in kwargs.items():
+                if args_key == k_key and  isinstance(k_value,list or tuple or set):
+                    args = args | tuple(k_value)
+                    del kwargs[k_key]
+    return args,kwargs
+
+def prune_inputs(func, *args, **kwargs):
+    """
+    Smart argument adapter:
+    - Detects if func accepts *args or **kwargs
+    - Builds new positional arguments from kwargs when appropriate
+    - Handles explicit {"args": [...]} convention
+    """
+
+    sig = inspect.signature(func)
+    params = sig.parameters
+
+    has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params.values())
+    has_varkw   = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+    new_args = list(args)
+    new_kwargs = dict(kwargs)
+
+    # -----------------------------------------------------------
+    # 1. If user provided explicit args: {"args": [...]}
+    # -----------------------------------------------------------
+    if "args" in new_kwargs:
+        explicit_args = new_kwargs.pop("args")
+        if isinstance(explicit_args, (list, tuple)):
+            new_args.extend(explicit_args)
+        else:
+            new_args.append(explicit_args)
+
+    # -----------------------------------------------------------
+    # 2. If function has *args, infer which kwargs belong there
+    # -----------------------------------------------------------
+    if has_varargs:
+
+        # Heuristic rules for upgrading kwargs to args:
+        #   - if the function has NO named params, treat all scalar kwargs as positional
+        #   - common param names like "file_path" also qualify
+        preferred_as_args = {"path", "file", "file_path", "filename", "value"}
+
+        positional_candidates = []
+
+        for k in list(new_kwargs.keys()):
+            v = new_kwargs[k]
+
+            # candidate rules:
+            if k in preferred_as_args:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+            # scalars but not mappings/lists (optional)
+            elif isinstance(v, (str, int, float)) and len(positional_candidates) == 0:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+        new_args.extend(positional_candidates)
+
+    # -----------------------------------------------------------
+    # 3. If function does NOT accept **kwargs → strip extras
+    # -----------------------------------------------------------
+    if not has_varkw:
+        allowed = {
+            name for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY
+            )
+        }
+        new_kwargs = {k: v for k, v in new_kwargs.items() if k in allowed}
+
+    return tuple(new_args), new_kwargs
+def run_pruned_func(func, *args, **kwargs):
+   args,kwargs = prune_inputs(func, *args, **kwargs)
+   return func(*args, **kwargs)
+
+def safe_construct(cls, *args, **kwargs):
+    """Build cls from whatever's given. Missing fields -> their default
+    (or None if none). Unknown keys -> dropped (or stashed in `extra` if
+    the class has one). Never raises on arg mismatch."""
+    flds = {f.name: f for f in fields(cls)} if is_dataclass(cls) else {}
+
+    out = {}
+    leftover = dict(kwargs)
+    arglist = list(args)
+
+    for name, f in flds.items():
+        if name in leftover:
+            out[name] = leftover.pop(name)
+        elif arglist:
+            out[name] = arglist.pop(0)
+        elif f.default is not MISSING:
+            out[name] = f.default
+        elif f.default_factory is not MISSING:
+            out[name] = f.default_factory()
+        else:
+            out[name] = None              # required but absent -> None, no crash
+
+    # unknown keys: keep them if the class has an `extra` field, else drop
+    if "extra" in flds:
+        out.setdefault("extra", {})
+        out["extra"].update(leftover)
+
+    return cls(**out)

abstract_utilities-0.0.0/abstract_utilities/class_utils/caller_utils.py

@@ -0,0 +1,92 @@
+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)
+
+
+def get_original_caller_dir(levels_up: int = None) -> Path:
+    """
+    Return the directory of the *original* caller in the call stack.
+
+    levels_up:
+        - None → automatically goes to the bottom-most user-level caller.
+        - N    → manually walk up N frames for custom behavior.
+    
+    Returns:
+        Path object pointing to caller's directory.
+    """
+
+    stack = inspect.stack()
+
+    # If the user specifies an exact depth
+    if levels_up is not None:
+        target = min(levels_up + 1, len(stack) - 1)
+        frame = stack[target]
+        return Path(frame.filename).resolve().parent
+
+    # Otherwise, auto-detect the FIRST file that isn't inside site-packages or abstract_* utilities
+    for frameinfo in reversed(stack):
+        file_path = Path(frameinfo.filename).resolve()
+
+        # Skip internal interpreter/frame files
+        if "site-packages" in str(file_path):
+            continue
+        if "abstract_" in file_path.name:
+            continue
+        if file_path.name.startswith("<"):
+            continue
+
+        return file_path.parent
+
+    # Fallback: last entry in the stack
+    return Path(stack[-1].filename).resolve().parent

abstract_utilities-0.0.0/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.0.0/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