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

abstract_utilities/file_utils/file_utils/map_utils.py

@@ -0,0 +1,29 @@
+from .imports import MIME_TYPES,make_list,os
+from .file_filters import get_globs
+def get_file_type(file_path,types=None,default=None):
+    mime_types = {}
+    if types:
+        types = make_list(types)
+        for typ in types:
+            mime_types[typ] = MIME_TYPES.get(typ)
+    else:
+        mime_types = MIME_TYPES
+    
+    if os.path.isfile(file_path):
+        basename = os.path.basename(file_path)
+        filename,ext = os.path.splitext(basename)
+        for file_type,ext_values in mime_types.items():
+            if ext in ext_values:
+                return file_type
+def get_file_map(directory,types=None,default=None):
+    if directory and os.path.isfile(directory):
+       directory = os.path.dirname(directory)
+    all_types = {}
+    files = get_globs(directory)
+    for file in files:
+        file_type = get_file_type(file,types=types,default=default)
+        if file_type:
+            if file_type not in all_types:
+                all_types[file_type] = []
+            all_types[file_type].append(file)
+    return all_types

abstract_utilities/{robust_reader → file_utils/file_utils}/pdf_utils.py

@@ -1,12 +1,4 @@
-import PyPDF2
-from typing import *
-from pdf2image import convert_from_path
-from abstract_utilities.path_utils import (is_file, mkdirs, get_directory, 
-                                           get_base_name, split_text, 
-                                           get_ext, get_file_name)
-from abstract_utilities.type_utils import is_str
-from abstract_utilities.cmd_utils import cmd_input
-from abstract_utilities.read_write_utils import write_to_file
+from .imports import *
 def if_none_return(obj: object, obj_2: object) -> object:
     """
     Return obj if obj_2 is None, otherwise return obj_2.

abstract_utilities/file_utils/file_utils/type_checks.py

@@ -0,0 +1,91 @@
+from .imports import *
+
+def get_user_pass_host_key(**kwargs):
+    args = ['password','user_at_host','host','key','user']
+    values,kwargs = get_from_kwargs(*args,**kwargs,del_kwarg=False)
+    return values
+
+# --- Base remote checker -----------------------------------------------------
+def _remote_test(path: str, test_flag: str, timeout: int = 5,*args, **kwargs) -> bool:
+    """
+    Run a remote shell test (e.g. -f, -d) via SSH.
+    Returns True if test succeeds, False otherwise.
+    """
+    try:
+        kwargs['cmd']=f"[ {test_flag} {shlex.quote(path)} ] && echo 1 || echo 0"
+        kwargs['text']=True
+        kwargs['timeout']=timeout
+        kwargs['stderr']=subprocess.DEVNULL
+        result = run_pruned_func(run_cmd,**kwargs)
+        return result.strip() == "1"
+    except Exception:
+        return False
+
+
+# --- Individual path checks --------------------------------------------------
+def is_remote_file(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a file."""
+    return _remote_test(path, "-f", **kwargs)
+
+
+def is_remote_dir(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a directory."""
+    return _remote_test(path, "-d", **kwargs)
+
+
+def is_local_file(path: str) -> bool:
+    """True if local path is a file."""
+    return os.path.isfile(path)
+
+
+def is_local_dir(path: str) -> bool:
+    """True if local path is a directory."""
+    return os.path.isdir(path)
+
+
+# --- Unified interface -------------------------------------------------------
+
+def is_file(path: str,*args,**kwargs) -> bool:
+    """Determine if path is a file (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_file(path, **kwargs)
+    return is_local_file(path)
+
+
+def is_dir(path: str, *args,**kwargs) -> bool:
+    """Determine if path is a directory (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_dir(path, **kwargs)
+    return is_local_dir(path)
+
+def is_exists(path: str, *args,**kwargs) -> bool:
+    if is_file(path,**kwargs):
+        return True
+    if is_dir(path,**kwargs):
+        return True
+    return False
+# --- Optional: keep your original all-in-one wrapper ------------------------
+def check_path_type(
+    path: str,
+    *args,
+    **kwargs
+) -> str:
+    """
+    Return 'file', 'directory', 'missing', or 'unknown'.
+    Uses isolated is_file/is_dir functions.
+    """
+    if get_user_pass_host_key(**kwargs):
+        if is_remote_file(path,**kwargs):
+            return "file"
+        elif is_remote_dir(path,**kwargs):
+            return "directory"
+        else:
+            return "missing"
+    else:
+        if os.path.isfile(path):
+            return "file"
+        elif os.path.isdir(path):
+            return "directory"
+        elif not os.path.exists(path):
+            return "missing"
+        return "unknown"

abstract_utilities/file_utils/imports/__init__.py

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

abstract_utilities/file_utils/imports/classes.py

@@ -0,0 +1,381 @@
+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: ...
+    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 __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:
+          - 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 []
+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 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, **kwargs) -> bool:
+        out = self.cell_spec_kwargs(is_file, path, **kwargs)
+        return "__OK__" in (out or "")
+
+    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)
+        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 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")
+    paths = make_list(paths)
+    for item in paths:
+        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(
+                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/clean_imps.py

@@ -0,0 +1,158 @@
+from abstract_utilities import read_from_file, eatAll
+import os, sys, re, inspect
+from typing import *
+
+# ============================================================
+# Constants
+# ============================================================
+import_tag = 'import '
+from_tag = 'from '
+
+# ============================================================
+# Helpers
+# ============================================================
+def get_caller_path(i=None):
+    i = i or 1
+    frame = inspect.stack()[i]
+    return os.path.abspath(frame.filename)
+
+def make_list(obj: any) -> list:
+    if isinstance(obj, str) and ',' in obj:
+        obj = obj.split(',')
+    if isinstance(obj, (set, tuple)):
+        return list(obj)
+    if isinstance(obj, list):
+        return obj
+    return [obj]
+
+def eatElse(stringObj, chars=None):
+    chars = make_list(chars or []) + list('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_')
+    while stringObj:
+        if stringObj and stringObj[0] not in chars:
+            stringObj = stringObj[1:]
+            continue
+        if stringObj and stringObj[-1] not in chars:
+            stringObj = stringObj[:-1]
+            continue
+        break
+    return stringObj
+
+def clean_line(line):
+    return eatAll(line, [' ', '', '\t', '\n'])
+
+def is_line_import(line):
+    return bool(line and line.startswith(import_tag) and 'from ' not in line)
+
+def is_line_from_import(line):
+    return bool(line and line.startswith(from_tag) and ' import ' in line)
+
+def is_from_group_start(line):
+    return bool(line and line.startswith(from_tag) and 'import' in line and '(' in line and not line.rstrip().endswith(')'))
+
+def is_from_group_end(line):
+    return bool(line and ')' in line)
+
+def clean_imports(imports):
+    if isinstance(imports, str):
+        imports = imports.split(',')
+    return [eatElse(imp.strip()) for imp in imports if imp.strip()]
+
+# ============================================================
+# Combine lone import statements
+# ============================================================
+def combine_lone_imports(text=None, file_path=None):
+    text = text or ''
+    if file_path and os.path.isfile(file_path):
+        text += read_from_file(file_path)
+    lines = text.split('\n')
+
+    cleaned_import_list = []
+    nu_lines = []
+    j = None
+
+    for i, line in enumerate(lines):
+        if is_line_import(line):
+            if j is None:
+                nu_lines.append(import_tag)
+                j = i
+            cleaned_import_list += clean_imports(line.split(import_tag)[1])
+        else:
+            nu_lines.append(line)
+
+    if j is None:
+        return '\n'.join(nu_lines)
+    cleaned_import_list = sorted(set(cleaned_import_list))
+    nu_lines[j] += ', '.join(cleaned_import_list)
+    return '\n'.join(nu_lines)
+
+# ============================================================
+# Merge repeated 'from pkg import ...' (1-line only)
+# Preserve multi-line grouped imports
+# ============================================================
+def merge_from_import_groups(text=None, file_path=None):
+    if file_path and os.path.isfile(file_path):
+        text = read_from_file(file_path)
+    text = text or ''
+    lines = text.split('\n')
+
+    pkg_to_imports: Dict[str, Set[str]] = {}
+    pkg_to_line_index: Dict[str, int] = {}
+    nu_lines: List[str] = []
+
+    in_group = False
+    for i, line in enumerate(lines):
+        stripped = line.strip()
+
+        # preserve multi-line grouped blocks intact
+        if in_group:
+            nu_lines.append(line)
+            if is_from_group_end(line):
+                in_group = False
+            continue
+
+        if is_from_group_start(line):
+            in_group = True
+            nu_lines.append(line)
+            continue
+
+        if is_line_from_import(line):
+            try:
+                pkg_part, imps_part = line.split(' import ', 1)
+                pkg_name = pkg_part.replace('from ', '').strip()
+                imps = clean_imports(imps_part)
+            except Exception:
+                nu_lines.append(line)
+                continue
+
+            if pkg_name not in pkg_to_imports:
+                pkg_to_imports[pkg_name] = set(imps)
+                pkg_to_line_index[pkg_name] = len(nu_lines)
+                nu_lines.append(line)
+            else:
+                pkg_to_imports[pkg_name].update(imps)
+        else:
+            nu_lines.append(line)
+
+    # Rewrite first occurrences
+    for pkg, idx in pkg_to_line_index.items():
+        all_imps = sorted(pkg_to_imports[pkg])
+        nu_lines[idx] = f"from {pkg} import {', '.join(all_imps)}"
+
+    return '\n'.join(nu_lines)
+
+# ============================================================
+# Pipeline
+# ============================================================
+def clean_imports_pipeline(path: str):
+    raw = read_from_file(path)
+    step1 = combine_lone_imports(text=raw)
+    step2 = merge_from_import_groups(text=step1)
+    return step2
+
+# ============================================================
+# Standalone Run
+# ============================================================
+if __name__ == "__main__":
+    abs_path = "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/abstract_utilities/file_utils/imports/imports.py"
+    cleaned = clean_imports_pipeline(abs_path)
+    print(cleaned)