abstract-utilities 0.2.2.448__py3-none-any.whl → 0.2.2.450__py3-none-any.whl

abstract_utilities-0.2.2.450.dist-info/RECORD

@@ -0,0 +1,49 @@
+abstract_utilities/__init__.py,sha256=07mV5GPv0lff7htzMdIW1nhWo59ykRG9bPIyPgki2Tw,6236
+abstract_utilities/abstract_classes.py,sha256=oKr2j7DRz_vGb7r-uN3hAchF2OcebN405ZOoeWGexUc,783
+abstract_utilities/class_utils.py,sha256=-YHkdbaChRIz9YLXJlFF4m7VkdwUCts_HOUbKXxkrYA,12735
+abstract_utilities/collator_utils.py,sha256=9exNoZAr9rABGYTwZOn7hdLbpnMtRd2AgfU7yjZrXGw,2348
+abstract_utilities/compare_utils.py,sha256=gWcjmeFI2h8-9q72ClaP8OmmxQDeMuB0eptupEwuYFk,14033
+abstract_utilities/doit.py,sha256=a1zkyMJbSGPvE-OmCQcH_dQyLME392UfvQmGztOWyhE,1646
+abstract_utilities/dynimport.py,sha256=QLQLMZZbw259cwbIbbuUluoQm_ckIZwcdEuh0P847es,6971
+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
+abstract_utilities/history_utils.py,sha256=2bG8hMSRzLWMae4mpd2sf1esYtqT2D_3MDxeJnAE2Jw,1633
+abstract_utilities/json_utils.py,sha256=bX0oRHkGt_yW5H7YErhC40IoGcwBxlBRw26vOmpZA9g,26150
+abstract_utilities/list_utils.py,sha256=i1fZ_kZ0mf_ei6w0MOkuEieRiyF-ReeAXzIdoRI1cvo,6298
+abstract_utilities/log_utils.py,sha256=dUu-12aprUygbTJ9rgOH57CBGlgwOciaDJNbsGuaNdE,8999
+abstract_utilities/math_utils.py,sha256=0o1ls1En03UAkYmxTBildCCJDfHygmNuvVnrNrLYtK0,6578
+abstract_utilities/parse_utils.py,sha256=Z5OGRwHuzCzY91fz0JJojk1BPAo1XF2quNNLuBF4_Vk,18602
+abstract_utilities/path_utils.py,sha256=AUOGC1X2HS9DSZHoPiyWky0-GcZ-CJjDNQ4ef97p1PA,16556
+abstract_utilities/read_write_utils.py,sha256=mmRmQaKFVXM5w4YKS_VsQpbQE7-LcyIRg0eyOrykWIY,7308
+abstract_utilities/string_clean.py,sha256=-gY9i2yqjX5UClvSaKsSrzA4GjR7eaNI3GnFjZpt2bo,5923
+abstract_utilities/tetsts.py,sha256=PrejTUew5dAAqNb4erMJwfdSHxDyuuHGWY2fMlWk5hk,21
+abstract_utilities/thread_utils.py,sha256=LhE1ylSuOKkkMErBf6SjZprjO_vfh3IKfvNKJQiCxho,5460
+abstract_utilities/time_utils.py,sha256=yikMjn7i-OBKfmOujfNtDz4R0VTMgi3dfQNrCIZUbQU,13052
+abstract_utilities/type_utils.py,sha256=wAbQKyfXsGFTQxiViV2FJzlNo52LC8UKihdGYPYChxI,27030
+abstract_utilities/utils.py,sha256=SCa_-x_wsWrcokQXKwlhalxndxLn5Wg25-zqRdJUmag,185049
+abstract_utilities/cmd_utils/__init__.py,sha256=StTaaB9uzJexvr4TFGVqp_o0_s9T6rQlE3fOZtb_y_0,51
+abstract_utilities/cmd_utils/cmd_utils.py,sha256=n2DEo91J8LWuIJoSoDkWdApUY_8mHrUW3kjEjjF34Io,7876
+abstract_utilities/cmd_utils/user_utils.py,sha256=d_ZPerAWPovKry0gsQBeCAQW9T7QvKZ2bcJnGa8ysGw,1864
+abstract_utilities/robust_reader/__init__.py,sha256=7JVGEqZ2VFyFF06cqQ8TFz8EyreOB7Jhisnd69rxL-8,28
+abstract_utilities/robust_reader/file_reader.py,sha256=6RuLTdLNVERKWOUyjheqYZZCcUkMOt1j-2u7U3EN0Rg,25097
+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
+abstract_utilities/robust_reader/pdf_utils.py,sha256=sNEJRBi4ypbA3hXQPFoFnPHVSPstbdBAwCoeyNa18YE,10763
+abstract_utilities/robust_reader/sadfsad.py,sha256=gH2ebI9KfiYFv78jzPGk8WPST_FGtojnd_yDwrcvQoM,25282
+abstract_utilities/robust_readers/__init__.py,sha256=JS5czvP8-_STym3vLQNU_vSGf3N1mAivSuqRuGIBVlI,83
+abstract_utilities/robust_readers/file_filters.py,sha256=O71C2xASPU2UjDOor8pob9i1EJWINHs_B9K3DmK7E5Y,7706
+abstract_utilities/robust_readers/filter_params.py,sha256=hmwPQR6K2m39w7ObWf1m5aL9Wo39dUDrUrefpsD3_pg,4912
+abstract_utilities/robust_readers/initFuncGen.py,sha256=dr2kjrwOvFoL5fu2GNqjghrgr0xV3npBVNpAT0Uy8ko,4615
+abstract_utilities/robust_readers/import_utils/__init__.py,sha256=hKYj8irPXAN-gIm0frFd0_8fnUNQraWEVugRUrSjcLw,166
+abstract_utilities/robust_readers/import_utils/dot_utils.py,sha256=pmwnY461mOnDjIjgHD6H9MhQXFaF-q8kWerJDgJ1DuI,2364
+abstract_utilities/robust_readers/import_utils/function_utils.py,sha256=Q9NKvRov3uAaz2Aal3d6fb_opWNXHF9C8GSKOjgfO8Y,1622
+abstract_utilities/robust_readers/import_utils/import_utils.py,sha256=l0GYdtj5FEYX2yknL-8ru7_U2Sp9Hi1NpegqWPLRMc8,11705
+abstract_utilities/robust_readers/import_utils/impot_functions.py,sha256=1_pzkfgixRAzTzGnICcZi-4ocdkjpB0ENPCx96ET3LM,2499
+abstract_utilities/robust_readers/import_utils/safe_import_utils.py,sha256=L-pwmWkV6eOkYNKA9c4QLTJ5v0DoWQu_v5HukCOo95w,2414
+abstract_utilities/robust_readers/import_utils/sysroot_utils.py,sha256=f8hj20VA9yvvYkqQ9ecuBlzmTOaT5G7ni14QesDtdL0,2098
+abstract_utilities/robust_readers/import_utils/utils.py,sha256=xyMObkdyvQAzAIv_kagLhFdkwSaPd4h0bCjTCYyfGhY,722
+abstract_utilities-0.2.2.450.dist-info/METADATA,sha256=ioD82GAVtolQlBj7TmSa1QfoBaMNVODKDn3E4_HxO20,28043
+abstract_utilities-0.2.2.450.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_utilities-0.2.2.450.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
+abstract_utilities-0.2.2.450.dist-info/RECORD,,

