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

abstract_utilities/import_utils/src/import_utils.py

@@ -0,0 +1,299 @@
+from ..imports import *
+from .dot_utils import *
+from .sysroot_utils import *
+from .extract_utils 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 safe_import(name: str, package: str | None = None, member: str | None = None):
+    """
+    Wraps importlib.import_module but also resolves relative imports like '..logPaneTab'.
+    If `member` is given, returns that attribute from the module.
+    """
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod
+def unique_module_name(base: str, path: Path) -> str:
+    # Make a stable, unique name per file
+    digest = hashlib.md5(str(path.resolve()).encode()).hexdigest()[:8]
+    stem = path.stem.replace('-', '_')
+    return f"_dyn.{base}.{stem}_{digest}"
+
+def import_from_path(module_name: str, file_path: Path):
+    spec = importlib.util.spec_from_file_location(module_name, str(file_path))
+    if spec is None or spec.loader is None:
+        raise ImportError(f"Could not load spec for {file_path}")
+    mod = importlib.util.module_from_spec(spec)
+    # Register before exec to satisfy intra-module relative imports (rare but safe)
+    sys.modules[module_name] = mod
+    spec.loader.exec_module(mod)
+    return mod 
+def get_imports(files: List[str],self=None) -> Dict[str, Dict[str, Any]]:
+    """
+    Discover package context from each file's relative-import requirements,
+    add the proper sysroot to sys.path once, and import by dotted name.
+    Returns: {modname: {"filepath", "sysroot", "module", "class", "funcs", "selfs"}}
+    """
+    results: Dict[str, Dict[str, Any]] = {}
+    seen_sysroots: set[str] = set()
+    files = make_list(files)
+    for file in files:
+        file_p = Path(file).resolve()
+
+        # 1) Use your logic to find a viable sysroot (top where dots won't exceed)
+        sysroot_guess = Path(get_dot_range_sysroot(str(file_p))).resolve()
+        # 2) Ensure we import with *package* context: we need the directory ABOVE
+        #    the topmost package on sys.path, not the package dir itself.
+        top_pkg_dir = find_top_package_dir(sysroot_guess) or find_top_package_dir(file_p)
+        if not top_pkg_dir:
+            raise RuntimeError(f"No package context found for {file_p}; add __init__.py up the tree.")
+        sysroot = top_pkg_dir.parent
+
+        if str(sysroot) not in seen_sysroots:
+            ensure_on_path(sysroot)
+            seen_sysroots.add(str(sysroot))
+
+        # 3) Compute dotted name from sysroot and import
+        dotted = dotted_from(file_p, sysroot)
+        try:
+            mod = importlib.import_module(dotted)
+        except Exception as e:
+            # Helpful hint if user ran file directly (no package context)
+            if "__package__" in dir() and not __package__:
+                raise RuntimeError(
+                    f"Import failed for {dotted}. If you ran this file directly, "
+                    f"bootstrap package context or run via `python -m ...`."
+                ) from e
+            raise
+
+        # 4) Collect symbols (you can keep your regex readers if you prefer)
+        classes = extract_class(str(file_p))
+        funcs   = extract_funcs(str(file_p))
+        selfs   = extract_selfs(str(file_p))
+        
+        # stable result key (avoid collisions)
+        key = get_unique_name(get_file_parts(str(file_p))['filename'], results)
+
+        results[key] = {
+            "filepath": str(file_p),
+            "sysroot": str(sysroot),
+            "module": mod,
+            "class": classes,
+            "funcs": funcs,
+            "selfs": selfs,
+        }
+
+    return results
+def inject_symbols_from_module(
+    mod,
+    into: dict,
+    *,
+    expose_functions: bool = True,
+    expose_classes: bool = True,
+    expose_methods: bool = False,
+    self: object | None = None,   # <---- NEW
+    ctor_overrides: Mapping[str, Tuple[tuple, dict]] | None = None,
+    name_prefix: str = "",
+    name_filter: Iterable[str] | None = None,
+    overwrite: bool = False
+) -> Dict[str, Any]:
+    """
+    Inject functions/classes from `mod` into `into` (usually globals()).
+    If expose_methods=True and a `self` object is passed, bind instance methods
+    directly onto `self` instead of globals().
+    """
+    exported: Dict[str, Any] = {}
+    ctor_overrides = ctor_overrides or {}
+
+    def allowed(name: str) -> bool:
+        return name_filter is None or name in name_filter
+
+    # 1) functions
+    if expose_functions:
+        for name, obj in vars(mod).items():
+            input(name)
+            if not allowed(name):
+                continue
+            if inspect.isfunction(obj) and obj.__module__ == mod.__name__:
+                out_name = f"{name_prefix}{name}"
+                if overwrite or out_name not in into:
+                    into[out_name] = obj
+                    exported[out_name] = obj
+
+    # 2) classes (+ optional bound methods)
+    if expose_classes or expose_methods:
+        for cls_name, cls in vars(mod).items():
+            if not allowed(cls_name):
+                continue
+            if inspect.isclass(cls) and cls.__module__ == mod.__name__:
+                if expose_classes:
+                    out_name = f"{name_prefix}{cls_name}"
+                    if overwrite or out_name not in into:
+                        into[out_name] = cls
+                        exported[out_name] = cls
+
+                if expose_methods and self is not None:
+                    # instantiate class
+                    args, kwargs = ctor_overrides.get(cls_name, ((), {}))
+                    try:
+                        inst = cls(*args, **kwargs)
+                    except Exception:
+                        continue
+
+                    for meth_name, meth_obj in vars(cls).items():
+                        if meth_name.startswith("__"):
+                            continue
+                        if inspect.isfunction(meth_obj) or inspect.ismethoddescriptor(meth_obj):
+                            try:
+                                bound = getattr(inst, meth_name)
+                            except Exception:
+                                continue
+                            if callable(bound):
+                                # attach directly to the `self` you passed in
+                                if not hasattr(self, meth_name) or overwrite:
+                                    setattr(self, meth_name, bound)
+                                    exported[f"{cls_name}.{meth_name}"] = bound
+
+    return exported
+def inject_from_imports_map(
+    imports_map: Dict[str, Dict[str, Any]],
+    *,
+    into: Optional[dict] = None,      # where to put free funcs/classes (defaults to this module's globals)
+    attach_self: Optional[object] = None,  # bind names listed in "selfs" onto this object
+    prefix_modules: bool = False,     # add "<module>__" prefix to avoid collisions
+    overwrite: bool = False,           # allow overwriting existing names
+    self:any=None
+) -> Dict[str, Any]:
+    """
+    Emulates: from functions import *   (plus: bind 'self' methods)
+    Returns dict of injected_name -> object (including methods bound to attach_self).
+    """
+    ns = into if into is not None else globals()
+    exported: Dict[str, Any] = {}
+
+    for mod_key, info in imports_map.items():
+        mod = info.get("module")
+        if mod is None:
+            continue
+
+        func_names: List[str]  = info.get("funcs", [])
+        self_names: List[str]  = info.get("selfs", [])
+        class_names: List[str] = info.get("class", [])
+
+        # 1) bind the "selfs" directly onto self
+        if self is not None:
+            for name in self_names:
+                func = getattr(mod, name, None)
+                if not callable(func):
+                    continue
+                # sanity: ensure first param is literally named 'self'
+                try:
+                    params = list(inspect.signature(func).parameters.values())
+                    if not params or params[0].name != "self":
+                        continue
+                except Exception:
+                    continue
+
+                bound = MethodType(func, self)
+                if overwrite or not hasattr(self, name):
+                    setattr(self, name, bound)
+                    exported[f"{mod_key}.self.{name}"] = bound
+
+        # 2) Inject free functions (exclude the ones we just bound to self to avoid dupes)
+        for name in func_names:
+            if name in self_names:
+                continue
+            obj = getattr(mod, name, None)
+            if inspect.isfunction(obj) and obj.__module__ == mod.__name__:
+                out_name = f"{mod_key}__{name}" if prefix_modules else name
+                if overwrite or out_name not in ns:
+                    ns[out_name] = obj
+                    exported[out_name] = obj
+
+        # 3) Inject classes
+        for name in class_names:
+            cls = getattr(mod, name, None)
+            if inspect.isclass(cls) and cls.__module__ == mod.__name__:
+                out_name = f"{mod_key}__{name}" if prefix_modules else name
+                if overwrite or out_name not in ns:
+                    ns[out_name] = cls
+                    exported[out_name] = cls
+
+    # optional: control wildcard export from THIS module
+    ns["__all__"] = sorted(set(list(ns.get("__all__", [])) + list(exported.keys())))
+    return exported
+def ifFunctionsInFiles(root: str | None = None, *, expose_methods: bool = True, self=None) -> Dict[str, Any]:
+    here = Path(__file__).resolve().parent
+    base = Path(root).resolve() if root else here
+    candidates = [base / "functions", base / "functions.py"]
+    files: List[str] = []
+    for item in candidates:
+        if item.exists():
+            if item.is_dir():
+                files = [str(p) for p in item.rglob("*.py") if p.name != "__init__.py"]
+            else:
+                files = [str(item)]
+            break
+
+    exported_all: Dict[str, Any] = {}
+    imports_map = get_imports(files)
+    
+    exported = inject_from_imports_map(
+            imports_map,
+            self=self
+        )
+        
+    return exported
+def attach_self_functions(
+    imports_map: Dict[str, Dict[str, Any]],
+    self_obj: object,
+    *,
+    overwrite: bool = False,
+    only: Optional[List[str]] = None,     # whitelist of method names to attach
+    prefix_modules: bool = False          # attach as core_utils__on_run_code instead of on_run_code
+) -> Dict[str, Any]:
+    """
+    For each module in imports_map, bind names listed in 'selfs' (top-level defs whose
+    first param is 'self') directly onto `self_obj`.
+
+    Returns {attached_name: bound_method}.
+    """
+    attached: Dict[str, Any] = {}
+
+    for mod_key, info in imports_map.items():
+        mod = info.get("module")
+        if not mod:
+            continue
+
+        self_names: List[str] = info.get("selfs", [])
+        for name in self_names:
+            if only is not None and name not in only:
+                continue
+
+            func = getattr(mod, name, None)
+            if not callable(func):
+                continue
+
+            # sanity check: first param literally named 'self'
+            try:
+                params = list(inspect.signature(func).parameters.values())
+                if not params or params[0].name != "self":
+                    continue
+            except Exception:
+                continue
+
+            bound = MethodType(func, self_obj)
+            out_name = f"{mod_key}__{name}" if prefix_modules else name
+
+            if overwrite or not hasattr(self_obj, out_name):
+                setattr(self_obj, out_name, bound)
+                attached[out_name] = bound
+
+    return attached

