abstract-utilities 0.2.2.449__py3-none-any.whl → 0.2.2.476__py3-none-any.whl

abstract_utilities/read_write_utils.py

@@ -1,115 +1,40 @@
 """
 read_write_utils.py
-
-This module, 'read_write_utils.py', provides utility functions for reading and writing to files.
-These include functions to:
+-------------------
+Unified read/write utility for safe file operations.
+Supports:
+- Writing content to a file
+- Reading content from a file
+- Creating and reading if missing
+- Detecting file/content params via positional args or kwargs
 
 Usage:
-    import abstract_utilities.read_write_utils as read_write_utils
-
-1. Write content to a file.
-2. Read content from a file.
-3. Check if a string has a file extension.
-4. Read from or write to a file depending on the number of arguments.
-5. Create a file if it does not exist, then read from it.
+    from abstract_utilities.read_write_utils import *
+"""
 
-Each function includes a docstring to further explain its purpose, input parameters, and return values.
 import os
+import shlex
+from .ssh_utils.utils import run_cmd,get_print_sudo_cmd,run_local_cmd,run_remote_cmd
+from .file_utils.file_utils.type_checks import is_file,is_dir
+from .abstract_classes import run_pruned_func
+_FILE_PATH_KEYS = ['file', 'filepath', 'file_path', 'path', 'directory', 'f', 'dst', 'dest']
+_CONTENTS_KEYS = ['cont', 'content', 'contents', 'data', 'datas', 'dat', 'src', 'source']
 
-# File and Directory Operations
-os.rename(src, dst)            # Rename a file or directory
-os.remove(path)               # Remove a file
-os.unlink(path)               # Alias for os.remove()
-os.rmdir(path)                # Remove an empty directory
-os.makedirs(path)             # Create directories recursively
-os.makedirs(path, exist_ok=True)  # Create directories, ignore if exists
-os.mkdir(path)                # Create a single directory
-os.listdir(path)              # List files and directories in a path
-os.chdir(path)                # Change current working directory
-os.getcwd()                   # Get current working directory
-os.stat(path)                 # Get file/directory information
-os.lstat(path)                # Get symbolic link information
-os.symlink(src, dst)          # Create a symbolic link
-os.readlink(path)             # Read the target of a symbolic link
-os.getcwd()                   # Get current working directory
-os.chdir(path)                # Change current working directory
-
-# File and Directory Information
-os.path.exists(path)          # Check if a path exists
-os.path.isfile(path)          # Check if a path points to a file
-os.path.isdir(path)           # Check if a path points to a directory
-os.path.islink(path)          # Check if a path points to a symbolic link
-os.path.abspath(path)         # Get the absolute path of a file/directory
-os.path.basename(path)        # Get the base name of a path
-os.path.dirname(path)         # Get the directory name of a path
-os.path.join(path1, path2, ...)  # Join path components into a single path
-
-# File Permissions
-os.chmod(path, mode)          # Change file permissions
-os.access(path, mode)         # Check if a file is accessible with given mode
-
-# File Times
-os.path.getatime(path)        # Get last access time of a file
-os.path.getmtime(path)        # Get last modification time of a file
-os.path.getctime(path)        # Get creation time of a file
-os.utime(path, times)         # Set access and modification times
-
-# Working with Paths
-os.path.split(path)           # Split a path into (head, tail)
-os.path.splitext(path)        # Split a path into (root, ext)
-os.path.normpath(path)        # Normalize a path (e.g., convert slashes)
-
-# Other
-os.path.samefile(path1, path2)  # Check if two paths refer to the same file
-
-# Directory Traversal
-for root, dirs, files in os.walk(top, topdown=True):
-    # Traverse a directory tree, yielding root, dirs, and files lists
-
-# Temporary Files and Directories
-import tempfile
-tempfile.mkstemp()            # Create a temporary file
-tempfile.mkdtemp()            # Create a temporary directory
-tempfile.TemporaryFile()      # Create a temporary file object
-
-# Environment Variables
-os.environ                    # Dictionary of environment variables
-os.environ['VAR_NAME']        # Access an environment variable
-os.environ.get('VAR_NAME')    # Access an environment variable (with default)
-
-# Path Manipulation
-os.path.abspath(path)         # Convert relative path to absolute path
-os.path.join(path1, path2, ...)  # Join paths together
-os.path.split(path)           # Split a path into directory and filename
-os.path.dirname(path)         # Get the directory part of a path
-os.path.basename(path)        # Get the filename part of a path
-os.path.exists(path)          # Check if a path exists
-os.path.isfile(path)          # Check if a path points to a file
-os.path.isdir(path)           # Check if a path points to a directory
-
-# File Permissions
-os.chmod(path, mode)          # Change file permissions
-
-# Miscellaneous
-os.getpid()                   # Get the current process ID
-os.getlogin()                 # Get the name of the logged-in user
-
-"""
-import os
-def break_down_find_existing(path):
-    test_path = ''
-    for part in path.split(os.sep):
-        test_path = os.path.join(test_path, part)
-        if not os.path.exists(test_path):
-            return test_path if test_path else None
-    return test_path
 
+# --- Helper utilities --------------------------------------------------------
 def string_in_keys(strings, kwargs):
-    return next((key for key in kwargs if any(s.lower() in key.lower() for s in strings)), None)
+    """Find a matching keyword in kwargs that contains any of the given substrings."""
+    for key in kwargs:
+        for s in strings:
+            if s.lower() in key.lower():
+                return key
+    return None
+
 
 def get_path(paths):
+    """Return the first valid path among given paths."""
     for path in paths:
-        if isinstance(path,str):
+        if isinstance(path, str):
             if os.path.isfile(path):
                 return path
             dirname = os.path.dirname(path)
@@ -117,83 +42,180 @@ def get_path(paths):
                 return path
     return None
 
+
+def break_down_find_existing(path):
+    """Return the first non-existent subpath within a path chain."""
+    test_path = ''
+    for part in path.split(os.sep):
+        test_path = os.path.join(test_path, part)
+        if not os.path.exists(test_path):
+            return test_path if test_path else None
+    return test_path
+
+
+# --- Parameter parsing --------------------------------------------------------
 def check_read_write_params(*args, **kwargs):
-    file_path = kwargs.get('file_path', None)
-    contents = kwargs.get('contents', None)
-    if contents is None:
-        contents = kwargs.get('data', None)
+    """
+    Determine file_path and contents from arguments.
+    Returns a tuple: (file_path, contents)
+    """
+    file_key = string_in_keys(_FILE_PATH_KEYS, kwargs)
+    content_key = string_in_keys(_CONTENTS_KEYS, kwargs)
 
-    # Handle positional arguments
+    file_path = kwargs.get(file_key) if file_key else None
+    contents = kwargs.get(content_key) if content_key else None
+
+    # Handle positional args (fallback)
     if file_path is None and len(args) > 0:
         file_path = args[0]
     if contents is None and len(args) > 1:
         contents = args[1]
-    elif contents is None and len(args) > 0 and file_path != args[0]:
-        contents = args[0]
-
-    if file_path is None or contents is None:
-        raise ValueError("Both 'file_path' and 'contents' (or 'data') are required.")
 
+    if file_path is None:
+        raise ValueError("Missing file_path argument.")
     return file_path, contents
 
-def write_to_file(file_path=None, contents=None,*args,  **kwargs):
+def write_to_path(
+        file_path: str,
+        contents: str,
+        *,
+        user_at_host: str = None,
+        cwd: str | None = None,
+        password=None,
+        key=None,
+        env_path=None,
+        **kwargs
+    ) -> str:
     """
-    Write contents to a file. If the file does not exist, it is created.
-
-    Args:
-        file_path: The path of the file to write to.
-        contents: The content to write to the file.
-        
-    Returns:
-        The contents that were written to the file.
+    Completely overwrite a file (locally or remotely).
+    Supports sudo and password-based remote execution.
     """
-    params = check_read_write_params(file_path=file_path, contents=contents,*args,  **kwargs)
-    if params:
-        with open(params[0], 'w', encoding='UTF-8') as f:
-            f.write(params[1])
-        return contents
 
-
-def read_from_file(file_path) -> str:
+    # sanitize for shell safety
+    quoted_path = shlex.quote(file_path)
+    quoted_data = shlex.quote(str(contents))
+
+    # shell command that fully overwrites
+    # (no append, replaces contents entirely)
+    base_cmd = f"echo {quoted_data} > {quoted_path}"
+
+    # optional sudo password injection
+    full_cmd = get_print_sudo_cmd(
+        cmd=base_cmd,
+        password=password,
+        key=key,
+        env_path=env_path
+    )
+
+    # local or remote dispatch
+    if user_at_host:
+        return run_remote_cmd(
+            user_at_host=user_at_host,
+            cmd=full_cmd,
+            cwd=cwd,
+            password=password,
+            key=key,
+            env_path=env_path,
+            **kwargs
+        )
+    else:
+        return run_local_cmd(
+            cmd=full_cmd,
+            cwd=cwd,
+            password=password,
+            key=key,
+            env_path=env_path,
+            **kwargs
+        )
+### --- Core functionality -------------------------------------------------------
+##def write_to_file(*args, **kwargs):
+##    """
+##    Write contents to a file (create if missing).
+##
+##    Returns the file_path written.
+##    """
+##    file_path, contents = check_read_write_params(*args, **kwargs)
+##    if contents is None:
+##        raise ValueError("Missing contents to write.")
+##
+##    os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
+##    with open(file_path, "w", encoding="utf-8") as f:
+##        f.write(str(contents))
+##    return file_path
+# --- Core functionality -------------------------------------------------------
+def write_to_file(*args, **kwargs):
     """
-    Read the contents of a file.
-    
-    Args:
-        file_path: The path of the file to read from.
-        
-    Returns:
-        The contents of the file.
+    Write contents to a file (create if missing).
+
+    Returns the file_path written.
     """
