abstract-utilities 0.2.2.495__py3-none-any.whl → 0.2.2.504__py3-none-any.whl

abstract_utilities/ssh_utils/cmd_utils.py

@@ -0,0 +1,207 @@
+from .imports import *
+def get_output(p):
+    """
+    Get the output of a subprocess command.
+
+    This function takes a subprocess Popen object as an argument and returns
+    the output generated by the command's execution.
+
+    Args:
+        p (subprocess.Popen): A Popen object representing a subprocess command.
+
+    Returns:
+        tuple: A tuple containing the standard output and standard error streams
+               of the executed command.
+    """
+    return p.communicate()
+
+def get_cmd_out(st):
+    """
+    Get the output of a shell command.
+
+    This function executes a shell command using the 'cmd_input' function and
+    retrieves the output generated by the command's execution.
+
+    Args:
+        st (str): The shell command to execute.
+
+    Returns:
+        tuple: A tuple containing the standard output and standard error streams
+               of the executed shell command.
+    """
+    return get_output(cmd_input(st))
+def cmd_input(st):
+    """
+    Execute a shell command using subprocess.
+
+    Args:
+    - st (str): Command to be executed.
+
+    Returns:
+    - subprocess.Popen: A Popen object for communication.
+    """
+    return subprocess.Popen(st, stdout=subprocess.PIPE, shell=True)
+def get_output_text(parent_dir: str = os.getcwd()) -> str:
+    """
+    Get the path to the 'output.txt' file in the given directory.
+
+    Args:
+        parent_dir (str, optional): Directory path. Defaults to the current working directory.
+
+    Returns:
+        str: Path to the 'output.txt' file.
+    """
+    return os.path.join(parent_dir,'output.txt')
+def get_env_value(key: str = None, env_path: str = None) -> str:
+    """
+    Retrieve environment value based on a key from a specified .env file.
+
+    Args:
+        key (str, optional): Environment key to search for. Defaults to None.
+        env_path (str, optional): Path to start searching for the .env file. Defaults to None.
+
+    Returns:
+        str: Value corresponding to the given environment key.
+    """
+    args={}
+    if key != None:
+        args["key"]=key
+    if env_path != None:
+        args["start_path"]=env_path
+    return find_and_read_env_file(**args)
+def print_cmd(input: str, output: str) -> None:
+    """
+    Print the input command and its corresponding output.
+
+    Args:
+        input (str): The command that was run.
+        output (str): Output produced by the command.
+    """
+    print(f"Command Line Arguments: {input}")
+    print(f"Output:\n{output}")
+def get_sudo_password(key: str = "SUDO_PASSWORD") -> str:
+    """
+    Retrieve the sudo password from an environment file.
+
+    Args:
+        key (str, optional): Environment key for the sudo password. Defaults to "SUDO_PASSWORD".
+
+    Returns:
+        str: The sudo password.
+    """
+    return find_and_read_env_file(key=key)
+def cmd_run_sudo(cmd: str, password: str = None, key: str = None, output_text: str = None) -> None:
+    """
+    Execute a command with sudo privileges using either provided password or retrieving it from an environment file.
+
+    Args:
+        cmd (str): Command to be executed.
+        password (str, optional): Password for sudo. Defaults to None.
+        key (str, optional): Environment key to retrieve sudo password. Defaults to None.
+        output_text (str, optional): Path to store the command output. Defaults to None.
+    """
+    if password !=None:
+        cmd_run(f'echo "{password}" | sudo -S -k {cmd}',output_text)
+    elif key != None:
+        cmd_run(f'echo "{get_env_value(key)}" | sudo -S -k {cmd}',output_text)
+    else:
+        cmd_run(f'echo "{get_sudo_password()}" | sudo -S -k {cmd}',output_text)
+def cmd_run(cmd: str, output_text: str = None, print_output: bool = False) -> None:
+    if output_text is None:
+        output_text = get_output_text()
+
+    # Clear output file
+    with open(output_text, 'w') as f:
+        pass
+
+    # Append output redirection
+    full_cmd = f'{cmd} >> {output_text}; echo END_OF_CMD >> {output_text}'
+
+    if print_output:
+        print(full_cmd)
+
+    subprocess.call(full_cmd, shell=True)
+
+    # Wait until END_OF_CMD appears
+    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())
+
+    os.remove(output_text)
+
+def pexpect_cmd_with_args(command: str, child_runs: list, output_text: str = os.getcwd(),print_output:bool=False) -> int:
+    """
+    Run a command using pexpect and handle its prompts with specified responses.
+
+    Args:
+        command (str): Command to be executed.
+        child_runs (list): List of prompts and their respective responses.
+        output_text (str, optional): Path to store the command output. Defaults to the current working directory.
+
+    Returns:
+        int: Exit status of the command.
+    """
+    child = pexpect.spawn(command)
+
+    for each in child_runs:
+        # Wait for the process to prompt for the input and respond with it
+        child.expect(each["prompt"])
+
+        # Respond with the corresponding input
+        if each["pass"] is not None:
+            pass_phrase = each["pass"]
+        else:
+            args = {}
+            if "key" in each:
+                if each["key"] is not None:
+                    args["key"] = each["key"]
+            if "env_path" in each:
+                if 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("Output after handling prompt:")
+            print(each["prompt"])
+
+    # Wait for the process to finish
+    child.expect(pexpect.EOF)
+    output = child.before.decode("utf-8")
+
+    # Write output to the output file
+    with open(get_output_text(), "w") as f:
+        f.write(output)
+    if print_output:
+        print_cmd(command, output)
+
+    return child.exitstatus
+def get_user_pass_host_key(**kwargs):
+    args = ['password','user_at_host','host','key','user']
+    kwargs['del_kwarg']=kwargs.get('del_kwarg',False)
+    values,kwargs = get_from_kwargs(*args,**kwargs)
+    return values
+
+# --- Base remote checker -----------------------------------------------------
+def _remote_test(path: str, test_flag: str, timeout: int = 5,*args, **kwargs) -> bool:
+    """
+    Run a remote shell test (e.g. -f, -d) via SSH.
+    Returns True if test succeeds, False otherwise.
+    """
+    try:
+        kwargs['cmd']=f"[ {test_flag} {shlex.quote(path)} ] && echo 1 || echo 0"
+        kwargs['text']=True
+        kwargs['timeout']=timeout
+        kwargs['stderr']=subprocess.DEVNULL
+        result = run_pruned_func(run_cmd,**kwargs)
+        return result.strip() == "1"
+    except Exception:
+        return False

