abstract-utilities 0.2.2.583__py3-none-any.whl → 0.2.2.700__py3-none-any.whl

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

@@ -1,4 +1,4 @@
-from .imports import *
+from .init_imports import *
 from .module_imports import *
 from .constants import *
 from .utils import *

abstract_utilities/import_utils/imports/init_imports.py

@@ -0,0 +1,3 @@
+from ...imports import *
+
+

abstract_utilities/import_utils/imports/module_imports.py

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

abstract_utilities/import_utils/imports/utils.py

@@ -1,4 +1,4 @@
-import os
+from .init_imports import *
 from .constants import *
 
 def is_line_import(line):

abstract_utilities/import_utils/src/__init__.py

@@ -5,3 +5,4 @@ from .import_utils import *
 from .import_functions import *
 from .pkg_utils import *
 from .sysroot_utils import *
+from .layze_import_utils import *

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/import_utils.py

@@ -297,3 +297,42 @@ def attach_self_functions(
                 attached[out_name] = bound
 
     return attached
+def initFuncs(self, mode=None):
+    """
+    Load functions in either dev (dynamic) or prod (static) mode.
+    """
+    mode = mode or "dev"
+    from abstract_utilities import get_logFile
+    logger = get_logFile(__name__)
+
+    try:
+        base_pkg = self.__class__.__module__.rsplit('.', 1)[0]
+
+        if mode == "prod":
+            # All imports come from the auto-generated import script
+            imports_mod = importlib.import_module(f"{base_pkg}.imports.funcs_imports")
+
+            # Attach all exports
+            for name in getattr(imports_mod, "__all__", []):
+                func = getattr(imports_mod, name)
+                setattr(self, name, func.__get__(self))
+
+            return self
+
+        # --- DEV MODE: your existing dynamic loader ---
+        import inspect, pkgutil, importlib
+        pkg = importlib.import_module(base_pkg + ".functions")
+
+        existing = set(self.__dict__) | set(dir(self))
+
+        for _, module_name, _ in pkgutil.iter_modules(pkg.__path__):
+            mod = importlib.import_module(f"{pkg.__name__}.{module_name}")
+
+            for name, obj in inspect.getmembers(mod, inspect.isfunction):
+                if name not in existing:
+                    setattr(self, name, obj.__get__(self))
+
+    except Exception as e:
+        logger.error(f"initFuncs({mode}) error: {e}")
+
+    return self

abstract_utilities/import_utils/src/layze_import_utils/__init__.py

@@ -0,0 +1,2 @@
+from .nullProxy import *
+from .lazy_utils import *

abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py

@@ -0,0 +1,41 @@
+from ...imports import *
+from .nullProxy import nullProxy,nullProxy_logger
+@lru_cache(maxsize=None)
+def lazy_import_single(name: str,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+
+    if name in sys.modules:
+        return sys.modules[name]
+
+    try:
+        module = importlib.import_module(name)
+        return module
+    except Exception as e:
+        nullProxy_logger.warning(
+            "[lazy_import] Failed to import '%s': %s",
+            name,
+            e,
+        )
+        return nullProxy(name,fallback=fallback)
+
+def get_lazy_attr(module_name: str, *attrs,fallback=None):
+    obj = lazy_import(module_name,fallback=fallback)
+
+    for attr in attrs:
+        try:
+            obj = getattr(obj, attr)
+        except Exception:
+            return nullProxy(module_name, attrs,fallback=fallback)
+
+    return obj
+def lazy_import(name: str, *attrs,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+    if attrs:
+        obj = get_lazy_attr(name, *attrs,fallback=fallback)
+    else:
+        obj = lazy_import_single(name,fallback=fallback)
+    return obj

abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py

@@ -0,0 +1,37 @@
+from ...imports import *
+nullProxy_logger = logging.getLogger("abstract.lazy_import")
+
+
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=(),fallback=None):
+        self._name = name
+        self._path = path
+        self.fallback=fallback
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        if self.fallback is not None:
+            try:
+                return self.fallback(*args, **kwargs)
+            except Exception as e:
+                logger.info(f"{e}")
+        nullProxy_logger.warning(
+            "[lazy_import] Call to missing module/attr: %s.%s args=%s kwargs=%s",
+            self._name,
+            ".".join(self._path),
+            args,
+            kwargs,
+        )
+        return None
+
+    def __repr__(self):
+        full = ".".join((self._name, *self._path))
+        return f"<nullProxy {full}>"
+
+    def __bool__(self):
+        return False  # safe in conditionals

abstract_utilities/import_utils/src/nullProxy.py

@@ -0,0 +1,30 @@
+from ...imports import *
+lazy_import_logger = logging.getLogger("abstract.lazy_import")
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=()):
+        self._name = name
+        self._path = path
+
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        lazy_import_logger.warning(
+            "[lazy_import] Call to missing module/attr: %s.%s args=%s kwargs=%s",
+            self._name,
+            ".".join(self._path),
+            args,
+            kwargs,
+        )
+        return None
+
+    def __repr__(self):
+        full = ".".join((self._name, *self._path))
+        return f"<nullProxy {full}>"
+
+    def __bool__(self):
+        return False  # safe in conditionals

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)