abstract-utilities 0.2.2.583__py3-none-any.whl → 0.2.2.627__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 *
@@ -108,7 +107,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 +119,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/caller_utils.py

@@ -17,6 +17,7 @@ def get_initial_caller_dir() -> str:
     """
     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.

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,27 +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(),typ=None):
-    
-    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)
 
+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/directory_utils/src/directory_utils.py

@@ -102,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/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_initial_caller_dir, 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/file_filters/ensure_utils.py

@@ -45,7 +45,9 @@ def ensure_directories(*args,**kwargs):
             dirname = os.path.dirname(arg_str)
             directories.append(dirname)
     safe_directories = get_dir_filter_kwargs(**kwargs)
-    directories+= make_list(safe_directories.get('directories',get_initial_caller_dir()))
+    safe_dirs = safe_directories.get('directories')
+    safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
+    directories+= make_list(safe_dirs)
     return list(set([r for r in directories if r]))
 def get_proper_type_str(string):
     if not string:

abstract_utilities/file_utils/src/file_filters/predicate_utils.py

@@ -1,16 +1,17 @@
 from .ensure_utils import *
-def get_allowed_predicate(allowed=None):
+def get_allowed_predicate(allowed=None,cfg=None,**kwargs):
     if allowed != False:
         if allowed == True:
             allowed = None
-        allowed = allowed or make_allowed_predicate()
+        allowed = allowed or make_allowed_predicate(cfg=cfg,**kwargs)
     else:
         def allowed(*args):
             return True
         allowed = allowed
     return allowed
-def get_globs(items,recursive: bool = True,allowed=None):
+def get_globs(items,recursive: bool = True,allowed=None,cfg=None,**kwargs):
     glob_paths = []
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
     items = [item for item in make_list(items) if item]
     for item in items:
         pattern = os.path.join(item, "**/*")  # include all files recursively\n
@@ -19,42 +20,43 @@ def get_globs(items,recursive: bool = True,allowed=None):
             nuItems = [nuItem for nuItem in nuItems if nuItem and allowed(nuItem)]
         glob_paths += nuItems
     return glob_paths
-def get_allowed_files(items,allowed=True):
-    allowed = get_allowed_predicate(allowed=allowed)
+def get_allowed_files(items,allowed=True,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
     return [item for item in items if item and os.path.isfile(item) and allowed(item)]
-def get_allowed_dirs(items,allowed=False):
-    allowed = get_allowed_predicate(allowed=allowed)
+def get_allowed_dirs(items,allowed=False,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
     return [item for item in items if item and os.path.isdir(item) and allowed(item)]
 
 def get_filtered_files(items,allowed=None,files = []):
-    allowed = get_allowed_predicate(allowed=allowed)
-    glob_paths = get_globs(items)
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
     return [glob_path for glob_path in glob_paths if glob_path and os.path.isfile(glob_path) and glob_path not in files and allowed(glob_path)]
-def get_filtered_dirs(items,allowed=None,dirs = []):
-    allowed = get_allowed_predicate(allowed=allowed)
-    glob_paths = get_globs(items)
+def get_filtered_dirs(items,allowed=None,dirs = [],cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
     return [glob_path for glob_path in glob_paths if glob_path and os.path.isdir(glob_path) and glob_path not in dirs and allowed(glob_path)]
 
-def get_all_allowed_files(items,allowed=None):
-    dirs = get_all_allowed_dirs(items)
-    files = get_allowed_files(items)
+def get_all_allowed_files(items,allowed=None,cfg=None,**kwargs):
+    dirs = get_all_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
+    files = get_allowed_files(items,allowed=allowed,cfg=cfg,**kwargs)
     nu_files = []
     for directory in dirs:
-        files += get_filtered_files(directory,allowed=allowed,files=files)
+        files += get_filtered_files(directory,allowed=allowed,files=files,cfg=cfg,**kwargs)
     return files
-def get_all_allowed_dirs(items,allowed=None):
-    allowed = get_allowed_predicate(allowed=allowed)
-    dirs = get_allowed_dirs(items)
+def get_all_allowed_dirs(items,allowed=None,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    dirs = get_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
     nu_dirs=[]
     for directory in dirs:
-        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs)
+        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs,cfg=cfg,**kwargs)
     return nu_dirs
 
-def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
+def make_allowed_predicate(cfg: ScanConfig=None,**kwargs) -> Callable[[str], bool]:
     """
     Build a predicate that returns True if a given path is considered allowed
     under the given ScanConfig. Applies allowed_* and exclude_* logic symmetrically.
     """
+    cfg=cfg or define_defaults(**kwargs)
     def allowed(path: str=None,p=None) -> bool:
         p = p or Path(path)
         name = p.name.lower()

abstract_utilities/file_utils/src/initFunctionsGen.py

@@ -1,8 +1,10 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from .find_collect import *
+from .find_collect import get_files_and_dirs
 from ..imports import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
 
 def caller_path():
     frame = inspect.stack()[1]
@@ -209,28 +211,37 @@ def get_for_all_tabs(root = None):
     root = root or caller_path()
     if os.path.isfile(root):
         root = os.path.dirname(root)
-    all_tabs = get_dirs(root = root)
+    all_tabs = get_files_and_dirs(root,allowed_patterns='*Tab')[0]
+    
     for ROOT in all_tabs:
-        FUNCS_DIR = ifFunctionsInFile(ROOT)
-        if FUNCS_DIR == None:
-            for ROOT in get_dirs(root = ROOT):
-                apply_inits(ROOT)
-        else: 
-            apply_inits(ROOT)
+        if os.path.isdir(ROOT):
+            [apply_inits(os.path.join(ROOT,func)) for func in os.listdir(ROOT) if 'functions'  == os.path.splitext(func)[0]]
+        
+      
             
 
 def apply_inits(ROOT):
-    FUNCS_DIR = ifFunctionsInFile(ROOT)
-
-    
-    if_fun_dir = isDir(FUNCS_DIR)
-    if if_fun_dir != None:
-        
-        if if_fun_dir:
-           filepaths = collect_filepaths(FUNCS_DIR,allowed_exts='.py',add=True)
+        filepaths=[ROOT]
+        TAB_DIR = os.path.dirname(ROOT)
+        INIT_FUNCS_PAPTH = os.path.join(TAB_DIR, "initFuncs.py")
+        if_fun_dir=False
+##        if os.path.isfile(ROOT):
+##            dirname= os.path.dirname(ROOT)
+##            basename= os.path.basename(ROOT)
+##            functions_dir = os.path.join(dirname,'functions')
+##            functions_path = os.path.join(functions_dir,basename)
+##            input(get_clean_imports(ROOT))
+##            
+##            os.makedirs(functions_dir,exist_ok=True)
+##            shutil.move(ROOT,functions_path)
+##            ROOT=functions_dir
+        if os.path.isdir(ROOT):
+            INIT_PATH = os.path.join(ROOT, "__init__.py")
             
-        else:
-            filepaths = [FUNCS_DIR]
+            filepaths = get_files_and_dirs(directory=ROOT,allowed_exts='py',add=True)[-1]
+            if_fun_dir=True
+    
+   
         
         # Parse top-level def names
         def extract_funcs(path: str):
@@ -240,7 +251,7 @@ def apply_inits(ROOT):
                 if m:
                     funcs.append(m.group(1))
             return funcs
-
+        
         # Build functions/__init__.py that re-exports all discovered functions
         import_lines = []
         all_funcs = []
@@ -252,7 +263,7 @@ def apply_inits(ROOT):
                 all_funcs.extend(funcs)
         if if_fun_dir:
             functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
-            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+            write_to_file(contents=functions_init, file_path=INIT_PATH)
 
         # Prepare the tuple literal of function names for import + loop
         uniq_funcs = sorted(set(all_funcs))
@@ -261,9 +272,10 @@ def apply_inits(ROOT):
         # Generate apiConsole/initFuncs.py using the safer setattr-loop
         init_funcs_src = textwrap.dedent(f"""\
             
