abstract-utilities 0.2.2.449__py3-none-any.whl → 0.2.2.476__py3-none-any.whl

abstract_utilities/{compare_utils.py → compare_utils/compare_utils.py}

@@ -9,7 +9,7 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import string
-from .type_utils import is_number,make_list
+from ..type_utils import is_number,make_list
 def get_comp(string:str, string_2:str):
     """
     Calculates the similarity between two strings.

abstract_utilities/compare_utils/find_value.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+from typing import Any, Callable, Iterable, Iterator, List, Tuple, Union, Dict
+import re
+
+JSONLike = Union[dict, list, tuple, set, str, int, float, bool, None]
+PathType = Tuple[Union[str, int], ...]  # ('window_title',) or ('tabs', 2, 'name'), etc.
+
+def iter_values(obj: JSONLike, path: PathType = ()) -> Iterator[Tuple[PathType, Any]]:
+    """
+    Depth-first walk of nested dict/list/tuple/set. Yields (path, value) for every leaf.
+    Path items are str (dict key) or int (list index).
+    """
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            yield from iter_values(v, path + (k,))
+    elif isinstance(obj, (list, tuple)):
+        for i, v in enumerate(obj):
+            yield from iter_values(v, path + (i,))
+    elif isinstance(obj, set):
+        for v in obj:
+            # sets are unordered/no index – use a pseudo-key
+            yield from iter_values(v, path + ('<setitem>',))
+    else:
+        # leaf (scalar)
+        yield path, obj
+
+def _mk_predicate(
+    terms: Iterable[str] | None = None,
+    *,
+    case_insensitive: bool = True,
+    substring: bool = True,
+    regex: bool = False
+) -> Callable[[Any], bool]:
+    """
+    Build a predicate that checks a scalar value against terms.
+    """
+    terms = list(terms or [])
+    if regex:
+        flags = re.IGNORECASE if case_insensitive else 0
+        patterns = [re.compile(t, flags) for t in terms]
+        def pred(value: Any) -> bool:
+            if not isinstance(value, str):
+                return False
+            return any(p.search(value) for p in patterns)
+        return pred
+
+    # string contains (or equals)
+    def pred(value: Any) -> bool:
+        if not isinstance(value, str):
+            return False
+        v = value.lower() if case_insensitive else value
+        for t in terms:
+            t2 = t.lower() if case_insensitive else t
+            if (t2 in v) if substring else (t2 == v):
+                return True
+        return False
+
+    return pred
+
+def search_values(
+    obj: JSONLike,
+    *,
+    terms: Iterable[str],
+    case_insensitive: bool = True,
+    substring: bool = True,
+    regex: bool = False,
+) -> List[Tuple[PathType, Any]]:
+    """
+    Return all (path, value) where value matches any term.
+    """
+    pred = _mk_predicate(terms, case_insensitive=case_insensitive, substring=substring, regex=regex)
+    results: List[Tuple[PathType, Any]] = []
+    for p, v in iter_values(obj):
+        if pred(v):
+            results.append((p, v))
+    return results
+
+def any_match(
+    obj: JSONLike,
+    *,
+    terms: Iterable[str],
+    **kw
+) -> bool:
+    """Fast boolean check."""
+    pred = _mk_predicate(terms, **kw)
+    for _, v in iter_values(obj):
+        if pred(v):
+            return True
+    return False
+def get_first_match(obj: JSONLike, *, terms: Iterable[str], **kw) -> Optional[Any]:
+    """Return just the first matching value, or None."""
+    pred = _mk_predicate(terms, **kw)
+    for _, v in iter_values(obj):
+        if pred(v):
+            return v
+    return None
+
+def get_all_match(obj: JSONLike, *, terms: Iterable[str], **kw) -> List[Any]:
+    """Return all matching values as a flat list."""
+    pred = _mk_predicate(terms, **kw)
+    results: List[Any] = []
+    for _, v in iter_values(obj):
+        if pred(v):
+            results.append(v)
+    return results

abstract_utilities/dynimport.py

@@ -1,12 +1,12 @@
 # abstract_utilities/dynimport.py
 from __future__ import annotations
-import importlib, sys, os
 from functools import lru_cache
-from typing import Any, Callable, Iterable, Optional
-import inspect, sys
+from typing import *
+import importlib, sys, os, sys,inspect
+from typing import Optional
 from importlib import import_module
 from .type_utils import make_list
-from .robust_readers import get_for_all_tabs,call_for_all_tabs
+
 class _LazyAttr:
     """Lazy resolver proxy to avoid import-time cycles.
     First use triggers actual import & attribute lookup.