abstract_utilities/ssh_utils/imports/__init__.py

@@ -0,0 +1,3 @@
+from .imports import *
+from .module_imports import *
+from .utils import *

abstract_utilities/ssh_utils/imports/imports.py

@@ -0,0 +1,5 @@
+# remote_fs.py
+from __future__ import annotations
+from typing import *
+from ...imports import shlex, os,subprocess,pexpect, fnmatch, glob, posixpath, re
+

abstract_utilities/ssh_utils/imports/module_imports.py

@@ -0,0 +1,5 @@
+from ...class_utils import SingletonMeta,run_pruned_func
+from ...string_utils import get_from_kwargs,eatOuter
+from ...type_utils import make_list  # whatever you already have
+from ...time_utils import get_sleep
+from ...env_utils import *

abstract_utilities/ssh_utils/imports/utils.py

@@ -0,0 +1,189 @@
+from .imports import *
+from .module_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/ssh_utils/pexpect_utils.py

@@ -1,6 +1,4 @@
-from .classes import *
-from .utils import *
-from ..env_utils import *
+from .imports import *
 # pexpect is optional; import lazily if you prefer
 
 # keep your execute_cmd; add a thin wrapper that supports stdin text cleanly
@@ -36,17 +34,17 @@ def exec_sudo_capture(
     """
     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,
+        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,
+        out = execute_cmd_input(sudo_cmd, input_text=password + "\n",
                                 shell=True, text=True, capture_output=True, cwd=cwd)
 
     if print_output:
@@ -123,8 +121,8 @@ def cmd_run(
             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 "")
+        if print_output:
+            print_cmd(cmd, out or "")
         return out or ""
 
     # ---- legacy file-backed path (unchanged in spirit) ----
@@ -150,10 +148,9 @@ def cmd_run(
             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())
+    if print_output:
+        with open(output_text, 'r') as f:
+            print_cmd(full_cmd, f.read().strip())
 
     try:
         os.remove(output_text)
@@ -212,8 +209,8 @@ def exec_expect(
 
     child.expect(pexpect.EOF)
     out = child.before.decode("utf-8", errors="ignore")
-##    if print_output:
-##        print_cmd(command, out)
+    if print_output:
+        print_cmd(command, out)
 
     return child.exitstatus if child.exitstatus is not None else 0
 
@@ -261,7 +258,6 @@ def cmd_run_sudo(
     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,
@@ -310,6 +306,3 @@ def pexpect_cmd_with_args(
     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/string_utils/__init__.py

@@ -0,0 +1,4 @@
+from .imports import *
+from .clean_utils import *
+from .eat_utils import *
+from .replace_utils import *

abstract_utilities/string_utils/clean_utils.py

@@ -0,0 +1,28 @@
+from .eat_utils import eatAll
+def clean_spaces(obj: str) -> str:
+    """
+    Removes leading spaces and tabs from a string.
+
+    Args:
+        obj (str): The input string.
+
+    Returns:
+        str: The string with leading spaces and tabs removed.
+    """
+    if len(obj) == 0:
+        return obj
+    while obj[0] in [' ', '\t']:
+        obj = obj[1:]
+    return obj
+def clean_line(line):
+    return eatAll(line,[' ','','\t','\n'])
+def url_join(*paths):
+    final_url = os.path.join(*paths)
+    for i,path in enumerate(paths):
+        if i == 0:
+            final_path = path  # Note: Fixed bug; original code had `final_path = paths`
+        else:
+            final_path = eatOuter(final_path, '/')
+            path = eatInner(path, '/')
+            final_path = f"{final_path}/{path}"
+    return final_path

abstract_utilities/string_utils/eat_utils.py

@@ -0,0 +1,103 @@
+from .imports import *
+def eatInner(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from the inner part of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        for char in string:
+            if string:
+                if char not in list_objects:
+                    return string
+                string = string[1:]
+    return string
+
+
+def eatOuter(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from the outer part of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        for i in range(len(string)):
+            if string:
+                if string[-1] not in list_objects:
+                    return string
+                string = string[:-1]
+    return string
+def eatAll(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from both the inner and outer parts of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        string = eatInner(string, list_objects)
+    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

abstract_utilities/string_utils/imports/__init__.py

@@ -0,0 +1,3 @@
+from .imports import *
+from .module_imports import *
+from .utils import *

abstract_utilities/string_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from typing import *
+from ...imports import os

abstract_utilities/string_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...list_utils import make_list
+from ...type_utils import get_alpha_ints