-
+            
+            from abstract_utilities import get_logFile
             from .functions import ({func_tuple})
-
+            logger=get_logFile(__name__)
             def initFuncs(self):
                 try:
                     for f in ({func_tuple}):
@@ -273,8 +285,9 @@ def apply_inits(ROOT):
                 return self
         """)
 
-        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+        write_to_file(contents=init_funcs_src, file_path=INIT_FUNCS_PAPTH)
 
 def call_for_all_tabs():
     root = get_caller_dir(2)
+    
     get_for_all_tabs(root)

abstract_utilities/file_utils/src/initFunctionsGens.py

@@ -0,0 +1,280 @@
+# attach_functions.py  — single helper you can import anywhere
+# attach_dynamic.py
+from __future__ import annotations
+from .find_collect import *
+from ..imports import *
+
+def caller_path():
+    frame = inspect.stack()[1]
+    return os.path.abspath(frame.filename)
+def _is_defined_here(mod: types.ModuleType, obj: object) -> bool:
+    try:
+        return inspect.getmodule(obj) is mod
+    except Exception:
+        return False
+
+def _collect_callables(mod: types.ModuleType) -> Dict[str, Callable]:
+    out: Dict[str, Callable] = {}
+    names = getattr(mod, "__all__", None)
+    if names:
+        # trust the author's export list
+        for n in names:
+            fn = getattr(mod, n, None)
+            if callable(fn):
+                out[n] = fn
+        return out
+    # otherwise, discover top-level callables defined in this module
+    for n in dir(mod):
+        if n.startswith("_"):
+            continue
+        obj = getattr(mod, n, None)
+        if callable(obj) and _is_defined_here(mod, obj):
+            out[n] = obj
+    return out
+
+def _import_module_by_name(name: str) -> Optional[types.ModuleType]:
+    try:
+        return importlib.import_module(name)
+    except Exception:
+        return None
+
+def _import_module_by_path(pkg_name: str, base_dir: str, filename: str) -> Optional[types.ModuleType]:
+    mod_name = f"{pkg_name}.functions"
+    path = os.path.join(base_dir, filename)
+    spec = importlib.util.spec_from_file_location(mod_name, path)
+    if not spec or not spec.loader:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[mod_name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+def _walk_functions_package(pkg_name: str, pkg_mod: types.ModuleType) -> List[types.ModuleType]:
+    """Import all immediate submodules in the functions/ package."""
+    mods: List[types.ModuleType] = [pkg_mod]
+    pkg_dir = os.path.dirname(pkg_mod.__file__ or "")
+    for info in pkgutil.iter_modules([pkg_dir]):
+        # only import direct children (no recursion here; easy to add if you need)
+        child_name = f"{pkg_mod.__name__}.{info.name}"
+        m = _import_module_by_name(child_name)
+        if m:
+            mods.append(m)
+    return mods
+
+def _discover_functions(base_pkg: str, *, hot_reload: bool) -> List[Tuple[str, Callable, str]]:
+    """
+    Returns a list of (export_name, callable, module_basename).
+    Works if you have base_pkg.functions.py or base_pkg/functions/ package.
+    """
+    # Prefer normal import of '<base_pkg>.functions'
+    fqn = f"{base_pkg}.functions"
+    mod = _import_module_by_name(fqn)
+
+    if mod is None:
+        # fallback: sibling functions.py, even without being a package
+        base = _import_module_by_name(base_pkg)
+        if not base or not getattr(base, "__file__", None):
+            return []
+        base_dir = os.path.dirname(base.__file__)
+        if os.path.isfile(os.path.join(base_dir, "functions.py")):
+            mod = _import_module_by_path(base_pkg, base_dir, "functions.py")
+        else:
+            return []
+
+    if hot_reload:
+        try:
+            mod = importlib.reload(mod)  # type: ignore[arg-type]
+        except Exception:
+            pass
+
+    results: List[Tuple[str, Callable, str]] = []
+    modules: List[types.ModuleType]
+
+    if hasattr(mod, "__path__"):  # it's a package: import children
+        modules = _walk_functions_package(base_pkg, mod)
+    else:
+        modules = [mod]
+
+    for m in modules:
+        exported = _collect_callables(m)
+        module_basename = m.__name__.split(".")[-1]
+        for name, fn in exported.items():
+            results.append((name, fn, module_basename))
+    return results
+
+def attach_functions(
+    obj_or_cls,
+    base_pkg: str | None = None,
+    hot_reload: bool = True,
+    prefix_with_module: bool = False,
+    include_private: bool = True,
+    only_defined_here: bool = True,   # don't attach stuff imported from elsewhere
+) -> list[str]:
+    """
+    Attach all free functions found in <base_pkg>.functions (module or package)
+    to the *class* of obj_or_cls. Returns the list of attached attribute names.
+    """
+    cls = obj_or_cls if inspect.isclass(obj_or_cls) else obj_or_cls.__class__
+    # Derive "<package>.functions" from the class's module unless you pass base_pkg
+    caller_mod = cls.__module__
+    pkg_root = (base_pkg or caller_mod.rsplit(".", 1)[0]).rstrip(".")
+    funcs_pkg_name = f"{pkg_root}.functions"
+
+    def _import(name: str) -> ModuleType | None:
+        try:
+            if hot_reload and name in sys.modules:
+                return importlib.reload(sys.modules[name])
+            return importlib.import_module(name)
+        except Exception:
+            return None
+
+    def _is_pkg(m: ModuleType) -> bool:
+        return hasattr(m, "__path__")
+
+    mod = _import(funcs_pkg_name)
+    if mod is None:
+        # Nothing to attach (no functions.py or functions/ next to your class)
+        setattr(cls, "_attached_functions", tuple())
+        return []
+
+    modules: list[ModuleType] = [mod]
+    if _is_pkg(mod):
+        # attach from every submodule under functions/
+        for it in pkgutil.iter_modules(mod.__path__):
+            sub = _import(f"{funcs_pkg_name}.{it.name}")
+            if sub is not None:
+                modules.append(sub)
+
+    attached: list[str] = []
+    for m in modules:
+        for name, obj in vars(m).items():
+            # only callables (skip classes), and keep them sane
+            if not callable(obj) or isinstance(obj, type):
+                continue
+            if only_defined_here and getattr(obj, "__module__", None) != m.__name__:
+                continue
+            if not include_private and name.startswith("_"):
+                continue
+            if name.startswith("__") and name.endswith("__"):
+                continue
+            attr = f"{m.__name__.rsplit('.', 1)[-1]}__{name}" if prefix_with_module else name
+            try:
+                setattr(cls, attr, obj)  # set on CLASS → becomes bound method on instances
+                attached.append(attr)
+            except Exception:
+                # don't explode if one name collides; keep going
+                continue
+
+    # handy for debugging
+    try:
+        setattr(cls, "_attached_functions", tuple(attached))
+    except Exception:
+        pass
+    return attached
+
+
+
+
+def isTab(item):
+    item_lower =  item.lower()
+    for key in ['console','tab']:
+        if item_lower.endswith(key):
+            return True
+    return False
+def get_dir(root,item):
+    if None in [root]:
+        return None
+    path = root
+    if item != None:
+        path = os.path.join(path,item)
+    return path
+def isDir(root,item=None):
+    path = get_dir(root,item)
+    if path:
+        return os.path.isdir(path)
+def check_dir_item(root,item=None):
+    return (item and isTab(item) and isDir(root,item))
+def get_dirs(root = None):
+    root = root or ABSROOT
+    dirpaths = [get_dir(root,item) for item in os.listdir(root) if check_dir_item(root,item)]
+    return dirpaths
+def ifFunctionsInFile(root):
+    items = [os.path.join(root, "functions"),os.path.join(root, "functions.py")]
+    for item in items:
+        if os.path.exists(item):
+            return item
+        
+
+def get_for_all_tabs(root = None):
+    root = root or get_initial_caller_dir()
+    if os.path.isfile(root):
+        root = os.path.dirname(root)
+    all_tabs = get_dirs(root = root)
+    for ROOT in all_tabs:
+        FUNCS_DIR = ifFunctionsInFile(ROOT)
+        if FUNCS_DIR == None:
+            for ROOT in get_dirs(root = ROOT):
+                apply_inits(ROOT)
+        else: 
+            apply_inits(ROOT)
+            
+
+def apply_inits(ROOT):
+    FUNCS_DIR = ifFunctionsInFile(ROOT)
+
+    
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:
+        
+        if if_fun_dir:
+           filepaths = collect_filepaths(FUNCS_DIR,allowed_exts='.py',add=True)
+            
+        else:
+            filepaths = [FUNCS_DIR]
+        
+        # Parse top-level def names
+        def extract_funcs(path: str):
+            funcs = []
+            for line in read_from_file(path).splitlines():
+                m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+                if m:
+                    funcs.append(m.group(1))
+            return funcs
+
+        # Build functions/__init__.py that re-exports all discovered functions
+        import_lines = []
+        all_funcs = []
+        for fp in filepaths:
+            module = os.path.splitext(os.path.basename(fp))[0]
+            funcs = extract_funcs(fp)
+            if funcs:
+                import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+                all_funcs.extend(funcs)
+        if if_fun_dir:
+            functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+
+        # Prepare the tuple literal of function names for import + loop
+        uniq_funcs = sorted(set(all_funcs))
+        func_tuple = ", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+        
+        # Generate apiConsole/initFuncs.py using the safer setattr-loop
+        init_funcs_src = textwrap.dedent(f"""\
+            
+            from abstract_utilities import get_logFile
+            from .functions import ({func_tuple})
+            logger=get_logFile(__name__)
+            def initFuncs(self):
+                try:
+                    for f in ({func_tuple}):
+                        setattr(self, f.__name__, f)
+                except Exception as e:
+                    logger.info(f"{{e}}")
+                return self
+        """)
+
+        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+
+def call_for_all_tabs():
+    root = get_initial_caller_dir()
+    get_for_all_tabs(root)

abstract_utilities/import_utils/imports/module_imports.py

@@ -1,6 +1,6 @@
 from ...read_write_utils import read_from_file,write_to_file,get_text_or_read
 from ...string_utils import eatAll,eatInner,eatElse,clean_line
-from ...class_utils import get_caller_path,get_caller_dir,if_none_default,get_initial_caller_dir
+from ...class_utils import if_none_change,if_none_default,get_true_globals,get_initial_caller_dir,get_caller_path,get_caller_dir,if_none_default
 from ...list_utils import make_list
 from ...path_utils import get_file_parts
 from ...type_utils  import is_number,make_list

abstract_utilities/import_utils/src/extract_utils.py

@@ -40,7 +40,7 @@ def extract_class(path: str):
         if m:
             funcs.append(m.group(1))
     return funcs
-def get_all_py_file_paths(*args,**kwargs):
-    globs = collect_globs(*args,allowed_exts='.py',**kwargs)
+def get_all_py_file_paths(directory,*args,**kwargs):
+    globs = collect_globs(directory,*args,allowed_exts='.py',**kwargs)
     globs = [glo for glo in globs.get('files') if glo]
     return globs

abstract_utilities/import_utils/src/import_functions.py

@@ -56,22 +56,17 @@ def dynamic_import(module_path: str, namespace: dict, all_imports = None):
         from module_path import *
     but includes private (_xxx) names too.
     """