-    with open(file_path, 'r', encoding='UTF-8') as f:
+    file_path, contents = check_read_write_params(*args, **kwargs)
+    if contents is None:
+        raise ValueError("Missing contents to write.")
+    user_at_host = kwargs.get("user_at_host")
+    if user_at_host:
+        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
+        # sanitize for shell safety
+        quoted_path = shlex.quote(file_path)
+        quoted_data = shlex.quote(str(contents))
+        # shell command that fully overwrites
+        # (no append, replaces contents entirely)
+        kwargs["cmd"] = f"echo {quoted_data} > {quoted_path}"
+        return run_pruned_func(run_cmd,**kwargs)
+
+
+    os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(str(contents))
+    return file_path
+
+
+def read_from_file(file_path,**kwargs):
+    user_at_host = kwargs.get("user_at_host")
+    if user_at_host:
+        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
+        basename = os.path.basename(file_path)
+        kwargs["cmd"] = f'cat {basename}'
+        return run_pruned_func(run_cmd,**kwargs)
+    """Read text content from a file."""
+    with open(file_path, "r", encoding="utf-8") as f:
         return f.read()
 
-def create_and_read_file(file_path=None, contents:str='',*args,  **kwargs) -> str:
+
+def create_and_read_file(*args, **kwargs):
     """
-    Create a file if it does not exist, then read from it.
-    
-    Args:
-        file_path: The path of the file to create and read from.
-        contents: The content to write to the file if it does not exist.
-        
-    Returns:
-        The contents of the file.
+    Create the file (if missing) and read contents from it.
     """
+    file_path, contents = check_read_write_params(*args, **kwargs)
     if not os.path.isfile(file_path):
-        write_to_file(contents, file_path)
+        write_to_file(file_path, contents or "")
     return read_from_file(file_path)
+
+
 def is_file_extension(obj: str) -> bool:
-    """
-    Check if a string has a file extension.
-    
-    Args:
-        obj: The string to check.
-        
-    Returns:
-        True if the string has a file extension, False otherwise.
-    """
-    return len(obj) >= 4 and '.' in obj[-4:-3]
+    """Return True if obj looks like a filename with extension."""
+    if not isinstance(obj, str):
+        return False
+    root, ext = os.path.splitext(obj)
+    return bool(root and ext)
+
 
 def delete_file(file_path: str):
+    """Safely delete a file if it exists."""
     if os.path.isfile(file_path):
         os.remove(file_path)
+        return True
+    return False
+
 
+def get_content_lines(*args, **kwargs):
+    """Return a list of lines from string or file path."""
+    file_path, contents = check_read_write_params(*args, **kwargs)
+    if os.path.isfile(file_path):
+        contents = read_from_file(filepath)
+
+    if isinstance(contents, str):
+        return contents.splitlines()
+    elif isinstance(contents, list):
+        return contents
+    return []

abstract_utilities/robust_reader/__init__.py

@@ -1,2 +1,2 @@
-from .file_reader import *
+from ..file_utils import *
 

abstract_utilities/robust_reader/imports/__init__.py

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

abstract_utilities/robust_reader/imports/imports.py

@@ -0,0 +1,3 @@
+from ...abstract_classes import SingletonMeta
+from ..pdf_utils import *
+from ...read_write_utils import *

abstract_utilities/robust_readers/__init__.py

@@ -1,3 +1,2 @@
-from .file_filters import *
 from .initFuncGen import *
 from .import_utils import *

abstract_utilities/robust_readers/import_utils/__init__.py

@@ -4,3 +4,4 @@ from .import_utils import *
 from .sysroot_utils import *
 from .utils import *
 from .safe_import_utils import *
+from .clean_imports import *

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/robust_readers/imports.py

@@ -0,0 +1,8 @@
+from types import ModuleType
+from typing import Iterable
+from ..file_utils import get_caller_dir,get_caller_path,define_defaults,get_files_and_dirs
+from ..read_write_utils import *
+import textwrap, pkgutil, os, re, textwrap, sys, types, importlib, importlib.util
+from typing import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)