abstract-utilities 0.2.2.495__py3-none-any.whl → 0.2.2.504__py3-none-any.whl

abstract_utilities/file_utils/imports/imports.py

@@ -6,23 +6,17 @@
 # ============================================================
 
 
-import os,re
-import sys, importlib,os
-import sys, importlib, os, inspect
+from ...imports import *
 from pathlib import Path
-import os,sys
+
 
 
 
 from typing import *
-import re
 
 from typing import *
 from types import MethodType
-import os,re, sys, importlib, inspect, os, importlib.util, hashlib
-import os,tempfile,shutil,logging,ezodf,fnmatch,pytesseract,pdfplumber
-import pandas as pd
-import geopandas as gpd
+
 from datetime import datetime
 
 from typing import *
@@ -30,8 +24,6 @@ from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
 from pdf2image import convert_from_path   # only used for OCR fallback
 # ---- Core standard library modules -------------------------
-import os, sys, re, shlex, glob, platform, textwrap, subprocess, inspect, json, time
-import tempfile, shutil, logging, pathlib, fnmatch, importlib, importlib.util, types
 
 from datetime import datetime
 from types import ModuleType
@@ -44,18 +36,11 @@ from typing import (
 )
 
 # ---- Common 3rd-party dependencies --------------------------
-import pandas as pd
-import geopandas as gpd
-import pytesseract
-import pdfplumber
-import PyPDF2
-import ezodf
 from pdf2image import convert_from_path
 from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
 
 # ---- Helpers ------------------------------------------------
-import textwrap as tw
 from pprint import pprint
 
 # ============================================================

abstract_utilities/file_utils/imports/module_imports.py

@@ -1,12 +1,9 @@
-from .imports import *
-from ...string_clean import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
 from ...ssh_utils import *
 from ...env_utils import *
-from ...read_write_utils import *
-from ...abstract_classes import SingletonMeta
+from ...read_write_utils import read_from_file,write_to_file
 from ...log_utils import get_logFile
-from ...class_utils import get_caller, get_caller_path, get_caller_dir
+from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
 from ...ssh_utils import run_cmd
-from ...string_utils import get_from_kwargs
+from ...string_utils import get_from_kwargs,eatAll

abstract_utilities/file_utils/src/type_checks.py

@@ -1,5 +1,4 @@
 from ..imports import *
-
 def get_user_pass_host_key(**kwargs):
     args = ['password','user_at_host','host','key','user']
     kwargs['del_kwarg']=kwargs.get('del_kwarg',False)

abstract_utilities/hash_utils/__init__.py

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

abstract_utilities/hash_utils/hash_utils.py

@@ -0,0 +1,5 @@
+from .imports import *
+def generate_data_hash(insertName,value):
+    # Combine values to create a unique reference
+    data_string = f"{insertName}_{value}"
+    return hashlib.md5(data_string.encode()).hexdigest()

abstract_utilities/hash_utils/imports/__init__.py

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

abstract_utilities/hash_utils/imports/imports.py

@@ -0,0 +1 @@
+from ...imports import hashlib

abstract_utilities/history_utils/__init__.py

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

abstract_utilities/history_utils/history_utils.py

@@ -0,0 +1,37 @@
+class HistoryManager:
+    def __init__(self):
+        self.history_names = {}
+
+    def add_history_name(self, name, initial_data=''):
+        self.history_names[name] = {"history": [initial_data], "history_redo": []}
+        return name
+
+    def transfer_state(self, primary_data, secondary_data):
+        """
+        Transfer the latest state from primary_data to secondary_data
+        Returns the modified primary and secondary data lists
+        """
+        self.last_data = None
+        # If there's data in primary, transfer the latest to secondary
+        if primary_data:
+            self.last_data = primary_data.pop()
+            secondary_data.append(self.last_data)
+
+        return primary_data, secondary_data
+
+    def add_to_history(self, name, data):
+        # Clear the redo history when a new state is added
+        self.history_names[name]['history_redo'] = []
+        self.history_names[name]['history'].append(data)
+
+    def redo(self, name):
+        # Redo by transferring state from redo history to actual history
+        self.history_names[name]["history_redo"], self.history_names[name]["history"] = self.transfer_state(
+            self.history_names[name]["history_redo"], self.history_names[name]["history"])
+        return self.last_data
+
+    def undo(self, name):
+        # Undo by transferring state from actual history to redo history
+        self.history_names[name]["history"], self.history_names[name]["history_redo"] = self.transfer_state(
+            self.history_names[name]["history"], self.history_names[name]["history_redo"])
+        return self.last_data

