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

abstract_utilities/__init__.py

@@ -3,8 +3,9 @@ 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 .dynimport import get_abstract_import
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,
@@ -40,42 +41,8 @@ from .json_utils import (unified_json_loader,
                          )
 from .read_write_utils import (read_from_file,
                                write_to_file)
-from .path_utils import (get_file_create_time,
-                         get_files,
-                         get_folders,
-                         path_join,
-                         mkdirs,
-                         split_text,
-                         get_all_item_paths,
-                         get_directory_items,
-                         get_files,
-                         get_folders,
-                         break_down_find_existing,
-                         get_directory_items,
-                         get_directory_files,
-                         get_all_item_paths,
-                         get_all_file_paths,
-                         get_directory,
-                         create_directory,
-                         initialize_file,
-                         join_path,
-                         is_last_itter,
-                         path_join,
-                         is_file,
-                         is_dir,
-                         is_path,
-                         get_all_directories,
-                         get_all_files,
-                         get_all_items,
-                         collate_text_docs,
-                         get_dirlist,
-                         get_content,
-                         is_directory_in_paths,
-                         make_dirs,
-                         remove_directory,
-                         remove_path,
-                         get_file_parts
-                         )
+from .path_utils import *
+from .file_utils import *
 from .list_utils import (get_highest_value_obj,
                          make_list,
                          safe_list_return,
@@ -120,7 +87,8 @@ from .type_utils import (make_bool,
                          get_numbers,
                          get_numbers_comp,
                          is_any_instance,
-                         break_string
+                         break_string,
+                         MIME_TYPES
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -132,7 +100,10 @@ from .math_utils import (convert_to_percentage,
                          return_0)
 from .compare_utils import (create_new_name,
                             get_last_comp_list,
-                            get_closest_match_from_list)
+                            get_closest_match_from_list,
+                            get_first_match,
+                            get_all_match,
+                            best_match)
 from .thread_utils import ThreadManager
 from .history_utils import HistoryManager
 from .abstract_classes import *
@@ -145,7 +116,10 @@ from .parse_utils import (num_tokens_from_string,
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
-from .class_utils import alias,get_class_inputs,get_set_attr
-from .robust_reader import *
-from .robust_readers import *
-
+from .ssh_utils import *
+from .env_utils import *
+from .path_utils import *
+from .file_utils import *
+from .file_utils import call_for_all_tabs
+from .string_utils import *
+from .class_utils import alias,get_class_inputs,get_set_attr,get_caller_path,get_caller_dir

abstract_utilities/abstract_classes.py

@@ -1,3 +1,4 @@
+import inspect
 class SingletonMeta(type):
     _instances = {}
     def __call__(cls, *args, **kwargs):
@@ -22,3 +23,51 @@ def get_inputs(cls, *args, **kwargs):
             values[field] = getattr(cls(), field)  # default from dataclass
 
     return cls(**values)
+
+
+def prune_inputs(func, *args, **kwargs):
+    """
+    Adapt the provided args/kwargs to fit the signature of func.
+    Returns (args, kwargs) suitable for calling func.
+    """
+    sig = inspect.signature(func)
+    params = sig.parameters
+
+    # Handle positional arguments
+    new_args = []
+    args_iter = iter(args)
+    for name, param in params.items():
+        if param.kind in (inspect.Parameter.POSITIONAL_ONLY,
+                          inspect.Parameter.POSITIONAL_OR_KEYWORD):
+            try:
+                new_args.append(next(args_iter))
+            except StopIteration:
+                break
+        elif param.kind == inspect.Parameter.VAR_POSITIONAL:
+            # collect all remaining args
+            new_args.extend(args_iter)
+            break
+        else:
+            break
+
+    # Handle keyword arguments
+    new_kwargs = {}
+    for name, param in params.items():
+        if name in kwargs:
+            new_kwargs[name] = kwargs[name]
+        elif param.default is inspect.Parameter.empty and param.kind == inspect.Parameter.KEYWORD_ONLY:
+            # Required keyword not provided
+            raise TypeError(f"Missing required keyword argument: {name}")
+
+    # Only include keywords func accepts
+    accepted_names = {
+        name for name, p in params.items()
+        if p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                      inspect.Parameter.KEYWORD_ONLY)
+    }
+    new_kwargs = {k: v for k, v in new_kwargs.items() if k in accepted_names}
+
+    return tuple(new_args), new_kwargs
+def run_pruned_func(func, *args, **kwargs):
+   args,kwargs = prune_inputs(func, *args, **kwargs)
+   return func(*args, **kwargs)

abstract_utilities/class_utils.py

@@ -44,9 +44,9 @@ Dependencies:
 Each function is furnished with its own docstring that elaborates on its purpose, expected inputs, and outputs.
 
 """
-import inspect
-import json
-import functools
+import os,json,functools,inspect
+from typing import *
+
 def get_type_list() -> list:
     """Get a list of common Python types."""
     return ['None','str','int','float','bool','list','tuple','set','dict','frozenset','bytearray','bytes','memoryview','range','enumerate','zip','filter','map','property','slice','super','type','Exception','object']
@@ -370,3 +370,38 @@ def get_class_inputs(cls, *args, **kwargs):
         else:
             values[field] = getattr(cls(), field)
     return cls(**values)
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)
+

abstract_utilities/cmd_utils/imports/__init__.py

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

abstract_utilities/cmd_utils/imports/imports.py

@@ -0,0 +1,10 @@
+# remote_fs.py
+from __future__ import annotations
+from typing import *
+import subprocess, shlex, os, fnmatch, glob, posixpath, re
+# ---- 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

abstract_utilities/cmd_utils/pexpect_utils.py

@@ -0,0 +1,310 @@
+
+from .ssh_utils import *
+from ..env_utils import *
+# pexpect is optional; import lazily if you prefer
+
+# keep your execute_cmd; add a thin wrapper that supports stdin text cleanly
+def execute_cmd_input(
+    *args,
+    input_text: str | None = None,
+    outfile: str | None = None,
+    **kwargs
+) -> str:
+    """
+    Like execute_cmd, but lets you pass text to stdin (subprocess.run(input=...)).
+    """
+    if input_text is not None:
+        kwargs["input"] = input_text
+        # ensure text mode so Python passes str not bytes
+        kwargs.setdefault("text", True)
+    return execute_cmd(*args, outfile=outfile, **kwargs)
+
+# -------------------------
+# Core: capture + printing
+# -------------------------
+def exec_sudo_capture(
+    cmd: str,
+    *,
+    password: str | None = None,
+    key: str | None = None,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False,
+) -> str:
+    """
+    Run a sudo command and return its output (no temp file).
+    """
+    if password is None:
+        password = get_env_value(key=key) if key else get_sudo_password()
+
+    sudo_cmd = f"sudo -S -k {cmd}"
+
+    if user_at_host:
+        # build the remote command (bash -lc + optional cd)
+        remote = get_remote_cmd(cmd=sudo_cmd, user_at_host=user_at_host, cwd=cwd)
+        # feed password to remote's stdin (ssh forwards stdin)
+        out = execute_cmd_input(remote, input_text=password + "\n",
+                                shell=True, text=True, capture_output=True)
+    else:
+        out = execute_cmd_input(sudo_cmd, input_text=password + "\n",
+                                shell=True, text=True, capture_output=True, cwd=cwd)
+
+    if print_output:
+        print_cmd(cmd, out or "")
+    return out or ""
+
+
+
+# ---------------------------------------------------
+# SUDO helpers (local + SSH) with env/password options
+# ---------------------------------------------------
+def exec_sudo(
+    cmd: str,
+    *,
+    password: Optional[str] = None,
+    key: Optional[str] = None,
+    user_at_host: Optional[str] = None,
+    cwd: Optional[str] = None,
+    outfile: Optional[str] = None,
+    print_output: bool = False,
+) -> str:
+    """
+    Execute `cmd` via sudo either locally or on remote.
+    Password order of precedence:
+      1) `password` arg
+      2) `key` -> get_env_value(key)
+      3) get_sudo_password()
+
+    Uses: sudo -S -k    (-S read password from stdin, -k invalidate cached timestamp)
+    """
+    if password is None:
+        if key:
+            password = get_env_value(key=key)
+        else:
+            password = get_sudo_password()
+
+    # Compose the sudo command that reads from stdin
+    sudo_cmd = f"sudo -S -k {cmd}"
+
+    if user_at_host:
+        # For remote: the password is piped to SSH stdin, which flows to remote sudo's stdin.
+        remote = get_remote_cmd(cmd=sudo_cmd, user_at_host=user_at_host, cwd=cwd)
+        full = f"printf %s {shlex.quote(password)} | {remote}"
+        out = execute_cmd(full, shell=True, text=True, capture_output=True, outfile=outfile)
+    else:
+        # Local
+        full = f"printf %s {shlex.quote(password)} | {sudo_cmd}"
+        out = execute_cmd(full, shell=True, text=True, capture_output=True, outfile=outfile)
+
+    if print_output:
+        print_cmd(cmd, out or "")
+    return out or ""
+
+
+# -------------------------------------------------
+# Fire-and-forget (file-backed) compatible runner
+# -------------------------------------------------
+def cmd_run(
+    cmd: str,
+    output_text: str | None = None,
+    print_output: bool = False,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+) -> str | None:
+    """
+    If output_text is None → capture+return output (no file).
+    If output_text is provided → legacy file-backed behavior.
+    """
+    if output_text is None:
+        # capture mode
+        if user_at_host:
+            remote = get_remote_cmd(cmd=cmd, user_at_host=user_at_host, cwd=cwd)
+            out = execute_cmd(remote, shell=True, text=True, capture_output=True)
+        else:
+            out = execute_cmd(cmd, shell=True, text=True, capture_output=True, cwd=cwd)
+        if print_output:
+            print_cmd(cmd, out or "")
+        return out or ""
+
+    # ---- legacy file-backed path (unchanged in spirit) ----
+    # Clear output file
+    with open(output_text, 'w'):
+        pass
+
+    # Append redirection + sentinel
+    full_cmd = f'{cmd} >> {output_text}; echo END_OF_CMD >> {output_text}'
+
+    # Execute local/remote
+    if user_at_host:
+        remote_line = get_remote_cmd(cmd=full_cmd, user_at_host=user_at_host, cwd=cwd)
+        subprocess.call(remote_line, shell=True)
+    else:
+        subprocess.call(full_cmd, shell=True, cwd=cwd)
+
+    # Wait for sentinel
+    while True:
+        get_sleep(sleep_timer=0.5)
+        with open(output_text, 'r') as f:
+            lines = f.readlines()
+            if lines and lines[-1].strip() == 'END_OF_CMD':
+                break
+
+    if print_output:
+        with open(output_text, 'r') as f:
+            print_cmd(full_cmd, f.read().strip())
+
+    try:
+        os.remove(output_text)
+    except OSError:
+        pass
+
+    return None
+
+
+# ----------------------------------------------------
+# pexpect wrappers (local + SSH) for interactive flows
+# ----------------------------------------------------
+def exec_expect(
+    command: str,
+    child_runs: List[Dict[str, Any]],
+    *,
+    user_at_host: Optional[str] = None,
+    cwd: Optional[str] = None,
+    print_output: bool = False,
+) -> int:
+    """
+    Run `command` and answer interactive prompts.
+
+    child_runs: list of dicts like:
+      { "prompt": r"Password:", "pass": "xyz" }
+      { "prompt": r"Enter passphrase:", "key": "MY_KEY", "env_path": "/path/for/.env" }
+    If "pass" is None, we resolve via get_env_value(key=..., start_path=env_path).
+
+    Returns exitstatus (0=success).
+    """
+    if user_at_host:
+        # Wrap command for remote execution
+        remote_line = get_remote_cmd(cmd=command, user_at_host=user_at_host, cwd=cwd)
+        spawn_cmd = f"{remote_line}"
+    else:
+        spawn_cmd = f"bash -lc {shlex.quote((f'cd {shlex.quote(cwd)} && {command}') if cwd else command)}"
+
+    child = pexpect.spawn(spawn_cmd)
+
+    for each in child_runs:
+        child.expect(each["prompt"])
+
+        if each.get("pass") is not None:
+            pass_phrase = each["pass"]
+        else:
+            args = {}
+            if "key" in each and each["key"] is not None:
+                args["key"] = each["key"]
+            if "env_path" in each and each["env_path"] is not None:
+                args["start_path"] = each["env_path"]
+            pass_phrase = get_env_value(**args)
+
+        child.sendline(pass_phrase)
+        if print_output:
+            print("Answered prompt:", each["prompt"])
+
+    child.expect(pexpect.EOF)
+    out = child.before.decode("utf-8", errors="ignore")
+    if print_output:
+        print_cmd(command, out)
+
+    return child.exitstatus if child.exitstatus is not None else 0
+
+
+# ---------------------------------------
+# Convenience shims to mirror your names
+# ---------------------------------------
+def cmd_run_sudo(
+    cmd: str,
+    password: str | None = None,
+    key: str | None = None,
+    output_text: str | None = None,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False,
+) -> str | None:
+    """
+    If output_text is None → capture sudo output and return it.
+    If output_text is provided → legacy file-backed behavior feeding sudo via stdin.
+    """
+    if output_text is None:
+        return exec_sudo_capture(
+            cmd,
+            password=password,
+            key=key,
+            user_at_host=user_at_host,
+            cwd=cwd,
+            print_output=print_output,
+        )
+
+    # ---- legacy file-backed path ----
+    # build the underlying sudo command
+    sudo_cmd = f"sudo -S -k {cmd}"
+    pw = password if password is not None else (get_env_value(key=key) if key else get_sudo_password())
+
+    # We need to feed password to stdin in the same shell that runs sudo.
+    # For file-backed mode we’ll inline a small shell that reads from a here-string.
+    # Local:
+    if not user_at_host:
+        full = f'bash -lc {shlex.quote((f"cd {shlex.quote(cwd)} && " if cwd else "") + f"printf %s {shlex.quote(pw)} | {sudo_cmd}")}'
+        return cmd_run(full, output_text=output_text, print_output=print_output)
+    # Remote:
+    # On remote, do the same in the remote bash -lc
+    remote_sudo_line = f'printf %s {shlex.quote(pw)} | {sudo_cmd}'
+    remote_full = get_remote_cmd(cmd=remote_sudo_line, user_at_host=user_at_host, cwd=cwd)
+    return cmd_run(remote_full, output_text=output_text, print_output=print_output)
+def pexpect_cmd_with_args(
+    command: str,
+    child_runs: list,
+    output_text: str | None = None,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False
+) -> int:
+    """
+    If output_text is None → return output string via print_output, else write to file then remove (legacy).
+    """
+    if user_at_host:
+        spawn_cmd = get_remote_cmd(cmd=command, user_at_host=user_at_host, cwd=cwd)
+    else:
+        spawn_cmd = f"bash -lc {shlex.quote((f'cd {shlex.quote(cwd)} && {command}') if cwd else command)}"
+
+    child = pexpect.spawn(spawn_cmd)
+
+    for each in child_runs:
+        child.expect(each["prompt"])
+        if each.get("pass") is not None:
+            pass_phrase = each["pass"]
+        else:
+            args = {}
+            if "key" in each and each["key"] is not None:
+                args["key"] = each["key"]
+            if "env_path" in each and each["env_path"] is not None:
+                args["start_path"] = each["env_path"]
+            pass_phrase = get_env_value(**args)
+        child.sendline(pass_phrase)
+        if print_output:
+            print("Answered prompt:", each["prompt"])
+
+    child.expect(pexpect.EOF)
+    out = child.before.decode("utf-8", errors="ignore")
+
+    if output_text:
+        with open(output_text, "w") as f:
+            f.write(out)
+        if print_output:
+            print_cmd(command, out)
+        # keep legacy? your old code removed the file; here we’ll keep it (safer).
+        # If you want the old behavior, uncomment:
+        # os.remove(output_text)
+    else:
+        if print_output:
+            print_cmd(command, out)

abstract_utilities/cmd_utils/user_utils.py

@@ -1,4 +1,4 @@
-from ..string_clean import eatOuter
+
 def get_user_input(text,default='y'):
     choices = '(y/n)' if default in ['y','n'] else ''
     response = input(f"{text} {choices}:({default}) ") or default

abstract_utilities/compare_utils/__init__.py

@@ -0,0 +1,3 @@
+from  .compare_utils import *
+from .find_value import get_first_match, get_all_match
+from .best_match import best_match

abstract_utilities/compare_utils/best_match.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+from typing import Any, Iterable, Iterator, Tuple, Union, Dict, List, Optional
+import re
+from difflib import SequenceMatcher
+
+JSONLike = Union[dict, list, tuple, set, str, int, float, bool, None]
+PathType = Tuple[Union[str, int], ...]
+
+def iter_values(obj: JSONLike, path: PathType = ()) -> Iterator[Tuple[PathType, Any]]:
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            yield from iter_values(v, path + (k,))
+    elif isinstance(obj, (list, tuple)):
+        for i, v in enumerate(obj):
+            yield from iter_values(v, path + (i,))
+    elif isinstance(obj, set):
+        for v in obj:
+            yield from iter_values(v, path + ('<setitem>',))
+    else:
+        yield path, obj
+
+def _norm(s: str, case_insensitive: bool) -> str:
+    return s.lower() if case_insensitive else s
+
+def _word_boundary_regex(term: str, case_insensitive: bool) -> re.Pattern:
+    flags = re.IGNORECASE if case_insensitive else 0
+    # word boundary around the whole term; escape term for literal
+    return re.compile(rf"\b{re.escape(term)}\b", flags)
+
+def _score_string(
+    value: str,
+    terms: Iterable[str],
+    *,
+    case_insensitive: bool = True,
+    min_ratio: float = 0.6,
+) -> Tuple[float, Dict[str, float]]:
+    """
+    Score a *string* against the list of terms. Returns (score, per_term_scores).
+    Weights:
+      exact=+3, word-boundary=+2, substring=+1, fuzzy=+0.5*ratio (if ratio>=min_ratio).
+      +0.2 bonus per extra unique term matched (beyond the first).
+    """
+    if not isinstance(value, str):
+        return 0.0, {}
+    v = _norm(value, case_insensitive)
+    per_term: Dict[str, float] = {}
+    matched_terms = 0
+
+    for term in terms:
+        t = _norm(term, case_insensitive)
+        term_score = 0.0
+
+        if v == t:
+            term_score = max(term_score, 3.0)
+
+        # word boundary
+        if _word_boundary_regex(term, case_insensitive).search(value):
+            term_score = max(term_score, 2.0)
+
+        # substring
+        if t in v:
+            term_score = max(term_score, 1.0)
+
+        # fuzzy similarity
+        ratio = SequenceMatcher(None, v, t).ratio()  # 0..1
+        if ratio >= min_ratio:
+            term_score = max(term_score, 0.5 * ratio)
+
+        if term_score > 0:
+            matched_terms += 1
+            per_term[term] = term_score
+
+    # Bonus for covering more than one term
+    bonus = 0.2 * max(0, matched_terms - 1)
+    total = sum(per_term.values()) + bonus
+    return total, per_term
+
+def best_match(
+    obj: JSONLike,
+    *,
+    terms: Iterable[str],
+    case_insensitive: bool = True,
+    min_ratio: float = 0.6,
+    key_weight: Dict[str, float] | None = None,  # e.g. {'window_title': 1.5}
+    coerce_non_strings: bool = False,
+) -> Optional[Dict[str, Any]]:
+    """
+    Return the single best leaf string:
+    { 'value': str, 'path': PathType, 'score': float, 'per_term': {term:score} }
+    """
+    key_weight = key_weight or {}
+    best: Optional[Dict[str, Any]] = None
+
+    for path, val in iter_values(obj):
+        s = val
+        if not isinstance(s, str):
+            if coerce_non_strings:
+                s = str(val)
+            else:
+                continue
+
+        score, per_term = _score_string(s, terms, case_insensitive=case_insensitive, min_ratio=min_ratio)
+        if score <= 0:
+            continue
+
+        # Apply path-based weight if any path segment matches a key in key_weight
+        weight = 1.0
+        for seg in path:
+            if isinstance(seg, str) and seg in key_weight:
+                weight *= key_weight[seg]
+        weighted = score * weight
+
+        cand = {'value': s, 'path': path, 'score': weighted, 'per_term': per_term}
+        if best is None or weighted > best['score']:
+            best = cand
+        # Optional tie-breakers (prefer more terms matched, then shorter value)
+        elif best is not None and abs(weighted - best['score']) < 1e-9:
+            if len(per_term) > len(best['per_term']):
+                best = cand
+            elif len(per_term) == len(best['per_term']) and len(s) < len(best['value']):
+                best = cand
+
+    return best
+
+def top_k_matches(
+    obj: JSONLike,
+    *,
+    terms: Iterable[str],
+    k: int = 5,
+    **kwargs
+) -> List[Dict[str, Any]]:
+    """Return top-k matches sorted by score desc."""
+    items: List[Dict[str, Any]] = []
+    for path, val in iter_values(obj):
+        s = val if isinstance(val, str) else (str(val) if kwargs.get('coerce_non_strings') else None)
+        if s is None:
+            continue
+        score, per_term = _score_string(s, terms,
+                                        case_insensitive=kwargs.get('case_insensitive', True),
+                                        min_ratio=kwargs.get('min_ratio', 0.6))
+        if score <= 0:
+            continue
+        weight = 1.0
+        for seg in path:
+            if isinstance(seg, str) and kwargs.get('key_weight', {}).get(seg):
+                weight *= kwargs['key_weight'][seg]
+        items.append({'value': s, 'path': path, 'score': score * weight, 'per_term': per_term})
+
+    items.sort(key=lambda d: d['score'], reverse=True)
+    return items[:k]