-    all_imports = if_none_default(all_imports,True,typ=bool)
+    all_imports = if_none_change(all_imports,True)
     if module_path:
         module = importlib.import_module(module_path)
-
         # Import literally everything except dunders, unless you want them too.
         names = [n for n in dir(module) if n and ((not all_imports and not n.startswith("_")) or all_imports)]
-
-
         for name in names:
             namespace[name] = getattr(module, name)
-
         return module
-
-
 def get_monorepo_root(directory=None,files=None):
     directory = directory or get_initial_caller_dir()
+    
     py_files = get_all_py_file_paths(directory,add=True)
     sysroots = get_all_py_sysroots(directory=directory,files=py_files)
     monorepo_root = get_common_root(sysroots)
@@ -80,12 +75,36 @@ def switch_to_monorepo_root(directory=None,files=None):
     monorepo_root = get_monorepo_root(directory=directory,files=files)
     if str(monorepo_root) not in sys.path:
         sys.path.insert(0, str(monorepo_root))
-def get_all_imports(directory=None,sysroot=None):
-    sysroot = sysroot or get_initial_caller_dir()
-    directory = directory or sysroot
-    files = get_py_files(directory=directory)
-    switch_to_monorepo_root(directory=directory,files=files)
-    for glo in [glo for glo in globs.get('files') if glo]:
+    return str(monorepo_root)
+def get_all_imports(directory=None,sysroot=None,globs=None):
+    globs = globs or get_true_globals() or globals()
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory,allowed_exts='.py').get('files')
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory,files=files)
+    for glo in files:
         imp = get_import_with_sysroot(glo, sysroot)
