abstract-utilities 0.2.2.412__py3-none-any.whl → 0.2.2.414__py3-none-any.whl

abstract_utilities/__init__.py

@@ -74,13 +74,17 @@ from .path_utils import (get_file_create_time,
                          make_dirs,
                          remove_directory,
                          remove_path,
-                         get_file_parts,
-                         get_file_map,
-                         get_file_type,
-                         call_for_all_tabs,
-                         get_files_and_dirs,
-                         define_defaults
+
                          )
+from .file_utils import (
+    get_file_parts,
+    get_file_map,
+    get_file_type,
+    call_for_all_tabs,
+    get_files_and_dirs,
+    define_defaults,
+    ScanConfig
+    )
 from .list_utils import (get_highest_value_obj,
                          make_list,
                          safe_list_return,
@@ -156,5 +160,5 @@ from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_re
 from .error_utils import try_func
 from .class_utils import alias,get_class_inputs,get_set_attr
 from .robust_reader import *
-
-
+from .robust_readers import *
+from .ssh_utils import *

abstract_utilities/cmd_utils/imports/__init__.py

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

abstract_utilities/cmd_utils/imports/imports.py

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

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

@@ -1,4 +1,4 @@
-from ..string_clean import eatOuter
+
 def get_user_input(text,default='y'):
     choices = '(y/n)' if default in ['y','n'] else ''
     response = input(f"{text} {choices}:({default}) ") or default

abstract_utilities/env_utils/__init__.py

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

abstract_utilities/env_utils/abstractEnv.py

@@ -0,0 +1,129 @@
+from .imports import *
+class abstractEnv:
+    def __init__(self,key='MY_PASSWORD',file_name=None,path=os.getcwd(),deep_scan=False):
+        file_name = file_name or '.env'
+        self.re_initialize(file_name=file_name,key=key,path=path,deep_scan=deep_scan)
+    def re_initialize(self,key='MY_PASSWORD',file_name='.env',path=os.getcwd(),deep_scan=False):
+        """
+        Initializes an AbstractEnv object to manage environment variables.
+
+        Args:
+            key (str, optional): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+            file_name (str, optional): The name of the .env file. Defaults to '.env'.
+            path (str, optional): The path where the .env file is located. Defaults to the current working directory.
+        """
+
+        self.key = key or 'MY_PASSWORD'
+
+        file_name = file_name or '.env'
+        self.key = key or 'MY_PASSWORD'
+        self.deep_scan=deep_scan
+        self.current_folder = os.getcwd()
+        if path and os.path.isfile(path):
+            self.file_name = os.path.basename(path)
+            self.path = os.path.dirname(path)
+        else:
+            self.path = path or self.current_folder
+            self.file_name = file_name or '.env'
+        self.start_path_env = os.path.join(self.path,self.file_name)
+        self.home_folder = os.path.expanduser("~")
+        self.envy_all = os.path.join(self.home_folder,'.envy_all')
+        self.directories = self.get_directories()
+        self.env_value = self.find_and_read_env_file(key=self.key,file_name=self.file_name, path=self.path,initialize=False)
+
+    def find_and_read_env_file(self,key:str=None, file_name:str=None, path=None,initialize=True,deep_scan=False):
+        """
+        Search for an environment file and read a specific key from it.
+
+        Args:
+            file_name (str): Name of the .env file to be searched. Defaults to '.env'.
+            key (str): Key to be retrieved from the .env file. Defaults to 'MY_PASSWORD'.
+            start_path (str): Directory path to start the search from. If None, search starts from current directory. 
+
+        Returns:
+            str: The value corresponding to the key if found, otherwise None.
+        """
+        # Set the default start_path to the current directory if it's None
+        # Try to find the file in the start_path
+        key = key or self.key
+        path = path or self.start_path_env
+        file_name = file_name or self.file_name
+        if initialize:
+            self.re_initialize(key=key,file_name=file_name,path=path)
+        for directory in self.directories:
+            if directory and os.path.isdir(directory) and self.file_name:
+                env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(env_path):
+                    value = self.search_for_env_key(key=key,path=env_path)
+                self.env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(self.env_path):
+                    value = self.search_for_env_key(key=key,path=self.env_path,deep_scan=deep_scan)
+                    if value:
+                        return value
+    def get_directories(self):
+        """
+        Retrieves a list of directories to search for the .env file.
+
+        Returns:
+            list: A list of directories including the specified path, current folder, home folder, and '.envy_all' directory.
+        """
+        directories=[]
+        for directory in [self.path,self.current_folder,self.home_folder,self.envy_all]:
+            if os.path.isdir(directory) and directory not in directories:
+                directories.append(directory)
+        return directories
+    
+
+    def search_for_env_key(self,key:str=None,path:str=None,deep_scan=False):
+
+        """
+        Retrieves the value of a specified environment variable from a .env file.
+
+        Args:
+            key (str, optional): The key to search for in the .env file. Defaults to None.
+            path (str, optional): The path to the .env file. Defaults to None.
+            file_name (str, optional): The name of the .env file. Defaults to None.
+
+        Returns:
+            str: The value of the environment variable if found, otherwise None.
+        """
+
+        highest = [None,0,0.0]
+        key = key or self.default_env_key
+        path = path or self.start_path_env
+        if path and os.path.isfile(path):
+            with open(path, "r") as f:
+                for line in f:
+                    line_key,line_value = split_eq(line)
+                    # If the line contains the key, return the value after stripping extra characters
+                    if line_key == key:
+                        return line_value
+                    if deep_scan:
+                        line_keys = []
+                        key_parts=0
+                        for key_part in key.split('_'):
+                            line_keys.append([])
+                            if key_part in line_key:
+                                line_keys[-1].append(line_key)
+                                key_parts+=len(key_part)
+                        if float(key_parts/len(key))>=0.5 and key_parts >highest[1]:
+                            highest = [line_value,key_parts]
+                    if deep_scan and highest[0] != None:
+                        return line_value
+    def get_env_value(key:str=None,path:str=os.getcwd(),file_name:str=None):
+        """
+        Retrieves the value of the specified environment variable.
+
+        Args:
+            path (str): The path to the environment file. Defaults to None.
+            file_name (str): The name of the environment file. Defaults to '.env'.
+            key (str): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+
+        Returns:
+            str: The value of the environment variable if found, otherwise None.
+        """
+        if safe_env_load(path):
+            return os.getenv(key)
+        return find_and_read_env_file(file_name=file_name, key=key, path=path_ls)
+
+AbstractEnv = abstractEnv

abstract_utilities/env_utils/envy_it.py

@@ -0,0 +1,33 @@
+from .imports import *
+from .abstractEnv import abstractEnv
+def get_env_value(key:str=None,path:str=None,file_name:str=None,deep_scan=False):
+    abstract_env = abstractEnv(key=key, file_name=file_name, path=path,deep_scan=deep_scan)
+
+    """
+    Retrieves the value of a specified environment variable from a .env file.
+
+    Args:
+        key (str, optional): The key to search for in the .env file. Defaults to None.
+        path (str, optional): The path to the .env file. Defaults to None.
+        file_name (str, optional): The name of the .env file. Defaults to None.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    return abstract_env.env_value
+
+
+def get_env_path(key:str=None,path:str=None,file_name:str=None,deep_scan=False):
+    abstract_env = abstractEnv(key=key, file_name=file_name, path=path,deep_scan=deep_scan)
+    """
+    Retrieves the value of a specified environment variable from a .env file.
+
+    Args:
+        key (str, optional): The key to search for in the .env file. Defaults to None.
+        path (str, optional): The path to the .env file. Defaults to None.
+        file_name (str, optional): The name of the .env file. Defaults to None.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    return abstract_env.env_path

abstract_utilities/env_utils/imports/__init__.py

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

abstract_utilities/env_utils/imports/imports.py

@@ -0,0 +1,8 @@
+import os
+from dotenv import load_dotenv
+from ...string_clean import eatAll,eatInner,eatOuter,safe_split
+from ...compare_utils import line_contains
+from ...type_utils import is_list,is_bool
+from ...path_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join,is_file
+DEFAULT_FILE_NAME = '.env'
+DEFAULT_KEY = 'MY_PASSWORD'

abstract_utilities/env_utils/imports/utils.py

@@ -0,0 +1,122 @@
+from .imports import *
+def find_and_read_env_file(key:str=DEFAULT_KEY,file_name:str=DEFAULT_FILE_NAME,  start_path:str=None):
+    """
+    Search for an environment file and read a specific key from it.
+
+    Args:
+        file_name (str): Name of the .env file to be searched. Defaults to '.env'.
+        key (str): Key to be retrieved from the .env file. Defaults to 'MY_PASSWORD'.
+        start_path (str): Directory path to start the search from. If None, search starts from current directory. 
+
+    Returns:
+        str: The value corresponding to the key if found, otherwise None.
+    """
+    # Set the default start_path to the current directory if it's None
+    directories = [start_path, os.getcwd(), get_home_folder(), simple_path_join(get_home_folder(),'.envy_all'),simple_path_join(get_home_folder(),'envy_all')]
+    if start_path in [None, os.getcwd()]:
+        directories = directories[1:]
+
+    # Try to find the file in the start_path
+    for k in range(0,len(directories)):
+        env_path = check_env_file(path=directories[k],file_name=file_name)
+        if not is_bool(env_path):
+            value = search_for_env_key(path=env_path,key=key)
+            if value != None:
+                return value
+
+def search_for_env_key(key:str,path:str):
+    """
+    Search for a specific key in a .env file.
+
+    Args:
+        path (str): The path to the .env file.
+        key (str): The key to search for in the .env file.
+
+    Returns:
+        str: The value of the key if found, otherwise None.
+    """
+    with open(path, "r") as f:
+        for line in f:
+            eq_split = safe_split(line,['=',0])
+            # If the line contains the key, return the value after stripping extra characters
+            if line_contains(string=eq_split, compare=key):
+                return eatAll(line[len(eq_split):],[' ','','=']).strip()
+
+def check_env_file(path:str,file_name:str=DEFAULT_FILE_NAME):
+    """
+    Check if the environment file exists in a specified path.
+
+    Args:
+        path (str): The path to check for the .env file.
+        file_name (str): The name of the .env file. Defaults to '.env'.
+
+    Returns:
+        str: The path of the .env file if it exists, otherwise False.
+    """
+    path = if_not_last_child_join(path=path, child=DEFAULT_FILE_NAME)
+    # Return the path if file exists, otherwise return False
+    if is_file(path):
+        return path
+    return False
+
+def safe_env_load(path:str=None):
+    """
+    Safely load the .env file if it exists at a specified path.
+
+    Args:
+        path (str): The path to load the .env file from. If None, no operation is performed. 
+
+    Returns:
+        bool: True if the .env file is successfully loaded, otherwise False.
+    """
+    if path == None:
+        return False
+    if is_file(path):
+        if str(safe_split(path,[get_slash(),-1]))[0] == '.':
+            load_dotenv(path)
+            return True
+    return False
+
+def get_env_value(key:str=DEFAULT_KEY,path:str=None,file_name:str=DEFAULT_FILE_NAME):
+    """
+    Retrieves the value of the specified environment variable.
+
+    Args:
+        path (str): The path to the environment file. Defaults to None.
+        file_name (str): The name of the environment file. Defaults to '.env'.
+        key (str): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    if safe_env_load(path):
+        return os.getenv(key)
+    return find_and_read_env_file(file_name=file_name, key=key, start_path=os.getcwd())
+def split_eq(line):
+    """
+    Splits a string at the first equals sign '=' and cleans up the key and value.
+
+    Args:
+        line (str): The string to be split.
+
+    Returns:
+        list: A list containing the cleaned key and value. If '=' is not found, returns [line, None].
+    """
+    if '=' in line:
+        key_side = line.split('=')[0]
+        value_side = line[len(key_side+'='):]
+        return [eatOuter(key_side,[' ','','\t']),eatAll(value_side,[' ','','\t','\n'])]
+    return [line,None]
+def dotenv_load(path:str=None):
+    """
+    Safely load the .env file if it exists at a specified path.
+
+    Args:
+        path (str): The path to load the .env file from. If None, no operation is performed. 
+
+    Returns:
+        bool: True if the .env file is successfully loaded, otherwise False.
+    """
+    if path and os.path.isfile(path) and os.path.basename(path)[0] == '.':
+        load_dotenv(path)
+        return True

abstract_utilities/{path_utils → file_utils}/__init__.py

@@ -1,6 +1,3 @@
 from .imports import *
-from .filter_params import *
-from .file_filters import *
 from .file_utils import *
-from .path_utils import *
 from .req import call_for_all_tabs

abstract_utilities/file_utils/file_utils/__init__.py

@@ -0,0 +1,4 @@
+from .file_filters import *
+from .file_utils import *
+from .filter_params import *
+from .map_utils import *