abstract-utilities 0.2.2.639__tar.gz → 0.2.2.671__tar.gz

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.639
+Version: 0.2.2.671
 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.639 → abstract_utilities-0.2.2.671}/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.639',
+    version='0.2.2.671',
     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.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/__init__.py

@@ -32,7 +32,8 @@ from .json_utils import (unified_json_loader,
                          safe_write_to_file,
                          safe_save_updated_json_data,
                          get_result_from_data,
-                         flatten_json
+                         flatten_json,
+                         to_json_safe
                          )
 
 from .directory_utils import *

abstract_utilities-0.2.2.671/src/abstract_utilities/class_utils/abstract_classes.py

@@ -0,0 +1,144 @@
+from .imports import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(**values)
+
+
+from abstract_utilities import *
+class SingletonMeta(type):
+    _instances = {}
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+def get_inputs(cls, *args, **kwargs):
+    """
+    Dynamically construct a dataclass instance from args and kwargs,
+    filling missing values from defaults in the dataclass.
+    """
+    fields = list(cls.__annotations__.keys())
+    values = {}
+
+    args = list(args)
+    for field in fields:
+        if field in kwargs:
+            values[field] = kwargs[field]
+        elif args:
+            values[field] = args.pop(0)
+        else:
+            values[field] = getattr(cls(), field)  # default from dataclass
+
+    return cls(*args,**values)
+def get_input_params(func):
+    sig = inspect.signature(func)
+    return sig.parameters
+def get_args(func, *args,**kwargs):
+    parameters = get_input_params(func)
+    parameters = dict(parameters)
+    for key,value in parameters.items():
+        value = str(value)
+        if value.startswith('**'):
+            kwargs_key = key
+        elif value.startswith('*'):
+            args_key = key
+            kwargs_copy = kwargs.copy()
+            for k_key,k_value in kwargs.items():
+                if args_key == k_key and  isinstance(k_value,list or tuple or set):
+                    args = args | tuple(k_value)
+                    del kwargs[k_key]
+    return args,kwargs
+
+def prune_inputs(func, *args, **kwargs):
+    """
+    Smart argument adapter:
+    - Detects if func accepts *args or **kwargs
+    - Builds new positional arguments from kwargs when appropriate
+    - Handles explicit {"args": [...]} convention
+    """
+
+    sig = inspect.signature(func)
+    params = sig.parameters
+
+    has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params.values())
+    has_varkw   = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values())
+
+    new_args = list(args)
+    new_kwargs = dict(kwargs)
+
+    # -----------------------------------------------------------
+    # 1. If user provided explicit args: {"args": [...]}
+    # -----------------------------------------------------------
+    if "args" in new_kwargs:
+        explicit_args = new_kwargs.pop("args")
+        if isinstance(explicit_args, (list, tuple)):
+            new_args.extend(explicit_args)
+        else:
+            new_args.append(explicit_args)
+
+    # -----------------------------------------------------------
+    # 2. If function has *args, infer which kwargs belong there
+    # -----------------------------------------------------------
+    if has_varargs:
+
+        # Heuristic rules for upgrading kwargs to args:
+        #   - if the function has NO named params, treat all scalar kwargs as positional
+        #   - common param names like "file_path" also qualify
+        preferred_as_args = {"path", "file", "file_path", "filename", "value"}
+
+        positional_candidates = []
+
+        for k in list(new_kwargs.keys()):
+            v = new_kwargs[k]
+
+            # candidate rules:
+            if k in preferred_as_args:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+            # scalars but not mappings/lists (optional)
+            elif isinstance(v, (str, int, float)) and len(positional_candidates) == 0:
+                positional_candidates.append(v)
+                del new_kwargs[k]
+
+        new_args.extend(positional_candidates)
+
+    # -----------------------------------------------------------
+    # 3. If function does NOT accept **kwargs → strip extras
+    # -----------------------------------------------------------
+    if not has_varkw:
+        allowed = {
+            name for name, p in params.items()
+            if p.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY
+            )
+        }
+        new_kwargs = {k: v for k, v in new_kwargs.items() if k in allowed}
+
+    return tuple(new_args), new_kwargs
+def run_pruned_func(func, *args, **kwargs):
+   args,kwargs = prune_inputs(func, *args, **kwargs)
+   return func(*args, **kwargs)

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/class_utils/caller_utils.py