abstract_utilities/history_utils/imports/__init__.py

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

abstract_utilities/history_utils/imports/imports.py

@@ -0,0 +1 @@
+

abstract_utilities/import_utils/imports/imports.py

@@ -1,4 +1,4 @@
 from pathlib import Path
 from typing import *
 from types import MethodType
-import os, sys, importlib, os, inspect, re, importlib.util, hashlib
+from ...imports import os, sys, importlib, os, inspect, re, hashlib

abstract_utilities/import_utils/imports/module_imports.py

@@ -1,5 +1,5 @@
 from ...read_write_utils import read_from_file,write_to_file,get_text_or_read
-from ...string_clean import eatAll,eatInner,eatElse,clean_line
+from ...string_utils import eatAll,eatInner,eatElse,clean_line
 from ...class_utils import get_caller_path
 from ...list_utils import make_list
 from ...path_utils import get_file_parts

abstract_utilities/import_utils/src/__init__.py

@@ -3,5 +3,5 @@ from .dot_utils import *
 from .extract_utils import *
 from .import_utils import *
 from .import_functions import *
-from .package_utils import *
+from .pkg_utils import *
 from .sysroot_utils import *

abstract_utilities/import_utils/src/clean_imports.py

@@ -1,6 +1,5 @@
 from ..imports import *
-
-from .package_utils import *
+from .pkg_utils import *
 
 def get_text_or_read(text=None,file_path=None):
     text = text or ''
@@ -54,7 +53,8 @@ def get_all_imports(text=None,file_path=None,import_pkg_js=None):
             if is_from_line_group(line) and is_from_group == False:
                 is_from_group=get_import_pkg(line)
     return import_pkg_js
-def clean_all_imports(text=None,file_path=None,import_pkg_js=None):
+
+def clean_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
     if text and os.path.isfile(text):
         file_path = text
         text = read_from_file(text)    
@@ -65,7 +65,7 @@ def clean_all_imports(text=None,file_path=None,import_pkg_js=None):
     for pkg,values in import_pkg_js.items():
         comments = []
         if pkg not in ["context"]: 
-            line = values.get('line')
+            
             imports = values.get('imports')
             for i,imp in enumerate(imports):
                 if '#' in imp:
@@ -81,9 +81,35 @@ def clean_all_imports(text=None,file_path=None,import_pkg_js=None):
                     comments=','.join(comments)
                     imports+=f" #{comments}"
             import_pkg_js[pkg]["imports"]=imports
-            nu_lines[line] += imports
+            if fill_nulines:
+                line = values.get('line')
+                if len(nu_lines) >= line:
+                    nu_lines[line] += imports
+    return import_pkg_js
+def clean_all_imports(text=None,file_path=None,import_pkg_js=None,fill_nulines=False):
+    clean_imports(text=text,file_path=file_path,import_pkg_js=import_pkg_js,fill_nulines=import_pkg_js)
     import_pkg_js["context"]["nulines"]=nu_lines
     return import_pkg_js
+def get_clean_import_string(import_pkg_js,fill_nulines=False,get_locals=False):
+    import_pkg_js = clean_imports(import_pkg_js=import_pkg_js,fill_nulines=fill_nulines)
+    import_ls = []
+    for key,values in import_pkg_js.items():
+        if key not in ['context','nulines']:
+            imports = None
+            input(values)
+            imp_values= values.get('imports')
+            if key == 'import':
+                imports = f'import {imp_values}'
+            elif get_locals or not key.startswith('.'):
+                imports = f'from {key} import {imp_values}'
+            if imports:
+                import_ls.append(imports)
+    return '\n'.join(import_ls)
+def get_clean_imports_from_files(files):
+    import_pkg_js={}
+    for file in files:
+        import_pkg_js = get_all_imports(file,import_pkg_js=import_pkg_js)
+    return get_clean_import_string(import_pkg_js)
 def get_dot_fro_line(line,dirname):
     from_line = line.split(FROM_TAG)[-1]
     dot_fro = ""

abstract_utilities/import_utils/src/dot_utils.py

@@ -1,4 +1,8 @@
 from ..imports import *
+def get_Path(path):
+    if isinstance(path,str):
+        path = Path(str(path))
+    return path
 def get_dot_range(filepath=None,list_obj=None):
     imports = make_list(list_obj) or extract_imports(filepath)
     highest=0
@@ -14,6 +18,8 @@ def dotted_from(file: Path, sysroot: Path) -> str:
     e.g.  /repo/abstract_ide/consoles/launcherWindowTab/functions/core_utils.py
         sysroot=/repo  -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
     """
+    file = get_Path(file)
+    sysroot = get_Path(sysroot)
     file = file.resolve()
     stem = file.with_suffix("")  # drop .py
     return ".".join(stem.relative_to(sysroot).parts)
@@ -23,6 +29,8 @@ def to_dotted_name(file_path: Path, top_package: str) -> str:
     -> abstract_ide.consoles.launcherWindowTab.functions.core_utils
     """
     # find the index of the top_package in the path parts
+    file_path = get_Path(file_path)
+    top_package = get_Path(top_package)
     parts = file_path.resolve().parts
     i = None
     if is_number(top_package):
@@ -43,6 +51,7 @@ def compute_dotted_and_sysroot(file_path: Path) -> Tuple[str, Path]:
     sysroot will be the directory *above* the top package.
     If not a package, we fall back to a repo-ish root guess (2 parents up).
     """
+    file_path = get_Path(file_path)
     file_path = file_path.resolve()
     stem = file_path.with_suffix("")  # drop .py
 

abstract_utilities/import_utils/src/package_utilss/__init__.py

@@ -0,0 +1,139 @@
+import ast
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+import ast, sys
+from pathlib import Path
+from importlib.util import find_spec
+from typing import Dict, Set
+from src.abstract_utilities.import_utils import *
+STDLIB_NAMES = set(sys.builtin_module_names)
+def parse_imports(file_path: Path):
+    """Return list of (module, level) for every import/from-import."""
+    try:
+        src = file_path.read_text(errors="ignore")
+        tree = ast.parse(src, filename=str(file_path))
+    except Exception:
+        return []
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append((alias.name, 0))
+        elif isinstance(node, ast.ImportFrom):
+            imports.append((node.module, node.level))
+    return imports
+
+
+def resolve_relative_import(base_file: Path, module: str | None, level: int) -> Path | None:
+    """Follow a relative import path to its real file if it exists."""
+    base = base_file.parent
+    for _ in range(level - 1):
+        base = base.parent
+    if not module:
+        target = base
+    else:
+        target = base / module.replace(".", "/")
+    if (target / "__init__.py").exists():
+        return target / "__init__.py"
+    if target.with_suffix(".py").exists():
+        return target.with_suffix(".py")
+    return None
+
+
+
+
+def classify_import(mod_name: str, root_pkg: str) -> str:
+    """Return 'local', 'internal', or 'external'."""
+    if not mod_name:
+        return "unknown"
+    if mod_name.startswith("."):
+        return "local"
+    if mod_name.split(".")[0] == root_pkg:
+        return "internal"
+    if mod_name.split(".")[0] in STDLIB_NAMES:
+        return "stdlib"
+    return "external"
+
+
+def follow_imports(entry: Path, root_pkg: str,
+                   visited: Dict[Path, Dict[str, Set[str]]] | None = None):
+    """
+    Recursively follow only internal/local imports.
+    Returns {file_path: {'internal': set(), 'external': set()}}
+    """
+    visited = visited or {}
+    if entry in visited:
+        return visited
+
+    visited[entry] = {"internal": set(), "external": set()}
+
+    for mod, level in parse_imports(entry):
+        if level > 0:
+            target = resolve_relative_import(entry, mod, level)
+            if target:
+                visited[entry]["internal"].add(str(target))
+                follow_imports(target, root_pkg, visited)
+            continue
+
+        category = classify_import(mod, root_pkg)
+        if category == "internal":
+            spec = find_spec(mod)
+            if spec and spec.origin and spec.origin.endswith(".py"):
+                visited[entry]["internal"].add(spec.origin)
+                follow_imports(Path(spec.origin), root_pkg, visited)
+        elif category == "external":
+            visited[entry]["external"].add(mod)
+        elif category == "stdlib":
+            # stdlib gets treated like external but labeled
+            visited[entry]["external"].add(mod + "  # stdlib")
+
+    return visited
+
+
+
+def build_master_imports(entry: Path, root_pkg: str, output: Path):
+    trace = follow_imports(entry, root_pkg)
+    lines = ["# Auto-generated master imports for abstract_utilities\n"]
+    all_modules = set()
+    external_modules = set()
+    imports = get_all_imports(path)
+    for _, data in trace.items():
+        for dep in data["internal"]:
+            path = Path(dep)
+            if path.suffix != ".py":
+                continue
+            try:
+                rel_parts = path.with_suffix("").parts
+                idx = rel_parts.index(root_pkg)
+                dotted = ".".join(rel_parts[idx:])
+                all_modules.add(dotted)
+            except ValueError:
+                continue
+        external_modules.update(data["external"])
+
+    for mod in sorted(all_modules):
+        short = mod.split(".", 1)[-1]
+        lines.append(f"from .{short} import *")
+
+    if external_modules:
+        lines.append("\n# External / stdlib imports (not traced, for reference)")
+        for ext in sorted(external_modules):
+            lines.append(f"# {ext}")
+    
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text("\n".join(lines+str(imports)))
+    print(f"✅ wrote master imports hub → {output}")
+
+
+
+if __name__ == "__main__":
+    entry = Path(
+        "/home/flerb/Documents/pythonTools/modules/src/modules/abstract_utilities/src/"
+        "abstract_utilities/import_utils/src/import_functions.py"
+    )
+
+    
+    pkg = "abstract_utilities"
+    out = entry.parents[4] / "imports" / "__init__.py"
+    build_master_imports(entry, pkg, out)

abstract_utilities/import_utils/src/package_utilss/context_utils.py

@@ -0,0 +1,27 @@
+import sys, os
+from pathlib import Path
+from .path_utils import find_top_package_dir, derive_package_for_file
+
+def ensure_package_context(file: str):
+    """Ensure that running this file directly gives correct package context."""
+    file = file or os.getcwd()
+    here = Path(file).resolve()
+    top_pkg_dir = find_top_package_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
+    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])
+    if (__name__ == "__main__") and not globals().get("__package__"):
+        globals()["__package__"] = pkg_name
+
+def ensure_caller_package(caller_file: str, caller_globals: dict | None = None) -> str:
+    """Ensure sysroot is on sys.path and return caller's dotted package name."""
+    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

