abstract-utilities 0.2.2.540__py3-none-any.whl → 0.2.2.667__py3-none-any.whl

abstract_utilities/import_utils/src/import_functions.py

@@ -1,7 +1,8 @@
 # --- auto-package bootstrap (run-safe) ---------------------------------
 from ..imports import *
 from .dot_utils import get_dot_range
-from .sysroot_utils import get_sysroot
+from .sysroot_utils import get_sysroot,get_import_with_sysroot,get_py_files,get_all_py_sysroots
+from .extract_utils import get_all_py_file_paths
 def clean_imports(imports,commaClean=True):
     chars=["*"]
     if not commaClean:
@@ -9,6 +10,13 @@ def clean_imports(imports,commaClean=True):
     if isinstance(imports,str):
         imports = imports.split(',')
     return [eatElse(imp,chars=chars) for imp in imports if imp]
+def get_dot_range(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
 def get_cleaned_import_list(line,commaClean=True):
     cleaned_import_list=[]
     if IMPORT_TAG in line:
@@ -17,7 +25,7 @@ def get_cleaned_import_list(line,commaClean=True):
     return cleaned_import_list
 def get_module_from_import(imp,path=None):
     path = path or os.getcwd()
-    i = get_dot_range(None,[imp])
+    i = get_dot_range(imp)
     imp = eatAll(imp,'.')
     sysroot = get_sysroot(path,i)
     return os.path.join(sysroot, imp)
@@ -42,5 +50,61 @@ def safe_import(name: str, *, package: str | None = None, member: str | None = N
     mod = importlib.import_module(name, package=package)
     return getattr(mod, member) if member else mod
 
+def dynamic_import(module_path: str, namespace: dict, all_imports = None):
+    """
+    Emulates:
+        from module_path import *
+    but includes private (_xxx) names too.
+    """
+    all_imports = if_none_change(all_imports,True)
+    if module_path:
+        module = importlib.import_module(module_path)
+        # Import literally everything except dunders, unless you want them too.
+        names = [n for n in dir(module) if n and ((not all_imports and not n.startswith("_")) or all_imports)]
+        for name in names:
+            namespace[name] = getattr(module, name)
+        return module
+def get_monorepo_root(directory=None,files=None):
+    directory = directory or get_initial_caller_dir()
+    
+    py_files = get_all_py_file_paths(directory,add=True)
+    sysroots = get_all_py_sysroots(directory=directory,files=py_files)
+    monorepo_root = get_common_root(sysroots)
+    return monorepo_root
+def switch_to_monorepo_root(directory=None,files=None):
+    monorepo_root = get_monorepo_root(directory=directory,files=files)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+    return str(monorepo_root)
+def get_all_imports(directory=None,sysroot=None,globs=None):
+    globs = globs or get_true_globals() or globals()
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory,allowed_exts='.py').get('files')
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory,files=files)
+    for glo in files:
+        imp = get_import_with_sysroot(glo, sysroot)
+        dynamic_import(imp, globs)
+def get_all_imports_for_class(self, directory=None, sysroot=None, include_private=True):
+    """
+    Load all modules under `directory` and assign their exports as attributes
+    on the class instance (self).
+    """
+    directory = directory or get_initial_caller_dir()
+    files = collect_globs(directory=directory, allowed_exts='.py').get("files")
+
+    # Compute sysroot (monorepo root)
+    sysroot = sysroot or switch_to_monorepo_root(directory=directory, files=files)
+
+    for glo in files:
+        mod_path = get_import_with_sysroot(glo, sysroot)
+        module = importlib.import_module(mod_path)
+
+        for name in dir(module):
+            if name.startswith("__"):
+                continue
+            if not include_private and name.startswith("_"):
+                continue
 
+            setattr(self, name, getattr(module, name))
 
+    return self

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/import_utils/src/layze_import_utils/__init__.py

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

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):
+    """
+    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)
+
+def get_lazy_attr(module_name: str, *attrs):
+    obj = lazy_import(module_name)
+
+    for attr in attrs:
+        try:
+            obj = getattr(obj, attr)
+        except Exception:
+            return nullProxy(module_name, attrs)
+
+    return obj
+def lazy_import(name: str, *attrs):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+    if attrs:
+        obj = get_lazy_attr(name, *attrs)
+    else:
+        obj = lazy_import_single(name)
+    return obj

abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py

@@ -0,0 +1,32 @@
+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=()):
+        self._name = name
+        self._path = path
+
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        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/import_utils/src/nullProxy.py

@@ -0,0 +1,30 @@
+from ...imports import *
+lazy_import_logger = logging.getLogger("abstract.lazy_import")
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=()):
+        self._name = name
+        self._path = path
+
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        lazy_import_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/import_utils/src/pkg_utils.py

@@ -1,6 +1,36 @@
 # safe_import_utils.py
 from ..imports import *
 from .import_functions import *
+from ...safe_utils import *
+from .sysroot_utils import get_import_with_sysroot
+def try_is_file(file_path):
+    try:
+        return os.path.isfile(file_path)
+    except:
+        return False
+def try_is_dir(file_path):
+    try:
+        return os.path.isdir(file_path)
+    except:
+        return False
+def try_join(*args):
+    try:
+        return safe_join(*args)
+    except:
+        return False
+def get_pkg_or_init(pkg_path):
+    if pkg_path:
+        if try_is_file(pkg_path):
+            return pkg_path
+        pkg_py_path = f"{pkg_path}.py"
+        if try_is_file(pkg_py_path):
+            return pkg_py_path
+        pkg_init_path = try_join(pkg_path,'__init__.py')
+        if try_is_dir(pkg_path):
+            if os.path.isfile(pkg_init_path):
+                return pkg_init_path
+
+
 
 def ensure_import_pkg_js(import_pkg_js,file_path=None):
     import_pkg_js = import_pkg_js or {"context":{}}
@@ -79,18 +109,42 @@ def ensure_caller_package(caller_file: str, caller_globals: dict | None = None)
     if caller_globals and caller_globals.get("__name__") == "__main__" and not caller_globals.get("__package__"):
         caller_globals["__package__"] = pkg
     return pkg
+def get_init_dots(import_pkg):
+    count = 0
+    for char in import_pkg:
+        if char != '.':
+            break
+        count+=1
+    return count
+def make_relative_pkg(import_pkg,file_path):
+    full_pkg = eatAll(import_pkg,'.')
+    if file_path:
+        dirname = file_path
+        dot_count = get_init_dots(import_pkg)
+        for i in range(dot_count):
+            dirname = os.path.dirname(dirname)
+            dirbase = os.path.basename(dirname)
+            full_pkg=f"{dirbase}.{full_pkg}"
+    return full_pkg
+def is_local_import(import_pkg,file_path=None):
+    relative_pkg = get_module_from_import(import_pkg,file_path)
+    if get_pkg_or_init(relative_pkg):
+        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):
+def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None,file_path=None):
     import_pkg_js = ensure_import_pkg_js(import_pkg_js)
     imports = clean_imports(imports)
+    pkg_path = get_module_from_import(import_pkg,file_path)
+    local_import = get_pkg_or_init(pkg_path)
     if import_pkg not in import_pkg_js:
         i = len(import_pkg_js["context"]["nulines"])
-        import_pkg_js[import_pkg]={"imports":imports,"line":i}
+        import_pkg_js[import_pkg]={"imports":imports,"line":i,"file_path":file_path,"local_import":local_import,"is_local":is_local_import(import_pkg,file_path=file_path)}
         import_line = f"from {import_pkg} import "
         if import_pkg == "import":
             import_line = IMPORT_TAG
@@ -98,12 +152,12 @@ def add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=None):
     else:
         import_pkg_js[import_pkg]["imports"]+=imports
     return import_pkg_js
-def update_import_pkg_js(line,import_pkg_js=None):
+def update_import_pkg_js(line,import_pkg_js=None,file_path=None):
     import_pkg_js = ensure_import_pkg_js(import_pkg_js)
     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)
+        import_pkg_js = add_imports_to_import_pkg_js(import_pkg,imports,import_pkg_js=import_pkg_js,file_path=file_path)
     else:
         if len(import_pkg_js["context"]["nulines"]) >0 and line == '' and is_line_import(import_pkg_js["context"]["nulines"][-1]):
             pass

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -1,6 +1,9 @@
 from ..imports import *
 from .dot_utils import *
-
+from .extract_utils import get_all_py_file_paths
+def get_py_files(directory=None):
+    directory = directory or get_initial_caller_dir()
+    return get_all_py_file_paths(directory,add=True)
 def ensure_on_path(p: Path):
     s = str(p)
     if s not in sys.path:
@@ -19,7 +22,59 @@ def get_dot_range_sysroot(filepath):
         sysroot = get_sysroot(sysroot,dot_range)
     
     return sysroot
+def get_import_with_sysroot(file_path, sysroot):
+    """
+    Rewrite imports like:
+        from imports.constants import *
+    into:
+        from <relative_path>.imports.constants import *
+    Where <relative_path> is computed relative to sysroot.
+    """
+
+
+    # Absolute paths
+    file_dir = os.path.dirname(os.path.abspath(file_path))
+    sysroot = os.path.abspath(sysroot)
+
+    # Compute relative path
+    relpath = os.path.relpath(file_dir, sysroot)
+
+    bare_rel = eatAll(relpath,'.')
+    
+    # Turn filesystem path into dotted python path
+    if relpath == ".":
+        dotted = ""
+    else:
+        dotted = ".".join(part for part in relpath.split(os.sep) if part)
+    if bare_rel.startswith('/') and dotted.startswith('.'):
+        dotted = dotted[1:]
+
+
+    # Build final rewritten import
+    return dotted
+def get_all_sysroots(files):
+    sysroots=[]
+    for glo in files:
+        imp = compute_dotted_and_sysroot(glo)
+        sysroots.append(imp[-1])
+    return sysroots
+def get_shortest_sysroot(files):
+    sysroots = get_all_sysroots(files)
+    return get_shortest_path(*sysroots)
+def get_all_py_sysroots(directory=None,files=None):
+    py_files = files or get_py_files(directory=directory)
+    return [compute_dotted_and_sysroot(glo)[1] for glo in py_files]
 
+def get__imports(directory=None, sysroot=None):
+    directory = directory or get_caller_dir(1)
+    globs = collect_globs(directory, allowed_exts='.py')
+    globs = [glo for glo in globs.get('files') if glo]
+    sysroots = [compute_dotted_and_sysroot(glo)[1] for glo in globs]
+    # ⭐ Get unified monorepo root
+    monorepo_root = get_common_root(sysroots)
+    if str(monorepo_root) not in sys.path:
+        sys.path.insert(0, str(monorepo_root))
+    get_all_imports(directory=directory, sysroot=monorepo_root)
 def is_import_or_init(sysroot,likely=None):
     file_data = get_file_parts(sysroot)
     nuroot = sysroot

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,4 @@ 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

abstract_utilities/json_utils/json_utils.py

@@ -26,6 +26,13 @@ from .imports import *
 
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+def get_keys(mapping,typ=None):
+    typ = typ or set
+    if isinstance(mapping,dict):
+        mapping = mapping.keys()
+    return typ(mapping)
+def make_key_map(dict_obj):
+    return {k:get_keys(v) for k,v in dict_obj.items()}
 def convert_and_normalize_values(values):
     for value in values:
         if isinstance(value, str):
@@ -116,10 +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 = args[0]
-    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:

abstract_utilities/log_utils/log_file.py

@@ -1,41 +1,90 @@
 from .imports import *
-def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+import os, sys, inspect, logging
+from logging.handlers import RotatingFileHandler
+
+PACKAGE_NAME = "abstract_utilities"   # ← update if needed
+
+
+def _resolve_log_root():
+    """
+    Returns a safe writable logging directory depending on environment:
+    - If running in a virtualenv → <venv>/.logs/<package>
+    - Else if user writable → ~/.cache/<package>/logs
+    - Else → /var/log/<package>
+    """
+    # 1) Virtualenv or Conda environment
+    venv = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
+    if venv:
+        root = os.path.join(venv, ".logs", PACKAGE_NAME)
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    # 2) User home cache folder
+    home = os.path.expanduser("~")
+    user_cache_root = os.path.join(home, ".cache", PACKAGE_NAME, "logs")
+    try:
+        os.makedirs(user_cache_root, exist_ok=True)
+        return user_cache_root
+    except PermissionError:
+        pass
+
+    # 3) Last resort: system log dir (requires correct service user permissions)
+    system_root = f"/var/log/{PACKAGE_NAME}"
+    try:
+        os.makedirs(system_root, exist_ok=True)
+        return system_root
+    except PermissionError:
+        # Fail-safe fallback to /tmp
+        fallback = f"/tmp/{PACKAGE_NAME}/logs"
+        os.makedirs(fallback, exist_ok=True)
+        return fallback
+
+
+LOG_ROOT = _resolve_log_root()
+
+
+def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
     """
-    If bpName is None, use the “caller module’s basename” as the logger name.
-    Otherwise, use the explicitly provided bpName.
+    A logger that always writes to a safe OS-appropriate path.
+    Works even when installed through pip.
     """
     if bpName is None:
-        # Find the first frame outside logging_utils.py
         frame_idx = _find_caller_frame_index()
         frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename  # e.g. "/home/joe/project/app/routes.py"
+        caller_path = frame_info.filename
         bpName = os.path.splitext(os.path.basename(caller_path))[0]
         del frame_info
 
-    log_dir = mkdirs("logs")
-    log_path = os.path.join(log_dir, f"{bpName}.log")
-
-    logger = logging.getLogger(bpName)
+    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
     logger.setLevel(logging.INFO)
 
     if not logger.handlers:
-        try:
-            handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
-            handler.setLevel(logging.INFO)
-
-            fmt = "%(asctime)s - %(levelname)s - %(pathname)s - %(message)s"
-            formatter = logging.Formatter(fmt)
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-
-            console = logging.StreamHandler()
-            console.setLevel(logging.INFO)
-            console.setFormatter(formatter)
-            logger.addHandler(console)
-        except Exception as e:
-            print(f"{e}")
+        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
+        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+
+        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
+        formatter = logging.Formatter(fmt)
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        # Console handler (optional; can disable for gunicorn)
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(formatter)
+        logger.addHandler(console)
+
     return logger
 
+
+def _find_caller_frame_index():
+    """Find the correct caller module outside this logger."""
+    for idx, frame_info in enumerate(inspect.stack()):
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        if module and module.__name__ not in (__name__, "logging"):
+            return idx
+    return 1
 def _find_caller_frame_index():
     """
     Scan up the call stack until we find a frame whose module is NOT logging_utils.

abstract_utilities/parse_utils/parse_utils.py

@@ -64,6 +64,29 @@ def detect_language_from_text(text: str):
 
     likely = [lang for lang, score in scores.items() if score == max_score]
     return likely[0] if len(likely) == 1 else 'uncertain'
+def get_tripple_string(string):
+    nustring = ''
+    for i in range(3):
+        nustring +=string
+    return nustring
+def get_within_quotes(text,quotes=None):
+    quotes_strings = quotes or ["'",'"']
+    in_quotes = []
+    for quotes_string in quotes_strings:
+        if not isinstance(quotes_string,list):
+            tripple= get_tripple_string(quotes_string)
+            texts = [text]
+            if tripple in text:
+                texts= text.split(tripple)
+            for text_part in texts:
+                quote_count = len(text_part) - len(text_part.replace(quotes_string,''))
+                quote_spl = text_part.split(quotes_string)
+                in_quotes+=[quote_spl[i] for i in range(quote_count) if ((i == 1 or i%2 != float(0)) and len(quote_spl) > i)]
+        else:
+            texts= text.split(quotes_string[0])
+            for text in texts:
+                in_quotes.append(text.split(quotes_string[1])[0])
+    return in_quotes
 
 def search_code(code_languages, parts):
     return [data for datas in parts for data in make_list(datas)

abstract_utilities/path_utils/imports/module_imports.py

@@ -2,7 +2,7 @@ from ...string_utils import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type,MIME_TYPES
 from ...safe_utils import safe_join,get_slash
-from ...class_utils import get_caller_path,get_caller_dir
+from ...class_utils import get_caller_path,get_caller_dir,get_initial_caller,get_initial_caller_dir
 from ...file_utils import is_file,is_dir,is_exists
 from ...ssh_utils import is_file,is_dir,is_exists
 from ...directory_utils import *