abstract-utilities 0.2.2.486__py3-none-any.whl → 0.2.2.540__py3-none-any.whl

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/class_utils/global_utils.py

@@ -0,0 +1,56 @@
+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']:
+        if glob == None:
+            return None
+        global_ledger['registry_names'].append(name)
+        global_ledger['registry_index'].append(glob)
+    length = len(global_ledger['registry_names']) 
+    change_glob('global_ledger',global_ledger)
+    for i in range(0,length):
+        if name == global_ledger['registry_names'][i]:
+            return i
+def get_registry_number(name:str):
+    return global_registry(name=name,glob=None)
+def update_registry(var:str,val:any,name:str):
+    global_ledger=get_globes(string='global_ledger',glob=globals())
+    change_glob(var=var,val=val,glob=get_global_from_registry(name))
+    global_ledger['registry_index'][get_registry_number(name)] = get_global_from_registry(name)
+    change_glob(var='global_ledger',val=global_ledger)
+def get_global_from_registry(name:str):
+    global_ledger=get_globes(string='global_ledger',glob=globals())
+    return global_ledger['registry_index'][get_registry_number(name)]
+def return_globals() -> dict:
+    """
+    Returns the global variables.
+
+    Args:
+        globs (dict, optional): The dictionary of global variables. Defaults to the current globals.
+
+    Returns:
+        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.
+    """
+    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)
+

abstract_utilities/class_utils/imports/__init__.py

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

abstract_utilities/class_utils/imports/imports.py

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

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/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/directory_utils/__init__.py

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

abstract_utilities/directory_utils/directory_utils.py

@@ -0,0 +1,94 @@
+from ..imports import os,shlex
+from ..safe_utils import safe_join
+from .utils import *
+def get_dirs(path):
+    """
+    Get List of Immediate Subdirectories in a Path
+
+    This function uses the os.walk method to traverse through a directory tree and returns a list of immediate subdirectories
+    within the specified path.
+
+    Parameters:
+    - path (str): The path for which subdirectories need to be retrieved.
+
+    Returns:
+    - subdirectories (list): A list of immediate subdirectories within the specified path.
+
+    Example:
+    subdirs = get_dirs("/path/to/directory")
+    print("Immediate Subdirectories:", subdirs)
+    """
+    from os import walk
+    for (dirpath, dirnames, filenames) in walk(path):
+        return dirnames
+def get_directory(file_path: str) -> str:
+    """
+    Extracts and returns the directory path from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The directory path extracted from the file path.
+    """
+    return file_path[:-len(get_base_name(file_path))]
+def if_not_last_child_join(path:str,child:str):
+    """
+    Adds a child path to the given path if it's not already present at the end.
+
+    Args:
+        path (str): The parent path.
+        child (str): The child path to add.
+    
+    Returns:
+        str: The updated path.
+    """
+    if path.endswith(child):
+        return path
+    return simple_path_join(path, child)
+def createFolds(ls: list) -> None:
+    """
+    Creates multiple directories.
+
+    Args:
+        ls (list): The list of directory paths to create.
+    """
+    for k in range(len(ls)):
+        mkdirs(ls[k])
+def list_directory_contents(path: str) -> list:
+    """Returns a list of directory contents or a list with a single file, if the path is a file.
+
+    Args:
+        path (str): The path of the directory or file.
+
+    Returns:
+        list: A list of directory contents or a list with a single file path.
+    """
+    if is_file(path):
+        return [path]
+    elif is_valid_path(path):
+        return os.listdir(path)
+    return [path]
+def is_string_in_dir(path,strings):
+    dirname =  path
+    if is_file(path):
+        dirname = os.path.dirname(path)
+    pieces = [pa for pa in dirname.split('/') if pa and pa in strings]
+    logger.info(f"pieces = {pieces}\nstrings == {strings}")
+    if pieces:
+        return True
+    return False
+def raw_create_dirs(*paths):
+    """Recursively create all directories along the given path."""
+    full_path = os.path.abspath(safe_join(*paths))
+    sub_parts = [p for p in full_path.split(os.sep) if p]
+
+    current_path = "/" if full_path.startswith(os.sep) else ""
+    for part in sub_parts:
+        current_path = safe_join(current_path, part)
+        os.makedirs(current_path, exist_ok=True)
+    return full_path
+mkdirs=raw_create_dirs
+makedirs = mkdirs
+make_dirs = makedirs
+

abstract_utilities/directory_utils/imports/__init__.py

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

abstract_utilities/directory_utils/imports/imports.py

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

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/directory_utils/name_utils.py

@@ -0,0 +1,43 @@
+from ..imports import *
+from .directory_utils import *
+def get_file_name(file_path: str) -> str:
+    """
+    Retrieves and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file (without extension).
+    """
+    return split_text(get_base_name(file_path))[0]
+def get_abs_name_of_this():
+    """
+    Returns the absolute name of the current module.
+
+    Returns:
+        Path: The absolute name of the current module.
+    """
+    return os.path.abspath(__name__)
+def sanitize_filename(name: str):
+    """
+    Sanitize a filename by removing invalid characters.
+    
+    Args:
+    name (str): Filename to sanitize.
+    
+    Returns:
+    str: Sanitized filename.
+    """
+    return re.sub(r'[\\/*?:"<>|]', "", name)
+def get_base_name(file_path: str) -> str:
+    """
+    Extracts and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file.
+    """
+    return os.path.basename(file_path)