-        dynamic_import(imp, globals())
+        dynamic_import(imp, globs)
+def get_all_imports_for_class(self, directory=None, sysroot=None, include_private=True):
+    """
+    Load all modules under `directory` and assign their exports as attributes
+    on the class instance (self).
+    """
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory, allowed_exts='.py').get("files")
+
+    # Compute sysroot (monorepo root)
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory, files=files)
+
+    for glo in files:
+        mod_path = get_import_with_sysroot(glo, sysroot)
+        module = importlib.import_module(mod_path)
+
+        for name in dir(module):
+            if name.startswith("__"):
+                continue
+            if not include_private and name.startswith("_"):
+                continue
+
+            setattr(self, name, getattr(module, name))
 
+    return self

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -2,7 +2,7 @@ from ..imports import *
 from .dot_utils import *
 from .extract_utils import get_all_py_file_paths
 def get_py_files(directory=None):
-    directory = directory or get_caller_dir(2)
+    directory = directory or get_initial_caller_dir()
     return get_all_py_file_paths(directory,add=True)
 def ensure_on_path(p: Path):
     s = str(p)

abstract_utilities/log_utils/log_file.py

@@ -1,42 +1,90 @@
 from .imports import *
-def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+import os, sys, inspect, logging
+from logging.handlers import RotatingFileHandler
+
+PACKAGE_NAME = "abstract_utilities"   # ← update if needed
+
+
+def _resolve_log_root():
     """
-    If bpName is None, use the “caller module’s basename” as the logger name.
-    Otherwise, use the explicitly provided bpName.
+    Returns a safe writable logging directory depending on environment:
+    - If running in a virtualenv → <venv>/.logs/<package>
+    - Else if user writable → ~/.cache/<package>/logs
+    - Else → /var/log/<package>
+    """
+    # 1) Virtualenv or Conda environment
+    venv = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
+    if venv:
+        root = os.path.join(venv, ".logs", PACKAGE_NAME)
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    # 2) User home cache folder
+    home = os.path.expanduser("~")
+    user_cache_root = os.path.join(home, ".cache", PACKAGE_NAME, "logs")
+    try:
+        os.makedirs(user_cache_root, exist_ok=True)
+        return user_cache_root
+    except PermissionError:
+        pass
+
+    # 3) Last resort: system log dir (requires correct service user permissions)
+    system_root = f"/var/log/{PACKAGE_NAME}"
+    try:
+        os.makedirs(system_root, exist_ok=True)
+        return system_root
+    except PermissionError:
+        # Fail-safe fallback to /tmp
+        fallback = f"/tmp/{PACKAGE_NAME}/logs"
+        os.makedirs(fallback, exist_ok=True)
+        return fallback
+
+
+LOG_ROOT = _resolve_log_root()
+
+
+def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
+    """
+    A logger that always writes to a safe OS-appropriate path.
+    Works even when installed through pip.
     """
     if bpName is None:
-        # Find the first frame outside logging_utils.py
         frame_idx = _find_caller_frame_index()
         frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename  # e.g. "/home/joe/project/app/routes.py"
+        caller_path = frame_info.filename
         bpName = os.path.splitext(os.path.basename(caller_path))[0]
         del frame_info
 
-
-
-    logger = logging.getLogger(bpName)
+    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
     logger.setLevel(logging.INFO)
 
     if not logger.handlers:
-        try:
-            log_dir = mkdirs("logs")
-            log_path = os.path.join(log_dir, f"{bpName}.log")
-            handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
-            handler.setLevel(logging.INFO)
-
-            fmt = "%(asctime)s - %(levelname)s - %(pathname)s - %(message)s"
-            formatter = logging.Formatter(fmt)
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-
-            console = logging.StreamHandler()
-            console.setLevel(logging.INFO)
-            console.setFormatter(formatter)
-            logger.addHandler(console)
-        except Exception as e:
-            print(f"{e}")
+        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
+        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+
+        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
+        formatter = logging.Formatter(fmt)
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        # Console handler (optional; can disable for gunicorn)
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(formatter)
+        logger.addHandler(console)
+
     return logger
 