abstract_utilities/import_utils/src/package_utils/__init__.py

@@ -0,0 +1,139 @@
+import ast
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+import ast, sys
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+from src.abstract_utilities.import_utils import *
+STDLIB_NAMES = set(sys.builtin_module_names)
+def parse_imports(file_path: Path):
+    """Return list of (module, level) for every import/from-import."""
+    try:
+        src = file_path.read_text(errors="ignore")
+        tree = ast.parse(src, filename=str(file_path))
+    except Exception:
+        return []
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            imports.append((node.module, node.level))
+    return imports
+
+
+def resolve_relative_import(base_file: Path, module: str | None, level: int) -> Path | None:
+    """Follow a relative import path to its real file if it exists."""
+    base = base_file.parent
+    for _ in range(level - 1):
+        base = base.parent
+    if not module:
+        target = base
+    else:
+        target = base / module.replace(".", "/")
+    if (target / "__init__.py").exists():
+        return target / "__init__.py"
+    if target.with_suffix(".py").exists():
+        return target.with_suffix(".py")
+    return None
+
+
+
+
+def classify_import(mod_name: str, root_pkg: str) -> str:
+    """Return 'local', 'internal', or 'external'."""
+    if not mod_name:
+        return "unknown"
+    if mod_name.startswith("."):
+        return "local"
+    if mod_name.split(".")[0] == root_pkg:
+        return "internal"
+    if mod_name.split(".")[0] in STDLIB_NAMES:
+        return "stdlib"
+    return "external"
+
+
+def follow_imports(entry: Path, root_pkg: str,
+                   visited: Dict[Path, Dict[str, Set[str]]] | None = None):
+    """
+    Recursively follow only internal/local imports.
+    Returns {file_path: {'internal': set(), 'external': set()}}
+    """
+    visited = visited or {}
+    if entry in visited:
+        return visited
+
+    visited[entry] = {"internal": set(), "external": set()}
+
+    for mod, level in parse_imports(entry):
+        if level > 0:
+            target = resolve_relative_import(entry, mod, level)
+            if target:
+                visited[entry]["internal"].add(str(target))
+                follow_imports(target, root_pkg, visited)
+            continue
+
+        category = classify_import(mod, root_pkg)
+        if category == "internal":
+            spec = find_spec(mod)
+            if spec and spec.origin and spec.origin.endswith(".py"):
+                visited[entry]["internal"].add(spec.origin)
+                follow_imports(Path(spec.origin), root_pkg, visited)
+        elif category == "external":
+            visited[entry]["external"].add(mod)
+        elif category == "stdlib":
+            # stdlib gets treated like external but labeled
+            visited[entry]["external"].add(mod + "  # stdlib")
+
+    return visited
+
+
+
+def build_master_imports(entry: Path, root_pkg: str, output: Path):
+    trace = follow_imports(entry, root_pkg)
+    lines = ["# Auto-generated master imports for abstract_utilities\n"]
+    all_modules = set()
+    external_modules = set()
+    imports = get_all_imports(path)
+    for _, data in trace.items():
+        for dep in data["internal"]:
+            path = Path(dep)
+            if path.suffix != ".py":
+                continue
+            try:
+                rel_parts = path.with_suffix("").parts
+                idx = rel_parts.index(root_pkg)
+                dotted = ".".join(rel_parts[idx:])
+                all_modules.add(dotted)
+            except ValueError:
+                continue
+        external_modules.update(data["external"])
+
+    for mod in sorted(all_modules):
+        short = mod.split(".", 1)[-1]
+        lines.append(f"from .{short} import *")
+
+    if external_modules:
+        lines.append("\n# External / stdlib imports (not traced, for reference)")
+        for ext in sorted(external_modules):
+            lines.append(f"# {ext}")
+    
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("\n".join(lines+str(imports)))
+    print(f"✅ wrote master imports hub → {output}")
+
+
+
+if __name__ == "__main__":
+    entry = Path(
+        "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/"
+        "abstract_utilities/import_utils/src/import_functions.py"
+    )
+
+    
+    pkg = "abstract_utilities"
+    out = entry.parents[4] / "imports" / "__init__.py"
+    build_master_imports(entry, pkg, out)

