abstract-utilities 0.2.2.467__py3-none-any.whl → 0.2.2.513__py3-none-any.whl

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/ssh_utils/type_checks.py

@@ -0,0 +1,92 @@
+from .imports import *
+
+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
+
+
+# --- Individual path checks --------------------------------------------------
+def is_remote_file(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a file."""
+    return _remote_test(path, "-f", **kwargs)
+
+
+def is_remote_dir(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a directory."""
+    return _remote_test(path, "-d", **kwargs)
+
+
+def is_local_file(path: str) -> bool:
+    """True if local path is a file."""
+    return os.path.isfile(path)
+
+
+def is_local_dir(path: str) -> bool:
+    """True if local path is a directory."""
+    return os.path.isdir(path)
+
+
+# --- Unified interface -------------------------------------------------------
+
+def is_file(path: str,*args,**kwargs) -> bool:
+    """Determine if path is a file (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_file(path, **kwargs)
+    return is_local_file(path)
+
+
+def is_dir(path: str, *args,**kwargs) -> bool:
+    """Determine if path is a directory (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_dir(path, **kwargs)
+    return is_local_dir(path)
+
+def is_exists(path: str, *args,**kwargs) -> bool:
+    if is_file(path,**kwargs):
+        return True
+    if is_dir(path,**kwargs):
+        return True
+    return False
+# --- Optional: keep your original all-in-one wrapper ------------------------
+def check_path_type(
+    path: str,
+    *args,
+    **kwargs
+) -> str:
+    """
+    Return 'file', 'directory', 'missing', or 'unknown'.
+    Uses isolated is_file/is_dir functions.
+    """
+    if get_user_pass_host_key(**kwargs):
+        if is_remote_file(path,**kwargs):
+            return "file"
+        elif is_remote_dir(path,**kwargs):
+            return "directory"
+        else:
+            return "missing"
+    else:
+        if os.path.isfile(path):
+            return "file"
+        elif os.path.isdir(path):
+            return "directory"
+        elif not os.path.exists(path):
+            return "missing"
+        return "unknown"

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/__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

abstract_utilities/string_utils/imports/utils.py

@@ -0,0 +1,81 @@
+def quoteIt(st: str, ls: list) -> str:
+    """
+    Quotes specific elements in a string.
+
+    Args:
+        st (str): The input string.
+        ls (list): The list of elements to quote.
+
+    Returns:
+        str: The modified string with quoted elements.
+    """
+    lsQ = ["'", '"']
+    for i in range(len(ls)):
+        for k in range(2):
+            if lsQ[k] + ls[i] in st:
+                st = st.replace(lsQ[k] + ls[i], ls[i])
+            if ls[i] + lsQ[k] in st:
+                st = st.replace(ls[i] + lsQ[k], ls[i])
+        st = st.replace(ls[i], '"' + str(ls[i]) + '"')
+    return st
+
+def truncate_text(text, max_chars):
+    """
+    Truncates a text to a specified maximum number of characters, preserving the last complete sentence or word.
+
+    Args:
+        text (str): The input text.
+        max_chars (int): The maximum number of characters.
+
+    Returns:
+        str: The truncated text.
+    """
+    if len(text) <= max_chars:
+        return text
+    truncated = text[:max_chars]
+    # Find the last complete sentence
+    last_sentence_end = max(truncated.rfind('.'), truncated.rfind('!'), truncated.rfind('?'))
+    # If a complete sentence is found, truncate up to its end
+    if last_sentence_end != -1:
+        truncated = truncated[:last_sentence_end + 1]
+    else:
+        # If no complete sentence is found, find the last complete word
+        last_word_end = truncated.rfind(' ')
+
+        # If a complete word is found, truncate up to its end
+        if last_word_end != -1:
+            truncated = truncated[:last_word_end]
+    return truncated
+def capitalize(string):
+    return string[:1].upper() + string[1:].lower() if string else string
+def get_from_kwargs(*args,**kwargs):
+    del_kwarg = 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 get_lines(string,strip=True):
+    lines = string.split('\n')
+    if strip:
+        lines = [line for line in lines if line]
+    return lines
+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

abstract_utilities/string_utils/replace_utils.py

@@ -0,0 +1,27 @@
+from .imports import *
+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,rep in kwargs.items():
+        string = for_replace(string,item,rep)
+    return string