+
+def _find_caller_frame_index():
+    """Find the correct caller module outside this logger."""
+    for idx, frame_info in enumerate(inspect.stack()):
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        if module and module.__name__ not in (__name__, "logging"):
+            return idx
+    return 1
 def _find_caller_frame_index():
     """
     Scan up the call stack until we find a frame whose module is NOT logging_utils.

abstract_utilities/parse_utils/parse_utils.py

@@ -64,6 +64,29 @@ def detect_language_from_text(text: str):
 
     likely = [lang for lang, score in scores.items() if score == max_score]
     return likely[0] if len(likely) == 1 else 'uncertain'
+def get_tripple_string(string):
+    nustring = ''
+    for i in range(3):
+        nustring +=string
+    return nustring
+def get_within_quotes(text,quotes=None):
+    quotes_strings = quotes or ["'",'"']
+    in_quotes = []
+    for quotes_string in quotes_strings:
+        if not isinstance(quotes_string,list):
+            tripple= get_tripple_string(quotes_string)
+            texts = [text]
+            if tripple in text:
+                texts= text.split(tripple)
+            for text_part in texts:
+                quote_count = len(text_part) - len(text_part.replace(quotes_string,''))
+                quote_spl = text_part.split(quotes_string)
+                in_quotes+=[quote_spl[i] for i in range(quote_count) if ((i == 1 or i%2 != float(0)) and len(quote_spl) > i)]
+        else:
+            texts= text.split(quotes_string[0])
+            for text in texts:
+                in_quotes.append(text.split(quotes_string[1])[0])
+    return in_quotes
 
 def search_code(code_languages, parts):
     return [data for datas in parts for data in make_list(datas)

abstract_utilities/read_write_utils/imports/imports.py

@@ -1,2 +1,2 @@
 from ...imports import os,shlex
-
+import base64

abstract_utilities/read_write_utils/read_write_utils.py

@@ -194,44 +194,112 @@ def write_to_path(
 ##        f.write(str(contents))
 ##    return file_path
 # --- Core functionality -------------------------------------------------------
-def write_to_file(*args, **kwargs):
+##def write_to_file(*args, **kwargs):
+##    """
+##    Write contents to a file (create if missing).
+##
+##    Returns the file_path written.
+##    """
+##    file_path, contents = check_read_write_params(*args, **kwargs)
+##    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
+##    dirname = os.path.dirname(file_path)
+##    
+##    if contents is None:
+##        raise ValueError("Missing contents to write.")
+##    user_at_host = kwargs.get("user_at_host")
+##    if get_user_pass_host_key(**kwargs):
+##        make_dirs(dirname, exist_ok=True,**kwargs)
+##        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
+##        # sanitize for shell safety
+##        quoted_path = shlex.quote(file_path)
+##        quoted_data = shlex.quote(str(contents))
+##        # shell command that fully overwrites
+##        # (no append, replaces contents entirely)
+##        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
+##        if not kwargs.get('password') and not kwargs.get('key'):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##        result = run_pruned_func(run_cmd,**kwargs)
+##        if 'file_path' in kwargs:
+##            del kwargs['file_path']
+##        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##            result = run_pruned_func(run_cmd,**kwargs)
+##        return result
+##
+##    make_dirs(dirname or ".", exist_ok=True)
+##    with open(file_path, "w", encoding="utf-8") as f:
+##        f.write(str(contents))
+##    return file_path
+
+def _should_use_remote(**kwargs) -> bool:
+    """
+    Only use remote mode IF:
+    - user_at_host is provided
+    - AND password/key is provided
+    Otherwise: local write.
     """
-    Write contents to a file (create if missing).
+    user = kwargs.get("user_at_host")
+    if not user:
+        return False  # not remote
 
-    Returns the file_path written.
+    # If user_at_host is provided, then password or key MUST be present
+    if kwargs.get("password") or kwargs.get("key"):
+        return True
+
+    return False  # user provided but no auth → treat as local
+
+
+def _write_to_file(contents: str, file_path: str, **kwargs) -> str:
     """
-    file_path, contents = check_read_write_params(*args, **kwargs)
-    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
+    Universal safe writer for any file content.
+    Works locally and remotely without breaking quotes.
+    """
+
+    # --- Decode mode selection ---
+    remote = _should_use_remote(**kwargs)
+
+    # Create directory path
     dirname = os.path.dirname(file_path)
-    
-    if contents is None:
-        raise ValueError("Missing contents to write.")
-    user_at_host = kwargs.get("user_at_host")
-    if get_user_pass_host_key(**kwargs):
-        make_dirs(dirname, exist_ok=True,**kwargs)
-        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
-        # sanitize for shell safety
-        quoted_path = shlex.quote(file_path)
-        quoted_data = shlex.quote(str(contents))
-        # shell command that fully overwrites
-        # (no append, replaces contents entirely)
-        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
-        if not kwargs.get('password') and not kwargs.get('key'):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-        result = run_pruned_func(run_cmd,**kwargs)
-        if 'file_path' in kwargs:
-            del kwargs['file_path']
-        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-            result = run_pruned_func(run_cmd,**kwargs)
-        return result
+    make_dirs(dirname, exist_ok=True, **kwargs)
+
+    # Base64 encoding ensures zero escaping issues
+    b64 = base64.b64encode(contents.encode("utf-8")).decode("utf-8")
 
-    make_dirs(dirname or ".", exist_ok=True)
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(str(contents))
-    return file_path
+    # Build decode + tee command
+    cmd = (
+        f"echo '{b64}' | base64 -d | "
+        f"sudo tee {shlex.quote(file_path)} > /dev/null"
+    )
 
+    # --- Local write ---
+    if not remote:
+        return run_pruned_func(
+            run_local_cmd,
+            cmd=cmd,
+            **kwargs
+        )
+
+    # --- Remote write ---
+    return run_pruned_func(
+        run_remote_cmd,
+        user_at_host=kwargs["user_at_host"],
+        cmd=cmd,
+        **kwargs
+    )
+
+
+def write_to_file(*, contents: str, file_path: str, **kwargs):
+    """
+    Error-handled wrapper.
+    """
+
+    try:
+        result = _write_to_file(contents=contents, file_path=file_path, **kwargs)
+        return result
 
+    except Exception as e:
+        print("WRITE ERROR:", e)
+        raise RuntimeError(f"Failed writing: {file_path}")
 def read_from_file(file_path,**kwargs):
     if get_user_pass_host_key(**kwargs):
         kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)

{abstract_utilities-0.2.2.583.dist-info → abstract_utilities-0.2.2.627.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.583
+Version: 0.2.2.627
 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.583.dist-info → abstract_utilities-0.2.2.627.dist-info}/RECORD

@@ -1,4 +1,4 @@
-abstract_utilities/__init__.py,sha256=bxnmLWA_YHxc5SVsaKr4uPzMhYLKCI3iKBITJEJzmQw,4933
+abstract_utilities/__init__.py,sha256=YfuG1LFHMOGUuxDyDzq24gfmeAvErfyGaUu8X6nyjfA,5220
 abstract_utilities/abstract_classes.py,sha256=A6-FNDQb2P_jcyt01Kc5SuY2QawLVKNjQ-rDGfsn4rA,2461
 abstract_utilities/circular_import_finder.py,sha256=bs1O4NjSDrJ2cC8whPfZPouNDr1oxdMCFKUIfRyIEB4,8415
 abstract_utilities/circular_import_finder2.py,sha256=n6OFjiIsxxw2u_bf8wcQ81fzQzXhsD4VYWzOC9pDYXw,3869
