abstract-utilities 0.2.2.563__tar.gz → 0.2.2.639__tar.gz

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.563
+Version: 0.2.2.639
 Summary: abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.
 Home-page: https://github.com/AbstractEndeavors/abstract_utilities
 Author: putkoff

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_utilities',
-    version='0.2.2.563',
+    version='0.2.2.639',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description='abstract_utilities is a collection of utility modules providing a variety of functions to aid in tasks such as data comparison, list manipulation, JSON handling, string manipulation, mathematical computations, and time operations.',

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/src/abstract_utilities/__init__.py

@@ -34,8 +34,7 @@ from .json_utils import (unified_json_loader,
                          get_result_from_data,
                          flatten_json
                          )
-from .read_write_utils import (read_from_file,
-                               write_to_file)
+
 from .directory_utils import *
 from .path_utils import *
 from .file_utils import *
@@ -84,7 +83,8 @@ from .type_utils import (make_bool,
                          get_numbers_comp,
                          is_any_instance,
                          break_string,
-                         MIME_TYPES
+                         MIME_TYPES,
+                         get_if_None
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -108,7 +108,8 @@ from .parse_utils import (num_tokens_from_string,
                           chunk_any_to_tokens,
                           detect_language_from_text,
                           chunk_by_language_context,
-                          search_code)
+                          search_code,
+                          get_within_quotes)
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
@@ -119,3 +120,11 @@ from .path_utils import *
 from .file_utils import *
 from .string_utils import *
 from .import_utils import *
+from .read_write_utils import (read_from_file,
+                               write_to_file,
+                               make_dirs,
+                               make_dirs,
+                               copy_files,
+                               make_path,
+                               run_cmd
+                               )

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/src/abstract_utilities/class_utils/caller_utils.py

@@ -1,4 +1,23 @@
 from .imports import *
+
+def get_initial_caller() -> str:
+    """
+    Return the TRUE original caller: the entrypoint script that launched the program.
+    """
+    main_mod = sys.modules.get('__main__')
+    
+    # interactive environments (REPL) may have no __file__
+    if not main_mod or not hasattr(main_mod, '__file__'):
+        return None
+
+    return os.path.realpath(main_mod.__file__)
+def get_initial_caller_dir() -> str:
+    """
+    Return the directory of the TRUE original entrypoint script.
+    """
+    caller = get_initial_caller()
+    return os.path.dirname(caller) if caller else None
+
 def get_caller(i: Optional[int] = None) -> str:
     """
     Return the filename of the calling frame.

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/src/abstract_utilities/class_utils/global_utils.py

@@ -1,3 +1,22 @@
+import importlib, sys,os
+from .caller_utils import get_initial_caller
+def file_to_module_name(path):
+    path = os.path.realpath(path)
+    # Find a path that exists in sys.path
+    for base in sys.path:
+        base = os.path.realpath(base)
+        if path.startswith(base):
+            rel = os.path.relpath(path, base)
+            mod = os.path.splitext(rel)[0]
+            return mod.replace(os.sep, ".")
+    # fallback (never should be used)
+    return os.path.splitext(os.path.basename(path))[0]
+def get_globals_from_path(module_path: str=None):
+    module_path = module_path or get_initial_caller()
+    module_name = file_to_module_name(module_path)
+    if module_name not in sys.modules:
+        importlib.import_module(module_name)
+    return sys.modules[module_name].__dict__
 def global_registry(name:str,glob:dict):
     global_ledger = if_none_default(string='global_ledger',glob=globals(),default={"registry_names":[],"registry_index":[]})
     if name not in global_ledger['registry_names']:
@@ -31,26 +50,22 @@ def return_globals() -> dict:
         dict: The global variables dictionary.
     """
     return globals()
-def change_glob(var: str, val: any, glob: dict = return_globals()) -> any:
-    """
-    Changes the value of a global variable.
-
-    Args:
-        var (str): The name of the global variable.
-        val (any): The new value.
-        glob (dict, optional): The dictionary of global variables. Defaults to the current globals.
-
-    Returns:
-        any: The new value of the variable.
-    """
+def get_true_globals():
+    return sys.modules['__main__'].__dict__
+def change_glob(var: str, val: any, glob: dict = None) -> any:
+    if glob is None:
+        glob = get_true_globals()
     glob[var] = val
     return val
-def get_globes(string:str='',glob:dict=return_globals()):
-    if string in glob:
-        return glob[string]
-def if_none_default(string:str, default:any,glob:dict=return_globals()):
-    piece = get_globes(string=string,glob=glob)
-    if piece is None:
-        piece = default
-    return change_glob(var=string,val=piece,glob=glob)
 
+def get_globes(string: str='', glob: dict=None):
+    if glob is None:
+        glob = get_true_globals()
+    return glob.get(string)
+def if_none_default(string: str, default: any, glob: dict=None, typ=None):
+    if glob is None:
+        glob = get_true_globals()
+    piece = get_globes(string=string, glob=glob)
+    if piece is None or (typ and not isinstance(piece, typ)):
+        piece = default
+    return change_glob(var=string, val=piece, glob=glob)

