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

abstract_utilities/env_utils/envy_it.py

@@ -0,0 +1,33 @@
+from .imports import *
+from .abstractEnv import abstractEnv
+def get_env_value(key:str=None,path:str=None,file_name:str=None,deep_scan=False):
+    abstract_env = abstractEnv(key=key, file_name=file_name, path=path,deep_scan=deep_scan)
+
+    """
+    Retrieves the value of a specified environment variable from a .env file.
+
+    Args:
+        key (str, optional): The key to search for in the .env file. Defaults to None.
+        path (str, optional): The path to the .env file. Defaults to None.
+        file_name (str, optional): The name of the .env file. Defaults to None.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    return abstract_env.env_value
+
+
+def get_env_path(key:str=None,path:str=None,file_name:str=None,deep_scan=False):
+    abstract_env = abstractEnv(key=key, file_name=file_name, path=path,deep_scan=deep_scan)
+    """
+    Retrieves the value of a specified environment variable from a .env file.
+
+    Args:
+        key (str, optional): The key to search for in the .env file. Defaults to None.
+        path (str, optional): The path to the .env file. Defaults to None.
+        file_name (str, optional): The name of the .env file. Defaults to None.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    return abstract_env.env_path

abstract_utilities/env_utils/imports/__init__.py

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

abstract_utilities/env_utils/imports/imports.py

@@ -0,0 +1,8 @@
+import os
+from dotenv import load_dotenv
+from ...string_clean import eatAll,eatInner,eatOuter,safe_split
+from ...compare_utils import line_contains
+from ...type_utils import is_list,is_bool
+from ...path_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join,is_file
+DEFAULT_FILE_NAME = '.env'
+DEFAULT_KEY = 'MY_PASSWORD'

abstract_utilities/env_utils/imports/utils.py

