abstract-utilities 0.2.2.413__py3-none-any.whl → 0.2.2.415__py3-none-any.whl

abstract_utilities/file_utils/file_utils/file_filters.py

@@ -0,0 +1,104 @@
+from .imports import *
+from .filter_params import *
+from .file_utils import *
+##from abstract_utilities import make_list,get_media_exts, is_media_type
+
+def collect_filepaths(
+    directory: List[str],
+    cfg: 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=False,
+    allowed: Optional[Callable[[str], bool]] = None,
+    **kwargs
+    ) -> List[str]:
+    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
+                                )
+    allowed = allowed or make_allowed_predicate(cfg)
+    directories = make_list(directory)
+    roots = [r for r in directories if r]
+
+    # your existing helpers (get_dirs, get_globs, etc.) stay the same
+    original_dirs = get_allowed_dirs(roots, allowed=allowed)
+    original_globs = get_globs(original_dirs)
+    files = get_allowed_files(original_globs, allowed=allowed)
+
+    for d in get_filtered_dirs(original_dirs, allowed=allowed):
+        files += get_filtered_files(d, allowed=allowed, files=files)
+
+    # de-dupe while preserving order
+    seen, out = set(), []
+    for f in files:
+        if f not in seen:
+            seen.add(f)
+            out.append(f)
+    return out
+
+
+def _fast_walk(
+    root: Path,
+    exts: Iterable[str],
+    skip_dirs: Iterable[str] = (),
+    skip_patterns: Iterable[str] = (),
+) -> List[Path]:
+    exts = tuple(exts)
+    skip_dirs = set(sd.lower() for sd in skip_dirs or ())
+    skip_patterns = tuple(sp.lower() for sp in (skip_patterns or ()))
+
+    out = []
+    for p in root.rglob("*"):
+        # skip directories by name hit
+        if p.is_dir():
+            name = p.name.lower()
+            if name in skip_dirs:
+                # rglob doesn't let us prune mid-iteration cleanly; we just won't collect under it
+                continue
+            # nothing to collect for dirs
+            continue
+
+        # file filters
+        name = p.name.lower()
+        if any(fnmatch.fnmatch(name, pat) for pat in skip_patterns):
+            continue
+        if p.suffix.lower() in exts:
+            out.append(p)
+
+    # de-dup and normalize
+    return sorted({pp.resolve() for pp in out})
+
+
+def enumerate_source_files(
+    src_root: Path,
+    cfg: Optional["ScanConfig"] = None,
+    *,
+    exts: Optional[Iterable[str]] = None,
+    fast_skip_dirs: Optional[Iterable[str]] = None,
+    fast_skip_patterns: Optional[Iterable[str]] = None,
+) -> List[Path]:
+    """
+    Unified enumerator:
+      - If `cfg` is provided: use collect_filepaths(...) with full rules.
+      - Else: fast walk using rglob over `exts` (defaults to EXTS) with optional light excludes.
+    """
+    src_root = Path(src_root)
+
+    if cfg is not None:
+        files = collect_filepaths([str(src_root)], cfg=cfg)
+        return sorted({Path(f).resolve() for f in files})
+
+    # Fast mode
+    return _fast_walk(
+        src_root,
+        exts or EXTS,
+        skip_dirs=fast_skip_dirs or (),
+        skip_patterns=fast_skip_patterns or (),
+    )

abstract_utilities/file_utils/file_utils/file_utils.py

@@ -0,0 +1,194 @@
+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()
+
+        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
+
+        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
+
+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("maxdepth", 1)
+    for fs, root in normalize_items(roots, **kwargs):
+        gl = 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)
+    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)
+    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):
+        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)
+    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):
+        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)
+    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)
+    seen = set(files)
+    for fs, directory in normalize_items(dirs):
+        for p in fs.glob_recursive(directory, **kwargs):
+            if p in seen: continue
+            if allowed and not allowed(p): continue
+            if fs.isfile(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] = []
+    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 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)
+    return out
+def get_files_and_dirs(
+    directory: str | list[str]=None,
+    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,
+    recursive: bool = True,
+    include_files: bool = True,
+    paths: str | list[str]=None,
+    **kwargs
+):
+    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,
+    )
+    # make predicate backend-agnostic here; the per-backend calls below pass strings only
+    allowed = make_allowed_predicate(cfg)
+
+    if recursive:
+        kwargs.setdefault("mindepth", 1)
+    else:
+        kwargs.setdefault("mindepth", 1)
+        kwargs.setdefault("maxdepth", 1)
+
+    roots = make_list(directory or paths)
+    items = get_globs(roots, recursive=recursive, allowed=allowed, **kwargs)
+
+    dirs = get_allowed_dirs(items, allowed=allowed, **kwargs)
+    files = get_allowed_files(items, allowed=allowed, **kwargs) if include_files else []
+    return dirs, files

abstract_utilities/file_utils/file_utils/imports.py

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

abstract_utilities/{path_utils → file_utils}/imports/__init__.py

@@ -1,3 +1,4 @@
 from .constants import *
 from .imports import *
 from .module_imports import *
+from .classes import *

abstract_utilities/file_utils/imports/classes.py

@@ -0,0 +1,125 @@
+from .imports import *
+from .module_imports import *
+from .constants import *
+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()]
+
+
+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/file_utils/imports/imports.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+from typing import *
+from dataclasses import dataclass, field
+import fnmatch, fnmatch, os, glob, platform, textwrap, pkgutil, re, textwrap, sys, types, importlib, importlib.util, inspect
+from types import ModuleType
+# Accept strings like:
+#   "/local/abs/dir"
+#   "relative/local/dir"
+#   "user@host:/abs/dir"
+REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
+AllowedPredicate = Optional[Callable[[str], bool]]

abstract_utilities/{path_utils → file_utils}/imports/module_imports.py

@@ -2,4 +2,6 @@ from ...read_write_utils import read_from_file,write_to_file
 from ...string_clean import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type,MIME_TYPES
-import os
+from ...ssh_utils import run_local_cmd, run_ssh_cmd,run_any_cmd,run_cmd
+from ...env_utils import *
+from ...path_utils import *

abstract_utilities/{path_utils → file_utils}/req.py

@@ -1,10 +1,8 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-
-from .file_filters import define_defaults,get_files_and_dirs
+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():
@@ -217,8 +215,7 @@ def attach_functions(
     return attached
 
 
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)
+
 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)

abstract_utilities/{path_utils/path_utils.py → path_utils.py}

@@ -22,7 +22,11 @@ Author: putkoff
 Date: 05/31/2023
 Version: 0.1.2
 """
-from .imports import *
+import os
+from .read_write_utils import read_from_file,write_to_file
+from .string_clean import eatAll
+from .list_utils import make_list
+from .type_utils import get_media_exts, is_media_type,MIME_TYPES
 def get_caller_path(i=1):
     frame = inspect.stack()[i]
     return os.path.abspath(frame.filename)

abstract_utilities/robust_readers/__init__.py

@@ -1 +1,2 @@
 from .initFuncGen import *
+from .import_utils import *

abstract_utilities/robust_readers/imports.py

@@ -1,6 +1,6 @@
 from types import ModuleType
 from typing import Iterable
-from ..path_utils import get_caller_dir,get_caller_path,define_defaults,get_files_and_dirs
+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 *

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,11 @@
+# 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  # whatever you already have
+from ..time_utils import get_sleep
+from ..ssh_utils import *
+from ..env_utils import *
+from ..string_clean import eatOuter