@@ -28,10 +28,10 @@ abstract_utilities/type_utils.py,sha256=XaaAel9hUKeOzBqSCqJsIC6UiPMXUlhtmU77jOHz
 abstract_utilities/utils.py,sha256=SCa_-x_wsWrcokQXKwlhalxndxLn5Wg25-zqRdJUmag,185049
 abstract_utilities/class_utils/__init__.py,sha256=FbEui_psjSFhwwYkyKEGePbLVij8GZOm69nGBnx-Zfc,196
 abstract_utilities/class_utils/abstract_classes.py,sha256=2qgVUiI1O_7gNYJAk5eb32IaHtULIXo0OasLGb045E8,2470
-abstract_utilities/class_utils/caller_utils.py,sha256=87BEuyEDJ_TmrQ-aI10w5QSMqy4YBVlcbjLhByDJzlo,1515
+abstract_utilities/class_utils/caller_utils.py,sha256=QFbMBBQMPkIHMrN0zEUINp4ODk8IwNIvoSyC1gMemmU,1516
 abstract_utilities/class_utils/class_utils.py,sha256=An-pTLzvDb7WPB2JZoEm2MEDops5HrWPNlR6dco6h5g,4033
 abstract_utilities/class_utils/function_utils.py,sha256=sP_qSrWGhvzU2XoWGk9Np1B4WPUpzrSf1f0Ywu6bzt0,5775
-abstract_utilities/class_utils/global_utils.py,sha256=dg1VhtMXGjuwlWLdvTZPaIJ_lmRiuKhL0Y7e6cREero,2257
+abstract_utilities/class_utils/global_utils.py,sha256=ZIX4i4dvoA36njUn9PVhuJj0koeVyM0BIcZHi8DJzFQ,2908
 abstract_utilities/class_utils/module_utils.py,sha256=EumlwSc5PJZwqqcFEzMOCtsFJUHNuqEQAJGJlywuqyY,1516
 abstract_utilities/class_utils/imports/__init__.py,sha256=LVIEQXKiAmaKKWxPxfSJKe7JGWi4RDt4eatm_VG-WUI,44
 abstract_utilities/class_utils/imports/imports.py,sha256=_F7UpONRaGnFNNUYH-baSv4H5NQXQOZeD-jW3pSoiiA,87
@@ -55,7 +55,7 @@ abstract_utilities/directory_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb
 abstract_utilities/directory_utils/imports/imports.py,sha256=R7rno0pnzOU9XpzPhco0Wp9aIR73w_BGqCLdYpAHowI,32
 abstract_utilities/directory_utils/imports/module_imports.py,sha256=v9jovq8n9EOS9lmjRonYu4pdKEDS-mw4ejgtRrAGYX0,69
 abstract_utilities/directory_utils/src/__init__.py,sha256=cKlenOq451R2VqV86AD5ZEh1qGX5FfJwwsohgL0fQU4,104
-abstract_utilities/directory_utils/src/directory_utils.py,sha256=DkFeLY_AMNWm57xdupXj5aSq0alff0tSsBYJSEsp-Co,3240
+abstract_utilities/directory_utils/src/directory_utils.py,sha256=3uuiGfC_P_K6Cue4BBdSgxBZQDU4vozButm8yhJ1d_k,3271
 abstract_utilities/directory_utils/src/name_utils.py,sha256=Lz4RoeI9Ux6CC4I7UCZj7K6GoIm4HpYeRyjJl9b_6FY,1136
 abstract_utilities/directory_utils/src/size_utils.py,sha256=6huRLt-UGhukGfq-3KtBM5qH_SjNCaBzWVP9Vc-EiiU,1758
 abstract_utilities/directory_utils/src/utils.py,sha256=FIxL_HcIoL0PzE6G7_qcgCNcelxX33J76gzkXJo3VUg,3206
@@ -94,7 +94,7 @@ abstract_utilities/file_utils/imports/clean_imps.py,sha256=DB_NEKR8YLla5qCkTMuNs
 abstract_utilities/file_utils/imports/constants.py,sha256=uPsIYVRs1Rf0SQ4pRdAke-tuc28LtgaSHSDS4_seaMk,5997
 abstract_utilities/file_utils/imports/file_functions.py,sha256=brQha7TV9DaJe-hZSuHoFZBUI_45hxrGOIBTAojPWU8,297
 abstract_utilities/file_utils/imports/imports.py,sha256=OQKsPec2raa55hxGUeTo0yDqzw-xBsshljFxG69rHk0,1504
-abstract_utilities/file_utils/imports/module_imports.py,sha256=e8BuZVLZnq4Dp6BnTe43omOLSGId1rnc7MfB91mBpeU,389
+abstract_utilities/file_utils/imports/module_imports.py,sha256=Mol48vj-m2204MCJgStUyAw8DbH-HFVs21rnGpx5HyI,420
 abstract_utilities/file_utils/src/__init__.py,sha256=kgjkZ6IWDR_fQJTAQTinUBKUPLurekgdZ15ZT1wm20E,203
 abstract_utilities/file_utils/src/file_filters.py,sha256=n8efrxxJRRd6dT4E5PbGoyGGKe1LU1cYy-b443XhqAo,6355
 abstract_utilities/file_utils/src/file_reader.py,sha256=9fZ2dEXFRYhJNUsUYQO3hGs2uWrHu2o4FacVhfhdefE,22320
@@ -102,15 +102,16 @@ abstract_utilities/file_utils/src/file_utils.py,sha256=jgxMKeOAhYB2dxoqtudo4DKXc
 abstract_utilities/file_utils/src/filter_params.py,sha256=tO5PJvYpd3bHQejulDVGHandR-_8w3VPnjiCayrLW9g,6774
 abstract_utilities/file_utils/src/find_collect.py,sha256=wV6u9AsVeJxMCHwyf3NGvzA-QbA_OgLRfQUhjSrLjew,5796
 abstract_utilities/file_utils/src/find_content.py,sha256=3UI8HsTHR0UnuqybeYW4rxHvER7-SK42_hNZih-LfUU,6806
