abstract-utilities 0.2.2.480__py3-none-any.whl → 0.2.2.688__py3-none-any.whl

abstract_utilities/import_utils/src/package_utilss/safe_import.py

@@ -0,0 +1,27 @@
+import inspect, importlib
+from .context_utils import ensure_caller_package
+
+def safe_import(
+    name: str,
+    *,
+    member: str | None = None,
+    package: str | None = None,
+    file: str | None = None,
+    caller_globals: dict | None = None,
+):
+    """
+    Safe dynamic import that resolves relative imports when run as a script.
+    """
+    if file is None:
+        frame = inspect.currentframe()
+        assert frame is not None
+        outer = frame.f_back
+        caller_file = (outer.f_globals.get("__file__") if outer else None) or __file__
+    else:
+        caller_file = file
+
+    if name.startswith(".") and not package:
+        package = ensure_caller_package(caller_file, caller_globals=caller_globals)
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod

abstract_utilities/import_utils/src/pkg_utils.py

@@ -0,0 +1,194 @@
+# 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":{}}
+    if "context" not in import_pkg_js:
+        import_pkg_js["context"]={}
+    for key in ["nulines","file_path","all_data"]:
+        if key not in import_pkg_js["context"]:
+            import_pkg_js["context"][key]=[]
+    if file_path and file_path != import_pkg_js["context"]["file_path"]:
+        found=False
+        nu_data = {"file_path":import_pkg_js["context"]["file_path"],"nulines":import_pkg_js["context"]["nulines"]}
+        for i,data in enumerate(import_pkg_js["context"]["all_data"]):
+            if data.get('file_path') == import_pkg_js["context"]["file_path"]:
+                import_pkg_js["context"]["all_data"][i] = nu_data
+                found = True
+                break
+        if found == False:
+            import_pkg_js["context"]["all_data"].append(nu_data)
+        import_pkg_js["context"]["nulines"]=[]
+        import_pkg_js["context"]["file_path"]=file_path
+    return import_pkg_js
+def ensure_package_context(file: str):
+    """
+    Ensure that running this file directly still gives it the correct package.
+    Sets sys.path and __package__ based on the __init__.py chain.
+    """
+    file = file or os.getcwd()
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_pkg_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py files up the tree.")
+
+    sysroot = top_pkg_dir.parent  # dir ABOVE the top package (e.g., .../src)
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+
+    # Compute this module's package (exclude the filename)
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])  # e.g. abstract_ide.consoles.launcherWindowTab
+
+    # When run as a script, __package__ is empty -> set it
+    if (__name__ == "__main__") and (not globals().get("__package__")):
+        globals()["__package__"] = pkg_name
+# --- tiny utils ---
+def find_top_package_dir(p: Path) -> Path | None:
+    p = p.resolve()
+    if p.is_file():
+        p = p.parent
+    top = None
+    while (p / "__init__.py").exists():
+        top = p
+        if p.parent == p:
+            break
+        p = p.parent
+    return top
+
+def derive_package_for_file(file: str) -> tuple[str, Path]:
+    """Return (pkg_name, sysroot) for the module file."""
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_pkg_dir(here)
+    if not top_pkg_dir:
+        raise RuntimeError(f"No package context above {here}. Add __init__.py up the tree.")
+    sysroot = top_pkg_dir.parent
+    if str(sysroot) not in sys.path:
+        sys.path.insert(0, str(sysroot))
+    parts = here.with_suffix("").relative_to(sysroot).parts
+    pkg_name = ".".join(parts[:-1])  # package of the module (drop the filename)
+    return pkg_name, sysroot
+
+def ensure_caller_package(caller_file: str, caller_globals: dict | None = None) -> str:
+    """
+    Ensure sysroot is on sys.path and return the caller's dotted package.
+    Optionally set caller_globals['__package__'] when running as a script.
+    """
+    pkg, _ = derive_package_for_file(caller_file)
+    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,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,"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
+        import_pkg_js["context"]["nulines"].append(import_line)
+    else:
+        import_pkg_js[import_pkg]["imports"]+=imports
+    return import_pkg_js
+def update_import_pkg_js(line,import_pkg_js=None,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,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
+        else:
+            import_pkg_js["context"]["nulines"].append(line)
+    return import_pkg_js
+# --- public API ---
+def safe_import(
+    name: str,
+    *,
+    member: str | None = None,
+    package: str | None = None,
+    file: str | None = None,
+    caller_globals: dict | None = None,
+):
+    """
+    Import `name` (relative or absolute).
+    - If `name` is relative and `package` is missing, derive it from `file` (or caller).
+    - If running the caller as a script, we can set its __package__ when caller_globals is provided.
+    """
+    if file is None:
+        # best-effort: use the immediate caller's file
+        frame = inspect.currentframe()
+        assert frame is not None
+        outer = frame.f_back
+        caller_file = (outer.f_globals.get("__file__") if outer else None) or __file__
+    else:
+        caller_file = file
+
+    if name.startswith(".") and not package:
+        package = ensure_caller_package(caller_file, caller_globals=caller_globals)
+
+    mod = importlib.import_module(name, package=package)
+    return getattr(mod, member) if member else mod

abstract_utilities/import_utils/src/sysroot_utils.py

@@ -0,0 +1,112 @@
+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:
+        sys.path.insert(0, s)
+def get_sysroot(filepath,i):
+    for j in range(i):
+        filepath = os.path.dirname(filepath)
+    return filepath
+
+def get_dot_range_sysroot(filepath):
+    sysroot = filepath
+    while True:
+        dot_range = get_dot_range(is_import_or_init(sysroot))
+        if dot_range == 0:
+            break
+        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
+    dirname = file_data.get('dirname')
+    if os.path.isdir(sysroot):
+        dirname = sysroot
+    ext = file_data.get('ext')
+    filename = file_data.get('filename')
+    
+    candidates = []
+    if likely:
+        candidates += [os.path.join(dirname,f"{likely}.py"),os.path.join(dirname,likely)]
+    candidates += [os.path.join(dirname,f"{filename}.py"),os.path.join(dirname,filename)]
+    files: List[Path] = []
+    for item in candidates:
+        
+        if os.path.exists(item):
+            if os.path.isdir(item):
+                
+                nuroot=None
+                init_name = '__init__.py'
+                rootList = os.listdir(item)
+                for basename in rootList:
+                    if get_file_parts(basename,'filename') == filename:
+                        nuroot = os.path.join(item,basename)
+                        break
+                if init_name in rootList:
+                    nuroot = os.path.join(item,init_name)
+                    break
+                    
+            else:
+               nuroot=sysroot
+               break
+
+    return nuroot

abstract_utilities/imports.py

@@ -0,0 +1,21 @@
+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, 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,lru_cache
+from types import MethodType,ModuleType
+from werkzeug.utils import secure_filename
+from werkzeug.datastructures import FileStorage
+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/json_utils/__init__.py

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

abstract_utilities/json_utils/imports/__init__.py

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

abstract_utilities/json_utils/imports/imports.py

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

abstract_utilities/json_utils/imports/module_imports.py

@@ -0,0 +1,5 @@
+from ...read_write_utils import check_read_write_params, read_from_file, write_to_file
+from ...compare_utils import get_closest_match_from_list
+from ...directory_utils import makedirs
+from ...list_utils import make_list
+from ...class_utils import alias