abstract-utilities 0.2.2.450__py3-none-any.whl → 0.2.2.451__py3-none-any.whl

abstract_utilities/read_write_utils.py

@@ -1,115 +1,38 @@
 """
 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
+from .ssh_utils.utils import run_cmd
+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 +40,103 @@ 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)
+
+    file_path = kwargs.get(file_key) if file_key else None
+    contents = kwargs.get(content_key) if content_key else None
 
-    # Handle positional arguments
+    # 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):
-    """
-    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.
-    """
-    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:
+# --- 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.")
+
+    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,12 @@
+import os,tempfile,shutil,logging,ezodf,fnmatch,pytesseract,pdfplumber
+import pandas as pd
+import geopandas as gpd
+from datetime import datetime
+from pathlib import Path
+from typing import *
+from werkzeug.utils import secure_filename
+from werkzeug.datastructures import FileStorage
+from pdf2image import convert_from_path   # only used for OCR fallback
+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/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)

abstract_utilities/robust_readers/initFuncGen.py

@@ -1,33 +1,22 @@
 # attach_functions.py  — single helper you can import anywhere
 # attach_dynamic.py
 from __future__ import annotations
-from types import ModuleType
-from typing import Iterable
-from .file_filters import define_defaults,get_files_and_dirs
+from .imports import *
+def call_for_all_tabs(root = None,tab_control=True):
+    root = root or get_caller_dir()
+    get_for_all_tabs(root,tab_control=tab_control)
 
-import inspect
-from ..read_write_utils import *
-import textwrap, pkgutil, os, re, textwrap, sys, types, importlib, importlib.util, inspect
-from typing import *
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)
-def get_caller_path():
-    frame = inspect.stack()[1]
-    return os.path.abspath(frame.filename)
-def get_caller_dir():
-    frame = inspect.stack()[1]
-    abspath = os.path.abspath(frame.filename)
-    return os.path.dirname(abspath)
-def call_for_all_tabs():
-
-    root = get_caller_dir()
-    get_for_all_tabs(root)
-
-ABSPATH = os.path.abspath(__file__)
-ABSROOT = os.path.dirname(ABSPATH)
-def clean_imports():
+def get_clean_list(*args):
+    objs = []
+    for arg in args:
+        objs+= make_list(arg)
+    return list(set(objs))
+def clean_imports(*args,**kwargs):
+    for pkg,imps in kwargs.items():
+        f"from {pkg} import make_list(imps)"
+        
     alls = str(list(set("""os,re,subprocess,sys,re,traceback,pydot, enum, inspect, sys, traceback, threading,json,traceback,logging,requests""".replace('\n','').replace(' ','').replace('\t','').split(','))))[1:-1].replace('"','').replace("'",'')
-    input(alls)
+    return 
 def isTab(item):
     item_lower =  item.lower()
     for key in ['console','tab']:
@@ -57,11 +46,17 @@ def ifFunctionsInFile(root):
             return item
         
 
-def get_for_all_tabs(root = None):
+def get_for_all_tabs(root = None,tab_control=True):
     root = root or caller_path()
     if os.path.isfile(root):
         root = os.path.dirname(root)
-    all_tabs = get_dirs(root = root)
+    if tab_control:
+        all_tabs = get_dirs(root = root)
+    else:
+        dirname = root
+        if root and os.path.isfile(root):
+            dirname = os.path.dirname(root)
+        all_tabs = [dirname]
     for ROOT in all_tabs:
         FUNCS_DIR = ifFunctionsInFile(ROOT)
         if FUNCS_DIR == None:
@@ -71,52 +66,38 @@ def get_for_all_tabs(root = None):
             apply_inits(ROOT)
             
 
-def apply_inits(ROOT):
-    FUNCS_DIR = ifFunctionsInFile(ROOT)
-
-    
-    if_fun_dir = isDir(FUNCS_DIR)
-    if if_fun_dir != None:
-        
-        if if_fun_dir:
-            CFG = define_defaults(allowed_exts='.py',
-                unallowed_exts = True,
-                exclude_types = True,
-                exclude_dirs = True,
-                exclude_patterns = True)
-            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
-            
-        else:
-            filepaths = [FUNCS_DIR]
-        
-        # Parse top-level def names
-        def extract_funcs(path: str):
-            funcs = []
-            for line in read_from_file(path).splitlines():
-                m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
-                if m:
-                    funcs.append(m.group(1))
-            return funcs
-
-        # Build functions/__init__.py that re-exports all discovered functions
-        import_lines = []
-        all_funcs = []
-        for fp in filepaths:
-            module = os.path.splitext(os.path.basename(fp))[0]
-            funcs = extract_funcs(fp)
-            if funcs:
-                import_lines.append(f"from .{module} import ({', '.join(funcs)})")
-                all_funcs.extend(funcs)
-        if if_fun_dir:
-            functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
-            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
-
-        # Prepare the tuple literal of function names for import + loop
-        uniq_funcs = sorted(set(all_funcs))
-        func_tuple = ", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
-        
-        # Generate apiConsole/initFuncs.py using the safer setattr-loop
-        init_funcs_src = textwrap.dedent(f"""\
+def write_init_functions(import_lines,functions_dir):
+    functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+    init_file_path = os.path.join(functions_dir, "__init__.py")
+    write_to_file(contents=functions_init, file_path=init_file_path)
+    return {"functions_init":functions_init,"init_file_path":init_file_path}
+def extract_funcs(filepaths):
+    funcs = []
+    for line in read_from_file(path).splitlines():
+        m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+        if m:
+            funcs.append(m.group(1))
+    return funcs
+def get_all_funcs(
+    filepaths,
+    all_funcs=None,
+    import_lines=None
+    ):
+    import_lines = import_lines or []
+    all_funcs = all_funcs or []
+    for fp in filepaths:
+        basename = os.path.basename(fp)
+        module = os.path.splitext(basename)[0]
+        funcs = extract_funcs(fp)
+        if funcs:
+            import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+            all_funcs.extend(funcs)
+    uniq_funcs = sorted(set(all_funcs))
+    func_tuple=", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+    all_funcs_js = {"import_lines":import_lines,"all_funcs":all_funcs,"uniq_funcs":uniq_funcs,"func_tuple":func_tuple}
+    return all_funcs_js
+def get_init_funcs_str(func_tuple):
+        init_funcs_str = textwrap.dedent(f"""\
             
 
             from .functions import ({func_tuple})
@@ -129,7 +110,42 @@ def apply_inits(ROOT):
                     logger.info(f"{{e}}")
                 return self
         """)
