abstract-utilities 0.2.2.387__py3-none-any.whl → 0.2.2.480__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
+cmd_input = execute_cmd_input

abstract_utilities/ssh_utils/utils.py

@@ -0,0 +1,188 @@
+from .imports import *
+def get_pass_from_key(key=None,env_path=None):
+    if key:
+        return get_env_value(key=key,path=env_path)
+def get_password(password=None,key=None,env_path=None):
+    password = password or get_pass_from_key(key=key,env_path=env_path)
+    return password
+
+def get_print_sudo_cmd(
+        cmd: str,
+        password=None,
+        key=None,
+        env_path=None
+    ):
+    password = get_password(password=password,key=key,env_path=env_path)
+    if password != None:
+        
+        cmd = get_password_cmd(password=password,cmd=cmd)
+    return cmd
+def get_password_cmd(password:str,cmd:str):
+    sudo_cmd = get_sudo_cmd(cmd)
+    password_sudo_cmd = get_raw_password_sudo_cmd(password=password,sudo_cmd=sudo_cmd)
+    return password_sudo_cmd
+def get_sudo_cmd(cmd: str):
+    return f"sudo -S -k {cmd}"
+def get_raw_password_sudo_cmd(password:str,sudo_cmd:str):
+    return f"printf %s {shlex.quote(password)} | {sudo_cmd}"
+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,
+            password=None,
+            key=None,
+            env_path=None
+            
+        ):
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
+    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,
+        user_at_host: str=None,
+        password=None,
+        key=None,
+        env_path=None
+    ) -> str:
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
+    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,
+        password=None,
+        key=None,
+        env_path=None
+    ) -> 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.
+    """
+    cmd = get_print_sudo_cmd(
+            cmd=cmd,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
+    # 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,
+        password=None,
+        key=None,
+        env_path=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,
+                password=password,
+                key=key,
+                env_path=env_path
+            )
+    return run_local_cmd(
+            cmd=cmd,
+            cwd=cwd,
+            outfile=outfile,
+            shell=shell,
+            text=text,
+            capture_output=capture_output,
+            password=password,
+            key=key,
+            env_path=env_path
+        )
+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/string_clean.py

@@ -22,6 +22,8 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import os
+from .list_utils import make_list
+from .type_utils import get_alpha_ints
 def quoteIt(st: str, ls: list) -> str:
     """
     Quotes specific elements in a string.
@@ -110,6 +112,42 @@ def eatAll(string: str, list_objects:(str or list)) -> any:
     if string and list_objects:
         string = eatOuter(string, list_objects)
     return string
+
+
+
+def eatElse(
+    stringObj,
+    chars=None,
+    ints=True,
+    alpha=True,
+    lower=True,
+    capitalize=True,
+    string=True,
+    listObj=True
+):
+    alpha_ints = get_alpha_ints(
+        ints=True,
+        alpha=True,
+        lower=True,
+        capitalize=True,
+        string=True,
+        listObj=True
+        )
+    chars = make_list(chars or [])+alpha_ints
+
+    while True:
+        if stringObj:
+            str_0 = stringObj[0] not in chars
+            str_1 = stringObj[-1] not in chars
+            str_eat = str_0 or str_1
+            if not str_eat:
+                return stringObj
+            if stringObj and str_0:
+                stringObj = stringObj[1:] if len(stringObj) !=1 else ""
+            if stringObj and str_1:
+                stringObj = stringObj[:-1] if len(stringObj) !=1 else ""   
+        else:
+            return stringObj
 def safe_split(obj, ls):
     """
     Safely splits a string using multiple delimiters.
@@ -185,6 +223,7 @@ def url_join(*paths):
             final_path = f"{final_path}/{path}"
     return final_path
        
-    
+def clean_line(line):
+    return eatAll(line,[' ','','\t','\n'])
 def capitalize(string):
     return string[:1].upper() + string[1:].lower() if string else string

abstract_utilities/string_utils.py

@@ -0,0 +1,51 @@
+from .list_utils import make_list
+def get_from_kwargs(*args,**kwargs):
+    del_kwargs = kwargs.get('del_kwargs',False)
+    values = {}
+    for key in args:
+        if key:
+            key = str(key)
+            if key in kwargs:
+                values[key] = kwargs.get(key)
+                if del_kwarg:
+                    del kwargs[key]
+    return values,kwargs
+
+def replace_it(string,item,rep):
+    if item in string:
+        string = string.replace(item,rep)
+    return string
+def while_replace(string,item,rep):
+    while True:
+        string = replace_it(string,item,rep)
+        if item not in string or item in rep:
+            return string
+def for_replace(string,item,replace):
+    replace = make_list(replace)
+    for rep in replace:
+        string = while_replace(string,item,rep)
+    return string
+def replace_all(string,*args,**kwargs):
+    for items in args:
+        if items and isinstance(items,list):
+            item = items[0]
+            replace = items[1:] if len(items)>1 else items[-1]
+            string = for_replace(string,item,replace)
+    values,kwargs = get_from_kwargs('item','replace',**kwargs)
+    if values:
+        string = for_replace(string,**values)
+    for item,replace in kwargs.items():
+        string = for_replace(string,item,rep)
+    return string
+def get_lines(string,strip=True):
+    lines = string.split('\n')
+    if strip:
+        lines = [line for line in lines if line]
+    return lines
+def get_alpha():
+    return 'abcdefghijklmnopqrstuvwxyz'
+def is_alpha(char,case_sensative=False):
+    alphas = get_alpha()
+    if not case_sensative:
+        alphas+=alphas.upper()
+    return char in alphas

abstract_utilities/type_utils.py

@@ -59,8 +59,8 @@ Version: 0.1.2
 import os
 from pathlib import Path
 from typing import Union
-from .path_utils import get_all_item_paths,get_files
 from .list_utils import make_list
+
 # A big, but by no means exhaustive, map of extensions to mime‐types by category:
 MIME_TYPES = {
     'image': {
@@ -937,7 +937,30 @@ def is_any_instance(value):
     for each in [dict, list, int, float]:
         if is_instance(value, each):
             return True
-
+def getAlphas(lower=True,capitalize=False,listObj=False):
+    obj = ''
+    alphas = 'abcdefghijklmoprstuvwxyz'
+    if lower:
+        obj+=alphas
+    if capitalize:
+        obj+=alphas.upper()
+    if listObj:
+        obj = list(obj)
+    return obj
+def getInts(string=False,listObj=False):
+    obj=12345678909
+    if string:
+        obj = str(obj)
+    if listObj:
+        obj = list(obj)
+    return obj
+def get_alpha_ints(ints=True,alpha=True,lower=True,capitalize=True,string=True,listObj=True):
+    objs = [] if listObj else ""
+    if ints:
+        objs+=getInts(string=string,listObj=listObj)
+    if alpha:
+        objs+=getAlphas(lower=lower,capitalize=capitalize,listObj=listObj)
+    return objs
 # Function: is_number
 # Function: is_str
 # Function: is_int

{abstract_utilities-0.2.2.387.dist-info → abstract_utilities-0.2.2.480.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.387
+Version: 0.2.2.480
 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