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

abstract_utilities/robust_readers/import_utils/clean_imports.py

@@ -0,0 +1,175 @@
+from ...read_write_utils import read_from_file,write_to_file
+from ...string_clean import eatAll,eatElse,clean_line
+from ...class_utils import get_caller_path
+from ...list_utils import make_list
+import os
+import_tag = 'import '
+from_tag = 'from '
+def get_text_or_read(text=None,file_path=None):
+    text = text or ''
+    imports_js = {}
+    if not text and file_path and os.path.isfile(file_path):
+        text=read_from_file(file_path)
+    return text
+def is_line_import(line):
+    if line and (line.startswith(from_tag) or line.startswith(import_tag)):
+        return True
+    return False
+def is_line_group_import(line):
+    if line and (line.startswith(from_tag) and import_tag in line):
+        return True
+    return False
+def get_import_pkg(line):
+    if is_line_group_import(line):
+        return clean_line(line.split(from_tag)[1].split(import_tag)[0])
+def get_imports_from_import_pkg(line):
+    if is_line_group_import(line):
+        return get_cleaned_import_list(line,commaClean=True)
+
+def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
+    import_pkg_js = import_pkg_js or {}
+    imports = clean_imports(imports)
+    if import_pkg not in import_pkg_js:
+        i = len(import_pkg_js["nulines"])
+        import_pkg_js[import_pkg]={"imports":imports,"line":i}
+        import_line = f"from {import_pkg} import "
+        if import_pkg == "import":
+            import_line = import_tag
+        import_pkg_js["nulines"].append(import_line)
+    else:
+        import_pkg_js[import_pkg]["imports"]+=imports
+    return import_pkg_js
+def update_import_pkg_js(line,import_pkg_js=None):
+    import_pkg_js = import_pkg_js or {}
+    if is_line_group_import(line):
+        import_pkg = get_import_pkg(line)
+        imports = get_imports_from_import_pkg(line)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js)
+    else:
+        if len(import_pkg_js["nulines"]) >0 and line == '' and is_line_import(import_pkg_js["nulines"][-1]):
+            pass
+        else:
+            import_pkg_js["nulines"].append(line)
+    return import_pkg_js
+def is_from_line_group(line):
+    if line and line.startswith(from_tag) and import_tag in line and '(' in line:
+        import_spl = line.split(import_tag)[-1]
+        import_spl_clean = clean_line(line)
+        if not import_spl_clean.endswith(')'):
+            return True
+    return False
+def clean_imports(imports,commaClean=True):
+    chars=["*"]
+    if not commaClean:
+        chars.append(',')
+    if isinstance(imports,str):
+        imports = imports.split(',')
+    return [eatElse(imp,chars=chars) for imp in imports if imp]
+def get_cleaned_import_list(line,commaClean=True):
+    cleaned_import_list=[]
+    if import_tag in line:
+        imports = line.split(import_tag)[1]
+        cleaned_import_list+=clean_imports(imports,commaClean=commaClean)
+    return cleaned_import_list
+def get_all_imports(text=None,file_path=None,import_pkg_js=None):
+    text = get_text_or_read(text=text,file_path=file_path)
+    lines = text.split('\n')
+    cleaned_import_list=[]
+    nu_lines = []
+    is_from_group = False
+    import_pkg_js = import_pkg_js or {}
+    if "nulines" not in import_pkg_js:
+        import_pkg_js["nulines"]=[]
+    if "file_path" not in import_pkg_js:
+        import_pkg_js["file_path"]=file_path
+    if "all_data" not in import_pkg_js:
+        import_pkg_js["all_data"]=[]
+    if file_path and file_path != import_pkg_js["file_path"]:
+        found=False
+        nu_data = {"file_path":import_pkg_js["file_path"],"nulines":import_pkg_js["nulines"]}
+        for i,data in enumerate(import_pkg_js["all_data"]):
+            if data.get('file_path') == import_pkg_js["file_path"]:
+                import_pkg_js["all_data"][i] = nu_data
+                found = True
+                break
+        if found == False:
+            import_pkg_js["all_data"].append(nu_data)
+        import_pkg_js["nulines"]=[]
+        import_pkg_js["file_path"]=file_path
+
+    for line in lines:
+        if line.startswith(import_tag) and ' from ' not in line:
+            cleaned_import_list = get_cleaned_import_list(line)
+            import_pkg_js = add_imports_to_import_pkg_js("import",cleaned_import_list,import_pkg_js=import_pkg_js)
+        else:
+            if is_from_group:
+                import_pkg=is_from_group
+                line = clean_line(line)
+                if line.endswith(')'):
+                   is_from_group=False
+                   line=line[:-1]
+                imports_from_import_pkg = clean_imports(line)
+                import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports_from_import_pkg,import_pkg_js=import_pkg_js)
+                
+            else:
+                import_pkg_js=update_import_pkg_js(line,import_pkg_js=import_pkg_js)
+            if is_from_line_group(line) and is_from_group == False:
+                is_from_group=get_import_pkg(line)
+    return import_pkg_js
+def clean_all_imports(text=None,file_path=None,import_pkg_js=None):
+    if not import_pkg_js:
+        import_pkg_js = get_all_imports(text=text,file_path=file_path)
+    nu_lines = import_pkg_js["nulines"]
+    for pkg,values in import_pkg_js.items():
+        comments = []
+        if pkg not in ["nulines","file_path","all_data"]: 
+            line = values.get('line')
+            imports = values.get('imports')
+            for i,imp in enumerate(imports):
+                if '#' in imp:
+                    imp_spl = imp.split('#')
+                    comments.append(imp_spl[-1])
+                    imports[i] = clean_line(imp_spl[0])
+            imports = list(set(imports))   
+            if '*' in imports:
+                imports="*"
+            else:
+                imports=','.join(imports)
+                if comments:
+                    comments=','.join(comments)
+                    imports+=f" #{comments}"
+            import_pkg_js[pkg]["imports"]=imports
+            nu_lines[line] += imports
+    import_pkg_js["nulines"]=nu_lines
+    return import_pkg_js
+
+def get_all_real_imps(file):
+    contents = read_from_file(file)
+    lines = contents.split('\n')
+    for line in lines:
+        if line.startswith('from '):
+            from_line = line.split('from ')[-1]
+            dot_fro = ""
+            dirname = file
+            for char in from_line:
+                if  char != '.':
+                    line = f"from {dot_fro}{eatAll(from_line,'.')}"
+                    if line in all_imps:
+                        line = ""
+                    break
+                if dot_fro == "":
+                    dot_fro = ""
+                dirname = os.path.dirname(dirname)
+                dirbase = os.path.basename(dirname)
+                dot_fro = f"{dirbase}.{dot_fro}"
+        if line:
+            all_imps.append(line)
+
+    return '\n'.join(all_imps)
+def save_cleaned_imports(text=None,file_path=None,write=False,import_pkg_js=None):
+    import_pkg_js=get_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    import_pkg_js = clean_all_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js)
+    contents = '\n'.join(import_pkg_js["nulines"])
+    if file_path and write:
+        write_to_file(contents=contents,file_path=file_path)
+    return contents