abstract_utilities-0.2.2.639/src/abstract_utilities/class_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from ...imports import inspect,os,json,functools,inspect,glob,sys
+from typing import *

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/src/abstract_utilities/directory_utils/src/directory_utils.py

@@ -1,5 +1,21 @@
-
+from pathlib import Path
 from .utils import *
+
+def get_shortest_path(*args):
+    shortest = None
+    args = {arg:str(arg).split('/') for arg in args if arg}
+    for path,spl in args.items():
+        if shortest is None or (len(spl)<len(shortest[-1])):
+            shortest=[path,spl]
+    return shortest[0]
+def get_common_root(paths):
+    """
+    Compute the deepest common parent directory of all sysroots.
+    """
+    paths = [Path(p).resolve() for p in paths]
+    common = os.path.commonpath(paths)
+    return common
+
 def get_dirs(path):
     """
     Get List of Immediate Subdirectories in a Path
@@ -86,7 +102,9 @@ def raw_create_dirs(*paths):
         current_path = safe_join(current_path, part)
         os.makedirs(current_path, exist_ok=True)
     return full_path
+
 mkdirs=raw_create_dirs
 makedirs = mkdirs
 make_dirs = makedirs
+makeAllDirs = raw_create_dirs
 

{abstract_utilities-0.2.2.563 → abstract_utilities-0.2.2.639}/src/abstract_utilities/file_utils/imports/module_imports.py

@@ -4,5 +4,5 @@ from ...ssh_utils import *
 from ...env_utils import *
 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,SingletonMeta,run_pruned_func
+from ...class_utils import if_none_default,if_none_change,get_caller,get_initial_caller_dir, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
 

abstract_utilities-0.2.2.639/src/abstract_utilities/file_utils/src/file_filters/__init__.py

@@ -0,0 +1 @@
+from .ensure_utils import *

abstract_utilities-0.2.2.639/src/abstract_utilities/file_utils/src/file_filters/ensure_utils.py

@@ -0,0 +1,487 @@
+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)
+
+def normalize_listlike(value, typ=list, sep=','):
+    """Normalize comma-separated or iterable values into the desired type."""
+    if value in [True, None, False]:
+        return value
+    if isinstance(value, str):
+        value = [v.strip() for v in value.split(sep) if v.strip()]
+    return typ(value)
+
+def ensure_exts(exts):
+    if exts in [True, None, False]:
+        return exts
+    cleaned = set()
+    for ext in normalize_listlike(exts, list):
+        ext = ext.strip().lower()
+        ext = ext.lstrip(".")      # remove ALL leading dots
+        cleaned.add("." + ext)     # add exactly one
+    return cleaned
+
+def ensure_patterns(patterns):
+    """Normalize pattern list and ensure they are valid globs."""
+    if patterns in [True, None, False]:
+        return patterns
+    patterns = normalize_listlike(patterns, list)
+    out = []
+    for pattern in patterns:
+        if not pattern:
+            continue
+        if '*' not in pattern and '?' not in pattern:
+            # Implicitly make it a prefix match
+            if pattern.startswith('.') or pattern.startswith('~'):
+                pattern = f"*{pattern}"
+            else:
+                pattern = f"{pattern}*"
+        out.append(pattern)
+    return out
+def ensure_directories(*args,**kwargs):
+    directories = []
+    for arg in args:
+        arg_str = str(arg)
+        
+        if run_pruned_func(is_dir,arg_str,**kwargs):
+            directories.append(arg_str)
+        elif run_pruned_func(is_file,arg_str,**kwargs):
+            dirname = os.path.dirname(arg_str)
+            directories.append(dirname)
+    safe_directories = get_dir_filter_kwargs(**kwargs)
+    safe_dirs = safe_directories.get('directories')
+    safe_dirs = if_none_change(safe_dirs or None,get_initial_caller_dir())
+    directories+= make_list(safe_dirs)
+    return list(set([r for r in directories if r]))
+def get_proper_type_str(string):
+    if not string:
+        return None
+    string_lower = string.lower()
+    items = {
+        "d":["dir","dirs","directory","directories","d","dirname"],
+        "f":["file","filepath","file_path","files","filepaths","file_paths","f"]
+     }
+    for key,values in items.items():
+        if string_lower in values:
+            return key
+    init = string_lower[0] if len(string_lower)>0 else None
+    if init in items:
+        return init
+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_allowed_predicate(allowed=None,cfg=None,**kwargs):
+    if allowed != False:
+        if allowed == True:
+            allowed = None
+        allowed = allowed or make_allowed_predicate(cfg=cfg,**kwargs)
+    else:
+        def allowed(*args):
+            return True
+        allowed = allowed
+    return allowed
+def get_globs(items,recursive: bool = True,allowed=None,cfg=None,**kwargs):
+    glob_paths = []
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    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,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    return [item for item in items if item and os.path.isfile(item) and allowed(item)]
+def get_allowed_dirs(items,allowed=False,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    return [item for item in items if item and os.path.isdir(item) and allowed(item)]
+
+def get_filtered_files(items,allowed=None,files = [],cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
+    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 = [],cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    glob_paths = get_globs(items,allowed=allowed,cfg=cfg,**kwargs)
+    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,cfg=None,**kwargs):
+    dirs = get_all_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
+    files = get_allowed_files(items,allowed=allowed,cfg=cfg,**kwargs)
+    nu_files = []
+    for directory in dirs:
+        files += get_filtered_files(directory,allowed=allowed,files=files,cfg=cfg,**kwargs)
+    return files
+def get_all_allowed_dirs(items,allowed=None,cfg=None,**kwargs):
+    allowed = get_allowed_predicate(allowed=allowed,cfg=cfg,**kwargs)
+    dirs = get_allowed_dirs(items,allowed=allowed,cfg=cfg,**kwargs)
+    nu_dirs=[]
+    for directory in dirs:
+        nu_dirs += get_filtered_dirs(directory,allowed=allowed,dirs=nu_dirs,cfg=cfg,**kwargs)
+    return nu_dirs
+
+def make_allowed_predicate(cfg: ScanConfig=None,**kwargs) -> 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.
+    """
+    cfg=cfg or define_defaults(**kwargs)
+    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 "*" not in 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 "*" not in 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 "*" not in cfg.allowed_types:
+            if not any(t in path_str for t in cfg.allowed_types):
+                return False
+        if cfg.exclude_types:
+            if any(t in path_str for t in cfg.exclude_types):
+                return False
+
+        return True
+
+    return allowed
+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 make_allowed_predicate(cfg: ScanConfig = None, **kwargs) -> Callable[[str], bool]:
+    """
+    Build and return a function `allowed(path)` that evaluates the given ScanConfig.
+    Unlike substring-based matching, this version avoids accidental matches inside
+    unrelated names (e.g., 'abstract' matching 'archive').
+    """
+
+    cfg = cfg or define_defaults(**kwargs)
+
+    def allowed(path: str) -> bool:
+        p = Path(path)
+        name = p.name.lower()
+        path_str = str(p).lower()
+
+        # --------------------
+        # A) directory filters
+        # --------------------
+        # Excluded dirs: reject if any directory in the path matches exactly
+        if cfg.exclude_dirs:
+            parts = path_str.split("/")
+            if any(d.lower() in parts for d in cfg.exclude_dirs):
+                print(f"[exclude_dirs] → {path}")
+                return False
+
+        # Allowed dirs: require at least one match (unless "*")
+        if cfg.allowed_dirs and cfg.allowed_dirs != ["*"]:
+            parts = path_str.split("/")
+            if not any(d.lower() in parts for d in cfg.allowed_dirs):
+                print(f"[allowed_dirs] → {path}")
+                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):
+                print(f"[allowed_patterns] → {path}")
+                return False
+
+        if cfg.exclude_patterns:
+            if any(fnmatch.fnmatch(name, pat.lower()) for pat in cfg.exclude_patterns):
+                print(f"[exclude_patterns] → {path}")
+                return False
+
+        # --------------------
+        # C) extension filters
+        # --------------------
+        if p.is_file():
+            ext = p.suffix.lower()
+
+            if cfg.allowed_exts and ext not in cfg.allowed_exts:
+                print(f"[allowed_exts] → {path}")
+                return False
+
+            if cfg.exclude_exts and ext in cfg.exclude_exts:
+                print(f"[exclude_exts] → {path}")
+                return False
+
+        # --------------------
+        # D) type filters (SAFE SEMANTIC MATCHING)
+        # --------------------
+        if cfg.allowed_types and "*" not in cfg.allowed_types:
+            if not any(t.lower() in path_str.split("/") for t in cfg.allowed_types):
+                print(f"[allowed_types] → {path}")
+                return False
+
+        if cfg.exclude_types:
+            if any(t.lower() in path_str.split("/") for t in cfg.exclude_types):
+                print(f"[exclude_types] → {path}")
+                return False
+
+        return True
+
+    # Preserve real name for debugging and repr
+    allowed.__name__ = "allowed"
+    return allowed
+
+def filter_allowed_items(items, cfg=None, **kwargs):
+    """
+    Apply ScanConfig allow/exclude rules to a flat list of file or directory paths.
+    No recursion. No globs. No shell calls.
+    Just pure deterministic filtering.
+    """
+    allowed_items = []
+    allowed = make_allowed_predicate(cfg=cfg, **kwargs)
+    for item in items:
+        if allowed(item):    
+            allowed_items.append(item)
+
+    return allowed_items
+
+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