-abstract_utilities/file_utils/src/initFunctionsGen.py,sha256=enTZA5hEYiBdOgM3yZoEEOyWaoxv66K1g-RrwIhPdIE,9692
+abstract_utilities/file_utils/src/initFunctionsGen.py,sha256=WyWv3Gt33QzvI8IxZCGLqAqsramAyoRbpvMTiuJeSTE,10418
+abstract_utilities/file_utils/src/initFunctionsGens.py,sha256=A-I2dL2G58LfpCSI6c_aLbDtAsYvG0wwY37joYnqGcw,9804
 abstract_utilities/file_utils/src/map_utils.py,sha256=7GYntXbMz3vYrXWE-TxLuZRcQudlDA6vAWGErzVv1mk,1044
 abstract_utilities/file_utils/src/pdf_utils.py,sha256=F-xzOMFK7Um_7ODTqJ8MsdgAOyupi1ijuB1zHv76bUw,10336
 abstract_utilities/file_utils/src/type_checks.py,sha256=THVaH23DYdPYuj6baC-KJOfWDsfEqWqxsVa_N7e8aEI,2890
 abstract_utilities/file_utils/src/file_filters/__init__.py,sha256=sHdfkZ6JrSlK8I6sNrzbGEUGz0ZUDTnFmXwaBMNxNLY,116
-abstract_utilities/file_utils/src/file_filters/ensure_utils.py,sha256=yKYaKkHiMct8aU8ENw8Ab4L4hWr5ziLaKh8uk1-UKjc,4192
+abstract_utilities/file_utils/src/file_filters/ensure_utils.py,sha256=JrJZPaoh9K5rD_DDA1r-az4lLgv_gcoBvKpUfNYAWdI,4268
 abstract_utilities/file_utils/src/file_filters/filter_params.py,sha256=RazBjD0Zl4fjXvmXl0YUrqAacwKn8w1EUaqKqunTB9Y,2993
 abstract_utilities/file_utils/src/file_filters/filter_utils.py,sha256=epi9V1OkYDAJb2O5LzkqQBtBoDtkCidGBvuXsUFCxaw,2916
-abstract_utilities/file_utils/src/file_filters/predicate_utils.py,sha256=sy1QR701j-i35aJ9D8okGdoHqPZfFCpUnOPA8kQAPDw,4489
+abstract_utilities/file_utils/src/file_filters/predicate_utils.py,sha256=E5JEfl0ytbBF3AvlR1WVhS7QRtwc1YKqVNB6md1rfpI,5040
 abstract_utilities/file_utils/src/reader_utils/__init__.py,sha256=GLUNbm2lK_2ZVk9EGQ6KNr5k1NR52tT3QBhzH93FqWo,112
 abstract_utilities/file_utils/src/reader_utils/directory_reader.py,sha256=qHZuhwIsrVkJkFT8kFwzkCH-6kmR1hyr7TFAGg9vcOw,2366
 abstract_utilities/file_utils/src/reader_utils/file_reader.py,sha256=FwDFIGCz5mMksvmLFJSkTLS2evBkUnN0kND7E_9b45g,22292
@@ -151,17 +152,17 @@ abstract_utilities/import_utils/circular_import_finder2.py,sha256=n6OFjiIsxxw2u_
 abstract_utilities/import_utils/imports/__init__.py,sha256=hiUo2P3qSWtgQHPdz5b2pe2AI3QXZlKJUSe2NUW5Cd4,99
 abstract_utilities/import_utils/imports/constants.py,sha256=UCSr0_KTu7atqanliMEv8u-XKjM4x0wdm4oySOK7APc,42
 abstract_utilities/import_utils/imports/imports.py,sha256=Qc9IoIDAJUuNOQJqZbOEqQfGI45EVhBBeuTm61K6PvI,143
-abstract_utilities/import_utils/imports/module_imports.py,sha256=EMx9NyQLrQhguqfglkZXMGJovBli_jacFl5r1lIqAuY,486
+abstract_utilities/import_utils/imports/module_imports.py,sha256=HrMpc0o4kBhbvxHyKZqbQ1U4LK03zaLJaLqMRg6LO9w,534
 abstract_utilities/import_utils/imports/utils.py,sha256=wgTzs8SpOe8jVdw0cCPNypYCo2X-BreeJuNW3N3_d8Q,961
 abstract_utilities/import_utils/src/__init__.py,sha256=KPF8T-ZQae2st8EKR7qIAt1jENGlQkwHRJDC8uupm48,197
 abstract_utilities/import_utils/src/clean_imports.py,sha256=awpVFI-DMd8oOtx3JcUiz4xbOdhLE4X04ZwdMKR1mMU,10447
 abstract_utilities/import_utils/src/dot_utils.py,sha256=oahEkVmexO-a2F3DKYQP5IrCvKJi9tjM_rjCImM_KCY,2793
-abstract_utilities/import_utils/src/extract_utils.py,sha256=j3jTBqRxHqso5730usAUmtQ8bplLbMg3uLp4aDFrBaw,1685
-abstract_utilities/import_utils/src/import_functions.py,sha256=2SXRcmixbyW61ujMKsmJt_o0Qi2o0HBSh-Smjv4hay4,3486
+abstract_utilities/import_utils/src/extract_utils.py,sha256=YuDVWbCKDrVDh9M7aZHdsrEoh_infJ3BUv46J6K-UYg,1705
+abstract_utilities/import_utils/src/import_functions.py,sha256=5GxFh32e-DWDZ5IR-LnQTOiEmv15tjb3Fn_yhgnu7q8,4408
 abstract_utilities/import_utils/src/import_utils.py,sha256=NvryqWqsoyufTKYEoGgnorl9awRbgVWcOroHJza_srM,11827
 abstract_utilities/import_utils/src/package_utils.py,sha256=9qjBzIApDhV7kOdSRgZA9k-EncBNAg3mZZodgsiUNM4,5861
 abstract_utilities/import_utils/src/pkg_utils.py,sha256=tSLaqFgitwswSuGhv-UnONT3rpri9DjK9ALt_0t5I30,7617
-abstract_utilities/import_utils/src/sysroot_utils.py,sha256=hn_24Ug4hs0na84YI1suCUbhzBY1rAXEEIKZfmVHqRY,3689
+abstract_utilities/import_utils/src/sysroot_utils.py,sha256=k9sNVvp3zYrPV62rsaFLfCzXhaIQc61XJreog0RvOIc,3696
 abstract_utilities/import_utils/src/package_utils/__init__.py,sha256=xV_XKJSLcXf4qRQSRseWLV_iqCqijPm4zvrs-tjNb2M,4618
 abstract_utilities/import_utils/src/package_utils/context_utils.py,sha256=8USSB6LR047k8fqge8J2jEM_StPEZ3cI1OKB3UENN8w,1177
 abstract_utilities/import_utils/src/package_utils/import_collectors.py,sha256=kueQead4CW6FGmHHiXpQilE8spbnt2mSK93dJ3bpeW4,2365
