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

abstract_utilities/file_utils/imports/constants.py

@@ -0,0 +1,39 @@
+from .imports import *
+from .module_imports import *
+@dataclass
+class ScanConfig:
+    allowed_exts: Set[str]
+    unallowed_exts: Set[str]
+    exclude_types: Set[str]
+    exclude_dirs: List[str] = field(default_factory=list)
+    exclude_patterns: List[str] = field(default_factory=list)
+DEFAULT_ALLOWED_EXTS: Set[str] = {
+    ".py", ".pyw",                             # python
+    ".js", ".jsx", ".ts", ".tsx", ".mjs",      # JS/TS
+    ".html", ".htm", ".xml",                   # markup
+    ".css", ".scss", ".sass", ".less",         # styles
+    ".json", ".yaml", ".yml", ".toml", ".ini",  # configs
+    ".cfg", ".md", ".markdown", ".rst",        # docs
+    ".sh", ".bash", ".env",                    # scripts/env
+    ".txt"                                     # plain text
+}
+
+DEFAULT_EXCLUDE_TYPES: Set[str] = {
+    "image", "video", "audio", "presentation",
+    "spreadsheet", "archive", "executable"
+}
+
+# never want these—even if they sneak into ALLOWED
+_unallowed = set(get_media_exts(DEFAULT_EXCLUDE_TYPES)) | {'.bak', '.shp', '.cpg', '.dbf', '.shx','.geojson',".pyc",'.shx','.geojson','.prj','.sbn','.sbx'}
+DEFAULT_UNALLOWED_EXTS = {e for e in _unallowed if e not in DEFAULT_ALLOWED_EXTS}
+
+DEFAULT_EXCLUDE_DIRS: Set[str] = {
+    "node_modules", "old","__pycache__", "backups", "backup", "backs", "trash", "depriciated", "old", "__init__"
+}
+
+DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
+    "__init__*", "*.tmp", "*.log", "*.lock", "*.zip","*~"
+}
+REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
+AllowedPredicate = Optional[Callable[[str], bool]]
+DEFAULT_EXCLUDE_FILE_PATTERNS=DEFAULT_EXCLUDE_PATTERNS

abstract_utilities/file_utils/imports/file_functions.py

@@ -0,0 +1,10 @@
+from .imports import *
+def get_caller_path(i=None):
+    i = i or 1
+    frame = inspect.stack()[i]
+    return os.path.abspath(frame.filename)
+def get_caller_dir(i=None):
+    i = i or 1
+    frame = inspect.stack()[i]
+    abspath = os.path.abspath(frame.filename)
+    return os.path.dirname(abspath)

abstract_utilities/file_utils/imports/imports.py

@@ -0,0 +1,65 @@
+# ============================================================
+# abstract_utilities/imports/imports.py
+# Global imports hub — everything imported here will be
+# automatically available to any module that does:
+#     from ..imports import *
+# ============================================================
+
+
+import os
+import sys, importlib,os
+import sys, importlib, os, inspect
+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 *
+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
+
+# ---- Dataclasses and typing --------------------------------
+from dataclasses import dataclass, field
+from typing import (
+    Any, Optional, List, Dict, Set, Tuple,
+    Iterable, Callable, Literal, Union, TypeVar
+)
+
+# ---- 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
+
+# ============================================================
+# AUTO-EXPORT ALL NON-PRIVATE NAMES
+# ============================================================
+__all__ = [name for name in globals() if not name.startswith("_")]
+

abstract_utilities/file_utils/imports/module_imports.py

@@ -0,0 +1,13 @@
+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 ...log_utils import get_logFile
+from ...class_utils import get_caller, get_caller_path, get_caller_dir
+from ...ssh_utils import run_cmd
+
+__all__ = [name for name in globals() if not name.startswith("_")]

abstract_utilities/file_utils/req.py

