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

abstract_utilities/ssh_utils/pexpect_utils.py

@@ -0,0 +1,315 @@
+from .classes import *
+from .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()
+    password = f"{password}\n" if password else 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,
+                                shell=True, text=True, capture_output=True)
+    else:
+        out = execute_cmd_input(sudo_cmd, input_text=password,
+                                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:
+##        print(full_cmd)
+##        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)
+
+    return child.exitstatus if child.exitstatus is not None else 0
+

abstract_utilities/ssh_utils/utils.py

@@ -0,0 +1,122 @@
+from .imports import *
+def get_remote_bash(
+            cmd: str,
+            cwd: str | None = None
+        ):
+    return f"bash -lc {shlex.quote((f'cd {shlex.quote(cwd)} && {cmd}') if cwd else cmd)}"
+def get_remote_ssh(
+            user_at_host: str=None,
+            remote:str=None
+        ):
+    return f"ssh {shlex.quote(user_at_host)} {shlex.quote(remote)}"
+                   
+def get_remote_cmd(
+            cmd: str,
+            user_at_host: str,
+            cwd: str | None = None,
+            
+        ):
+    remote = get_remote_bash(
+        cmd=cmd,
+        cwd=cwd
+        )
+    full = get_remote_ssh(
+        user_at_host=user_at_host,
+        remote=remote
+        )
+    return full
+def execute_cmd(
+        *args,
+        outfile=None,
+        **kwargs
+    ) -> str:
+    proc = subprocess.run(*args, **kwargs)
+    output = (proc.stdout or "") + (proc.stderr or "")
+    if outfile:
+        try:
+            with open(outfile, "w", encoding="utf-8", errors="ignore") as f:
+                f.write(output)
+        except Exception:
+            pass
+    return output
+
+def run_local_cmd(
+        cmd: str,
+        cwd: str | None = None,
+        outfile: Optional[str] = None,
+        shell=True,
+        text=True,
+        capture_output=True
+    ) -> str:
+    return execute_cmd(
+            cmd,
+            outfile=outfile,
+            shell=shell,
+            cwd=cwd,
+            text=text,
+            capture_output=capture_output
+        )
+
+def run_remote_cmd(
+        user_at_host: str,
+        cmd: str,
+        cwd: str | None = None,
+        outfile: Optional[str] = None,
+        shell=True,
+        text=True,
+        capture_output=True
+    ) -> str:
+    """
+    Run on remote via SSH; capture stdout+stderr locally; write to local outfile.
+    NOTE: we do *not* try to write the file on the remote to avoid later scp.
+    """
+    # wrap in bash -lc for PATH/profile + allow 'cd && ...'
+    cmd = get_remote_cmd(
+        cmd=cmd,
+        user_at_host=user_at_host,
+        cwd=cwd
+        )
+    return execute_cmd(
+            cmd,
+            outfile=outfile,
+            shell=shell,
+            text=text,
+            capture_output=capture_output
+        )
+def run_cmd(
+        cmd: str=None,
+        cwd: str | None = None,
+        outfile: Optional[str] = None,
+        shell=True,
+        text=True,
+        capture_output=True,
+        user_at_host: str=None
+    ) -> str:
+    if user_at_host:
+        return run_ssh_cmd(
+                user_at_host=user_at_host,
+                cmd=cmd,
+                cwd=cwd,
+                outfile=outfile,
+                shell=shell,
+                text=text,
+                capture_output=capture_output
+            )
+    return run_local_cmd(
+            cmd=cmd,
+            cwd=cwd,
+            outfile=outfile,
+            shell=shell,
+            text=text,
+            capture_output=capture_output
+        )
+run_ssh_cmd = run_remote_cmd
+remote_cmd = run_remote_cmd
+ssh_cmd = run_remote_cmd
+
+local_cmd = run_local_cmd
+
+
+run_any_cmd = run_cmd
+any_cmd = run_cmd
+cmd_run = run_cmd

{abstract_utilities-0.2.2.413.dist-info → abstract_utilities-0.2.2.415.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.413
+Version: 0.2.2.415
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.413.dist-info → abstract_utilities-0.2.2.415.dist-info}/RECORD

@@ -1,4 +1,4 @@
-abstract_utilities/__init__.py,sha256=nVQ_3HwOQopqPEq6JNnxvlkNsbfOuQakue1tmXO1I2M,6619
+abstract_utilities/__init__.py,sha256=sdSohSe4mvqnprCt3-EX46MiT63jD6Bi_jamt2WuJPY,6558
 abstract_utilities/abstract_classes.py,sha256=A6-FNDQb2P_jcyt01Kc5SuY2QawLVKNjQ-rDGfsn4rA,2461
 abstract_utilities/class_utils.py,sha256=-YHkdbaChRIz9YLXJlFF4m7VkdwUCts_HOUbKXxkrYA,12735
 abstract_utilities/collator_utils.py,sha256=9exNoZAr9rABGYTwZOn7hdLbpnMtRd2AgfU7yjZrXGw,2348
@@ -13,6 +13,7 @@ abstract_utilities/list_utils.py,sha256=i1fZ_kZ0mf_ei6w0MOkuEieRiyF-ReeAXzIdoRI1
 abstract_utilities/log_utils.py,sha256=Crt1qlACE2z1R9s0d11pRhlizh7ryryp4gCl3hQOrV0,9383
 abstract_utilities/math_utils.py,sha256=0o1ls1En03UAkYmxTBildCCJDfHygmNuvVnrNrLYtK0,6578
 abstract_utilities/parse_utils.py,sha256=Z5OGRwHuzCzY91fz0JJojk1BPAo1XF2quNNLuBF4_Vk,18602
+abstract_utilities/path_utils.py,sha256=chEUkTQa-W4FNX7DGkWj_IQFY9x6PiqyVEYWxhfPh5U,18140
 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
@@ -22,29 +23,41 @@ abstract_utilities/type_utils.py,sha256=1gpwfG5ze8dTUi7IXnMc65vHrw8XgI0F8m6x4esZ
 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/cmd_utils/pexpect_utils.py,sha256=u33BkeyQAiGlP81569a-iH95znRBmURM_cbN-nLlFAQ,10357
+abstract_utilities/cmd_utils/user_utils.py,sha256=e1s-VPucZ_Ldg2LsXH-W3OQdh_X5vV8gU_-ARF2khsM,1829
+abstract_utilities/cmd_utils/imports/__init__.py,sha256=mp6T1rBZdOzj0IDkvlteTqtyKJiOZaJTlgrjTdHO1Qw,23
+abstract_utilities/cmd_utils/imports/imports.py,sha256=TmvKQJb02_bZBo4ANNtCADl42LSWaYaU-6nml51Tt9o,362
 abstract_utilities/compare_utils/__init__.py,sha256=ay_tktzoXtj85IdVCGR6Pc6fLX_DR4Mg_Y_-sS5qcmY,120
 abstract_utilities/compare_utils/best_match.py,sha256=XVf0cypM8u4Tp595k7r9jxeOkAXWjXrcGwcNFLEseMk,5160
 abstract_utilities/compare_utils/compare_utils.py,sha256=1Bu8pQEOwLIzDpEmqfeBO7BDxMdcXuG2sVHqdd1IeK8,14034
 abstract_utilities/compare_utils/find_value.py,sha256=_Jss3AvmwQMDLVlkgDPcp6tAXD4KnUbXjCR370sb1Xo,3349
-abstract_utilities/path_utils/__init__.py,sha256=G6yBwrhU6O3_HWTB_9pw_hEABzR4zeAQzXsa87Ptebg,167
-abstract_utilities/path_utils/file_filters.py,sha256=2aVuD0sB-P2gmo_kUsE11aHc6WzLvHUAerMkmy3y9vk,7751
-abstract_utilities/path_utils/file_utils.py,sha256=B_MlkLP8s-o0yU0R3Y2LcTpBntBzysJO18qq181xz9c,1043
-abstract_utilities/path_utils/filter_params.py,sha256=NF692W0cBhEsbtmaVzb8EKMAasasHDElSRaC9fnzYwE,3382
-abstract_utilities/path_utils/path_utils.py,sha256=ZdtTuQSwl5U1YejZn0Xz53faGwGUkCVPNfay5HAbMOU,17962
-abstract_utilities/path_utils/req.py,sha256=FIUA0YCCJ2sZJlBS3c4LDFIXNzPhytjBk62WKiU2aug,12179
-abstract_utilities/path_utils/imports/__init__.py,sha256=bbi0iMyhXW50cAdzDWCHj8L8-iY40tWjd669vG50TTw,78
-abstract_utilities/path_utils/imports/constants.py,sha256=VxTiOpJg7k9FpPgJRnFOJ2rQU8KPPd-pcphsBQDnO1o,1445
-abstract_utilities/path_utils/imports/imports.py,sha256=Ee0B4UIwUR6hxZQhiSyH2X4Kglei1FgDdi0WLXv8ooI,233
-abstract_utilities/path_utils/imports/module_imports.py,sha256=XLULIVBimJyA0uL4X2H-JabMil9cZKazFkTeMPJxQ24,209
+abstract_utilities/env_utils/__init__.py,sha256=VIihpuDHrrI0CBj3kGN0ZcgxaGgoqBe4Be7q2Ks8IEw,73
+abstract_utilities/env_utils/abstractEnv.py,sha256=01W7jkvZMmvdrcYIrZFd1-WFdcOULKc-SNAPF6FdyLM,6027
+abstract_utilities/env_utils/envy_it.py,sha256=lGkTB3AOY1KTRfQgtJji_yjSVVt0FV9YTETZD7vhnM4,1353
+abstract_utilities/env_utils/imports/__init__.py,sha256=LVIEQXKiAmaKKWxPxfSJKe7JGWi4RDt4eatm_VG-WUI,44
+abstract_utilities/env_utils/imports/imports.py,sha256=ZrGEf-J2lyVbb4MrNBX3DwHR0o-frba52RbPkypNvao,355
+abstract_utilities/env_utils/imports/utils.py,sha256=oB7WhIm_-cHLrUHRXypZGCdWUtNRyePaVO5_kq5Cv84,4490
+abstract_utilities/file_utils/__init__.py,sha256=BoDOPNR7HUHCakF9-RDjY0PK8UfvZJHcHcyPYh48g_k,84
+abstract_utilities/file_utils/req.py,sha256=DicCS80V4L8GPWr7lBKDR_gTC1WI9o8lMC2IYLyDUBk,12105
+abstract_utilities/file_utils/file_utils/__init__.py,sha256=eSx06LVBmD1WLWXN8lvSDH03FT4bR7KPOC3c7J9VLXA,108
+abstract_utilities/file_utils/file_utils/file_filters.py,sha256=khfbonAPEAhW1wxfFo0I4dawYPCrIKEjNc7VKb1RvzA,3437
+abstract_utilities/file_utils/file_utils/file_utils.py,sha256=vRXUKIuJvLEOKWPUrceLAwTfozh6bBPZdEDI7xRS4zY,7226
+abstract_utilities/file_utils/file_utils/filter_params.py,sha256=NF692W0cBhEsbtmaVzb8EKMAasasHDElSRaC9fnzYwE,3382
+abstract_utilities/file_utils/file_utils/imports.py,sha256=SXCMBuHUwqXbfRBk4LjKehsBKZa8-Po5UfEcNTwn4Es,24
+abstract_utilities/file_utils/file_utils/map_utils.py,sha256=B_MlkLP8s-o0yU0R3Y2LcTpBntBzysJO18qq181xz9c,1043
+abstract_utilities/file_utils/imports/__init__.py,sha256=0nezbIo1RqmfZ7pZ0V3kxZDNchNWH8wVATnnvNeILMo,101
+abstract_utilities/file_utils/imports/classes.py,sha256=nE860spCea0rV2JjR1xQ7aewNQUd-q9AQTeRkjfup94,4675
+abstract_utilities/file_utils/imports/constants.py,sha256=VxTiOpJg7k9FpPgJRnFOJ2rQU8KPPd-pcphsBQDnO1o,1445
+abstract_utilities/file_utils/imports/imports.py,sha256=jEdn5Crc_LkpgJH7XH4PQSKyG-2tcifQMZi4aZVytyI,455
+abstract_utilities/file_utils/imports/module_imports.py,sha256=FlukD7cOA9O6mGbPubMvuGq0elh6ltC5BLFvPrYzqLo,326
 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=rvHd723OkSyxJe0w2qKQHmdn6X_5AL5O9r_jm-vAkHY,27
-abstract_utilities/robust_readers/imports.py,sha256=3bjM7i074pz4ho1OaBixnT9zQji1gGfQ78qBSnIu8kY,355
+abstract_utilities/robust_readers/__init__.py,sha256=_1vhOG1FJnfrRK0ubkT1v6U6udHMIk3qiy1qajL1IiM,55
+abstract_utilities/robust_readers/imports.py,sha256=FtNxdPoLeeNycDnl-6rBGxBfYjhQ7VhmI5guj8XKFcU,355
 abstract_utilities/robust_readers/initFuncGen.py,sha256=D3_JEJgSiMFPNAMVMcml6hceydTCYnvu_rG_z6n_Nd8,5217
 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
@@ -54,7 +67,12 @@ abstract_utilities/robust_readers/import_utils/impot_functions.py,sha256=1_pzkfg
 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.413.dist-info/METADATA,sha256=Ow5bslO_VYlvDflVU2GdJDgJvZi-DW6PI-d_K1zNuoM,28108
-abstract_utilities-0.2.2.413.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_utilities-0.2.2.413.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
-abstract_utilities-0.2.2.413.dist-info/RECORD,,
+abstract_utilities/ssh_utils/__init__.py,sha256=-DxUpOmfMi5zdG3lu93uT9MziZ-I_anwWOg1XduBH6o,73
+abstract_utilities/ssh_utils/classes.py,sha256=3Q9BfLpyagNFYyiF4bt-5UCezeUJv9NK9YAFdTsLCV0,4802
+abstract_utilities/ssh_utils/imports.py,sha256=7-pVJK1RfR0KiZsv0mNYGPuNXA4iYqmDvqbAR9h1llU,371
+abstract_utilities/ssh_utils/pexpect_utils.py,sha256=HTwGFiZ0xrBe1iFDYWvLkAvXHzr4KYDexWG5GboVe-8,10527
+abstract_utilities/ssh_utils/utils.py,sha256=Sy-plzJ9SgnYCL_wGoPZz_aE1hbbDNEMINwNMePY_v4,3069
+abstract_utilities-0.2.2.415.dist-info/METADATA,sha256=WI6pQ0lNASDjQf3XKjWxyvK75B_PpjjRac4kahtmv8g,28108
+abstract_utilities-0.2.2.415.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_utilities-0.2.2.415.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
+abstract_utilities-0.2.2.415.dist-info/RECORD,,