abstract-utilities 0.2.2.436__tar.gz → 0.2.2.438__tar.gz

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.436
+Version: 0.2.2.438
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_utilities',
-    version='0.2.2.436',
+    version='0.2.2.438',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description='abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.',

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities/class_utils.py

@@ -44,9 +44,9 @@ Dependencies:
 Each function is furnished with its own docstring that elaborates on its purpose, expected inputs, and outputs.
 
 """
-import inspect
-import json
-import functools
+import os,json,functools,inspect
+from typing import *
+
 def get_type_list() -> list:
     """Get a list of common Python types."""
     return ['None','str','int','float','bool','list','tuple','set','dict','frozenset','bytearray','bytes','memoryview','range','enumerate','zip','filter','map','property','slice','super','type','Exception','object']
@@ -370,3 +370,39 @@ def get_class_inputs(cls, *args, **kwargs):
         else:
             values[field] = getattr(cls(), field)
     return cls(**values)
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)
+
+

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities/dynimport.py

@@ -1,12 +1,12 @@
 # abstract_utilities/dynimport.py
 from __future__ import annotations
-import importlib, sys, os
 from functools import lru_cache
-from typing import Any, Callable, Iterable, Optional
-import inspect, sys
+from typing import *
+import importlib, sys, os, sys
+from typing import Optional
 from importlib import import_module
 from .type_utils import make_list
-from .file_utils import get_for_all_tabs,call_for_all_tabs
+
 class _LazyAttr:
     """Lazy resolver proxy to avoid import-time cycles.
     First use triggers actual import & attribute lookup.
@@ -181,14 +181,6 @@ def get_many_module_imports(*args):
             all_modules[symbol] = get_abstract_import(module = module,symbol=symbol)
     import_symbols(all_modules)
     return all_modules
-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=None):
-    
-    root = root or get_caller_dir()
-    get_for_all_tabs(root)
+
+
+

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities/file_utils/imports/module_imports.py

@@ -6,3 +6,4 @@ from ...env_utils import *
 from ...read_write_utils import *
 from ...abstract_classes import SingletonMeta
 from ...log_utils import get_logFile
+from ...inspect_utils import get_caller,get_caller_path,get_caller_dir

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities/log_utils.py

