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

abstract_utilities/__init__.py

@@ -4,7 +4,6 @@ from datetime import datetime
 from typing import *
 from .hash_utils import *
 ##from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
-from .robust_readers import *
 from .dynimport import get_abstract_import
 from .json_utils import (unified_json_loader,
                          find_keys,

abstract_utilities/file_utils/__init__.py

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

abstract_utilities/file_utils/imports/constants.py

@@ -4,8 +4,11 @@ from .module_imports import *
 class ScanConfig:
     allowed_exts: Set[str]
     unallowed_exts: Set[str]
+    allowed_types: Set[str]
     exclude_types: Set[str]
+    allowed_dirs: List[str] = field(default_factory=list)
     exclude_dirs: List[str] = field(default_factory=list)
+    allowed_patterns: List[str] = field(default_factory=list)
     exclude_patterns: List[str] = field(default_factory=list)
 DEFAULT_ALLOWED_EXTS: Set[str] = {
     ".py", ".pyw",                             # python
@@ -37,3 +40,6 @@ DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
 REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
 AllowedPredicate = Optional[Callable[[str], bool]]
 DEFAULT_EXCLUDE_FILE_PATTERNS=DEFAULT_EXCLUDE_PATTERNS
+DEFAULT_ALLOWED_PATTENS="*"
+DEFAULT_ALLOWED_DIRS="*"
+DEFAULT_ALLOWED_TYPES="*"

abstract_utilities/file_utils/imports/imports.py

@@ -6,7 +6,7 @@
 # ============================================================
 
 
-import os
+import os,re
 import sys, importlib,os
 import sys, importlib, os, inspect
 from pathlib import Path

abstract_utilities/file_utils/imports/module_imports.py

@@ -9,5 +9,4 @@ 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("_")]
+from ...string_utils import get_from_kwargs

abstract_utilities/file_utils/module_imports.py

@@ -0,0 +1,12 @@
+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
+

abstract_utilities/file_utils/src/__init__.py

@@ -0,0 +1,10 @@
+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 *
+from .initFunctionsGen import call_for_all_tabs,get_for_all_tabs
+

abstract_utilities/file_utils/src/file_filters.py

@@ -0,0 +1,110 @@
+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,
+    allowed_types: Optional[Set[str]] = False,
+    exclude_types: Optional[Set[str]] = False,
+    allowed_dirs: Optional[List[str]] = False,
+    exclude_dirs: Optional[List[str]] = False,
+    allowed_patterns: 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,
+            allowed_types = allowed_types,
+            exclude_types = exclude_types,
+            allowed_dirs = allowed_dirs,
+            exclude_dirs = exclude_dirs,
+            allowed_patterns = allowed_patterns,
+            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 (),
+    )