@@ -0,0 +1,122 @@
+from .imports import *
+def find_and_read_env_file(key:str=DEFAULT_KEY,file_name:str=DEFAULT_FILE_NAME,  start_path:str=None):
+    """
+    Search for an environment file and read a specific key from it.
+
+    Args:
+        file_name (str): Name of the .env file to be searched. Defaults to '.env'.
+        key (str): Key to be retrieved from the .env file. Defaults to 'MY_PASSWORD'.
+        start_path (str): Directory path to start the search from. If None, search starts from current directory. 
+
+    Returns:
+        str: The value corresponding to the key if found, otherwise None.
+    """
+    # Set the default start_path to the current directory if it's None
+    directories = [start_path, os.getcwd(), get_home_folder(), simple_path_join(get_home_folder(),'.envy_all'),simple_path_join(get_home_folder(),'envy_all')]
+    if start_path in [None, os.getcwd()]:
+        directories = directories[1:]
+
+    # Try to find the file in the start_path
+    for k in range(0,len(directories)):
+        env_path = check_env_file(path=directories[k],file_name=file_name)
+        if not is_bool(env_path):
+            value = search_for_env_key(path=env_path,key=key)
+            if value != None:
+                return value
+
+def search_for_env_key(key:str,path:str):
+    """
+    Search for a specific key in a .env file.
+
+    Args:
+        path (str): The path to the .env file.
+        key (str): The key to search for in the .env file.
+
+    Returns:
+        str: The value of the key if found, otherwise None.
+    """
+    with open(path, "r") as f:
+        for line in f:
+            eq_split = safe_split(line,['=',0])
+            # If the line contains the key, return the value after stripping extra characters
+            if line_contains(string=eq_split, compare=key):
+                return eatAll(line[len(eq_split):],[' ','','=']).strip()
+
+def check_env_file(path:str,file_name:str=DEFAULT_FILE_NAME):
+    """
+    Check if the environment file exists in a specified path.
+
+    Args:
+        path (str): The path to check for the .env file.
+        file_name (str): The name of the .env file. Defaults to '.env'.
+
+    Returns:
+        str: The path of the .env file if it exists, otherwise False.
+    """
+    path = if_not_last_child_join(path=path, child=DEFAULT_FILE_NAME)
+    # Return the path if file exists, otherwise return False
+    if is_file(path):
+        return path
+    return False
+
+def safe_env_load(path:str=None):
+    """
+    Safely load the .env file if it exists at a specified path.
+
+    Args:
+        path (str): The path to load the .env file from. If None, no operation is performed. 
+
+    Returns:
+        bool: True if the .env file is successfully loaded, otherwise False.
+    """
+    if path == None:
+        return False
+    if is_file(path):
+        if str(safe_split(path,[get_slash(),-1]))[0] == '.':
+            load_dotenv(path)
+            return True
+    return False
+
+def get_env_value(key:str=DEFAULT_KEY,path:str=None,file_name:str=DEFAULT_FILE_NAME):
+    """
+    Retrieves the value of the specified environment variable.
+
+    Args:
+        path (str): The path to the environment file. Defaults to None.
+        file_name (str): The name of the environment file. Defaults to '.env'.
+        key (str): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+
+    Returns:
+        str: The value of the environment variable if found, otherwise None.
+    """
+    if safe_env_load(path):
+        return os.getenv(key)
+    return find_and_read_env_file(file_name=file_name, key=key, start_path=os.getcwd())
+def split_eq(line):
+    """
+    Splits a string at the first equals sign '=' and cleans up the key and value.
+
+    Args:
+        line (str): The string to be split.
+
+    Returns:
+        list: A list containing the cleaned key and value. If '=' is not found, returns [line, None].
+    """
+    if '=' in line:
+        key_side = line.split('=')[0]
+        value_side = line[len(key_side+'='):]
+        return [eatOuter(key_side,[' ','','\t']),eatAll(value_side,[' ','','\t','\n'])]
+    return [line,None]
+def dotenv_load(path:str=None):
+    """
+    Safely load the .env file if it exists at a specified path.
+
+    Args:
+        path (str): The path to load the .env file from. If None, no operation is performed. 
+
+    Returns:
+        bool: True if the .env file is successfully loaded, otherwise False.
+    """
+    if path and os.path.isfile(path) and os.path.basename(path)[0] == '.':
+        load_dotenv(path)
+        return True

abstract_utilities/file_utils/__init__.py

@@ -0,0 +1,3 @@
+from .imports import *
+from .file_utils import *
+from .req import call_for_all_tabs,get_for_all_tabs

abstract_utilities/file_utils/file_utils/__init__.py

@@ -0,0 +1,8 @@
+from .file_filters import *
+from .file_utils import *
+from .filter_params import *
+from .map_utils import *
+from .pdf_utils import *
+from .file_reader import *
+from .find_collect import *
+from .type_checks import *

abstract_utilities/file_utils/file_utils/file_filters.py