-
-        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
-
+        return init_funcs_str
+def get_function_file_paths(functions_dir):
+    filepaths=[]
+    if_fun_dir = isDir(functions_dir)
+    if if_fun_dir != None:
+        input(if_fun_dir)
+        if if_fun_dir:
+            CFG = define_defaults(allowed_exts='.py',
+                unallowed_exts = True,
+                exclude_types = True,
+                exclude_dirs = True,
+                exclude_patterns = True)
+            input(CFG)
+            _,filepaths = get_files_and_dirs(functions_dir,cfg=CFG)
+        else:
+            filepaths = [FUNCS_DIR]
+    input(filepaths)
+    return filepaths
+def apply_inits(root=None,tab_control=True):
+    root = root or get_caller_dir()
+    FUNCS_DIR = ifFunctionsInFile(root)
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:  
+        file_paths = get_function_file_paths(FUNCS_DIR)
+ 
+        all_funcs_js = get_all_funcs(
+            filepaths=file_paths
+            )
+        if if_fun_dir:
+            init_func_js = write_init_functions(import_lines=all_funcs_js.get('import_lines'),functions_dir=FUNCS_DIR)
+            all_funcs_js.update(init_func_js)
+        func_tuple = all_funcs_js.get("func_tuple")
+        init_funcs_str = get_init_funcs_str(func_tuple)
+        init_funcs_file_path = os.path.join(root, "initFuncs.py")
+        all_funcs_js["funcs_str"]=init_funcs_str
+        all_funcs_js["funcs_file_path"]=init_funcs_file_path
+        write_to_file(contents=init_funcs_str, file_path=init_funcs_file_path)
+        return all_funcs_js
 

abstract_utilities/safe_utils.py

@@ -0,0 +1,133 @@
+"""
+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 typing import *
+from .type_utils import is_number
+from .class_utils import get_caller_dir
+
+_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

abstract_utilities/ssh_utils/__init__.py

@@ -0,0 +1,3 @@
+from .classes import *
+from .utils import *
+from .pexpect_utils import *