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

abstract_utilities/__init__.py

@@ -34,8 +34,7 @@ from .json_utils import (unified_json_loader,
                          get_result_from_data,
                          flatten_json
                          )
-from .read_write_utils import (read_from_file,
-                               write_to_file)
+
 from .directory_utils import *
 from .path_utils import *
 from .file_utils import *
@@ -84,7 +83,8 @@ from .type_utils import (make_bool,
                          get_numbers_comp,
                          is_any_instance,
                          break_string,
-                         MIME_TYPES
+                         MIME_TYPES,
+                         get_if_None
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -108,7 +108,8 @@ from .parse_utils import (num_tokens_from_string,
                           chunk_any_to_tokens,
                           detect_language_from_text,
                           chunk_by_language_context,
-                          search_code)
+                          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
@@ -119,3 +120,11 @@ from .path_utils import *
 from .file_utils import *
 from .string_utils import *
 from .import_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/class_utils/abstract_classes.py

@@ -26,47 +26,117 @@ def get_inputs(cls, *args, **kwargs):
     return cls(**values)
 
 
+from abstract_utilities 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,
+    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):
     """
-    Adapt the provided args/kwargs to fit the signature of func.
-    Returns (args, kwargs) suitable for calling func.
+    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
 
-    # Handle positional arguments
-    new_args = []
-    args_iter = iter(args)
-    for name, param in params.items():
-        if param.kind in (inspect.Parameter.POSITIONAL_ONLY,
-                          inspect.Parameter.POSITIONAL_OR_KEYWORD):
-            try:
-                new_args.append(next(args_iter))
-            except StopIteration:
-                break
-        elif param.kind == inspect.Parameter.VAR_POSITIONAL:
-            # collect all remaining args
-            new_args.extend(args_iter)
-            break
+    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:
-            break
-
-    # Handle keyword arguments
-    new_kwargs = {}
-    for name, param in params.items():
-        if name in kwargs:
-            new_kwargs[name] = kwargs[name]
-        elif param.default is inspect.Parameter.empty and param.kind == inspect.Parameter.KEYWORD_ONLY:
-            # Required keyword not provided
-            raise TypeError(f"Missing required keyword argument: {name}")
-
-    # Only include keywords func accepts
-    accepted_names = {
-        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 accepted_names}
+            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):

abstract_utilities/class_utils/caller_utils.py

@@ -1,4 +1,23 @@
 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.
@@ -33,3 +52,41 @@ def get_caller_dir(i: Optional[int] = None) -> str:
     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/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/class_utils/imports/imports.py

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

abstract_utilities/directory_utils/src/directory_utils.py

@@ -1,5 +1,21 @@
-
+from pathlib import Path
 from .utils import *
+
+def get_shortest_path(*args):
+    shortest = None
+    args = {arg:str(arg).split('/') for arg in args if arg}
+    for path,spl in args.items():
+        if shortest is None or (len(spl)<len(shortest[-1])):
+            shortest=[path,spl]
+    return shortest[0]
+def get_common_root(paths):
+    """
+    Compute the deepest common parent directory of all sysroots.
+    """
+    paths = [Path(p).resolve() for p in paths]
+    common = os.path.commonpath(paths)
+    return common
+
 def get_dirs(path):
     """
     Get List of Immediate Subdirectories in a Path
@@ -86,7 +102,9 @@ def raw_create_dirs(*paths):
         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
+makeAllDirs = raw_create_dirs
 

abstract_utilities/file_utils/imports/classes.py

@@ -50,19 +50,20 @@ def is_file(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isfile(path)
-    cmd = get_item_check_cmd(path,file=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isfile(path)
+        cmd = get_item_check_cmd(path,file=True)
+        return run_cmd(cmd=cmd,
+                user_at_host=user_at_host,
+                password=password,
+                key=key,
+                env_path=env_path,
+                **kwargs
+                )
 def is_dir(
     path,
     user_at_host=None,
@@ -71,34 +72,13 @@ def is_dir(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isdir(path)
-    cmd = get_item_check_cmd(path,file=False,directory=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
-def is_exists(
-    path,
-    user_at_host=None,
-    password=None,
-    key=None,
-    env_path=None,
-    **kwargs
-    ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        cmd = get_item_check_cmd(path,exists=True)
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isdir(path)
+        cmd = get_item_check_cmd(path,file=False,directory=True)
         return run_cmd(cmd=cmd,
                 user_at_host=user_at_host,
                 password=password,
@@ -106,7 +86,7 @@ def is_exists(
                 env_path=env_path,
                 **kwargs
                 )
-def is_any(
+def is_exists(
     path,
     user_at_host=None,
     password=None,
@@ -114,25 +94,49 @@ def is_any(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
-        for typ,cmd in out_js.items():
-            response = run_cmd(cmd=cmd,
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            cmd = get_item_check_cmd(path,exists=True)
+            return run_cmd(cmd=cmd,
                     user_at_host=user_at_host,
                     password=password,
                     key=key,
                     env_path=env_path,
                     **kwargs
                     )
-            result = "__OK__" in (response or "")
-            if result:
-                return typ
-    return None
+def is_any(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
+            for typ,cmd in out_js.items():
+                response = run_cmd(cmd=cmd,
+                        user_at_host=user_at_host,
+                        password=password,
+                        key=key,
+                        env_path=env_path,
+                        **kwargs
+                        )
+                result = "__OK__" in (response or "")
+                if result:
+                    return typ
+
 class PathBackend(Protocol):
     def join(self, *parts: str) -> str: ...
     def isfile(self, path: str) -> bool: ...

abstract_utilities/file_utils/imports/imports.py

@@ -8,10 +8,6 @@
 
 from ...imports import *
 from pathlib import Path
-
-
-
-
 from typing import *
 
 from typing import *

abstract_utilities/file_utils/imports/module_imports.py

@@ -4,5 +4,5 @@ from ...ssh_utils import *
 from ...env_utils import *
 from ...read_write_utils import read_from_file,write_to_file
 from ...log_utils import get_logFile
-from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
+from ...class_utils import if_none_default,if_none_change,get_caller,get_initial_caller_dir, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
 

abstract_utilities/file_utils/src/__init__.py

@@ -1,8 +1,7 @@
 from .file_filters import *
-from .filter_params import *
 from .map_utils import *
-from .pdf_utils import *
-from .file_reader import *
+from .reader_utils import *
 from .find_collect import *
+from .find_content import *
 from .initFunctionsGen import call_for_all_tabs,get_for_all_tabs
 

abstract_utilities/file_utils/src/file_filters/__init__.py

@@ -0,0 +1 @@
+from .ensure_utils import *