@@ -0,0 +1,104 @@
+from .imports import *
+from .filter_params import *
+from .file_utils import *
+##from abstract_utilities import make_list,get_media_exts, is_media_type
+
+def collect_filepaths(
+    directory: List[str],
+    cfg: ScanConfig=None,
+    allowed_exts: Optional[Set[str]] = False,
+    unallowed_exts: Optional[Set[str]] = False,
+    exclude_types: Optional[Set[str]] = False,
+    exclude_dirs: Optional[List[str]] = False,
+    exclude_patterns: Optional[List[str]] = False,
+    add=False,
+    allowed: Optional[Callable[[str], bool]] = None,
+    **kwargs
+    ) -> List[str]:
+    cfg = cfg or define_defaults(
+                                allowed_exts=allowed_exts,
+                                unallowed_exts=unallowed_exts,
+                                exclude_types=exclude_types,
+                                exclude_dirs=exclude_dirs,
+                                exclude_patterns=exclude_patterns,
+                                add = add
+                                )
+    allowed = allowed or make_allowed_predicate(cfg)
+    directories = make_list(directory)
+    roots = [r for r in directories if r]
+
+    # your existing helpers (get_dirs, get_globs, etc.) stay the same
+    original_dirs = get_allowed_dirs(roots, allowed=allowed)
+    original_globs = get_globs(original_dirs)
+    files = get_allowed_files(original_globs, allowed=allowed)
+
+    for d in get_filtered_dirs(original_dirs, allowed=allowed):
+        files += get_filtered_files(d, allowed=allowed, files=files)
+
+    # de-dupe while preserving order
+    seen, out = set(), []
+    for f in files:
+        if f not in seen:
+            seen.add(f)
+            out.append(f)
+    return out
+
+
+def _fast_walk(
+    root: Path,
+    exts: Iterable[str],
+    skip_dirs: Iterable[str] = (),
+    skip_patterns: Iterable[str] = (),
+) -> List[Path]:
+    exts = tuple(exts)
+    skip_dirs = set(sd.lower() for sd in skip_dirs or ())
+    skip_patterns = tuple(sp.lower() for sp in (skip_patterns or ()))
+
+    out = []
+    for p in root.rglob("*"):
+        # skip directories by name hit
+        if p.is_dir():
+            name = p.name.lower()
+            if name in skip_dirs:
+                # rglob doesn't let us prune mid-iteration cleanly; we just won't collect under it
+                continue
+            # nothing to collect for dirs
+            continue
+
+        # file filters
+        name = p.name.lower()
+        if any(fnmatch.fnmatch(name, pat) for pat in skip_patterns):
+            continue
+        if p.suffix.lower() in exts:
+            out.append(p)
+
+    # de-dup and normalize
+    return sorted({pp.resolve() for pp in out})
+
+
+def enumerate_source_files(
+    src_root: Path,
+    cfg: Optional["ScanConfig"] = None,
+    *,
+    exts: Optional[Iterable[str]] = None,
+    fast_skip_dirs: Optional[Iterable[str]] = None,
+    fast_skip_patterns: Optional[Iterable[str]] = None,
+) -> List[Path]:
+    """
+    Unified enumerator:
+      - If `cfg` is provided: use collect_filepaths(...) with full rules.
+      - Else: fast walk using rglob over `exts` (defaults to EXTS) with optional light excludes.
+    """
+    src_root = Path(src_root)
+
+    if cfg is not None:
+        files = collect_filepaths([str(src_root)], cfg=cfg)
+        return sorted({Path(f).resolve() for f in files})
+
+    # Fast mode
+    return _fast_walk(
+        src_root,
+        exts or EXTS,
+        skip_dirs=fast_skip_dirs or (),
+        skip_patterns=fast_skip_patterns or (),
+    )

abstract_utilities/{robust_reader → file_utils/file_utils}/file_reader.py

@@ -1,29 +1,15 @@
 # file_reader.py
-import os,tempfile,shutil,logging,ezodf,fnmatch
-from typing import Union
-import pandas as pd
-import geopandas as gpd
-from abstract_utilities import * 
-from datetime import datetime
-from werkzeug.utils import secure_filename
-from werkzeug.datastructures import FileStorage
-from datetime import datetime
-from typing import Dict, Union, List
+from .imports import *
+# -------- Public API drop-ins that mirror your originals --------
+from .filter_params import *
+from .file_filters import *
+from .file_utils import *
 from .pdf_utils import *
-import pdfplumber
-from pdf2image import convert_from_path   # only used for OCR fallback
-import pytesseract
-from pathlib import Path
 # ---------------------------------------------------------------------------
 # NOTE: The following helper functions must be provided elsewhere:
 #   - convert_date_string(s: str) -> datetime
 #   - read_from_file(path: str) -> pd.DataFrame
 # ---------------------------------------------------------------------------