abstract_utilities/directory_utils/size_utils.py

@@ -0,0 +1,57 @@
+from ..imports import *
+from .name_utils import *
+def get_os_info():
+    """
+    Get Operating System Information
+
+    This function retrieves information about the current operating system, including its name and bit size.
+
+    Returns:
+    - os_info (dict): A dictionary containing the operating system information.
+                      Keys:
+                      - "operating_system" (str): The name of the operating system (e.g., "Windows", "Linux", "Darwin").
+                      - "bit_size" (str): The bit size of the operating system (e.g., "32bit", "64bit").
+
+    Example:
+    os_info = get_os_info()
+    print("Operating System:", os_info["operating_system"])
+    print("Bit Size:", os_info["bit_size"])
+    """
+    os_name = platform.system()
+    bit_size = platform.architecture()[0]
+    return {"operating_system": os_name, "bit_size": bit_size}
+def mkGb(k) -> float:
+    """
+    Converts a value to Gigabytes (GB).
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB.
+    """
+    return float(float(k)*(10**9))
+
+def mkGbTrunk(k) -> float:
+    """
+    Converts a value to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(k), 5)
+
+def mkGbTrunFroPathTot(k) -> float:
+    """
+    Fetches the file size from a path, converts it to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (str): The file path.
+
+    Returns:
+        float: The file size converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(s.path.getsize(k)), 5)

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 *

abstract_utilities/directory_utils/src/directory_utils.py

@@ -0,0 +1,92 @@
+
+from .utils import *
+def get_dirs(path):
+    """
+    Get List of Immediate Subdirectories in a Path
+
+    This function uses the os.walk method to traverse through a directory tree and returns a list of immediate subdirectories
+    within the specified path.
+
+    Parameters:
+    - path (str): The path for which subdirectories need to be retrieved.
+
+    Returns:
+    - subdirectories (list): A list of immediate subdirectories within the specified path.
+
+    Example:
+    subdirs = get_dirs("/path/to/directory")
+    print("Immediate Subdirectories:", subdirs)
+    """
+    from os import walk
+    for (dirpath, dirnames, filenames) in walk(path):
+        return dirnames
+def get_directory(file_path: str) -> str:
+    """
+    Extracts and returns the directory path from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The directory path extracted from the file path.
+    """
+    return os.path.dirname(file_path)
+def if_not_last_child_join(path:str,child:str):
+    """
+    Adds a child path to the given path if it's not already present at the end.
+
+    Args:
+        path (str): The parent path.
+        child (str): The child path to add.
+    
+    Returns:
+        str: The updated path.
+    """
+    if path.endswith(child):
+        return path
+    return simple_path_join(path, child)
+def createFolds(ls: list) -> None:
+    """
+    Creates multiple directories.
+
+    Args:
+        ls (list): The list of directory paths to create.
+    """
+    for k in range(len(ls)):
+        mkdirs(ls[k])
+def list_directory_contents(path: str) -> list:
+    """Returns a list of directory contents or a list with a single file, if the path is a file.
+
+    Args:
+        path (str): The path of the directory or file.
+
+    Returns:
+        list: A list of directory contents or a list with a single file path.
+    """
+    if is_file(path):
+        return [path]
+    elif is_valid_path(path):
+        return os.listdir(path)
+    return [path]
+def is_string_in_dir(path,strings,**kwargs):
+    dirname =  path
+    if is_file(path,**kwargs):
+        dirname = os.path.dirname(path)
+    pieces = [pa for pa in dirname.split('/') if pa and pa in strings]
+    if pieces:
+        return True
+    return False
+def raw_create_dirs(*paths):
+    """Recursively create all directories along the given path."""
+    full_path = os.path.abspath(safe_join(*paths))
+    sub_parts = [p for p in full_path.split(os.sep) if p]
+
+    current_path = "/" if full_path.startswith(os.sep) else ""
+    for part in sub_parts:
+        current_path = safe_join(current_path, part)
+        os.makedirs(current_path, exist_ok=True)
+    return full_path
+mkdirs=raw_create_dirs
+makedirs = mkdirs
+make_dirs = makedirs
+

abstract_utilities/directory_utils/src/name_utils.py

@@ -0,0 +1,43 @@
+from ..imports import *
+from .directory_utils import *
+def get_file_name(file_path: str) -> str:
+    """
+    Retrieves and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file (without extension).
+    """
+    return split_text(get_base_name(file_path))[0]
+def get_abs_name_of_this():
+    """
+    Returns the absolute name of the current module.
+
+    Returns:
+        Path: The absolute name of the current module.
+    """
+    return os.path.abspath(__name__)
+def sanitize_filename(name: str):
+    """
+    Sanitize a filename by removing invalid characters.
+    
+    Args:
+    name (str): Filename to sanitize.
+    
+    Returns:
+    str: Sanitized filename.
+    """
+    return re.sub(r'[\\/*?:"<>|]', "", name)
+def get_base_name(file_path: str) -> str:
+    """
+    Extracts and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file.
+    """
+    return os.path.basename(file_path)