@@ -0,0 +1,329 @@
+# attach_functions.py  — single helper you can import anywhere
+# attach_dynamic.py
+from __future__ import annotations
+from .file_utils import define_defaults,get_files_and_dirs
+from .imports import *
+ABSPATH = os.path.abspath(__file__)
+ABSROOT = os.path.dirname(ABSPATH)
+def caller_path():
+    frame = inspect.stack()[1]
+    return os.path.abspath(frame.filename)
+def _is_defined_here(mod: types.ModuleType, obj: object) -> bool:
+    try:
+        return inspect.getmodule(obj) is mod
+    except Exception:
+        return False
+
+def _collect_callables(mod: types.ModuleType) -> Dict[str, Callable]:
+    out: Dict[str, Callable] = {}
+    names = getattr(mod, "__all__", None)
+    if names:
+        # trust the author's export list
+        for n in names:
+            fn = getattr(mod, n, None)
+            if callable(fn):
+                out[n] = fn
+        return out
+    # otherwise, discover top-level callables defined in this module
+    for n in dir(mod):
+        if n.startswith("_"):
+            continue
+        obj = getattr(mod, n, None)
+        if callable(obj) and _is_defined_here(mod, obj):
+            out[n] = obj
+    return out
+
+def _import_module_by_name(name: str) -> Optional[types.ModuleType]:
+    try:
+        return importlib.import_module(name)
+    except Exception:
+        return None
+
+def _import_module_by_path(pkg_name: str, base_dir: str, filename: str) -> Optional[types.ModuleType]:
+    mod_name = f"{pkg_name}.functions"
+    path = os.path.join(base_dir, filename)
+    spec = importlib.util.spec_from_file_location(mod_name, path)
+    if not spec or not spec.loader:
+        return None
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[mod_name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+def _walk_functions_package(pkg_name: str, pkg_mod: types.ModuleType) -> List[types.ModuleType]:
+    """Import all immediate submodules in the functions/ package."""
+    mods: List[types.ModuleType] = [pkg_mod]
+    pkg_dir = os.path.dirname(pkg_mod.__file__ or "")
+    for info in pkgutil.iter_modules([pkg_dir]):
+        # only import direct children (no recursion here; easy to add if you need)
+        child_name = f"{pkg_mod.__name__}.{info.name}"
+        m = _import_module_by_name(child_name)
+        if m:
+            mods.append(m)
+    return mods
+
+def _discover_functions(base_pkg: str, *, hot_reload: bool) -> List[Tuple[str, Callable, str]]:
+    """
+    Returns a list of (export_name, callable, module_basename).
+    Works if you have base_pkg.functions.py or base_pkg/functions/ package.
+    """
+    # Prefer normal import of '<base_pkg>.functions'
+    fqn = f"{base_pkg}.functions"
+    mod = _import_module_by_name(fqn)
+
+    if mod is None:
+        # fallback: sibling functions.py, even without being a package
+        base = _import_module_by_name(base_pkg)
+        if not base or not getattr(base, "__file__", None):
+            return []
+        base_dir = os.path.dirname(base.__file__)
+        if os.path.isfile(os.path.join(base_dir, "functions.py")):
+            mod = _import_module_by_path(base_pkg, base_dir, "functions.py")
+        else:
+            return []
+
+    if hot_reload:
+        try:
+            mod = importlib.reload(mod)  # type: ignore[arg-type]
+        except Exception:
+            pass
+
+    results: List[Tuple[str, Callable, str]] = []
+    modules: List[types.ModuleType]
+
+    if hasattr(mod, "__path__"):  # it's a package: import children
+        modules = _walk_functions_package(base_pkg, mod)
+    else:
+        modules = [mod]
+
+    for m in modules:
+        exported = _collect_callables(m)
+        module_basename = m.__name__.split(".")[-1]
+        for name, fn in exported.items():
+            results.append((name, fn, module_basename))
+    return results
+
+def attach_functionss(
+    self,
+    *,
+    base_pkg: Optional[str] = None,
+    hot_reload: bool = False,
+    prefix_with_module: bool = False,
+    on_collision: str = "last_wins",  # or "error" or "skip"
+):
+    """
+    Attach discovered functions from '<base_pkg>.functions' onto `self`.
+
+    - base_pkg: package containing either functions.py or functions/ (defaults to the class' package)
+    - hot_reload: reload modules each call (handy during development)
+    - prefix_with_module: if True, attach as '<module>_<funcname>' to avoid name clashes
+    - on_collision: how to handle duplicate names: 'last_wins' | 'error' | 'skip'
+    """
+    if base_pkg is None:
+        # Infer from the class' module: e.g., "myapp.tabs.users.widgets" -> "myapp.tabs.users"
+        cls_mod = self.__class__.__module__
+        base_pkg = cls_mod.rsplit(".", 1)[0] if "." in cls_mod else cls_mod
+
+    discovered = _discover_functions(base_pkg, hot_reload=hot_reload)
+    seen: Dict[str, str] = {}
+
+    for name, fn, mod_base in discovered:
+        attr_name = f"{mod_base}_{name}" if prefix_with_module else name
+
+        if hasattr(self, attr_name):
+            if on_collision == "skip":
+                continue
+            if on_collision == "error":
+                raise RuntimeError(f"attach_functions collision on '{attr_name}' from module '{mod_base}'")
+            # last_wins: fall through
+
+        setattr(self, attr_name, fn)
+        seen[attr_name] = mod_base
+
+    # breadcrumb for debugging
+    setattr(self, "_attached_functions", sorted(seen.keys()))
+    return self
+
+def attach_functions(
+    obj_or_cls,
+    base_pkg: str | None = None,
+    hot_reload: bool = True,
+    prefix_with_module: bool = False,
+    include_private: bool = True,
+    only_defined_here: bool = True,   # don't attach stuff imported from elsewhere
+) -> list[str]:
+    """
+    Attach all free functions found in <base_pkg>.functions (module or package)
+    to the *class* of obj_or_cls. Returns the list of attached attribute names.
+    """
+    cls = obj_or_cls if inspect.isclass(obj_or_cls) else obj_or_cls.__class__
+    # Derive "<package>.functions" from the class's module unless you pass base_pkg
+    caller_mod = cls.__module__
+    pkg_root = (base_pkg or caller_mod.rsplit(".", 1)[0]).rstrip(".")
+    funcs_pkg_name = f"{pkg_root}.functions"
+
+    def _import(name: str) -> ModuleType | None:
+        try:
+            if hot_reload and name in sys.modules:
+                return importlib.reload(sys.modules[name])
+            return importlib.import_module(name)
+        except Exception:
+            return None
+
+    def _is_pkg(m: ModuleType) -> bool:
+        return hasattr(m, "__path__")
+
+    mod = _import(funcs_pkg_name)
+    if mod is None:
+        # Nothing to attach (no functions.py or functions/ next to your class)
+        setattr(cls, "_attached_functions", tuple())
+        return []
+
+    modules: list[ModuleType] = [mod]
+    if _is_pkg(mod):
+        # attach from every submodule under functions/
+        for it in pkgutil.iter_modules(mod.__path__):
+            sub = _import(f"{funcs_pkg_name}.{it.name}")
+            if sub is not None:
+                modules.append(sub)
+
+    attached: list[str] = []
+    for m in modules:
+        for name, obj in vars(m).items():
+            # only callables (skip classes), and keep them sane
+            if not callable(obj) or isinstance(obj, type):
+                continue
+            if only_defined_here and getattr(obj, "__module__", None) != m.__name__:
+                continue
+            if not include_private and name.startswith("_"):
+                continue
+            if name.startswith("__") and name.endswith("__"):
+                continue
+            attr = f"{m.__name__.rsplit('.', 1)[-1]}__{name}" if prefix_with_module else name
+            try:
+                setattr(cls, attr, obj)  # set on CLASS → becomes bound method on instances
+                attached.append(attr)
+            except Exception:
+                # don't explode if one name collides; keep going
+                continue
+
+    # handy for debugging
+    try:
+        setattr(cls, "_attached_functions", tuple(attached))
+    except Exception:
+        pass
+    return attached
+
+
+
+def clean_imports():
+    alls = str(list(set("""os,re,subprocess,sys,re,traceback,pydot, enum, inspect, sys, traceback, threading,json,traceback,logging,requests""".replace('\n','').replace(' ','').replace('\t','').split(','))))[1:-1].replace('"','').replace("'",'')
+    input(alls)
+def isTab(item):
+    item_lower =  item.lower()
+    for key in ['console','tab']:
+        if item_lower.endswith(key):
+            return True
+    return False
+def get_dir(root,item):
+    if None in [root]:
+        return None
+    path = root
+    if item != None:
+        path = os.path.join(path,item)
+    return path
+def isDir(root,item=None):
+    path = get_dir(root,item)
+    if path:
+        return os.path.isdir(path)
+def check_dir_item(root,item=None):
+    return (item and isTab(item) and isDir(root,item))
+def get_dirs(root = None):
+    root = root or ABSROOT
+    dirpaths = [get_dir(root,item) for item in os.listdir(root) if check_dir_item(root,item)]
+    return dirpaths
+def ifFunctionsInFile(root):
+    items = [os.path.join(root, "functions"),os.path.join(root, "functions.py")]
+    for item in items:
+        if os.path.exists(item):
+            return item
+        
+
+def get_for_all_tabs(root = None):
+    root = root or caller_path()
+    if os.path.isfile(root):
+        root = os.path.dirname(root)
+    all_tabs = get_dirs(root = root)
+    for ROOT in all_tabs:
+        FUNCS_DIR = ifFunctionsInFile(ROOT)
+        if FUNCS_DIR == None:
+            for ROOT in get_dirs(root = ROOT):
+                apply_inits(ROOT)
+        else: 
+            apply_inits(ROOT)
+            
+
+def apply_inits(ROOT):
+    FUNCS_DIR = ifFunctionsInFile(ROOT)
+
+    
+    if_fun_dir = isDir(FUNCS_DIR)
+    if if_fun_dir != None:
+        
+        if if_fun_dir:
+            CFG = define_defaults(allowed_exts='.py',
+                unallowed_exts = True,
+                exclude_types = True,
+                exclude_dirs = True,
+                exclude_patterns = True)
+            _,filepaths = get_files_and_dirs(FUNCS_DIR,cfg=CFG)
+            
+        else:
+            filepaths = [FUNCS_DIR]
+        
+        # Parse top-level def names
+        def extract_funcs(path: str):
+            funcs = []
+            for line in read_from_file(path).splitlines():
+                m = re.match(r"^def\s+([A-Za-z_]\w*)\s*\(self", line)
+                if m:
+                    funcs.append(m.group(1))
+            return funcs
+
+        # Build functions/__init__.py that re-exports all discovered functions
+        import_lines = []
+        all_funcs = []
+        for fp in filepaths:
+            module = os.path.splitext(os.path.basename(fp))[0]
+            funcs = extract_funcs(fp)
+            if funcs:
+                import_lines.append(f"from .{module} import ({', '.join(funcs)})")
+                all_funcs.extend(funcs)
+        if if_fun_dir:
+            functions_init = "\n".join(import_lines) + ("\n" if import_lines else "")
+            write_to_file(contents=functions_init, file_path=os.path.join(FUNCS_DIR, "__init__.py"))
+
+        # Prepare the tuple literal of function names for import + loop
+        uniq_funcs = sorted(set(all_funcs))
+        func_tuple = ", ".join(uniq_funcs) + ("," if len(uniq_funcs) == 1 else "")
+        
+        # Generate apiConsole/initFuncs.py using the safer setattr-loop
+        init_funcs_src = textwrap.dedent(f"""\
+            
+
+            from .functions import ({func_tuple})
+
+            def initFuncs(self):
+                try:
+                    for f in ({func_tuple}):
+                        setattr(self, f.__name__, f)
+                except Exception as e:
+                    logger.info(f"{{e}}")
+                return self
+        """)
+
+        write_to_file(contents=init_funcs_src, file_path=os.path.join(ROOT, "initFuncs.py"))
+
+def call_for_all_tabs():
+    root = get_caller_dir(2)
+    get_for_all_tabs(root)

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/path_utils.py

@@ -23,8 +23,13 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import os
-import platform
-from .read_write_utils import read_from_file
+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
+from .safe_utils import safe_join
+from .class_utils import get_caller_path,get_caller_dir
+
 def get_os_info():
     """
     Get Operating System Information
@@ -572,8 +577,87 @@ def remove_path(path=None):
             remove_directory(path)
         else:
             os.remove(path)
+def get_safe_dirname(path=None):
+    if path:
+        path_str = str(path)
+        return os.path.dirname(path_str)
+def get_safe_basename(path=None):
+    if path:
+        path_str = str(path)
+        return os.path.basename(path_str)
+def get_safe_splitext(path=None,basename=None):
+    basename = basename or get_safe_basename(path=path)
+    if basename:
+        basename_str = str(basename)
+        filename,ext = os.path.splitext(basename_str)
+        return filename,ext
+def get_safe_filename(path=None,basename=None):
+    filename,_ = get_safe_splitext(path=path,basename=basename)
+    return filename
+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):
-    dirName = os.path.dirname(path)
-    baseName = os.path.basename(path)
-    fileName, ext = os.path.splitext(baseName)
-    return {"dirName": dirName, "baseName": baseName, "fileName": fileName, "ext": ext}
+    
+    basename = get_safe_basename(path)
+    filename, ext = get_safe_splitext(basename=basename)
+
+    dirname = get_safe_dirname(path)
+    dirbase = get_safe_basename(dirname)
+    
+    parent_dirname = get_safe_dirname(dirname)
+    parent_dirbase = get_safe_basename(parent_dirname)
+    
+    super_dirname = get_safe_dirname(parent_dirname)
+    super_dirbase = get_safe_basename(super_dirname)
+
+    return {"dirname": dirname,
+            "basename": basename,
+            "filename": filename,
+            "ext": ext,
+            "dirbase":dirbase,
+            "parent_dirname":parent_dirname,
+            "parent_dirbase":parent_dirbase,
+            "super_dirname":super_dirname,
+            "super_dirbase":super_dirbase
+            }