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

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

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

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

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

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/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.

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

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

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

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

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/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-0.2.2.563 → abstract_utilities-0.2.2.613}/src/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-0.2.2.563 → abstract_utilities-0.2.2.613}/src/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',[]))
+    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-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/file_utils/src/find_collect.py

@@ -5,8 +5,7 @@ from typing import Optional, List, Set
 
 
 
-def run_pruned_cmd(cmd,*args,*kwargs):
-    return run_pruned_func(run_cmd,cmd,*args,*kwargs)
+
 
 
 def get_find_cmd(
@@ -134,6 +133,7 @@ def collect_globs(
     - If file_type is "f" or "d" → returns a list of that type
     - Supports SSH mode via `user_at_host`
     """
+    user_pass_host_key = get_user_pass_host_key(**kwargs)
     kwargs["directories"] = ensure_directories(*args, **kwargs)
     kwargs= get_safe_canonical_kwargs(**kwargs)
     kwargs["cfg"] = kwargs.get('cfg') or define_defaults(**kwargs)
@@ -149,13 +149,18 @@ def collect_globs(
         type_str = type_strs.get(file_type)
         # Remote path (SSH)
         find_cmd = get_find_cmd(
+            directories=kwargs.get("directories"),
+            cfg=kwargs.get('cfg'),
                 mindepth=mindepth,
                 maxdepth=maxdepth,
                 depth=depth,
                 file_type=file_type,
-                **{k: v for k, v in kwargs.items() if v},
+                **user_pass_host_key,
+            )
+        result = run_pruned_func(run_cmd,find_cmd,
+            **kwargs
+            
             )
-        result = run_pruned_func(run_cmd,find_cmd,**kwargs)
         return_result = [res for res in result.split('\n') if res]
         return_results[type_str]=return_result
     if len(file_types) == 1:

abstract_utilities-0.2.2.563/src/abstract_utilities/file_utils (2)/src/initFunctionsGen.py → abstract_utilities-0.2.2.613/src/abstract_utilities/file_utils/src/initFunctionsGen.py

@@ -1,10 +1,11 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-
+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]
     return os.path.abspath(frame.filename)
@@ -200,6 +201,7 @@ def get_dirs(root = None):
     dirpaths = [get_dir(root,item) for item in os.listdir(root) if check_dir_item(root,item)]
     return dirpaths
 def ifFunctionsInFile(root):
+    input(root)
     items = [os.path.join(root, "functions"),os.path.join(root, "functions.py")]
     for item in items:
         if os.path.exists(item):
@@ -210,33 +212,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)
+        [apply_inits(os.path.join(ROOT,func)) for func in os.listdir(ROOT) if 'functions' in func]
+        
+      
             
 
 def apply_inits(ROOT):
-    FUNCS_DIR = ifFunctionsInFile(ROOT)
-
+        filepaths=[ROOT]
+        TAB_DIR = os.path.dirname(ROOT)
+        INIT_DIR = None
+        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):
+            TAB_DIR = os.path.dirname(ROOT)
+            INIT_DIR = ROOT
+            filepaths = get_files_and_dirs(directory=INIT_DIR,allowed_exts='py',add=True)[-1]
+            if_fun_dir=True
+            input(filepaths)
     
-    if_fun_dir = isDir(FUNCS_DIR)
-    if if_fun_dir != None:
-        
-        if if_fun_dir:
-            CFG = define_defaults(allowed_exts='.py',
-                unallowed_exts = True,
-                exclude_types = True,
-                exclude_dirs = True,
-                exclude_patterns = True)
-            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
-            
-        else:
-            filepaths = [FUNCS_DIR]
+   
         
         # Parse top-level def names
         def extract_funcs(path: str):
@@ -246,7 +252,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 = []
@@ -258,7 +264,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=os.path.join(INIT_DIR, "__init__.py"))
 
         # Prepare the tuple literal of function names for import + loop
         uniq_funcs = sorted(set(all_funcs))
@@ -267,9 +273,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}):
@@ -279,8 +286,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=os.path.join(TAB_DIR, "initFuncs.py"))
 
 def call_for_all_tabs():
     root = get_caller_dir(2)
+    
     get_for_all_tabs(root)

abstract_utilities-0.2.2.563/src/abstract_utilities/file_utils/src/initFunctionsGen.py → abstract_utilities-0.2.2.613/src/abstract_utilities/file_utils/src/initFunctionsGens.py

@@ -206,7 +206,7 @@ def ifFunctionsInFile(root):
         
 
 def get_for_all_tabs(root = None):
-    root = root or caller_path()
+    root = root or get_initial_caller_dir()
     if os.path.isfile(root):
         root = os.path.dirname(root)
     all_tabs = get_dirs(root = root)
@@ -261,9 +261,9 @@ 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}):
@@ -276,5 +276,5 @@ def apply_inits(ROOT):
         write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
 
 def call_for_all_tabs():
-    root = get_caller_dir(2)
+    root = get_initial_caller_dir()
     get_for_all_tabs(root)

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/file_utils (2)/imports/imports/imports.py

@@ -8,7 +8,7 @@
 
 from ....imports import *
 from pathlib import Path
-
+from abstract_utilities import read_from_file, eatAll
 import os, sys, re, inspect
 from typing import *
 from types import MethodType

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/file_utils (2)/imports/utils/filter_utils.py

@@ -320,13 +320,12 @@ def define_all_params(*args, **kwargs) -> AllParams:
     merged = asdict(search_params)
      
     merged.update({
-        "cfg":cfg,
         "directories":directories,
         "allowed": allowed,
         "include_files": include_files,
         "recursive": recursive,  # override existing value safely
     })
-     
+    input(merged)   
     # Step 6: instantiate AllParams
     return AllParams(**merged)
 def get_file_filters(*args, **kwargs) -> AllParams:

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

@@ -0,0 +1,8 @@
+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 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
+from ...file_utils  import collect_filepaths,collect_globs
+from ...directory_utils import get_shortest_path,get_common_root

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/import_utils/src/dot_utils.py

@@ -1,4 +1,15 @@
 from ..imports import *
+def find_top_package_dir(p: Path) -> Path | None:
+    p = p.resolve()
+    if p.is_file():
+        p = p.parent
+    top = None
+    while (p / "__init__.py").exists():
+        top = p
+        if p.parent == p:
+            break
+        p = p.parent
+    return top
 def get_Path(path):
     if isinstance(path,str):
         path = Path(str(path))

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/import_utils/src/extract_utils.py

@@ -40,3 +40,7 @@ def extract_class(path: str):
         if m:
             funcs.append(m.group(1))
     return funcs
+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-0.2.2.613/src/abstract_utilities/import_utils/src/import_functions.py

@@ -0,0 +1,110 @@
+# --- auto-package bootstrap (run-safe) ---------------------------------
+from ..imports import *
+from .dot_utils import get_dot_range
+from .sysroot_utils import get_sysroot,get_import_with_sysroot,get_py_files,get_all_py_sysroots
+from .extract_utils import get_all_py_file_paths
+def clean_imports(imports,commaClean=True):
+    chars=["*"]
+    if not commaClean:
+        chars.append(',')
+    if isinstance(imports,str):
+        imports = imports.split(',')
+    return [eatElse(imp,chars=chars) for imp in imports if imp]
+def get_dot_range(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
+def get_cleaned_import_list(line,commaClean=True):
+    cleaned_import_list=[]
+    if IMPORT_TAG in line:
+        imports = line.split(IMPORT_TAG)[1]
+        cleaned_import_list+=clean_imports(imports,commaClean=commaClean)
+    return cleaned_import_list
+def get_module_from_import(imp,path=None):
+    path = path or os.getcwd()
+    i = get_dot_range(imp)
+    imp = eatAll(imp,'.')
+    sysroot = get_sysroot(path,i)
+    return os.path.join(sysroot, imp)
+
+def safe_import(name: str, *, package: str | None = None, member: str | None = None, file: str | None = None):
+    """
+    Wrapper over importlib.import_module that:
+    - if `name` is relative (starts with '.'), ensures `package` is set.
+    - if `package` is missing, derives it from `file` (defaults to __file__).
+    """
+    file = file or __file__
+    ensure_package_context(file)
+    if name.startswith(".") and not package:
+        
+            
+        pkg_name = get_module_from_import(name,path=None)
+        # also set __package__ if we are running as a script
+        if __name__ == "__main__" and (not globals().get("__package__")):
+            globals()["__package__"] = pkg_name
+        package = pkg_name
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod
+
+def dynamic_import(module_path: str, namespace: dict, all_imports = None):
+    """
+    Emulates:
+        from module_path import *
+    but includes private (_xxx) names too.
+    """
+    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)
+    return monorepo_root
+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))
+    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, 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-0.2.2.563 → abstract_utilities-0.2.2.613}/src/abstract_utilities/import_utils/src/pkg_utils.py

@@ -2,7 +2,7 @@
 from ..imports import *
 from .import_functions import *
 from ...safe_utils import *
-
+from .sysroot_utils import get_import_with_sysroot
 def try_is_file(file_path):
     try:
         return os.path.isfile(file_path)
@@ -29,36 +29,7 @@ def get_pkg_or_init(pkg_path):
         if try_is_dir(pkg_path):
             if os.path.isfile(pkg_init_path):
                 return pkg_init_path
-def get_import_with_sysroot(file_path, sysroot):
-    """
-    Rewrite imports like:
-        from imports.constants import *
-    into:
-        from <relative_path>.imports.constants import *
-    Where <relative_path> is computed relative to sysroot.
-    """
-
-
-    # Absolute paths
-    file_dir = os.path.dirname(os.path.abspath(file_path))
-    sysroot = os.path.abspath(sysroot)
-
-    # Compute relative path
-    relpath = os.path.relpath(file_dir, sysroot)
-    input(relpath)
-    bare_rel = eatAll(relpath,'.')
-    
-    # Turn filesystem path into dotted python path
-    if relpath == ".":
-        dotted = ""
-    else:
-        dotted = ".".join(part for part in relpath.split(os.sep) if part)
-    if bare_rel.startswith('/') and dotted.startswith('.'):
-        dotted = dotted[1:]
-
 
-    # Build final rewritten import
-    return dotted
 
 
 def ensure_import_pkg_js(import_pkg_js,file_path=None):