abstract-utilities 0.2.2.448__py3-none-any.whl → 0.2.2.449__py3-none-any.whl

abstract_utilities/file_utils/req.py

@@ -1,329 +0,0 @@
-# attach_functions.py  — single helper you can import anywhere
-# attach_dynamic.py
-from __future__ import annotations
-from .file_utils import define_defaults,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)
-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_functionss(
-    self,
-    *,
-    base_pkg: Optional[str] = None,
-    hot_reload: bool = False,
-    prefix_with_module: bool = False,
-    on_collision: str = "last_wins",  # or "error" or "skip"
-):
-    """
-    Attach discovered functions from '<base_pkg>.functions' onto `self`.
-
-    - base_pkg: package containing either functions.py or functions/ (defaults to the class' package)
-    - hot_reload: reload modules each call (handy during development)
-    - prefix_with_module: if True, attach as '<module>_<funcname>' to avoid name clashes
-    - on_collision: how to handle duplicate names: 'last_wins' | 'error' | 'skip'
-    """
-    if base_pkg is None:
-        # Infer from the class' module: e.g., "myapp.tabs.users.widgets" -> "myapp.tabs.users"
-        cls_mod = self.__class__.__module__
-        base_pkg = cls_mod.rsplit(".", 1)[0] if "." in cls_mod else cls_mod
-
-    discovered = _discover_functions(base_pkg, hot_reload=hot_reload)
-    seen: Dict[str, str] = {}
-
-    for name, fn, mod_base in discovered:
-        attr_name = f"{mod_base}_{name}" if prefix_with_module else name
-
-        if hasattr(self, attr_name):
-            if on_collision == "skip":
-                continue
-            if on_collision == "error":
-                raise RuntimeError(f"attach_functions collision on '{attr_name}' from module '{mod_base}'")
-            # last_wins: fall through
-
-        setattr(self, attr_name, fn)
-        seen[attr_name] = mod_base
-
-    # breadcrumb for debugging
-    setattr(self, "_attached_functions", sorted(seen.keys()))
-    return self
-
-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 clean_imports():
-    alls = str(list(set("""os,re,subprocess,sys,re,traceback,pydot, enum, inspect, sys, traceback, threading,json,traceback,logging,requests""".replace('\n','').replace(' ','').replace('\t','').split(','))))[1:-1].replace('"','').replace("'",'')
-    input(alls)
-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 caller_path()
-    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:
-            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):
-            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 .functions import ({func_tuple})
-
-            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_caller_dir(2)
-    get_for_all_tabs(root)

abstract_utilities/robust_reader/imports/__init__.py

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

abstract_utilities/robust_reader/imports/imports.py

@@ -1,12 +0,0 @@
-import os,tempfile,shutil,logging,ezodf,fnmatch,pytesseract,pdfplumber
-import pandas as pd
-import geopandas as gpd
-from datetime import datetime
-from pathlib import Path
-from typing import *
-from werkzeug.utils import secure_filename
-from werkzeug.datastructures import FileStorage
-from pdf2image import convert_from_path   # only used for OCR fallback
-from ...abstract_classes import SingletonMeta
-from ..pdf_utils import *
-from ...read_write_utils import *

abstract_utilities/robust_readers/imports.py

@@ -1,8 +0,0 @@
-from types import ModuleType
-from typing import Iterable
-from ..file_utils import get_caller_dir,get_caller_path,define_defaults,get_files_and_dirs
-from ..read_write_utils import *
-import textwrap, pkgutil, os, re, textwrap, sys, types, importlib, importlib.util
-from typing import *
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)

abstract_utilities/safe_utils.py