@@ -181,14 +181,6 @@ def get_many_module_imports(*args):
             all_modules[symbol] = get_abstract_import(module = module,symbol=symbol)
     import_symbols(all_modules)
     return all_modules
-def get_caller_path():
-    frame = inspect.stack()[1]
-    return os.path.abspath(frame.filename)
-def get_caller_dir():
-    frame = inspect.stack()[1]
-    abspath = os.path.abspath(frame.filename)
-    return os.path.dirname(abspath)
-def call_for_all_tabs():
-    
-    root = get_caller_dir()
-    get_for_all_tabs(root)
+
+
+

abstract_utilities/env_utils/__init__.py

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

abstract_utilities/env_utils/abstractEnv.py

@@ -0,0 +1,129 @@
+from .imports import *
+class abstractEnv:
+    def __init__(self,key='MY_PASSWORD',file_name=None,path=os.getcwd(),deep_scan=False):
+        file_name = file_name or '.env'
+        self.re_initialize(file_name=file_name,key=key,path=path,deep_scan=deep_scan)
+    def re_initialize(self,key='MY_PASSWORD',file_name='.env',path=os.getcwd(),deep_scan=False):
+        """
+        Initializes an AbstractEnv object to manage environment variables.
+
+        Args:
+            key (str, optional): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+            file_name (str, optional): The name of the .env file. Defaults to '.env'.
+            path (str, optional): The path where the .env file is located. Defaults to the current working directory.
+        """
+
+        self.key = key or 'MY_PASSWORD'
+
+        file_name = file_name or '.env'
+        self.key = key or 'MY_PASSWORD'
+        self.deep_scan=deep_scan
+        self.current_folder = os.getcwd()
+        if path and os.path.isfile(path):
+            self.file_name = os.path.basename(path)
+            self.path = os.path.dirname(path)
+        else:
+            self.path = path or self.current_folder
+            self.file_name = file_name or '.env'
+        self.start_path_env = os.path.join(self.path,self.file_name)
+        self.home_folder = os.path.expanduser("~")
+        self.envy_all = os.path.join(self.home_folder,'.envy_all')
+        self.directories = self.get_directories()
+        self.env_value = self.find_and_read_env_file(key=self.key,file_name=self.file_name, path=self.path,initialize=False)
+
+    def find_and_read_env_file(self,key:str=None, file_name:str=None, path=None,initialize=True,deep_scan=False):
+        """
+        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
+        # Try to find the file in the start_path
+        key = key or self.key
+        path = path or self.start_path_env
+        file_name = file_name or self.file_name
+        if initialize:
+            self.re_initialize(key=key,file_name=file_name,path=path)
+        for directory in self.directories:
+            if directory and os.path.isdir(directory) and self.file_name:
+                env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(env_path):
+                    value = self.search_for_env_key(key=key,path=env_path)
+                self.env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(self.env_path):
+                    value = self.search_for_env_key(key=key,path=self.env_path,deep_scan=deep_scan)
+                    if value:
+                        return value
+    def get_directories(self):
+        """
+        Retrieves a list of directories to search for the .env file.
+
+        Returns:
+            list: A list of directories including the specified path, current folder, home folder, and '.envy_all' directory.
+        """
+        directories=[]
+        for directory in [self.path,self.current_folder,self.home_folder,self.envy_all]:
+            if os.path.isdir(directory) and directory not in directories:
+                directories.append(directory)
+        return directories
+    
+
+    def search_for_env_key(self,key:str=None,path:str=None,deep_scan=False):
+
+        """
+        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.
+        """
+
+        highest = [None,0,0.0]
+        key = key or self.default_env_key
+        path = path or self.start_path_env
+        if path and os.path.isfile(path):
+            with open(path, "r") as f:
+                for line in f:
+                    line_key,line_value = split_eq(line)
+                    # If the line contains the key, return the value after stripping extra characters
+                    if line_key == key:
+                        return line_value
+                    if deep_scan:
+                        line_keys = []
+                        key_parts=0
+                        for key_part in key.split('_'):
+                            line_keys.append([])
+                            if key_part in line_key:
+                                line_keys[-1].append(line_key)
+                                key_parts+=len(key_part)
+                        if float(key_parts/len(key))>=0.5 and key_parts >highest[1]:
+                            highest = [line_value,key_parts]
+                    if deep_scan and highest[0] != None:
+                        return line_value
+    def get_env_value(key:str=None,path:str=os.getcwd(),file_name:str=None):
+        """
+        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, path=path_ls)
+
+AbstractEnv = abstractEnv

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]: