abstract-utilities 0.2.2.387__py3-none-any.whl → 0.2.2.480__py3-none-any.whl

abstract_utilities/robust_readers/initFuncGen.py

@@ -1,33 +1,22 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from types import ModuleType
-from typing import Iterable
-from .file_filters import define_defaults,get_files_and_dirs
+from .imports import *
+def call_for_all_tabs(root = None,tab_control=True):
+    root = root or get_caller_dir()
+    get_for_all_tabs(root,tab_control=tab_control)
 
-import inspect
-from ..read_write_utils import *
-import textwrap, pkgutil, os, re, textwrap, sys, types, importlib, importlib.util, inspect
-from typing import *
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)
-def get_caller_path():
-    frame = inspect.stack()[1]
-    return os.path.abspath(frame.filename)
-def get_caller_dir():
-    frame = inspect.stack()[1]
-    abspath = os.path.abspath(frame.filename)
-    return os.path.dirname(abspath)
-def call_for_all_tabs():
-
-    root = get_caller_dir()
-    get_for_all_tabs(root)
-
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)
-def clean_imports():
+def get_clean_list(*args):
+    objs = []
+    for arg in args:
+        objs+= make_list(arg)
+    return list(set(objs))
+def clean_imports(*args,**kwargs):
+    for pkg,imps in kwargs.items():
+        f"from {pkg} import make_list(imps)"
+        
     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)
+    return 
 def isTab(item):
     item_lower =  item.lower()
     for key in ['console','tab']:
@@ -57,11 +46,17 @@ def ifFunctionsInFile(root):
             return item
         
 
-def get_for_all_tabs(root = None):
+def get_for_all_tabs(root = None,tab_control=True):
     root = root or caller_path()
     if os.path.isfile(root):
         root = os.path.dirname(root)
-    all_tabs = get_dirs(root = root)
+    if tab_control:
+        all_tabs = get_dirs(root = root)
+    else:
+        dirname = root
+        if root and os.path.isfile(root):
+            dirname = os.path.dirname(root)
+        all_tabs = [dirname]
     for ROOT in all_tabs:
         FUNCS_DIR = ifFunctionsInFile(ROOT)
         if FUNCS_DIR == None:
@@ -71,52 +66,38 @@ def get_for_all_tabs(root = None):
             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"""\
+def write_init_functions(import_lines,functions_dir):
+    functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+    init_file_path = os.path.join(functions_dir, "__init__.py")
+    write_to_file(contents=functions_init, file_path=init_file_path)
+    return {"functions_init":functions_init,"init_file_path":init_file_path}
+def extract_funcs(filepaths):
+    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
+def get_all_funcs(
+    filepaths,
+    all_funcs=None,
+    import_lines=None
+    ):
+    import_lines = import_lines or []
+    all_funcs = all_funcs or []
+    for fp in filepaths:
+        basename = os.path.basename(fp)
+        module = os.path.splitext(basename)[0]
+        funcs = extract_funcs(fp)
+        if funcs:
+            import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+            all_funcs.extend(funcs)
+    uniq_funcs = sorted(set(all_funcs))
+    func_tuple=", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+    all_funcs_js = {"import_lines":import_lines,"all_funcs":all_funcs,"uniq_funcs":uniq_funcs,"func_tuple":func_tuple}
+    return all_funcs_js
+def get_init_funcs_str(func_tuple):
+        init_funcs_str = textwrap.dedent(f"""\
             
 
             from .functions import ({func_tuple})
@@ -129,7 +110,42 @@ def apply_inits(ROOT):
                     logger.info(f"{{e}}")
                 return self
         """)
-
-        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
-
+        return init_funcs_str
+def get_function_file_paths(functions_dir):
+    filepaths=[]
+    if_fun_dir = isDir(functions_dir)
+    if if_fun_dir != None:
+        input(if_fun_dir)
+        if if_fun_dir:
+            CFG = define_defaults(allowed_exts='.py',
+                unallowed_exts = True,
+                exclude_types = True,
+                exclude_dirs = True,
+                exclude_patterns = True)
+            input(CFG)
+            _,filepaths = get_files_and_dirs(functions_dir,cfg=CFG)
+        else:
+            filepaths = [FUNCS_DIR]
+    input(filepaths)
+    return filepaths
+def apply_inits(root=None,tab_control=True):
+    root = root or get_caller_dir()
+    FUNCS_DIR = ifFunctionsInFile(root)
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:  
+        file_paths = get_function_file_paths(FUNCS_DIR)
+ 
+        all_funcs_js = get_all_funcs(
+            filepaths=file_paths
+            )
+        if if_fun_dir:
+            init_func_js = write_init_functions(import_lines=all_funcs_js.get('import_lines'),functions_dir=FUNCS_DIR)
+            all_funcs_js.update(init_func_js)
+        func_tuple = all_funcs_js.get("func_tuple")
+        init_funcs_str = get_init_funcs_str(func_tuple)
+        init_funcs_file_path = os.path.join(root, "initFuncs.py")
+        all_funcs_js["funcs_str"]=init_funcs_str
+        all_funcs_js["funcs_file_path"]=init_funcs_file_path
+        write_to_file(contents=init_funcs_str, file_path=init_funcs_file_path)
+        return all_funcs_js
 

abstract_utilities/safe_utils.py

@@ -0,0 +1,133 @@
+"""
+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

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

abstract_utilities/ssh_utils/classes.py

@@ -0,0 +1,127 @@
+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

@@ -0,0 +1,10 @@
+# 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