@@ -229,7 +229,7 @@ def initialize_call_log(value=None,
 
     print_or_log(full_message,level=log_level)
     
-def get_json_call_response(value, status_code, data=None, logMsg=None, callLog=False):
+def get_json_call_response(value=None, status_code=None, data=None, logMsg=None, callLog=False):
     response_body = {}
     if status_code == 200:
         response_body["success"] = True

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities/path_utils.py

@@ -27,12 +27,9 @@ from .read_write_utils import read_from_file,write_to_file
 from .string_clean import eatAll
 from .list_utils import make_list
 from .type_utils import get_media_exts, is_media_type,MIME_TYPES
-def get_caller_path(i=1):
-    frame = inspect.stack()[i]
-    return os.path.abspath(frame.filename)
-def get_caller_dir(i=1):
-    abspath = get_caller_path(i+1)
-    return os.path.dirname(abspath)
+from .safe_utils import safe_join
+from .class_utils import get_caller_path,get_caller_dir
+
 def get_os_info():
     """
     Get Operating System Information
@@ -600,6 +597,45 @@ def get_safe_filename(path=None,basename=None):
 def get_safe_ext(path=None,basename=None):
     _,ext = get_safe_splitext(path=path,basename=basename)
     return ext
+def raw_create_dirs(*paths):
+    """Recursively create all directories along the given path."""
+    full_path = os.path.abspath(safe_join(*paths))
+    sub_parts = [p for p in full_path.split(os.sep) if p]
+
+    current_path = "/" if full_path.startswith(os.sep) else ""
+    for part in sub_parts:
+        current_path = safe_join(current_path, part)
+        os.makedirs(current_path, exist_ok=True)
+    return full_path
+
+
+def create_dirs(directory, child=None):
+    """Create directory and optional child path safely."""
+    full_path = os.path.abspath(safe_join(directory, child))
+    if not os.path.exists(full_path):
+        raw_create_dirs(full_path)
+    return full_path
+
+
+def get_base_dir(directory=None):
+    """Return given directory or _BASE_DIR fallback."""
+    return directory or _BASE_DIR
+
+
+def create_base_path(directory=None, child=None):
+    """Join base dir with child."""
+    directory = get_base_dir(directory)
+    return safe_join(directory, child)
+
+
+def create_base_dir(directory=None, child=None):
+    """Ensure existence of base directory path."""
+    full_path = create_base_path(directory, child)
+    if not os.path.exists(full_path):
+        raw_create_dirs(full_path)
+    return full_path
+
+
 
 def get_file_parts(path):
     

abstract_utilities-0.2.2.438/src/abstract_utilities/read_write_utils.py

@@ -0,0 +1,135 @@
+"""
+read_write_utils.py
+-------------------
+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:
+    from abstract_utilities.read_write_utils import *
+"""
+
+import os
+
+_FILE_PATH_KEYS = ['file', 'filepath', 'file_path', 'path', 'directory', 'f', 'dst', 'dest']
+_CONTENTS_KEYS = ['cont', 'content', 'contents', 'data', 'datas', 'dat', 'src', 'source']
+
+
+# --- Helper utilities --------------------------------------------------------
+def string_in_keys(strings, kwargs):
+    """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 os.path.isfile(path):
+                return path
+            dirname = os.path.dirname(path)
+            if os.path.exists(dirname):
+                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):
+    """
+    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 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]
+
+    if file_path is None:
+        raise ValueError("Missing file_path argument.")
+    return file_path, contents
+
+
+# --- 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
+
+
+def read_from_file(file_path):
+    """Read text content from a file."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def create_and_read_file(*args, **kwargs):
+    """
+    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(file_path, contents or "")
+    return read_from_file(file_path)
+
+
+def is_file_extension(obj: str) -> bool:
+    """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-0.2.2.438/src/abstract_utilities/safe_utils.py

@@ -0,0 +1,130 @@
+"""
+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_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-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.436
+Version: 0.2.2.438
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.436 → abstract_utilities-0.2.2.438}/src/abstract_utilities.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/abstract_utilities/math_utils.py
 src/abstract_utilities/parse_utils.py
 src/abstract_utilities/path_utils.py
 src/abstract_utilities/read_write_utils.py
+src/abstract_utilities/safe_utils.py
 src/abstract_utilities/string_clean.py
 src/abstract_utilities/tetsts.py
 src/abstract_utilities/thread_utils.py

abstract_utilities-0.2.2.436/src/abstract_utilities/read_write_utils.py

@@ -1,199 +0,0 @@
-"""
-read_write_utils.py
-
-This module, 'read_write_utils.py', provides utility functions for reading and writing to files.
-These include functions to:
-
-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.
-
-Each function includes a docstring to further explain its purpose, input parameters, and return values.
-import os
-
-# 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
-
-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)
-
-def get_path(paths):
-    for path in paths:
-        if isinstance(path,str):
-            if os.path.isfile(path):
-                return path
-            dirname = os.path.dirname(path)
-            if os.path.exists(dirname):
-                return path
-    return None
-
-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)
-
-    # Handle positional arguments
-    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.")
-
-    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:
-    """
-    Read the contents of a file.
-    
-    Args:
-        file_path: The path of the file to read from.
-        
-    Returns:
-        The contents of the 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:
-    """
-    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.
-    """
-    if not os.path.isfile(file_path):
-        write_to_file(contents, file_path)
-    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]
-
-def delete_file(file_path: str):
-    if os.path.isfile(file_path):
-        os.remove(file_path)
-