abstract-utilities 0.2.2.513__py3-none-any.whl → 0.2.2.583__py3-none-any.whl

abstract_utilities/file_utils/src/file_filters/filter_params.py

@@ -0,0 +1,86 @@
+from .predicate_utils import *
+def _get_default_modular(value, default, add=False, typ=set):
+    """Merge user and default values intelligently."""
+    if value == None:
+        value = add
+    if value in [True]:
+        return default
+    if value is False:
+        return value
+    if add:
+        return combine_params(value,default,typ=None)
+
+    return typ(value)
+
+# -------------------------
+# Default derivation logic
+# -------------------------
+def _get_default_modular(value, default, add=None, typ=set):
+    """Merge user and default values intelligently."""
+    add = add or False
+    if value == None:
+        value = add
+    if value in [True]:
+        return default
+    if value is False:
+        return value
+    if add:
+        return combine_params(value,default,typ=None)
+    return typ(value)
+def derive_all_defaults(**kwargs):
+    kwargs = get_safe_canonical_kwargs(**kwargs)
+    add = kwargs.get("add",False)
+    nu_defaults = {}
+    for key,values in DEFAULT_CANONICAL_MAP.items():
+        default = values.get("default")
+        typ = values.get("type")
+        key_value = kwargs.get(key)
+        if key in DEFAULT_ALLOWED_EXCLUDE_MAP:
+
+            if key.endswith('exts'):
+                input_value = ensure_exts(key_value)
+            if key.endswith('patterns'):
+                input_value = ensure_patterns(key_value)
+            else:
+                input_value = normalize_listlike(key_value, typ)
+            nu_defaults[key] = _get_default_modular(input_value, default, add, typ)
+        else:
+            value = default if key_value is None else key_value
+            if typ == list:
+                value = make_list(value)
+            elif typ == bool:
+                value = bool(value)
+            nu_defaults[key] = value
+   
+    return nu_defaults
+# -------------------------
+# Default derivation logic
+# -------------------------
+def derive_file_defaults(**kwargs):
+    kwargs = derive_all_defaults(**kwargs)
+    add = kwargs.get("add",True)
+    nu_defaults = {}
+    for key,values in DEFAULT_ALLOWED_EXCLUDE_MAP.items():
+        default = values.get("default")
+        typ = values.get("type")
+        key_value = kwargs.get(key)
+        if key.endswith('exts'):
+            input_value = ensure_exts(key_value)
+        if key.endswith('patterns'):
+            input_value = ensure_patterns(key_value)
+        else:
+            input_value = normalize_listlike(key_value, typ)
+        nu_defaults[key] = _get_default_modular(input_value, default, add, typ)
+    return nu_defaults
+
+def define_defaults(**kwargs):
+    defaults = derive_file_defaults(**kwargs)
+    return ScanConfig(**defaults)
+
+def get_file_filters(*args,**kwargs):
+    directories = ensure_directories(*args,**kwargs)
+    recursive = kwargs.get('recursive',True)
+    include_files = kwargs.get('include_files',True)
+    cfg = define_defaults(**kwargs)
+    allowed = kwargs.get("allowed") or make_allowed_predicate(cfg)
+    return directories,cfg,allowed,include_files,recursive

abstract_utilities/file_utils/src/file_filters/filter_utils.py