-DEFAULT_EXCLUDE_DIRS = {"node_modules", "__pycache__","backups","backup"}
-DEFAULT_EXCLUDE_FILE_PATTERNS = {"__init__*", "*.tmp", "*.log"}
-DEFAULT_EXCLUDE_TYPES = {"image","video","audio","presentation"}
-def get_ext(item):
-    return item.split('.')[-1]
 def _should_skip_dir(dir_name: str, exclude_dirs: set[str]) -> bool:
     """
     Return True if dir_name match=self.exclude_types)es one of the excluded directory names exactly.

abstract_utilities/{robust_readers/file_filters.py → file_utils/file_utils/file_utils.py}

@@ -1,7 +1,7 @@
-from pathlib import Path
-from typing import *
-import fnmatch, os, glob
+
 from .filter_params import *
+from .imports import *
+
 ##from abstract_utilities import make_list,get_media_exts, is_media_type
 def get_allowed_predicate(allowed=None):
     if allowed != False:
@@ -15,7 +15,8 @@ def get_allowed_predicate(allowed=None):
     return allowed
 def get_globs(items,recursive: bool = True,allowed=None):
     glob_paths = []
-    for item in make_list(items):
+    items = [item for item in make_list(items) if item]
+    for item in items:
         pattern = os.path.join(item, "**/*")  # include all files recursively\n
         nuItems = glob.glob(pattern, recursive=recursive)
         if allowed:

abstract_utilities/{robust_readers → file_utils/file_utils}/filter_params.py

@@ -1,41 +1,4 @@
-from typing import *
-from ..type_utils import make_list,get_media_exts, is_media_type
-from ..string_clean import eatAll
-from dataclasses import dataclass, field
-@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", "__pycache__", "backups", "backup", "backs", "trash", "depriciated", "old", "__init__"
-}
-
-DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
-    "__init__*", "*.tmp", "*.log", "*.lock", "*.zip","*~"
-}
+from .imports import *
 def get_default_modular(obj,default=None,add=False,typ=set):
     if obj in [False,True,None]:
         if obj in [True,None]:

abstract_utilities/file_utils/file_utils/find_collect.py

@@ -0,0 +1,154 @@
+from .imports import *
+from .filter_params import *
+from .file_filters import enumerate_source_files
+
+
+def check_path_type(
+    path: str,
+    user: Optional[str] = None,
+    host: Optional[str] = None,
+    user_as_host: Optional[str] = None,
+    use_shell: bool = False
+) -> Literal["file", "directory", "missing", "unknown"]:
+    """
+    Determine whether a given path is a file, directory, or missing.
+    Works locally or remotely (via SSH).
+
+    Args:
+        path: The path to check.
+        user, host, user_as_host: SSH parameters if remote.
+        use_shell: Force shell test instead of Python os.path.
+    Returns:
+        One of: 'file', 'directory', 'missing', or 'unknown'
+    """
+
+    # --- remote check if user/host is given ---
+    if user_as_host or (user and host):
+        remote_target = user_as_host or f"{user}@{host}"
+        cmd = f"if [ -f '{path}' ]; then echo file; elif [ -d '{path}' ]; then echo directory; else echo missing; fi"
+        try:
+            result = subprocess.check_output(
+                ["ssh", remote_target, cmd],
+                stderr=subprocess.DEVNULL,
+                text=True,
+                timeout=5
+            ).strip()
+            return result if result in ("file", "directory", "missing") else "unknown"
+        except Exception:
+            return "unknown"
+
+    # --- local check ---
+    if not use_shell:
+        if os.path.isfile(path):
+            return "file"
+        elif os.path.isdir(path):
+            return "directory"
+        elif not os.path.exists(path):
+            return "missing"
+        return "unknown"
+    else:
+        # fallback using shell tests (useful for sandboxed contexts)
+        cmd = f"if [ -f '{path}' ]; then echo file; elif [ -d '{path}' ]; then echo directory; else echo missing; fi"
+        try:
+            output = subprocess.check_output(
+                cmd, shell=True, stderr=subprocess.DEVNULL, text=True
+            ).strip()
+            return output if output in ("file", "directory", "missing") else "unknown"
+        except Exception:
+            return "unknown"
+
+
+
+
+def get_find_cmd(
+    directory: str,
+    *,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,  # 'f' or 'd'
+    name: Optional[str] = None,
+    size: Optional[str] = None,
+    mtime: Optional[str] = None,
+    perm: Optional[str] = None,
+    user: Optional[str] = None,
+    **kwargs
+) -> str:
+    """Constructs a Unix `find` command string from keyword args."""
+    cmd = [f"find {directory}"]
+
+    if depth is not None:
+        cmd += [f"-mindepth {depth}", f"-maxdepth {depth}"]
+    else:
+        if mindepth is not None:
+            cmd.append(f"-mindepth {mindepth}")
+        if maxdepth is not None:
+            cmd.append(f"-maxdepth {maxdepth}")
+
+    if file_type in ("f", "d"):
+        cmd.append(f"-type {file_type}")
+    if name:
+        cmd.append(f"-name '{name}'")
+    if size:
+        cmd.append(f"-size {size}")
+    if mtime:
+        cmd.append(f"-mtime {mtime}")
+    if perm:
+        cmd.append(f"-perm {perm}")
+    if user:
+        cmd.append(f"-user {user}")
+
+    return " ".join(cmd)
+
+
+def collect_globs(
+    directory: str,
+    cfg: Optional["ScanConfig"] = None,
+    *,
+    exts: Optional[Set[str]] = None,
+    patterns: Optional[List[str]] = None,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,
+    user_at_host: Optional[str] = None,
+    add: bool = False,
+    **kwargs
+) -> List[str]:
+    """
+    Collect file or directory paths using either:
+      - local recursive logic (rglob)
+      - or remote shell call (find via run_cmd)
+    """
+    cfg = cfg or define_defaults(add=add)
+    directory = str(directory)
+    exts = ensure_exts(exts)
+    patterns = ensure_patterns(patterns)
+
+    # Remote path via SSH
+    if user_at_host:
+        find_cmd = get_find_cmd(
+            directory,
+            mindepth=mindepth,
+            maxdepth=maxdepth,
+            depth=depth,
+            file_type=file_type,
+            **{k: v for k, v in kwargs.items() if v},
+        )
+        return run_cmd(find_cmd, user_at_host=user_at_host)
+
+    # Local path (Python-native walk)
+    root = Path(directory)
+    results = []
+    for p in root.rglob("*"):
+        if file_type == "f" and not p.is_file():
+            continue
+        if file_type == "d" and not p.is_dir():
+            continue
+        if exts and p.suffix.lower() not in exts:
+            continue
+        if patterns and not any(p.match(pat) for pat in patterns):
+            continue
+        results.append(str(p.resolve()))
+
+    return sorted(results)

abstract_utilities/file_utils/file_utils/imports/__init__.py

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

abstract_utilities/file_utils/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/file_utils/imports/file_functions.py

@@ -0,0 +1,10 @@
+from .imports import *
+def get_caller_path():
+    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/file_utils/imports/imports.py

@@ -0,0 +1,39 @@
+# ============================================================
+# abstract_utilities/imports/imports.py
+# Global imports hub — everything imported here will be
+# automatically available to any module that does:
+#     from ..imports import *
+# ============================================================
+# ---- 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 pathlib import Path
+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/file_utils/imports/module_imports.py

@@ -0,0 +1,14 @@
+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 ....string_utils import get_from_kwargs
+from ....abstract_classes import run_pruned_func
+from ....class_utils import get_caller, get_caller_path, get_caller_dir
+
+
+__all__ = [name for name in globals() if not name.startswith("_")]

abstract_utilities/file_utils/file_utils/imports.py

@@ -0,0 +1,10 @@
+from ..imports import *
+from typing import *
+from dataclasses import dataclass, field
+@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)