@@ -185,7 +186,7 @@ abstract_utilities/list_utils/imports/module_imports.py,sha256=47DEQpj8HBSa-_TIm
 abstract_utilities/log_utils/__init__.py,sha256=QzmY8RLyegJsq9Id06dHMiJAit5jxUzwhkY5-qgqxBU,141
 abstract_utilities/log_utils/abstractLogManager.py,sha256=EF4GkNbeCUh_RStN2Sf_PmxgyUmxeB5RJT7P-SHGZ3w,2823
 abstract_utilities/log_utils/call_response.py,sha256=E_QdT6R5REuXxeUuEXLwjUh8D0Lk0vair2ryRj4zocY,2518
-abstract_utilities/log_utils/log_file.py,sha256=n6-Hb_3fVG3pZuuMiBrpFKW_pZB4W01y3j_w76dsbY0,2363
+abstract_utilities/log_utils/log_file.py,sha256=5W3Ia5RLGho6WbQNnqZTmQbRiEzUqGYIMlbEyzKElQg,3769
 abstract_utilities/log_utils/logger_callable.py,sha256=9STZtZrmUlXmakxhwmXNPpCSQC10aCTMNjXbhaWZ7_8,1629
 abstract_utilities/log_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
 abstract_utilities/log_utils/imports/imports.py,sha256=TGhATFGyhvovFFKYH-CbCnEQK0WCkmA1C5LqvmmzlrQ,189
@@ -196,7 +197,7 @@ abstract_utilities/math_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU
 abstract_utilities/math_utils/imports/imports.py,sha256=IIGHGPK61piV3IKDaLVRvUPIkxznkKqYGIQV_QFpCZs,57
 abstract_utilities/math_utils/imports/module_imports.py,sha256=xt-zuDypjLnq2FBacEeho9LpDwfQHngT9tT1GxEUFbU,47
 abstract_utilities/parse_utils/__init__.py,sha256=7Ubmny6MOJibdI3B22_iLaHH6iobrwii0fjRAUzewEU,50
-abstract_utilities/parse_utils/parse_utils.py,sha256=FQd8OCP3d9eC1nTmfe1-qp3FcHlyeDKiBKjltUHQ1fk,18143
+abstract_utilities/parse_utils/parse_utils.py,sha256=0bYFLOzhTTEW0eqAEPRCEqcamInUJF7iAQlf7ZoHrp4,19120
 abstract_utilities/parse_utils/imports/__init__.py,sha256=ba1PFyO4a5Qjp35ZjGesaVoZJ7mV9l2OnTK_7M9tGis,78
 abstract_utilities/parse_utils/imports/constants.py,sha256=PsYAIKIwg_-oxO_rgPrT554B7yLPsFF1dvmyHF6cibQ,227
 abstract_utilities/parse_utils/imports/imports.py,sha256=HSPmM0Y9GCFEIPbovNh79ayKjdNWMC-m-8QYa1JEpDk,76
@@ -207,9 +208,9 @@ abstract_utilities/path_utils/imports/__init__.py,sha256=wBNCq8vHWdl7DleRNq0UK_-
 abstract_utilities/path_utils/imports/imports.py,sha256=R7rno0pnzOU9XpzPhco0Wp9aIR73w_BGqCLdYpAHowI,32
 abstract_utilities/path_utils/imports/module_imports.py,sha256=bPhfxar3bk4PjEfHdBK7Q6VSODpXyTXNLO2GKnHr2AE,376
 abstract_utilities/read_write_utils/__init__.py,sha256=MYC2oSY2NEbnu-iwX55t9m_rFRVxwILY_oUbBCpGJkw,32
-abstract_utilities/read_write_utils/read_write_utils.py,sha256=Ad7oHJqdaO5XN_QLKGoZ0WdFA6YV176t4O_qtU4bKaY,10812
+abstract_utilities/read_write_utils/read_write_utils.py,sha256=sbz4jWcFjYG-WywOsPizMS-oRRs-l_57RQ-Ow9A8xfo,12685
 abstract_utilities/read_write_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
-abstract_utilities/read_write_utils/imports/imports.py,sha256=ilUIFUxk5-klbt1SJOJD3sx0QAn_WfM0Z4voFc0RWRM,33
+abstract_utilities/read_write_utils/imports/imports.py,sha256=zN1zEfAJ-UbJB34wxm2oVuAiDmyqS12dSoIzojUrsiM,46
 abstract_utilities/read_write_utils/imports/module_imports.py,sha256=cwmzuy1RKPyq2rQtMU6KSMSjDE9jUhPzHPjRTdTXcto,204
 abstract_utilities/robust_reader/__init__.py,sha256=4i6qW4lwhdYuoO5-p9Xbt8Lpmr3hzCh9Rgb9y19QJwk,28
 abstract_utilities/robust_reader/file_reader2.py,sha256=U-5opkLu-bct091Eb-5CiNBTf0UFoSITYi8zR-Sz38w,25077
@@ -271,7 +272,7 @@ abstract_utilities/type_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU
 abstract_utilities/type_utils/imports/imports.py,sha256=C_ZAQO-y7R31BYxTuaHJCEQE9IZSU1JgCtdHNWxZKhY,77
 abstract_utilities/type_utils/imports/module_imports.py,sha256=sxF9YJQhUFUivgslnU-4Y5GG_J1IHR7kunUefIYZ0Lk,36
 imports/__init__.py,sha256=2PSEAwZY88J2NHt98XCO5drFNok5ctiJ8LE02kwABP4,944
-abstract_utilities-0.2.2.583.dist-info/METADATA,sha256=isTXd6scUF73kb9WDhE78AcNJhmMAyKcDIcZo1VRMbY,28108
-abstract_utilities-0.2.2.583.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_utilities-0.2.2.583.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
-abstract_utilities-0.2.2.583.dist-info/RECORD,,
+abstract_utilities-0.2.2.627.dist-info/METADATA,sha256=ZLU9D2LYyLcu0fXp2TXt2QRxMy5B8FELrZc2x-6Susc,28108
+abstract_utilities-0.2.2.627.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_utilities-0.2.2.627.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
+abstract_utilities-0.2.2.627.dist-info/RECORD,,