@@ -0,0 +1,78 @@
+from ...imports import *
+import re
+def combine_params(*values,typ=None):
+    nu_values = None
+    for value in values:
+        if value is not None:
+            typ = typ or type(value)
+            if nu_values is None:
+                nu_values = typ()
+            
+            if typ is set:
+                nu_values = nu_values | typ(value)
+            if typ is list:
+                nu_values += typ(value)
+    return nu_values
+def get_safe_kwargs(canonical_map, **kwargs):
+    # Lowercase all keys for safety
+    canonical_map = canonical_map or CANONICAL_MAP
+    norm_kwargs = {k.lower(): v for k, v in kwargs.items() if v is not None}
+
+    # Inverse lookup: alias → canonical key
+    alias_lookup = {
+        alias: canon
+        for canon, aliases in canonical_map.items()
+        if aliases
+        for alias in aliases
+    }
+
+    # Preserve correctly named keys
+    safe_kwargs = {k: v for k, v in norm_kwargs.items() if k in canonical_map}
+
+    for k, v in norm_kwargs.items():
+        if k in alias_lookup:
+            canonical_key = alias_lookup[k]
+            prev = safe_kwargs.get(canonical_key)
+            if prev is None:
+                safe_kwargs[canonical_key] = v
+            else:
+                # merge intelligently if both exist
+                if isinstance(prev, (set, list)) and isinstance(v, (set, list)):
+                    safe_kwargs[canonical_key] = list(set(prev) | set(v))
+                else:
+                    safe_kwargs[canonical_key] = v  # overwrite for non-iterables
+
+    # fill defaults if missing
+    for canon in canonical_map:
+        safe_kwargs.setdefault(canon, None)
+
+    return safe_kwargs
+
+def create_canonical_map(*args,canonical_map=None):
+    keys = [arg for arg in args if arg]
+    if not keys:
+        return CANONICAL_MAP
+    canonical_map = canonical_map or CANONICAL_MAP
+
+    return {key:canonical_map.get(key) for key in keys}
+def get_safe_canonical_kwargs(*args,canonical_map=None,**kwargs):
+    canonical_map = canonical_map or create_canonical_map(*args)
+    
+    return get_safe_kwargs(canonical_map=canonical_map,**kwargs)    
+def get_dir_filter_kwargs(**kwargs):
+    canonical_map = create_canonical_map("directories")
+    return get_safe_kwargs(canonical_map=canonical_map,**kwargs)
+def get_file_filter_kwargs(**kwargs):
+    """
+    Normalize arbitrary keyword arguments for file scanning configuration.
+    
+    Examples:
+      - 'excluded_ext' or 'unallowed_exts' → 'exclude_exts'
+      - 'include_dirs' or 'allow_dir' → 'allowed_dirs'
+      - 'excludePattern' or 'excluded_patterns' → 'exclude_patterns'
+      - 'allowed_type' or 'include_types' → 'allowed_types'
+    """
+    # Canonical keys and aliases
+    canonical_keys =["allowed_exts","exclude_exts","allowed_types","exclude_types","allowed_dirs","exclude_dirs","allowed_patterns","exclude_patterns"]
+   
+    return get_safe_canonical_kwargs(*canonical_keys,**kwargs)

abstract_utilities/file_utils/src/file_filters/predicate_utils.py