abstract_utilities/import_utils/src/package_utils/context_utils.py

@@ -0,0 +1,27 @@
+import sys, os
+from pathlib import Path
+from .path_utils import find_top_package_dir, derive_package_for_file
+
+def ensure_package_context(file: str):
+    """Ensure that running this file directly gives correct package context."""
+    file = file or os.getcwd()
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_package_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py files up the tree.")
+
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])
+    if (__name__ == "__main__") and not globals().get("__package__"):
+        globals()["__package__"] = pkg_name
+
+def ensure_caller_package(caller_file: str, caller_globals: dict | None = None) -> str:
+    """Ensure sysroot is on sys.path and return caller's dotted package name."""
+    pkg, _ = derive_package_for_file(caller_file)
+    if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
+        caller_globals["__package__"] = pkg
+    return pkg

abstract_utilities/import_utils/src/package_utils/import_collectors.py

@@ -0,0 +1,53 @@
+from ..imports import *
+from .import_functions import *
+
+def ensure_import_pkg_js(import_pkg_js=None, file_path=None):
+    import_pkg_js = import_pkg_js or {"context": {}}
+    if "context" not in import_pkg_js:
+        import_pkg_js["context"] = {}
+    for key in ["nulines", "file_path", "all_data"]:
+        import_pkg_js["context"].setdefault(key, [] if key != "file_path" else None)
+
+    if file_path and file_path != import_pkg_js["context"].get("file_path"):
+        found = False
+        nu_data = {
+            "file_path": import_pkg_js["context"]["file_path"],
+            "nulines": import_pkg_js["context"]["nulines"]
+        }
+        for i, data in enumerate(import_pkg_js["context"]["all_data"]):
+            if data.get("file_path") == import_pkg_js["context"]["file_path"]:
+                import_pkg_js["context"]["all_data"][i] = nu_data
+                found = True
+                break
+        if not found:
+            import_pkg_js["context"]["all_data"].append(nu_data)
+        import_pkg_js["context"]["nulines"] = []
+        import_pkg_js["context"]["file_path"] = file_path
+    return import_pkg_js
+
+def add_imports_to_import_pkg_js(import_pkg, imports, import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    imports = clean_imports(imports)
+    if import_pkg not in import_pkg_js:
+        i = len(import_pkg_js["context"]["nulines"])
+        file_path = import_pkg_js["context"]["file_path"]
+        file_parts = get_file_parts(file_path)
+        dirname = file_parts["dirname"]
+        import_pkg_js[import_pkg] = {"imports": imports, "line": i}
+        import_pkg_js["context"]["nulines"].append(f"from {import_pkg} import ")
+    else:
+        import_pkg_js[import_pkg]["imports"] += imports
+    return import_pkg_js
+
+def update_import_pkg_js(line, import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    if is_line_group_import(line):
+        import_pkg = get_import_pkg(line)
+        imports = get_imports_from_import_pkg(line)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg, imports, import_pkg_js=import_pkg_js)
+    else:
+        if import_pkg_js["context"]["nulines"] and line == "" and is_line_import(import_pkg_js["context"]["nulines"][-1]):
+            pass
+        else:
+            import_pkg_js["context"]["nulines"].append(line)
+    return import_pkg_js

abstract_utilities/import_utils/src/package_utils/path_utils.py

@@ -0,0 +1,28 @@
+import os, sys
+from pathlib import Path
+
+def find_top_package_dir(p: Path) -> Path | None:
+    """Walk upward until the topmost __init__.py-containing directory."""
+    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 derive_package_for_file(file: str) -> tuple[str, Path]:
+    """Return (pkg_name, sysroot) for the module file."""
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_package_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py up the tree.")
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])
+    return pkg_name, sysroot

abstract_utilities/import_utils/src/package_utils/safe_import.py

@@ -0,0 +1,27 @@
+import inspect, importlib
+from .context_utils import ensure_caller_package
+
+def safe_import(
+    name: str,
+    *,
+    member: str | None = None,
+    package: str | None = None,
+    file: str | None = None,
+    caller_globals: dict | None = None,
+):
+    """
+    Safe dynamic import that resolves relative imports when run as a script.
+    """
+    if file is None:
+        frame = inspect.currentframe()
+        assert frame is not None
+        outer = frame.f_back
+        caller_file = (outer.f_globals.get("__file__") if outer else None) or __file__
+    else:
+        caller_file = file
+
+    if name.startswith(".") and not package:
+        package = ensure_caller_package(caller_file, caller_globals=caller_globals)
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod