abstract-utilities 0.2.2.420__py3-none-any.whl → 0.2.2.422__py3-none-any.whl

abstract_utilities/__init__.py

@@ -3,9 +3,8 @@ from datetime import timedelta
 from datetime import datetime
 from typing import *
 from .hash_utils import *
-from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
+##from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
 
-from .robust_readers import *
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,

abstract_utilities/dynimport.py

@@ -6,7 +6,7 @@ from typing import Any, Callable, Iterable, Optional
 import inspect, sys
 from importlib import import_module
 from .type_utils import make_list
-from .robust_readers import get_for_all_tabs,call_for_all_tabs
+from .file_utils import get_for_all_tabs,call_for_all_tabs
 class _LazyAttr:
     """Lazy resolver proxy to avoid import-time cycles.
     First use triggers actual import & attribute lookup.

abstract_utilities/file_utils/file_utils/file_utils.py

@@ -2,193 +2,207 @@ from .imports import *
 # -------- Public API drop-ins that mirror your originals --------
 from .filter_params import *
 from .file_filters import *
-def make_allowed_predicate(cfg: ScanConfig, *, isdir=None, isfile=None) -> Callable[[str], bool]:
-    def _isdir(p: str) -> bool: return isdir(p) if isdir else Path(p).is_dir()
-    def _isfile(p: str) -> bool: return isfile(p) if isfile else Path(p).is_file()
-    def allowed(path: str) -> bool:
-        name = os.path.basename(path).lower()
-        path_str = path.lower()
+# -------------------------------------------------------------
+# Wrapper: respects your original API and naming conventions
+# -------------------------------------------------------------
 
-        if cfg.exclude_dirs:
-            for dpat in cfg.exclude_dirs:
-                d = dpat.lower()
-                if d in path_str or fnmatch.fnmatch(name, d):
-                    if _isdir(path) or d in path_str:
-                        return False
+def get_allowed_predicate(allowed=None):
+    if allowed is not False:
+        if allowed is True:
+            allowed = None
+        allowed = allowed or make_allowed_predicate()
+    else:
+        def allowed(*args):
+            return True
+    return allowed
 
-        if cfg.exclude_patterns:
-            for pat in cfg.exclude_patterns:
-                if fnmatch.fnmatch(name, pat.lower()):
-                    return False
 
-        if _isfile(path):
-            ext = os.path.splitext(name)[1].lower()
-            if (cfg.allowed_exts and ext not in cfg.allowed_exts) or (cfg.unallowed_exts and ext in cfg.unallowed_exts):
-                return False
-        return True
-    return allowed
+# -------------------------------------------------------------
+# Remote-aware globbing
+# -------------------------------------------------------------
+def get_globs(items, recursive: bool = True, allowed=None, **kwargs):
+    """
+    Behaves like your original get_globs(), but can traverse both
+    local and remote paths transparently via normalize_items().
+    """
+    glob_paths = []
+    roots = [p for p in make_list(items) if p]
 
-def get_globs(paths, recursive: bool = True, allowed=None, **kwargs) -> List[str]:
-    roots = [p for p in make_list(paths) if p]
-    res: List[str] = []
-    if recursive:
-        kwargs.setdefault("mindepth", 1)
-    else:
-        kwargs.setdefault("mindepth", 1)
+    kwargs.setdefault("mindepth", 0)
+    if not recursive:
         kwargs.setdefault("maxdepth", 1)
-    for fs, root in normalize_items(roots, **kwargs):
-        gl = fs.glob_recursive(root, **kwargs)
+    
+    for fs, root, _ in normalize_items(roots, **kwargs):
+        # use the backend's recursive walker
+        nu_items = fs.glob_recursive(root, **kwargs)
         if allowed:
-            gl = [p for p in gl if allowed(p)]
-        res.extend(gl)
-    return res
-
-def get_allowed_files(paths, allowed=True, **kwargs) -> List[str]:
-    if allowed is not False:
-        if allowed is True:
-            allowed = None
-        allowed = allowed or make_allowed_predicate(ScanConfig())
-    elif allowed is False:
-        allowed = (lambda *_: True)
-
-    roots = [p for p in make_list(paths) if p]
-    out: List[str] = []
-    kwargs = {**kwargs, "include_files": True, "include_dirs": False}
-    for fs, root in normalize_items(roots):
-        if fs.isdir(root):
-            for p in fs.glob_recursive(root, **kwargs):
-                if allowed and not allowed(p): continue
-                if fs.isfile(p): out.append(p)
-        else:
-            if allowed and not allowed(root): continue
-            if fs.isfile(root): out.append(root)
+           
+            nu_items = [n for n in nu_items if n and allowed(n)]
+            
+        glob_paths += nu_items
+    return glob_paths
+
+
+# -------------------------------------------------------------
+# Allowed filters
+# -------------------------------------------------------------
+def get_allowed_files(items, allowed=True, **kwargs):
+    allowed = get_allowed_predicate(allowed=allowed)
+    out = []
+    for fs, item, _ in normalize_items(items, **kwargs):
+        if fs.isfile(item) and allowed(item):
+            out.append(item)
     return out
 
-def get_allowed_dirs(paths, allowed=False, **kwargs) -> List[str]:
-    if allowed is not False:
-        if allowed is True:
-            allowed = None
-        allowed = allowed or make_allowed_predicate(ScanConfig())
-    else:
-        allowed = (lambda *_: True)
-
-    roots = [p for p in make_list(paths) if p]
-    out: List[str] = []
-    kwargs = {**kwargs, "include_files": False, "include_dirs": True}
-    for fs, root in normalize_items(roots):
-        if fs.isdir(root):
-            if (not allowed) or allowed(root):
-                out.append(root)
-            for p in fs.glob_recursive(root, **kwargs):
-                if (not allowed) or allowed(p):
-                    if fs.isdir(p): out.append(p)
+
+def get_allowed_dirs(items, allowed=False, **kwargs):
+    allowed = get_allowed_predicate(allowed=allowed)
+    out = []
+    for fs, item, _ in normalize_items(items, **kwargs):
+        if fs.isdir(item) and allowed(item):
+            out.append(item)
     return out
 
-def get_filtered_files(paths, allowed=None, files: List[str] | None = None, **kwargs) -> List[str]:
-    if allowed is not False:
-        if allowed is True:
-            allowed = None
-        allowed = allowed or make_allowed_predicate(ScanConfig())
-    else:
-        allowed = (lambda *_: True)
 
-    files = files or []
-    roots = [p for p in make_list(paths) if p]
-    out: List[str] = []
-    kwargs = {**kwargs, "include_files": True, "include_dirs": False}
-    for fs, root in normalize_items(roots):
+# -------------------------------------------------------------
+# Filtered sets
+# -------------------------------------------------------------
+def get_filtered_files(items, allowed=None, files=None, **kwargs):
+    allowed = get_allowed_predicate(allowed=allowed)
+    files = set(files or [])
+    out = []
+    for fs, root, _ in normalize_items(items, **kwargs):
         for p in fs.glob_recursive(root, **kwargs):
-            if p in files: continue
-            if allowed and not allowed(p): continue
-            if fs.isfile(p): out.append(p)
+            if p in files:
+                continue
+            if allowed(p) and fs.isfile(p):
+                out.append(p)
     return out
 
-def get_filtered_dirs(paths, allowed=None, dirs: List[str] | None = None, **kwargs) -> List[str]:
-    if allowed is not False:
-        if allowed is True:
-            allowed = None
-        allowed = allowed or make_allowed_predicate(ScanConfig())
-    else:
-        allowed = (lambda *_: True)
 
-    dirs = dirs or []
-    roots = [p for p in make_list(paths) if p]
-    out: List[str] = []
-    kwargs = {**kwargs, "include_files": False, "include_dirs": True}
-    for fs, root in normalize_items(roots):
+def get_filtered_dirs(items, allowed=None, dirs=None, **kwargs):
+    allowed = get_allowed_predicate(allowed=allowed)
+    dirs = set(dirs or [])
+    out = []
+    for fs, root, _ in normalize_items(items, **kwargs):
         for p in fs.glob_recursive(root, **kwargs):
-            if p in dirs: continue
-            if allowed and not allowed(p): continue
-            if fs.isdir(p): out.append(p)
+            if p in dirs:
+                continue
+            if allowed(p) and fs.isdir(p):
+                out.append(p)
     return out
 
-def get_all_allowed_files(paths, allowed=None, **kwargs) -> List[str]:
-    dirs = get_all_allowed_dirs(paths, allowed=allowed, **kwargs)
-    files = get_allowed_files(paths, allowed=allowed, **kwargs)
+
+# -------------------------------------------------------------
+# Recursive expansion
+# -------------------------------------------------------------
+def get_all_allowed_files(items, allowed=None, **kwargs):
+    dirs = get_all_allowed_dirs(items, allowed=allowed, **kwargs)
+    files = get_allowed_files(items, allowed=allowed, **kwargs)
     seen = set(files)
-    for fs, directory in normalize_items(dirs):
+    for fs, directory, _ in normalize_items(dirs, **kwargs):
         for p in fs.glob_recursive(directory, **kwargs):
-            if p in seen: continue
-            if allowed and not allowed(p): continue
+            if p in seen:
+                continue
+            if allowed and not allowed(p):
+                continue
             if fs.isfile(p):
-                files.append(p); seen.add(p)
+                files.append(p)
+                seen.add(p)
     return files
 
-def get_all_allowed_dirs(paths, allowed=None, **kwargs) -> List[str]:
-    if allowed is not False:
-        if allowed is True:
-            allowed = None
-        allowed = allowed or make_allowed_predicate(ScanConfig())
-    else:
-        allowed = (lambda *_: True)
 
-    roots = [p for p in make_list(paths) if p]
-    out: List[str] = []
+def get_all_allowed_dirs(items, allowed=None, **kwargs):
+    allowed = get_allowed_predicate(allowed=allowed)
+    out = []
     seen = set()
-    kwargs = {**kwargs, "include_dirs": True}
-    for fs, root in normalize_items(roots):
-        if fs.isdir(root) and ((not allowed) or allowed(root)):
-            out.append(root); seen.add(root)
+    for fs, root, _ in normalize_items(items, **kwargs):
+        if fs.isdir(root) and allowed(root):
+            out.append(root)
+            seen.add(root)
         for p in fs.glob_recursive(root, **kwargs):
-            if p in seen: continue
-            if allowed and not allowed(p): continue
-            if fs.isdir(p):
-                out.append(p); seen.add(p)
+            if p in seen:
+                continue
+            if allowed(p) and fs.isdir(p):
+                out.append(p)
+                seen.add(p)
     return out
+
+
+# -------------------------------------------------------------
+# Unified directory scan
+# -------------------------------------------------------------
 def get_files_and_dirs(
-    directory: str | list[str]=None,
+    directory: str,
     cfg: Optional["ScanConfig"] = None,
     allowed_exts: Optional[Set[str]] = False,
     unallowed_exts: Optional[Set[str]] = False,
     exclude_types: Optional[Set[str]] = False,
     exclude_dirs: Optional[List[str]] = False,
     exclude_patterns: Optional[List[str]] = False,
-    add: bool = False,
+    add=False,
     recursive: bool = True,
     include_files: bool = True,
-    paths: str | list[str]=None,
     **kwargs
 ):
+    """
+    Same public signature as your original get_files_and_dirs(),
+    but powered by backend objects (LocalFS or SSHFS).
+    """
     cfg = cfg or define_defaults(
         allowed_exts=allowed_exts,
         unallowed_exts=unallowed_exts,
         exclude_types=exclude_types,
         exclude_dirs=exclude_dirs,
         exclude_patterns=exclude_patterns,
-        add=add,
+        add=add
     )
-    # make predicate backend-agnostic here; the per-backend calls below pass strings only
     allowed = make_allowed_predicate(cfg)
-
+    items = []
+    files = []
+    input(allowed)
     if recursive:
-        kwargs.setdefault("mindepth", 1)
+        items = get_globs(directory, recursive=recursive, allowed=allowed, **kwargs)
     else:
-        kwargs.setdefault("mindepth", 1)
-        kwargs.setdefault("maxdepth", 1)
-    paths = paths or []
-    roots = paths+make_list(directory)
-    items = get_globs(roots, recursive=recursive, allowed=allowed, **kwargs)
+        for fs, base, _ in normalize_items(make_list(directory), **kwargs):
+            try:
+                items += [fs.join(base, name) for name in fs.listdir(base)]
+            except Exception:
+                pass
 
     dirs = get_allowed_dirs(items, allowed=allowed, **kwargs)
-    files = get_allowed_files(items, allowed=allowed, **kwargs) if include_files else []
+    if include_files:
+        files = get_allowed_files(items, allowed=allowed, **kwargs)
     return dirs, files
+
+
+# -------------------------------------------------------------
+# Unchanged predicate builder
+# -------------------------------------------------------------
+def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
+    def allowed(path: str) -> bool:
+        p = Path(path)
+        name = p.name.lower()
+        path_str = str(p).lower()
+
+        # A) directory exclusions
+        if cfg.exclude_dirs:
+            for dpat in cfg.exclude_dirs:
+                if dpat in path_str or fnmatch.fnmatch(name, dpat.lower()):
+                    if p.is_dir() or dpat in path_str:
+                        return False
+
+        # B) filename pattern exclusions
+        if cfg.exclude_patterns:
+            for pat in cfg.exclude_patterns:
+                if fnmatch.fnmatch(name, pat.lower()):
+                    return False
+
+        # C) extension gates
+        if p.is_file():
+            ext = p.suffix.lower()
+            if (cfg.allowed_exts and ext not in cfg.allowed_exts) or \
+               (cfg.unallowed_exts and ext in cfg.unallowed_exts):
+                return False
+        return True
+    return allowed

abstract_utilities/file_utils/imports/classes.py

@@ -1,6 +1,138 @@
 from .imports import *
 from .module_imports import *
 from .constants import *
+def get_item_check_cmd(path, file=True, directory=False, exists=False):
+    if (directory and file) or exists:
+        typ = "e"
+    elif file:
+        typ = "f"
+    elif directory:
+        typ = "d"
+    elif isinstance(file, str):
+        if "f" in file:
+            typ = "f"
+        elif "d" in file:
+            typ = "d"
+        else:
+            typ = "e"
+    else:
+        typ = "e"
+    return f"test -{typ} {shlex.quote(path)} && echo __OK__ || true"
+
+
+def get_all_item_check_cmd(path, file=True, directory=True, exists=True):
+    collects = []
+    out_js = {}
+
+    if file:
+        collects.append("file")
+    if directory:
+        collects.append("dir")
+    if exists:
+        collects.append("exists")
+
+    if not collects:
+        return out_js
+
+    path = shlex.quote(path)
+    for typ in collects:
+        t = typ[0]  # f, d, or e
+        out_js[typ] = f"test -{t} {path} && echo __OK__ || true"
+
+    return out_js
+        
+
+def is_file(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    contingencies = list(set([user_at_host,password,key,env_path]))
+    len_contingencies = len(contingencies)
+    is_potential = (len_contingencies >1 or (None not in contingencies))
+    if not is_potential:
+        return os.path.isfile(path)
+    cmd = get_item_check_cmd(path,file=True)
+    return run_cmd(cmd=cmd,
+            user_at_host=user_at_host,
+            password=password,
+            key=key,
+            env_path=env_path,
+            **kwargs
+            )
+def is_dir(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    contingencies = list(set([user_at_host,password,key,env_path]))
+    len_contingencies = len(contingencies)
+    is_potential = (len_contingencies >1 or (None not in contingencies))
+    if not is_potential:
+        return os.path.isdir(path)
+    cmd = get_item_check_cmd(path,file=False,directory=True)
+    return run_cmd(cmd=cmd,
+            user_at_host=user_at_host,
+            password=password,
+            key=key,
+            env_path=env_path,
+            **kwargs
+            )
+def is_exists(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    contingencies = list(set([user_at_host,password,key,env_path]))
+    len_contingencies = len(contingencies)
+    is_potential = (len_contingencies >1 or (None not in contingencies))
+    if not is_potential:
+        return os.path.exists(path)
+    if is_potential == True:
+        cmd = get_item_check_cmd(path,exists=True)
+        return run_cmd(cmd=cmd,
+                user_at_host=user_at_host,
+                password=password,
+                key=key,
+                env_path=env_path,
+                **kwargs
+                )
+def is_any(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    contingencies = list(set([user_at_host,password,key,env_path]))
+    len_contingencies = len(contingencies)
+    is_potential = (len_contingencies >1 or (None not in contingencies))
+    if not is_potential:
+        return os.path.exists(path)
+    if is_potential == True:
+        out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
+        for typ,cmd in out_js.items():
+            response = run_cmd(cmd=cmd,
+                    user_at_host=user_at_host,
+                    password=password,
+                    key=key,
+                    env_path=env_path,
+                    **kwargs
+                    )
+            result = "__OK__" in (response or "")
+            if result:
+                return typ
+    return None
 class PathBackend(Protocol):
     def join(self, *parts: str) -> str: ...
     def isfile(self, path: str) -> bool: ...
@@ -9,12 +141,42 @@ class PathBackend(Protocol):
     def listdir(self, base: str) -> List[str]: ...
 
 class LocalFS:
+    def __init__(self, get_type=False, get_is_dir=False, get_is_file=False, get_is_exists=False, **kwargs):
+        self.get_type = get_type
+        self.get_is_dir = get_is_dir
+        self.get_is_file = get_is_file
+        self.get_is_exists = get_is_exists
+
     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 isexists(self, path: str) -> bool:
+        return os.path.exists(path)
+
+    def istype(self, path: str) -> str | None:
+        funcs_js = {"file": os.path.isfile, "dir": os.path.isdir, "exists": os.path.exists}
+        for key, func in funcs_js.items():
+            if func(path):
+                return key
+        return None
+
+    def is_included(self, path, **kwargs):
+        include_js = {}
+        if self.get_type:
+            include_js["typ"] = self.istype(path)
+        if self.get_is_dir:
+            include_js["dir"] = self.isdir(path)
+        if self.get_is_file:
+            include_js["file"] = self.isfile(path)
+        if self.get_is_exists:
+            include_js["exists"] = self.isexists(path)
+        return include_js
     def glob_recursive(self, base: str, **opts) -> List[str]:
         """
         opts:
@@ -55,25 +217,73 @@ class LocalFS:
             return [os.path.join(base, name) for name in os.listdir(base)]
         except Exception:
             return []
-
+def get_spec_kwargs(
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    kwargs=None
+):
+    kwargs = kwargs or {}
+    kwargs["user_at_host"] = kwargs.get("user_at_host") or user_at_host
+    kwargs["password"] = kwargs.get("password") or password
+    kwargs["key"] = kwargs.get("key") or key
+    kwargs["env_path"] = kwargs.get("env_path") or env_path
+    return kwargs
 class SSHFS:
-    """Remote POSIX backend via your run_remote_cmd."""
-    def __init__(self, user_at_host: str):
-        self.user_at_host = user_at_host
+    """Remote POSIX backend via run_remote_cmd."""
+    def __init__(self, password=None, key=None, env_path=None,
+                 get_type=False, get_is_dir=False, get_is_file=False, get_is_exists=False, **kwargs):
+        self.user_at_host = kwargs.get('user_at_host') or kwargs.get('user') or kwargs.get('host')
+        self.password = password
+        self.key = key
+        self.env_path = env_path
+        self.get_type = get_type
+        self.get_is_dir = get_is_dir
+        self.get_is_file = get_is_file
+        self.get_is_exists = get_is_exists
+
+    def cell_spec_kwargs(self, func, path, **kwargs):
+        kwargs = get_spec_kwargs(
+            user_at_host=self.user_at_host,
+            password=self.password,
+            key=self.key,
+            env_path=self.env_path,
+            kwargs=kwargs
+        )
+        return func(path, **kwargs)
+
+    def is_included(self, path, **kwargs):
+        include_js = {}
+        if self.get_type:
+            include_js["typ"] = self.istype(path, **kwargs)
+        if self.get_is_dir:
+            include_js["dir"] = self.isdir(path, **kwargs)
+        if self.get_is_file:
+            include_js["file"] = self.isfile(path, **kwargs)
+        if self.get_is_exists:
+            include_js["exists"] = self.isexists(path, **kwargs)
+        return include_js
 
     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)