abstract_utilities/import_utils/src/package_utilss/import_collectors.py

@@ -0,0 +1,53 @@
+from ..imports import *
+from .import_functions import *
+
+def ensure_import_pkg_js(import_pkg_js=None, 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"]:
+        import_pkg_js["context"].setdefault(key, [] if key != "file_path" else None)
+
+    if file_path and file_path != import_pkg_js["context"].get("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 not found:
+            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 add_imports_to_import_pkg_js(import_pkg, imports, import_pkg_js=None):
+    import_pkg_js = ensure_import_pkg_js(import_pkg_js)
+    imports = clean_imports(imports)
+    if import_pkg not in import_pkg_js:
+        i = len(import_pkg_js["context"]["nulines"])
+        file_path = import_pkg_js["context"]["file_path"]
+        file_parts = get_file_parts(file_path)
+        dirname = file_parts["dirname"]
+        import_pkg_js[import_pkg] = {"imports": imports, "line": i}
+        import_pkg_js["context"]["nulines"].append(f"from {import_pkg} import ")
+    else:
+        import_pkg_js[import_pkg]["imports"] += imports
+    return import_pkg_js
+
+def update_import_pkg_js(line, import_pkg_js=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)
+    else:
+        if import_pkg_js["context"]["nulines"] 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

abstract_utilities/import_utils/src/package_utilss/path_utils.py

@@ -0,0 +1,28 @@
+import os, sys
+from pathlib import Path
+
+def find_top_package_dir(p: Path) -> Path | None:
+    """Walk upward until the topmost __init__.py-containing directory."""
+    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_package_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])
+    return pkg_name, sysroot

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