@@ -1,133 +0,0 @@
-"""
-abstract_safeops.py
--------------------
-Utility functions for safely splitting, slicing, and retrieving elements from iterable or string objects
-without raising exceptions on invalid input or out-of-range indices.
-
-Designed for compatibility with the abstract_ ecosystem (e.g. abstract_utilities, abstract_math, etc.).
-"""
-
-from typing import *
-from .type_utils import is_number
-from .class_utils import get_caller_dir
-
-_BASE_DIR = get_caller_dir()
-
-
-def safe_split(
-    string: Any,
-    char: Any,
-    i: Optional[int] = None,
-    default: Union[bool, Any] = False
-) -> Union[str, List[str], Any, None]:
-    """
-    Safely split a string by a character and optionally return index i.
-
-    Args:
-        string: Input string (or any object convertible to string).
-        char: Delimiter to split on.
-        i: Optional index to retrieve from the split result.
-        default: If True, return the original string on error. 
-                 If any other value, return that instead of raising.
-
-    Returns:
-        The split list, or the element at index i, or default behavior on error.
-    """
-    if string is None or char is None:
-        return string
-
-    s, c = str(string), str(char)
-    if c not in s:
-        return string
-
-    parts = s.split(c)
-
-    if i is None:
-        return parts
-
-    if is_number(i):
-        idx = int(i)
-        if 0 <= idx < len(parts):
-            return parts[idx]
-
-    if default:
-        return string if default is True else default
-
-    return None
-
-
-def safe_slice(
-    obj: Any,
-    i: Optional[int] = None,
-    k: Optional[int] = None,
-    default: Union[bool, Any] = False
-) -> Any:
-    """
-    Safely slice an iterable object or string, with fallback behavior on invalid indices.
-
-    Args:
-        obj: Iterable or string-like object.
-        i: Start index (can be negative).
-        k: End index (can be negative).
-        default: If True, returns the original object on error.
-                 If any other value, return that value on error.
-
-    Returns:
-        The sliced object, or default behavior on error.
-    """
-    # Null or invalid base case
-    if obj is None or isinstance(obj, bool):
-        return obj if default is True else default if default else None
-
-    # Non-iterable guard
-    if not hasattr(obj, "__getitem__"):
-        return obj if default is True else default if default else None
-
-    obj_len = len(obj)
-
-    # Normalize negative indices
-    if isinstance(i, int) and i < 0:
-        i = obj_len + i
-    if isinstance(k, int) and k < 0:
-        k = obj_len + k
-
-    # Bound indices
-    if i is not None:
-        i = max(0, min(i, obj_len))
-    if k is not None:
-        k = max(0, min(k, obj_len))
-
-    try:
-        return obj[i:k]
-    except Exception:
-        return obj if default is True else default if default else None
-
-def safe_join(*paths):
-    paths = list(paths)
-    paths = [path for path in paths if path]
-    return os.path.join(*paths)
-def safe_get(
-    obj: Any,
-    key: Union[int, str, None] = None,
-    default: Union[bool, Any] = False
-) -> Any:
-    """
-    Generalized safe getter for both indexable and mapping types.
-
-    Args:
-        obj: The object to access (list, dict, string, etc.).
-        key: Index or key to retrieve.
-        default: Fallback value or True for "return obj".
-
-    Returns:
-        Retrieved element, or default value on failure.
-    """
-    if obj is None or key is None:
-        return obj if default is True else default if default else None
-
-    try:
-        if isinstance(obj, dict):
-            return obj.get(key, obj if default is True else default if default else None)
-        return obj[key]
-    except Exception:
-        return obj if default is True else default if default else None

abstract_utilities/ssh_utils/__init__.py

@@ -1,3 +0,0 @@
-from .classes import *
-from .utils import *
-from .pexpect_utils import *

abstract_utilities/ssh_utils/classes.py

