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

abstract_utilities/env_utils/abstractEnv.py

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

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

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

abstract_utilities/env_utils/imports/imports.py

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

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

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

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

abstract_utilities/file_utils/file_utils/file_filters.py

@@ -1,104 +0,0 @@
-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/file_utils/file_utils/imports.py

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

abstract_utilities/file_utils/file_utils/map_utils.py

@@ -1,29 +0,0 @@
-from .imports import MIME_TYPES,make_list,os
-from .file_filters import get_globs
-def get_file_type(file_path,types=None,default=None):
-    mime_types = {}
-    if types:
-        types = make_list(types)
-        for typ in types:
-            mime_types[typ] = MIME_TYPES.get(typ)
-    else:
-        mime_types = MIME_TYPES
-    
-    if os.path.isfile(file_path):
-        basename = os.path.basename(file_path)
-        filename,ext = os.path.splitext(basename)
-        for file_type,ext_values in mime_types.items():
-            if ext in ext_values:
-                return file_type
-def get_file_map(directory,types=None,default=None):
-    if directory and os.path.isfile(directory):
-       directory = os.path.dirname(directory)
-    all_types = {}
-    files = get_globs(directory)
-    for file in files:
-        file_type = get_file_type(file,types=types,default=default)
-        if file_type:
-            if file_type not in all_types:
-                all_types[file_type] = []
-            all_types[file_type].append(file)
-    return all_types

abstract_utilities/file_utils/imports/__init__.py

@@ -1,5 +0,0 @@
-from .constants import *
-from .imports import *
-from .module_imports import *
-from .classes import *
-from .file_functions import *