+    def isfile(self, path: str, **kwargs) -> bool:
+        out = self.cell_spec_kwargs(is_file, path, **kwargs)
         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)
+    def isdir(self, path: str, **kwargs) -> bool:
+        out = self.cell_spec_kwargs(is_dir, path, **kwargs)
+        return "__OK__" in (out or "")
+
+    def isexists(self, path: str, **kwargs) -> bool:
+        out = self.cell_spec_kwargs(is_exists, path, **kwargs)
         return "__OK__" in (out or "")
 
+    def istype(self, path: str, **kwargs) -> str | None:
+        out = self.cell_spec_kwargs(is_any, path, **kwargs)
+        return out
+
     def glob_recursive(self, base: str, **opts) -> List[str]:
         maxdepth = opts.get("maxdepth")
         mindepth = opts.get("mindepth", 1)
@@ -111,18 +321,86 @@ class SSHFS:
         return [line.strip() for line in (out or "").splitlines() if line.strip()]
 
 
-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') or kwargs.get('user')
+def make_allowed_predicate(cfg: ScanConfig,fs=None) -> Callable[[str], bool]:
+    fs = fs or LocalFS()
+    def allowed(path: str) -> bool:
+        
+        name = p.name.lower()
+        path_str = str(p).lower()
+        # A) directories
+        if cfg.exclude_dirs:
+            for dpat in cfg.exclude_dirs:
+                if dpat in path_str or fnmatch.fnmatch(name, dpat.lower()):
+                    if p.is_dir() or dpat in path_str:
+                        return False
+
+        if cfg.exclude_patterns:
+            # B) filename patterns
+            for pat in cfg.exclude_patterns:
+                if fnmatch.fnmatch(name, pat.lower()):
+                    return False
+
+        # C) extension gates
+        if p.is_file():
+            ext = p.suffix.lower()
+            if (cfg.allowed_exts and ext not in cfg.allowed_exts) or (cfg.unallowed_exts and ext in cfg.unallowed_exts):
+                return False
+        return True
+    return allowed
+def try_group(pre,item,strings):
+    
+    try:
+        m = pre.match(item)
+        for i,string in enumerate(strings):
+            strings[i] = m.group(string)
+        
+    except:
+        return None
+    return strings
+def normalize_items(
+    paths: Iterable[str],
+    user_at_host=None,
+    get_type=True,
+    get_is_dir=False,
+    get_is_file=False,
+    get_is_exists=False,
+    **kwargs
+) -> List[tuple[PathBackend, str, dict]]:
+    pairs: List[tuple[PathBackend, str, dict]] = []
+    host = user_at_host or kwargs.get("host") or kwargs.get("user")
+
     for item in paths:
-        if not item: continue
-        m = REMOTE_RE.match(item)
-        if m:
-            fs_host = SSHFS(m.group("host"))
-            item = m.group("path") or item
-        elif host:
-           fs_host = SSHFS(host)
+        if not item:
+            continue
+
+        strings = try_group(REMOTE_RE, item, ["host", "path"])
+        fs_host = None
+        nuhost = None
+
+        if (strings and None not in strings) or host:
+            if strings and None not in strings:
+                nuhost = strings[0]
+                item = strings[1] or item
+            nuhost = nuhost or host
+            fs_host = SSHFS(
+                nuhost,
+                user_at_host=user_at_host,
+                get_type=get_type,
+                get_is_dir=get_is_dir,
+                get_is_file=get_is_file,
+                get_is_exists=get_is_exists,
+                **kwargs
+            )
         else:
-           fs_host = LocalFS() 
-        pairs.append((fs_host, item))
+            fs_host = LocalFS(
+                get_type=get_type,
+                get_is_dir=get_is_dir,
+                get_is_file=get_is_file,
+                get_is_exists=get_is_exists
+            )
+
+        includes = fs_host.is_included(item)
+        pairs.append((fs_host, item, includes))
     return pairs
+
+

abstract_utilities/file_utils/imports/module_imports.py

@@ -1,8 +1,8 @@
 from ...string_clean import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type,MIME_TYPES,is_str
-from ...ssh_utils import run_local_cmd, run_ssh_cmd,run_any_cmd,run_cmd,cmd_input,run_remote_cmd
+from ...ssh_utils import *
 from ...env_utils import *
-from ...path_utils import *
+
 from ...abstract_classes import SingletonMeta
-from ...read_write_utils import *
+

abstract_utilities/ssh_utils/utils.py

@@ -1,4 +1,30 @@
 from .imports import *
+def get_pass_from_key(key=None,env_path=None):
+    if key:
+        return get_env_value(key=key,path=env_path)
+def get_password(password=None,key=None,env_path=None):
+    password = password or get_pass_from_key(key=key,env_path=env_path)
+    return password
+
+def get_print_sudo_cmd(
+        cmd: str,
+        password=None,
+        key=None,
+        env_path=None
+    ):
+    password = get_password(password=password,key=key,env_path=env_path)
+    if password != None:
+        
+        cmd = get_password_cmd(password=password,cmd=cmd)
+    return cmd
+def get_password_cmd(password:str,cmd:str):
+    sudo_cmd = get_sudo_cmd(cmd)
+    password_sudo_cmd = get_raw_password_sudo_cmd(password=password,sudo_cmd=sudo_cmd)
+    return password_sudo_cmd
+def get_sudo_cmd(cmd: str):
+    return f"sudo -S -k {cmd}"
+def get_raw_password_sudo_cmd(password:str,sudo_cmd:str):
+    return f"printf %s {shlex.quote(password)} | {sudo_cmd}"
 def get_remote_bash(
             cmd: str,
             cwd: str | None = None
@@ -9,13 +35,21 @@ def get_remote_ssh(
             remote:str=None
         ):
     return f"ssh {shlex.quote(user_at_host)} {shlex.quote(remote)}"
-                   
 def get_remote_cmd(
             cmd: str,
             user_at_host: str,
             cwd: str | None = None,
+            password=None,
+            key=None,
+            env_path=None
             
         ):
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
     remote = get_remote_bash(
         cmd=cmd,
         cwd=cwd
@@ -25,6 +59,8 @@ def get_remote_cmd(
         remote=remote
         )
     return full
+
+
 def execute_cmd(
         *args,
         outfile=None,
@@ -46,8 +82,18 @@ def run_local_cmd(
         outfile: Optional[str] = None,
         shell=True,
         text=True,
-        capture_output=True
+        capture_output=True,
+        user_at_host: str=None,
+        password=None,
+        key=None,
+        env_path=None
     ) -> str:
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
     return execute_cmd(
             cmd,
             outfile=outfile,
@@ -64,12 +110,21 @@ def run_remote_cmd(
         outfile: Optional[str] = None,
         shell=True,
         text=True,
-        capture_output=True
+        capture_output=True,
+        password=None,
+        key=None,
+        env_path=None
     ) -> str:
     """
     Run on remote via SSH; capture stdout+stderr locally; write to local outfile.
     NOTE: we do *not* try to write the file on the remote to avoid later scp.
     """
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
     # wrap in bash -lc for PATH/profile + allow 'cd && ...'
     cmd = get_remote_cmd(
         cmd=cmd,
@@ -83,6 +138,7 @@ def run_remote_cmd(
             text=text,
             capture_output=capture_output
         )
+
 def run_cmd(
         cmd: str=None,
         cwd: str | None = None,
@@ -90,8 +146,12 @@ def run_cmd(
         shell=True,
         text=True,
         capture_output=True,
-        user_at_host: str=None
+        user_at_host: str=None,
+        password=None,
+        key=None,
+        env_path=None
     ) -> str:
+
     if user_at_host:
         return run_ssh_cmd(
                 user_at_host=user_at_host,
@@ -100,7 +160,10 @@ def run_cmd(
                 outfile=outfile,
                 shell=shell,
                 text=text,
-                capture_output=capture_output
+                capture_output=capture_output,
+                password=password,
+                key=key,
+                env_path=env_path
             )
     return run_local_cmd(
             cmd=cmd,
@@ -108,7 +171,10 @@ def run_cmd(
             outfile=outfile,
             shell=shell,
             text=text,
-            capture_output=capture_output
+            capture_output=capture_output,
+            password=password,
+            key=key,
+            env_path=env_path
         )
 run_ssh_cmd = run_remote_cmd
 remote_cmd = run_remote_cmd

{abstract_utilities-0.2.2.420.dist-info → abstract_utilities-0.2.2.422.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.420
+Version: 0.2.2.422
 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.420.dist-info → abstract_utilities-0.2.2.422.dist-info}/RECORD

@@ -1,9 +1,9 @@
-abstract_utilities/__init__.py,sha256=YKa8RgAsIW8IsWWOU6HKnvCRE5vqb3k7HrBWmKRGb9I,6408
+abstract_utilities/__init__.py,sha256=hnDgg4ErEvB4kQ9j1GyN-wex9ba_XqTmz1Etf_i-XC8,6380
 abstract_utilities/abstract_classes.py,sha256=A6-FNDQb2P_jcyt01Kc5SuY2QawLVKNjQ-rDGfsn4rA,2461
 abstract_utilities/class_utils.py,sha256=-YHkdbaChRIz9YLXJlFF4m7VkdwUCts_HOUbKXxkrYA,12735
 abstract_utilities/collator_utils.py,sha256=9exNoZAr9rABGYTwZOn7hdLbpnMtRd2AgfU7yjZrXGw,2348
 abstract_utilities/doit.py,sha256=a1zkyMJbSGPvE-OmCQcH_dQyLME392UfvQmGztOWyhE,1646
-abstract_utilities/dynimport.py,sha256=vJJhQdKtE3XXABFOcdfYO8e8pSOnPBfps6gcH5r2DJ0,6988
+abstract_utilities/dynimport.py,sha256=vGNALk6vbbXSANk1akzj9bO3xLLItAWXjNrrO2VCCg8,6984
 abstract_utilities/error_utils.py,sha256=dSMIM3TKe4e9i_akObyjDwy3Zu4fnoWRK9hucg_ryZo,890
 abstract_utilities/global_utils.py,sha256=UkCS1nE561bVbxWsH-YQdFPSeZFMYXV7xg-DAtGUvrI,2204
 abstract_utilities/hash_utils.py,sha256=u7t209ERD9aGONZHqmkYtiQRRadD2qG5ICSTxlYlZMc,206
@@ -42,16 +42,16 @@ abstract_utilities/file_utils/req.py,sha256=DicCS80V4L8GPWr7lBKDR_gTC1WI9o8lMC2I
 abstract_utilities/file_utils/file_utils/__init__.py,sha256=fm_uNRnfKfZOIg7e1HXhWbHac5VoUgRD2iTO5cxLkA0,160
 abstract_utilities/file_utils/file_utils/file_filters.py,sha256=khfbonAPEAhW1wxfFo0I4dawYPCrIKEjNc7VKb1RvzA,3437
 abstract_utilities/file_utils/file_utils/file_reader.py,sha256=2MRj2PGKq4C-iKL8dmhHwWnhmA8GPVsNaWkTREOF9vo,24545
-abstract_utilities/file_utils/file_utils/file_utils.py,sha256=jYVnAYasPtwmQOeXIkqOA7k6zNxr0QEdQw1SI-TCCZc,7246
+abstract_utilities/file_utils/file_utils/file_utils.py,sha256=jKMp2ch6xsxjZ8YXk2oYxTp22SU4YklCmddq3E3rmcY,7011
 abstract_utilities/file_utils/file_utils/filter_params.py,sha256=NF692W0cBhEsbtmaVzb8EKMAasasHDElSRaC9fnzYwE,3382
 abstract_utilities/file_utils/file_utils/imports.py,sha256=SXCMBuHUwqXbfRBk4LjKehsBKZa8-Po5UfEcNTwn4Es,24
 abstract_utilities/file_utils/file_utils/map_utils.py,sha256=B_MlkLP8s-o0yU0R3Y2LcTpBntBzysJO18qq181xz9c,1043
 abstract_utilities/file_utils/file_utils/pdf_utils.py,sha256=D_wg8h-SapCvqinxRIKxMri1jWZNpr5jGvKq9EJePfY,10335
 abstract_utilities/file_utils/imports/__init__.py,sha256=0nezbIo1RqmfZ7pZ0V3kxZDNchNWH8wVATnnvNeILMo,101
-abstract_utilities/file_utils/imports/classes.py,sha256=kxZvt_Saaw62TUZSYG4Bpecp7ql9mFduGDwwvnk_2qc,4774
+abstract_utilities/file_utils/imports/classes.py,sha256=hNOw48TPAkcDwOY530I7DiYjIfPjVXwEtvb_vN00vdg,13186
 abstract_utilities/file_utils/imports/constants.py,sha256=kSWXjZrbM7MmkytpiCFnsEJcfhPGI5ztUmrvTmT1xpU,1571
 abstract_utilities/file_utils/imports/imports.py,sha256=OjHHuys4ue01PjTIBJuOBAseWUN9pxmAvWsPEj0QcCw,532
-abstract_utilities/file_utils/imports/module_imports.py,sha256=_VKG1c5ampuYLJ-Cu4v6e5lUurVgHbu3L_u77J5dVb0,377
+abstract_utilities/file_utils/imports/module_imports.py,sha256=jhigHKn-tA98-nKvnp2WBeD9vQrC0xQ10AmKIUOV1r4,247
 abstract_utilities/robust_reader/__init__.py,sha256=7JVGEqZ2VFyFF06cqQ8TFz8EyreOB7Jhisnd69rxL-8,28
 abstract_utilities/robust_reader/file_reader2.py,sha256=U-5opkLu-bct091Eb-5CiNBTf0UFoSITYi8zR-Sz38w,25077
 abstract_utilities/robust_reader/file_readers.py,sha256=U-5opkLu-bct091Eb-5CiNBTf0UFoSITYi8zR-Sz38w,25077
@@ -73,8 +73,8 @@ abstract_utilities/ssh_utils/__init__.py,sha256=-DxUpOmfMi5zdG3lu93uT9MziZ-I_anw
 abstract_utilities/ssh_utils/classes.py,sha256=3Q9BfLpyagNFYyiF4bt-5UCezeUJv9NK9YAFdTsLCV0,4802
 abstract_utilities/ssh_utils/imports.py,sha256=7-pVJK1RfR0KiZsv0mNYGPuNXA4iYqmDvqbAR9h1llU,371
 abstract_utilities/ssh_utils/pexpect_utils.py,sha256=JBdOIXBTXAqE5TrsFjmPWJgwSaWyRJN8rbJ6y3_zKPY,10556
-abstract_utilities/ssh_utils/utils.py,sha256=Sy-plzJ9SgnYCL_wGoPZz_aE1hbbDNEMINwNMePY_v4,3069
-abstract_utilities-0.2.2.420.dist-info/METADATA,sha256=nJvijoQVq0soIV-97X-NA6XFkZH6-NJ0DxVW4G65f8I,28108
-abstract_utilities-0.2.2.420.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_utilities-0.2.2.420.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
-abstract_utilities-0.2.2.420.dist-info/RECORD,,
+abstract_utilities/ssh_utils/utils.py,sha256=smUWAx3nW1h0etTndJ_te9bkUX5YzQ8kYd9_gD1TXLk,4882
+abstract_utilities-0.2.2.422.dist-info/METADATA,sha256=yq0rgeCL3-cooP8x1yMcIAKAnYxfSCEV2WcOxIJmDEA,28108
+abstract_utilities-0.2.2.422.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_utilities-0.2.2.422.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
+abstract_utilities-0.2.2.422.dist-info/RECORD,,