@@ -0,0 +1,114 @@
+from .ensure_utils import *
+def get_allowed_predicate(allowed=None):
+    if allowed != False:
+        if allowed == True:
+            allowed = None
+        allowed = allowed or make_allowed_predicate()
+    else:
+        def allowed(*args):
+            return True
+        allowed = allowed
+    return allowed
+def get_globs(items,recursive: bool = True,allowed=None):
+    glob_paths = []
+    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:
+            nuItems = [nuItem for nuItem in nuItems if nuItem and allowed(nuItem)]
+        glob_paths += nuItems
+    return glob_paths
+def get_allowed_files(items,allowed=True):
+    allowed = get_allowed_predicate(allowed=allowed)
+    return [item for item in items if item and os.path.isfile(item) and allowed(item)]
+def get_allowed_dirs(items,allowed=False):
+    allowed = get_allowed_predicate(allowed=allowed)
+    return [item for item in items if item and os.path.isdir(item) and allowed(item)]
+
+def get_filtered_files(items,allowed=None,files = []):
+    allowed = get_allowed_predicate(allowed=allowed)
+    glob_paths = get_globs(items)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isfile(glob_path) and glob_path not in files and allowed(glob_path)]
+def get_filtered_dirs(items,allowed=None,dirs = []):
+    allowed = get_allowed_predicate(allowed=allowed)
+    glob_paths = get_globs(items)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isdir(glob_path) and glob_path not in dirs and allowed(glob_path)]
+
+def get_all_allowed_files(items,allowed=None):
+    dirs = get_all_allowed_dirs(items)
+    files = get_allowed_files(items)
+    nu_files = []
+    for directory in dirs:
+        files += get_filtered_files(directory,allowed=allowed,files=files)
+    return files
+def get_all_allowed_dirs(items,allowed=None):
+    allowed = get_allowed_predicate(allowed=allowed)
+    dirs = get_allowed_dirs(items)
+    nu_dirs=[]
+    for directory in dirs:
+        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs)
+    return nu_dirs
+
+def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
+    """
+    Build a predicate that returns True if a given path is considered allowed
+    under the given ScanConfig. Applies allowed_* and exclude_* logic symmetrically.
+    """
+    def allowed(path: str=None,p=None) -> bool:
+        p = p or Path(path)
+        name = p.name.lower()
+        path_str = str(p).lower()
+
+        # --------------------
+        # A) directory filters
+        # --------------------
+        if cfg.exclude_dirs:
+            for dpat in cfg.exclude_dirs:
+                dpat_l = dpat.lower()
+                if dpat_l in path_str or fnmatch.fnmatch(name, dpat_l):
+                    if p.is_dir() or dpat_l in path_str:
+                        return False
+
+        if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
+            # must be in at least one allowed dir
+            if not any(
+                fnmatch.fnmatch(path_str, f"*{dpat.lower()}*") for dpat in cfg.allowed_dirs
+            ):
+                return False
+
+        # --------------------
+        # B) pattern filters
+        # --------------------
+        if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
+            if not any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.allowed_patterns):
+                return False
+
+        if cfg.exclude_patterns:
+            for pat in cfg.exclude_patterns:
+                if fnmatch.fnmatch(name, pat.lower()):
+                    return False
+
+        # --------------------
+        # C) extension filters
+        # --------------------
+        if p.is_file():
+            ext = p.suffix.lower()
+            if cfg.allowed_exts and ext not in cfg.allowed_exts:
+                return False
+            if cfg.exclude_exts and ext in cfg.exclude_exts:
+                return False
+
+        # --------------------
+        # D) type filters (optional)
+        # --------------------
+        if cfg.allowed_types and cfg.allowed_types != {"*"}:
+            if not any(t in path_str for t in cfg.allowed_types):
+                return False
+        if cfg.exclude_types and cfg.exclude_types != {"*"}:
+            if any(t in path_str for t in cfg.exclude_types):
+                return False
+
+        return True
+
+    return allowed

abstract_utilities/file_utils/src/file_filters.py

@@ -1,53 +1,120 @@
-from ..imports import *
 from .filter_params import *
-from .file_utils 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:
+        if allowed == True:
+            allowed = None
+        allowed = allowed or make_allowed_predicate()
+    else:
+        def allowed(*args):
+            return True
+        allowed = allowed
+    return allowed
+def get_globs(items,recursive: bool = True,allowed=None):
+    glob_paths = []
+    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:
+            nuItems = [nuItem for nuItem in nuItems if nuItem and allowed(nuItem)]
+        glob_paths += nuItems
+    return glob_paths
+def get_allowed_files(items,allowed=True):
+    allowed = get_allowed_predicate(allowed=allowed)
+    return [item for item in items if item and os.path.isfile(item) and allowed(item)]
+def get_allowed_dirs(items,allowed=False):
+    allowed = get_allowed_predicate(allowed=allowed)
+    return [item for item in items if item and os.path.isdir(item) and allowed(item)]
+
+def get_filtered_files(items,allowed=None,files = []):
+    allowed = get_allowed_predicate(allowed=allowed)
+    glob_paths = get_globs(items)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isfile(glob_path) and glob_path not in files and allowed(glob_path)]
+def get_filtered_dirs(items,allowed=None,dirs = []):
+    allowed = get_allowed_predicate(allowed=allowed)
+    glob_paths = get_globs(items)
+    return [glob_path for glob_path in glob_paths if glob_path and os.path.isdir(glob_path) and glob_path not in dirs and allowed(glob_path)]
+
+def get_all_allowed_files(items,allowed=None):
+    dirs = get_all_allowed_dirs(items)
+    files = get_allowed_files(items)
+    nu_files = []
+    for directory in dirs:
+        files += get_filtered_files(directory,allowed=allowed,files=files)
+    return files
+def get_all_allowed_dirs(items,allowed=None):
+    allowed = get_allowed_predicate(allowed=allowed)
+    dirs = get_allowed_dirs(items)
+    nu_dirs=[]
+    for directory in dirs:
+        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs)
+    return nu_dirs
+
+def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
+    """
+    Build a predicate that returns True if a given path is considered allowed
+    under the given ScanConfig. Applies allowed_* and exclude_* logic symmetrically.
+    """
+    def allowed(path: str=None,p=None) -> bool:
+        p = p or Path(path)
+        name = p.name.lower()
+        path_str = str(p).lower()
+
+        # --------------------
+        # A) directory filters
+        # --------------------
+        if cfg.exclude_dirs:
+            for dpat in cfg.exclude_dirs:
+                dpat_l = dpat.lower()
+                if dpat_l in path_str or fnmatch.fnmatch(name, dpat_l):
+                    if p.is_dir() or dpat_l in path_str:
+                        return False
+
+        if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
+            # must be in at least one allowed dir
+            if not any(
+                fnmatch.fnmatch(path_str, f"*{dpat.lower()}*") for dpat in cfg.allowed_dirs
+            ):
+                return False
+
+        # --------------------
+        # B) pattern filters
+        # --------------------
+        if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
+            if not any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.allowed_patterns):
+                return False
+
+        if cfg.exclude_patterns:
+            for pat in cfg.exclude_patterns:
+                if fnmatch.fnmatch(name, pat.lower()):
+                    return False
+
+        # --------------------
+        # C) extension filters
+        # --------------------
+        if p.is_file():
+            ext = p.suffix.lower()
+            if cfg.allowed_exts and ext not in cfg.allowed_exts:
+                return False
+            if cfg.exclude_exts and ext in cfg.exclude_exts:
+                return False
+
+        # --------------------
+        # D) type filters (optional)
+        # --------------------
+        if cfg.allowed_types and cfg.allowed_types != {"*"}:
+            if not any(t in path_str for t in cfg.allowed_types):
+                return False
+        if cfg.exclude_types and cfg.exclude_types != {"*"}:
+            if any(t in path_str for t in cfg.exclude_types):
+                return False
+
+        return True
+
+    return allowed
 