abstract_utilities/cmd_utils/imports/__init__.py

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

abstract_utilities/cmd_utils/imports/imports.py

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

@@ -1,310 +0,0 @@
-
-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/compare_utils/__init__.py

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

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

abstract_utilities/compare_utils/find_value.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-from typing import Any, Callable, Iterable, Iterator, List, Tuple, Union, Dict
-import re
-
-JSONLike = Union[dict, list, tuple, set, str, int, float, bool, None]
-PathType = Tuple[Union[str, int], ...]  # ('window_title',) or ('tabs', 2, 'name'), etc.
-
-def iter_values(obj: JSONLike, path: PathType = ()) -> Iterator[Tuple[PathType, Any]]:
-    """
-    Depth-first walk of nested dict/list/tuple/set. Yields (path, value) for every leaf.
-    Path items are str (dict key) or int (list index).
-    """
-    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:
-            # sets are unordered/no index – use a pseudo-key
-            yield from iter_values(v, path + ('<setitem>',))
-    else:
-        # leaf (scalar)
-        yield path, obj
-
-def _mk_predicate(
-    terms: Iterable[str] | None = None,
-    *,
-    case_insensitive: bool = True,
-    substring: bool = True,
-    regex: bool = False
-) -> Callable[[Any], bool]:
-    """
-    Build a predicate that checks a scalar value against terms.
-    """
-    terms = list(terms or [])
-    if regex:
-        flags = re.IGNORECASE if case_insensitive else 0
-        patterns = [re.compile(t, flags) for t in terms]
-        def pred(value: Any) -> bool:
-            if not isinstance(value, str):
-                return False
-            return any(p.search(value) for p in patterns)
-        return pred
-
-    # string contains (or equals)
-    def pred(value: Any) -> bool:
-        if not isinstance(value, str):
-            return False
-        v = value.lower() if case_insensitive else value
-        for t in terms:
-            t2 = t.lower() if case_insensitive else t
-            if (t2 in v) if substring else (t2 == v):
-                return True
-        return False
-
-    return pred
-
-def search_values(
-    obj: JSONLike,
-    *,
-    terms: Iterable[str],
-    case_insensitive: bool = True,
-    substring: bool = True,
-    regex: bool = False,
-) -> List[Tuple[PathType, Any]]:
-    """
-    Return all (path, value) where value matches any term.
-    """
-    pred = _mk_predicate(terms, case_insensitive=case_insensitive, substring=substring, regex=regex)
-    results: List[Tuple[PathType, Any]] = []
-    for p, v in iter_values(obj):
-        if pred(v):
-            results.append((p, v))
-    return results
-
-def any_match(
-    obj: JSONLike,
-    *,
-    terms: Iterable[str],
-    **kw
-) -> bool:
-    """Fast boolean check."""
-    pred = _mk_predicate(terms, **kw)
-    for _, v in iter_values(obj):
-        if pred(v):
-            return True
-    return False
-def get_first_match(obj: JSONLike, *, terms: Iterable[str], **kw) -> Optional[Any]:
-    """Return just the first matching value, or None."""
-    pred = _mk_predicate(terms, **kw)
-    for _, v in iter_values(obj):
-        if pred(v):
-            return v
-    return None
-
-def get_all_match(obj: JSONLike, *, terms: Iterable[str], **kw) -> List[Any]:
-    """Return all matching values as a flat list."""
-    pred = _mk_predicate(terms, **kw)
-    results: List[Any] = []
-    for _, v in iter_values(obj):
-        if pred(v):
-            results.append(v)
-    return results

abstract_utilities/env_utils/__init__.py

@@ -1,3 +0,0 @@
-from .imports import *
-from .abstractEnv import *
-from .envy_it import *