abstract_utilities/safe_utils/__init__.py

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

abstract_utilities/safe_utils/imports/__init__.py

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

abstract_utilities/safe_utils/imports/imports.py

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

abstract_utilities/safe_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...type_utils import is_number
+from ...class_utils import get_caller_dir

abstract_utilities/safe_utils/safe_utils.py

@@ -0,0 +1,136 @@
+"""
+abstract_safeops.py
+-------------------
+Utility functions for safely splitting, slicing, and retrieving elements from iterable or string objects
+without raising exceptions on invalid input or out-of-range indices.
+
+Designed for compatibility with the abstract_ ecosystem (e.g. abstract_utilities, abstract_math, etc.).
+"""
+
+from .imports import *
+_BASE_DIR = get_caller_dir()
+
+
+def safe_split(
+    string: Any,
+    char: Any,
+    i: Optional[int] = None,
+    default: Union[bool, Any] = False
+) -> Union[str, List[str], Any, None]:
+    """
+    Safely split a string by a character and optionally return index i.
+
+    Args:
+        string: Input string (or any object convertible to string).
+        char: Delimiter to split on.
+        i: Optional index to retrieve from the split result.
+        default: If True, return the original string on error. 
+                 If any other value, return that instead of raising.
+
+    Returns:
+        The split list, or the element at index i, or default behavior on error.
+    """
+    if string is None or char is None:
+        return string
+
+    s, c = str(string), str(char)
+    if c not in s:
+        return string
+
+    parts = s.split(c)
+
+    if i is None:
+        return parts
+
+    if is_number(i):
+        idx = int(i)
+        if 0 <= idx < len(parts):
+            return parts[idx]
+
+    if default:
+        return string if default is True else default
+
+    return None
+
+
+def safe_slice(
+    obj: Any,
+    i: Optional[int] = None,
+    k: Optional[int] = None,
+    default: Union[bool, Any] = False
+) -> Any:
+    """
+    Safely slice an iterable object or string, with fallback behavior on invalid indices.
+
+    Args:
+        obj: Iterable or string-like object.
+        i: Start index (can be negative).
+        k: End index (can be negative).
+        default: If True, returns the original object on error.
+                 If any other value, return that value on error.
+
+    Returns:
+        The sliced object, or default behavior on error.
+    """
+    # Null or invalid base case
+    if obj is None or isinstance(obj, bool):
+        return obj if default is True else default if default else None
+
+    # Non-iterable guard
+    if not hasattr(obj, "__getitem__"):
+        return obj if default is True else default if default else None
+
+    obj_len = len(obj)
+
+    # Normalize negative indices
+    if isinstance(i, int) and i < 0:
+        i = obj_len + i
+    if isinstance(k, int) and k < 0:
+        k = obj_len + k
+
+    # Bound indices
+    if i is not None:
+        i = max(0, min(i, obj_len))
+    if k is not None:
+        k = max(0, min(k, obj_len))
+
+    try:
+        return obj[i:k]
+    except Exception:
+        return obj if default is True else default if default else None
+
+def safe_join(*paths):
+    paths = list(paths)
+    paths = [path for path in paths if path]
+    return os.path.join(*paths)
+def safe_get(
+    obj: Any,
+    key: Union[int, str, None] = None,
+    default: Union[bool, Any] = False
+) -> Any:
+    """
+    Generalized safe getter for both indexable and mapping types.
+
+    Args:
+        obj: The object to access (list, dict, string, etc.).
+        key: Index or key to retrieve.
+        default: Fallback value or True for "return obj".
+
+    Returns:
+        Retrieved element, or default value on failure.
+    """
+    if obj is None or key is None:
+        return obj if default is True else default if default else None
+
+    try:
+        if isinstance(obj, dict):
+            return obj.get(key, obj if default is True else default if default else None)
+        return obj[key]
+    except Exception:
+        return obj if default is True else default if default else None
+def get_slash(path):
+    if '/' in path:
+        return '/'
+    else:
+        return '//'
+join_path=safe_join

abstract_utilities/ssh_utils/__init__.py

@@ -1,3 +1,5 @@
+from .imports import *
 from .classes import *
-from .utils import *
+from .cmd_utils import *
 from .pexpect_utils import *
+from .type_checks import *

abstract_utilities/ssh_utils/classes.py

@@ -1,5 +1,4 @@
 from .imports import *
-from .utils import run_local_cmd, run_ssh_cmd,run_any_cmd,run_cmd
 
 class PathBackend(Protocol):
     def join(self, *parts: str) -> str: ...

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,6 @@
+from ...string_utils import get_from_kwargs,eatAll,eatOuter
+from ...type_utils import make_list  # whatever you already have
+from ...time_utils import get_sleep
+from abstract_security import *
+
+from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func