-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(

abstract_utilities/file_utils/src/file_reader.py

@@ -1,9 +1,7 @@
 # file_reader.py
 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 *
 # ---------------------------------------------------------------------------
 # NOTE: The following helper functions must be provided elsewhere:
@@ -238,68 +236,6 @@ def read_shape_file(path: str) -> Union[gpd.GeoDataFrame, None]:
     return None
 
 
-def collect_filepaths(
-    inputs: Union[str, List[str]],
-    exclude_dirs: set[str] = None,
-    exclude_file_patterns: set[str] = None,
-    exclude_types: set[str] = None
-) -> List[str]:
-    """
-    Given a path or list of paths, return a list of all file paths under them.
-    - If an input is a file, it's included (unless it matches an exclude pattern).
-    - If an input is a directory, walk it recursively:
-        • Skip any subdirectory named in `exclude_dirs`
-        • Skip any file whose name matches one of `exclude_file_patterns`
-    """
-    re_initialize_skip_mgr(exclude_types=exclude_types,
-                           exclude_file_patterns=exclude_file_patterns,
-                           exclude_dirs=exclude_dirs)
-
-
-    # Normalize to list
-    if isinstance(inputs, str):
-        paths_to_scan = [inputs]
-    else:
-        paths_to_scan = list(inputs)
-
-    all_files: List[str] = []
-
-
-
-    def _collect_from_dir(dirpath: str):
-        for dirpath_root, dirnames, filenames in os.walk(dirpath):
-            # Remove any excluded subdirectories from os.walk
-            dirnames[:] = [d for d in dirnames if d not in exclude_dirs]
-
-            for fname in filenames:
-                if should_skip(exclude_item=fname,
-                               exclude_types=True,
-                               exclude_file_patterns=True):
-                    continue
-                full = os.path.join(dirpath_root, fname)
-                all_files.append(full)
-
-    for p in paths_to_scan:
-        if not os.path.exists(p):
-            # skip nonexistent paths
-            continue
-
-        if os.path.isfile(p):
-            basename = os.path.basename(p)
-            fname = os.path.splitext(basename)
-            if not should_skip(exclude_item=fname,
-                               exclude_types=True,
-                               exclude_file_patterns=True):
-                all_files.append(p)
-        else:
-            # p is a directory
-            _collect_from_dir(p)
-
-    return all_files
-
-# requirements:
-#   pip install pdfplumber pdf2image pytesseract pillow
-#   # plus Tesseract binary (apt install tesseract-ocr or brew install tesseract)
 
 
 

abstract_utilities/file_utils/src/file_utils.py

@@ -52,38 +52,13 @@ def get_all_allowed_dirs(items,allowed=None):
     for directory in dirs:
         nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs)
     return nu_dirs