@@ -1,127 +0,0 @@
-from .imports import *
-from .utils import run_local_cmd, run_ssh_cmd,run_any_cmd,run_cmd
-
-class PathBackend(Protocol):
-    def join(self, *parts: str) -> str: ...
-    def isfile(self, path: str) -> bool: ...
-    def isdir(self, path: str) -> bool: ...
-    def glob_recursive(self, base: str, **opts) -> List[str]: ...
-    def listdir(self, base: str) -> List[str]: ...
-
-class LocalFS:
-    def join(self, *parts: str) -> str:
-        return os.path.join(*parts)
-    def isfile(self, path: str) -> bool:
-        return os.path.isfile(path)
-    def isdir(self, path: str) -> bool:
-        return os.path.isdir(path)
-    def glob_recursive(self, base: str, **opts) -> List[str]:
-        """
-        opts:
-          - maxdepth: int | None
-          - mindepth: int (default 1)
-          - follow_symlinks: bool
-          - include_dirs: bool
-          - include_files: bool
-          - exclude_hidden: bool
-        """
-        maxdepth = opts.get("maxdepth")
-        mindepth = opts.get("mindepth", 1)
-        follow   = opts.get("follow_symlinks", False)
-        want_d   = opts.get("include_dirs", True)
-        want_f   = opts.get("include_files", True)
-        hide     = opts.get("exclude_hidden", False)
-
-        results: List[str] = []
-        base_depth = os.path.normpath(base).count(os.sep)
-
-        for root, dirs, files in os.walk(base, followlinks=follow):
-            depth = os.path.normpath(root).count(os.sep) - base_depth
-            if maxdepth is not None and depth > maxdepth:
-                dirs[:] = []
-                continue
-            if want_d and depth >= mindepth:
-                for d in dirs:
-                    if hide and d.startswith("."): continue
-                    results.append(os.path.join(root, d))
-            if want_f and depth >= mindepth:
-                for f in files:
-                    if hide and f.startswith("."): continue
-                    results.append(os.path.join(root, f))
-        return results
-
-    def listdir(self, base: str) -> List[str]:
-        try:
-            return [os.path.join(base, name) for name in os.listdir(base)]
-        except Exception:
-            return []
-
-class SSHFS:
-    """Remote POSIX backend via your run_remote_cmd."""
-    def __init__(self, user_at_host: str):
-        self.user_at_host = user_at_host
-
-    def join(self, *parts: str) -> str:
-        return posixpath.join(*parts)
-
-    def isfile(self, path: str) -> bool:
-        cmd = f"test -f {shlex.quote(path)} && echo __OK__ || true"
-        out = run_remote_cmd(self.user_at_host, cmd)
-        return "__OK__" in (out or "")
-
-    def isdir(self, path: str) -> bool:
-        cmd = f"test -d {shlex.quote(path)} && echo __OK__ || true"
-        out = run_remote_cmd(self.user_at_host, cmd)
-        return "__OK__" in (out or "")
-
-    def glob_recursive(self, base: str, **opts) -> List[str]:
-        maxdepth = opts.get("maxdepth")
-        mindepth = opts.get("mindepth", 1)
-        follow   = opts.get("follow_symlinks", False)
-        want_d   = opts.get("include_dirs", True)
-        want_f   = opts.get("include_files", True)
-        hide     = opts.get("exclude_hidden", False)
-
-        parts = []
-        if follow:
-            parts.append("-L")
-        parts += ["find", shlex.quote(base)]
-        if mindepth is not None:
-            parts += ["-mindepth", str(mindepth)]
-        if maxdepth is not None:
-            parts += ["-maxdepth", str(maxdepth)]
-
-        type_filters = []
-        if want_d and not want_f:
-            type_filters = ["-type", "d"]
-        elif want_f and not want_d:
-            type_filters = ["-type", "f"]
-
-        hidden_filter = []
-        if hide:
-            hidden_filter = ["!", "-regex", r".*/\..*"]
-
-        cmd = " ".join(parts + type_filters + hidden_filter + ["-printf", r"'%p\n'"]) + " 2>/dev/null"
-        out = run_remote_cmd(self.user_at_host, cmd)
-        return [line.strip().strip("'") for line in (out or "").splitlines() if line.strip()]
-
-    def listdir(self, base: str) -> List[str]:
-        cmd = f"find {shlex.quote(base)} -maxdepth 1 -mindepth 1 -printf '%p\\n' 2>/dev/null"
-        out = run_remote_cmd(self.user_at_host, cmd)
-        return [line.strip() for line in (out or "").splitlines() if line.strip()]
-
-# ---- auto-detect "user@host:/abs/path" ----
-REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
-
-def normalize_items(paths: Iterable[str],user_at_host=None,**kwargs) -> List[tuple[PathBackend, str]]:
-    pairs: List[tuple[PathBackend, str]] = []
-    host = user_at_host or kwargs.get('host')
-    
-    for item in paths:
-        if not item: continue
-        m = REMOTE_RE.match(item)
-        if m:
-            pairs.append((SSHFS(m.group("host") or user_at_host), m.group("path")))
-        else:
-            pairs.append((LocalFS(), item))
-    return pairs

abstract_utilities/ssh_utils/imports.py

@@ -1,10 +0,0 @@
-# remote_fs.py
-from __future__ import annotations
-from typing import *
-import subprocess, shlex, os, fnmatch, glob, posixpath, re
-# exec_api.py
-# ---- import your existing pieces ----
-from ..type_utils import make_list 
-from ..time_utils import get_sleep
-from ..env_utils import *
-from ..string_clean import eatOuter