@@ -52,3 +52,41 @@ def get_caller_dir(i: Optional[int] = None) -> str:
     depth = 1 if i is None else int(i)
     abspath = get_caller_path(depth + 1)
     return os.path.dirname(abspath)
+
+
+def get_original_caller_dir(levels_up: int = None) -> Path:
+    """
+    Return the directory of the *original* caller in the call stack.
+
+    levels_up:
+        - None → automatically goes to the bottom-most user-level caller.
+        - N    → manually walk up N frames for custom behavior.
+    
+    Returns:
+        Path object pointing to caller's directory.
+    """
+
+    stack = inspect.stack()
+
+    # If the user specifies an exact depth
+    if levels_up is not None:
+        target = min(levels_up + 1, len(stack) - 1)
+        frame = stack[target]
+        return Path(frame.filename).resolve().parent
+
+    # Otherwise, auto-detect the FIRST file that isn't inside site-packages or abstract_* utilities
+    for frameinfo in reversed(stack):
+        file_path = Path(frameinfo.filename).resolve()
+
+        # Skip internal interpreter/frame files
+        if "site-packages" in str(file_path):
+            continue
+        if "abstract_" in file_path.name:
+            continue
+        if file_path.name.startswith("<"):
+            continue
+
+        return file_path.parent
+
+    # Fallback: last entry in the stack
+    return Path(stack[-1].filename).resolve().parent

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/class_utils/imports/imports.py

@@ -1,2 +1,2 @@
-from ...imports import inspect,os,json,functools,inspect,glob,sys
+from ...imports import inspect,os,json,functools,inspect,glob,sys,Path
 from typing import *

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/file_utils/imports/classes.py

@@ -50,19 +50,20 @@ def is_file(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isfile(path)
-    cmd = get_item_check_cmd(path,file=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isfile(path)
+        cmd = get_item_check_cmd(path,file=True)
+        return run_cmd(cmd=cmd,
+                user_at_host=user_at_host,
+                password=password,
+                key=key,
+                env_path=env_path,
+                **kwargs
+                )
 def is_dir(
     path,
     user_at_host=None,
@@ -71,34 +72,13 @@ def is_dir(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.isdir(path)
-    cmd = get_item_check_cmd(path,file=False,directory=True)
-    return run_cmd(cmd=cmd,
-            user_at_host=user_at_host,
-            password=password,
-            key=key,
-            env_path=env_path,
-            **kwargs
-            )
-def is_exists(
-    path,
-    user_at_host=None,
-    password=None,
-    key=None,
-    env_path=None,
-    **kwargs
-    ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        cmd = get_item_check_cmd(path,exists=True)
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.isdir(path)
+        cmd = get_item_check_cmd(path,file=False,directory=True)
         return run_cmd(cmd=cmd,
                 user_at_host=user_at_host,
                 password=password,
@@ -106,7 +86,7 @@ def is_exists(
                 env_path=env_path,
                 **kwargs
                 )
-def is_any(
+def is_exists(
     path,
     user_at_host=None,
     password=None,
@@ -114,25 +94,49 @@ def is_any(
     env_path=None,
     **kwargs
     ):
-    contingencies = list(set([user_at_host,password,key,env_path]))
-    len_contingencies = len(contingencies)
-    is_potential = (len_contingencies >1 or (None not in contingencies))
-    if not is_potential:
-        return os.path.exists(path)
-    if is_potential == True:
-        out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
-        for typ,cmd in out_js.items():
-            response = run_cmd(cmd=cmd,
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            cmd = get_item_check_cmd(path,exists=True)
+            return run_cmd(cmd=cmd,
                     user_at_host=user_at_host,
                     password=password,
                     key=key,
                     env_path=env_path,
                     **kwargs
                     )
-            result = "__OK__" in (response or "")
-            if result:
-                return typ
-    return None
+def is_any(
+    path,
+    user_at_host=None,
+    password=None,
+    key=None,
+    env_path=None,
+    **kwargs
+    ):
+    if path:
+        contingencies = list(set([user_at_host,password,key,env_path]))
+        len_contingencies = len(contingencies)
+        is_potential = (len_contingencies >1 or (None not in contingencies))
+        if not is_potential:
+            return os.path.exists(path)
+        if is_potential == True:
+            out_js = get_all_item_check_cmd(path,file=True,directory=True,exists=True)
+            for typ,cmd in out_js.items():
+                response = run_cmd(cmd=cmd,
+                        user_at_host=user_at_host,
+                        password=password,
+                        key=key,
+                        env_path=env_path,
+                        **kwargs
+                        )
+                result = "__OK__" in (response or "")
+                if result:
+                    return typ
+
 class PathBackend(Protocol):
     def join(self, *parts: str) -> str: ...
     def isfile(self, path: str) -> bool: ...

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/file_utils/src/file_filters/ensure_utils.py

@@ -119,14 +119,17 @@ def ensure_directories(*args,**kwargs):
         
         if run_pruned_func(is_dir,arg_str,**kwargs):
             directories.append(arg_str)
+            
         elif run_pruned_func(is_file,arg_str,**kwargs):
             dirname = os.path.dirname(arg_str)
             directories.append(dirname)
-    safe_directories = get_dir_filter_kwargs(**kwargs)
-    safe_dirs = safe_directories.get('directories')
-    safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
-    directories+= make_list(safe_dirs)
+    if not directories:    
+        safe_directories = get_dir_filter_kwargs(**kwargs)
+        safe_dirs = safe_directories.get('directories')
+        safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
+        directories+= make_list(safe_dirs)
     return list(set([r for r in directories if r]))
+
 def get_proper_type_str(string):
     if not string:
         return None

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/import_utils/imports/__init__.py

@@ -1,4 +1,4 @@
-from .imports import *
+from .init_imports import *
 from .module_imports import *
 from .constants import *
 from .utils import *

abstract_utilities-0.2.2.671/src/abstract_utilities/import_utils/imports/init_imports.py

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

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/import_utils/imports/module_imports.py

@@ -6,3 +6,4 @@ from ...path_utils import get_file_parts
 from ...type_utils  import is_number,make_list
 from ...file_utils  import collect_filepaths,collect_globs
 from ...directory_utils import get_shortest_path,get_common_root
+from ...log_utils import get_logFile

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/import_utils/imports/utils.py

@@ -1,4 +1,4 @@
-import os
+from .init_imports import *
 from .constants import *
 
 def is_line_import(line):

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/import_utils/src/__init__.py

@@ -5,3 +5,4 @@ from .import_utils import *
 from .import_functions import *
 from .pkg_utils import *
 from .sysroot_utils import *
+from .layze_import_utils import *

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/import_utils/src/import_utils.py

@@ -297,3 +297,42 @@ def attach_self_functions(
                 attached[out_name] = bound
 
     return attached
+def initFuncs(self, mode=None):
+    """
+    Load functions in either dev (dynamic) or prod (static) mode.
+    """
+    mode = mode or "dev"
+    
+    logger = get_logFile(__name__)
+
+    try:
+        base_pkg = self.__class__.__module__.rsplit('.', 1)[0]
+
+        if mode == "prod":
+            # All imports come from the auto-generated import script
+            imports_mod = importlib.import_module(f"{base_pkg}.imports.funcs_imports")
+
+            # Attach all exports
+            for name in getattr(imports_mod, "__all__", []):
+                func = getattr(imports_mod, name)
+                setattr(self, name, func.__get__(self))
+
+            return self
+
+        # --- DEV MODE: your existing dynamic loader ---
+        import inspect, pkgutil, importlib
+        pkg = importlib.import_module(base_pkg + ".functions")
+
+        existing = set(self.__dict__) | set(dir(self))
+
+        for _, module_name, _ in pkgutil.iter_modules(pkg.__path__):
+            mod = importlib.import_module(f"{pkg.__name__}.{module_name}")
+
+            for name, obj in inspect.getmembers(mod, inspect.isfunction):
+                if name not in existing:
+                    setattr(self, name, obj.__get__(self))
+
+    except Exception as e:
+        logger.error(f"initFuncs({mode}) error: {e}")
+
+    return self

abstract_utilities-0.2.2.671/src/abstract_utilities/import_utils/src/layze_import_utils/__init__.py

@@ -0,0 +1,2 @@
+from .nullProxy import *
+from .lazy_utils import *

abstract_utilities-0.2.2.671/src/abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py

@@ -0,0 +1,41 @@
+from ...imports import *
+from .nullProxy import nullProxy,nullProxy_logger
+@lru_cache(maxsize=None)
+def lazy_import_single(name: str,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+
+    if name in sys.modules:
+        return sys.modules[name]
+
+    try:
+        module = importlib.import_module(name)
+        return module
+    except Exception as e:
+        nullProxy_logger.warning(
+            "[lazy_import] Failed to import '%s': %s",
+            name,
+            e,
+        )
+        return nullProxy(name,fallback=fallback)
+
+def get_lazy_attr(module_name: str, *attrs,fallback=None):
+    obj = lazy_import(module_name,fallback=fallback)
+
+    for attr in attrs:
+        try:
+            obj = getattr(obj, attr)
+        except Exception:
+            return nullProxy(module_name, attrs,fallback=fallback)
+
+    return obj
+def lazy_import(name: str, *attrs,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+    if attrs:
+        obj = get_lazy_attr(name, *attrs,fallback=fallback)
+    else:
+        obj = lazy_import_single(name,fallback=fallback)
+    return obj

abstract_utilities-0.2.2.671/src/abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py

@@ -0,0 +1,37 @@
+from ...imports import *
+nullProxy_logger = logging.getLogger("abstract.lazy_import")
+
+
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=(),fallback=None):
+        self._name = name
+        self._path = path
+        self.fallback=fallback
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        if self.fallback is not None:
+            try:
+                return self.fallback(*args, **kwargs)
+            except Exception as e:
+                logger.info(f"{e}")
+        nullProxy_logger.warning(
+            "[lazy_import] Call to missing module/attr: %s.%s args=%s kwargs=%s",
+            self._name,
+            ".".join(self._path),
+            args,
+            kwargs,
+        )
+        return None
+
+    def __repr__(self):
+        full = ".".join((self._name, *self._path))
+        return f"<nullProxy {full}>"
+
+    def __bool__(self):
+        return False  # safe in conditionals

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/imports.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 import re,pexpect,shlex,ezodf,tiktoken,geopandas as gpd,os,PyPDF2,json,tempfile,requests
 import textwrap,pdfplumber,math,hashlib,pandas as pd,platform,textwrap as tw,glob,asyncio
-import fnmatch,importlib,shutil,sys,time,threading,posixpath,importlib.util,types
+import fnmatch,importlib,shutil,sys,time,threading,posixpath,importlib.util,types, logging
 import subprocess,pytesseract,queue,logging,functools,pathlib,pkgutil,inspect
 from typing import *
 from datetime import timedelta,datetime
 from flask import jsonify
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
-from functools import reduce
+from functools import reduce,lru_cache
 from types import MethodType,ModuleType
 from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
@@ -16,3 +16,6 @@ from pdf2image import convert_from_path # only used for OCR fallback
 from dataclasses import dataclass,field,asdict
 from pprint import pprint
 from dotenv import load_dotenv
+from types import MethodType
+from datetime import datetime, date
+from decimal import Decimal

{abstract_utilities-0.2.2.639 → abstract_utilities-0.2.2.671}/src/abstract_utilities/json_utils/json_utils.py

@@ -123,11 +123,11 @@ def safe_dump_to_file(data, file_path=None, ensure_ascii=False, indent=4, *args,
     else:
         logger.error("file_path and data must be provided to safe_dump_to_file")
 
-def safe_read_from_json(*args,**kwargs):
+def safe_read_from_json(file_path,*args,**kwargs):
     is_read=True
-    file_path,_ = check_read_write_params(*args, **kwargs)
 
-    valid_file_path = get_file_path(*args,is_read=is_read,**kwargs)
+
+    valid_file_path = get_file_path(file_path,*args,is_read=is_read,**kwargs)
     if valid_file_path:
         file_path = valid_file_path
     try:
@@ -749,3 +749,29 @@ def flatten_json(data, parent_key='', sep='_'):
         items.append((parent_key, data))
 
     return dict(items)
+
+
+def to_json_safe(obj):
+    if obj is None:
+        return None
+
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+
+    if isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+
+    if isinstance(obj, Decimal):
+        return float(obj)
+
+    if isinstance(obj, Path):
+        return str(obj)
+
+    if isinstance(obj, dict):
+        return {k: to_json_safe(v) for k, v in obj.items()}
+
+    if isinstance(obj, (list, tuple, set)):
+        return [to_json_safe(v) for v in obj]
+
+    # Fallback (yt-dlp objects, enums, etc.)
+    return str(obj)