-def get_files_and_dirs(
-    directory: str,
-    cfg: Optional["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,
-    recursive: bool = True,
-    include_files: bool = True,
-    **kwargs
-    ):
-    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 = make_allowed_predicate(cfg)
+def get_files_and_dirs(*args,**kwargs)-> List[str]:
+    directories,cfg,allowed,include_files,recursive = get_file_filters(*args,**kwargs)
     items=[]
     files =[]
     if recursive:
-        items = get_globs(directory,recursive=recursive,allowed=allowed)
+        for directory in directories:
+            items += get_globs(directories,recursive=recursive,allowed=allowed)
     else:
         directories = make_list(directory)
         for directory in directories:
@@ -92,68 +67,7 @@ def get_files_and_dirs(
     if include_files:
         files = get_allowed_files(items,allowed=allowed)
     return dirs,files
-def make_allowed_predicate(cfg: ScanConfig) -> Callable[[str], bool]:
-    """
-    Build a predicate that returns True if a given path is considered allowed
-    under the given ScanConfig. Applies allowed_* and exclude_* logic symmetrically.
-    """
-    def allowed(path: str=None,p=None) -> bool:
-        p = p or Path(path)
-        name = p.name.lower()
-        path_str = str(p).lower()
-
-        # --------------------
-        # A) directory filters
-        # --------------------
-        if cfg.exclude_dirs:
-            for dpat in cfg.exclude_dirs:
-                dpat_l = dpat.lower()
-                if dpat_l in path_str or fnmatch.fnmatch(name, dpat_l):
-                    if p.is_dir() or dpat_l in path_str:
-                        return False
-
-        if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
-            # must be in at least one allowed dir
-            if not any(
-                fnmatch.fnmatch(path_str, f"*{dpat.lower()}*") for dpat in cfg.allowed_dirs
-            ):
-                return False
 
-        # --------------------
-        # B) pattern filters
-        # --------------------
-        if cfg.allowed_patterns and cfg.allowed_patterns != ["*"]:
-            if not any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.allowed_patterns):
-                return False
-
-        if cfg.exclude_patterns:
-            for pat in cfg.exclude_patterns:
-                if fnmatch.fnmatch(name, pat.lower()):
-                    return False
-
-        # --------------------
-        # C) extension filters
-        # --------------------
-        if p.is_file():
-            ext = p.suffix.lower()
-            if cfg.allowed_exts and ext not in cfg.allowed_exts:
-                return False
-            if cfg.unallowed_exts and ext in cfg.unallowed_exts:
-                return False
-
-        # --------------------
-        # D) type filters (optional)
-        # --------------------
-        if cfg.allowed_types and cfg.allowed_types != {"*"}:
-            if not any(t in path_str for t in cfg.allowed_types):
-                return False
-        if cfg.exclude_types and cfg.exclude_types != {"*"}:
-            if any(t in path_str for t in cfg.exclude_types):
-                return False
-
-        return True
-
-    return allowed
 def correct_kwargs(**kwargs):
     for key,values in kwargs.items():
         if key.startswith('excluded'):
@@ -163,47 +77,10 @@ def correct_kwargs(**kwargs):
             kwargs[correct_key]=combine_params(correct_vals,values)
             del kwargs[key]
     
-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]:
-    kwargs = correct_kwargs(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,
-        **kwargs)
-    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]
-
+def collect_filepaths(*args,**kwargs)-> List[str]:
+    directories,cfg,allowed,include_files,recursive = get_file_filters(*args,**kwargs)
     # your existing helpers (get_dirs, get_globs, etc.) stay the same
-    original_dirs = get_allowed_dirs(roots, allowed=allowed)
+    original_dirs = get_allowed_dirs(directories, allowed=allowed)
     original_globs = get_globs(original_dirs)
     files = get_allowed_files(original_globs, allowed=allowed)