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

abstract_utilities/directory_utils/src/size_utils.py

@@ -0,0 +1,57 @@
+from ..imports import *
+from .name_utils import *
+def get_os_info():
+    """
+    Get Operating System Information
+
+    This function retrieves information about the current operating system, including its name and bit size.
+
+    Returns:
+    - os_info (dict): A dictionary containing the operating system information.
+                      Keys:
+                      - "operating_system" (str): The name of the operating system (e.g., "Windows", "Linux", "Darwin").
+                      - "bit_size" (str): The bit size of the operating system (e.g., "32bit", "64bit").
+
+    Example:
+    os_info = get_os_info()
+    print("Operating System:", os_info["operating_system"])
+    print("Bit Size:", os_info["bit_size"])
+    """
+    os_name = platform.system()
+    bit_size = platform.architecture()[0]
+    return {"operating_system": os_name, "bit_size": bit_size}
+def mkGb(k) -> float:
+    """
+    Converts a value to Gigabytes (GB).
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB.
+    """
+    return float(float(k)*(10**9))
+
+def mkGbTrunk(k) -> float:
+    """
+    Converts a value to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (float): The value to convert to GB.
+
+    Returns:
+        float: The value converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(k), 5)
+
+def mkGbTrunFroPathTot(k) -> float:
+    """
+    Fetches the file size from a path, converts it to Gigabytes (GB) and truncates the result to five decimal places.
+
+    Args:
+        k (str): The file path.
+
+    Returns:
+        float: The file size converted to GB and truncated to five decimal places.
+    """
+    return trunc(mkGb(s.path.getsize(k)), 5)

abstract_utilities/directory_utils/src/utils.py

@@ -0,0 +1,116 @@
+from ..imports import *
+def split_text(string: str) -> tuple:
+    """
+    Splits a string into its base name and extension and returns them as a tuple.
+
+    Args:
+        string (str): A string to be split, typically representing a file name.
+
+    Returns:
+        tuple: A tuple containing the base name and extension of the input string.
+    """
+    return os.path.splitext(string)
+def get_ext(file_path: str) -> str:
+    """
+    Retrieves and returns the extension of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The extension of the file (including the dot).
+    """
+    return split_text(get_base_name(file_path))[1]
+
+def get_slash():
+    """
+    Returns the appropriate file path separator depending on the current operating system.
+    """
+    slash = '/'  # Assume a Unix-like system by default
+    if slash not in get_current_path():
+        slash = '\\'  # Use backslash for Windows systems
+    return slash
+def get_current_path():
+    """
+    Returns the current working directory.
+    
+    Returns:
+        str: The current working directory.
+    """
+    return os.getcwd()
+
+def get_home_folder():
+    """
+    Returns the path to the home directory of the current user.
+    
+    Returns:
+        str: The path to the home directory.
+    """
+    return os.path.expanduser("~")
+def simple_path_join(path_A:str, path_B:str):
+    """
+    Join two paths using the appropriate file path separator.
+
+    Args:
+        path_A (str): The first path to join.
+        path_B (str): The second path to join.
+    
+    Returns:
+        str: The joined path.
+    """
+    return os.path.join(str(path_A), str(path_B))
+
+def path_join(path_A, path_B=None):
+    """
+    Joins two paths or a list of paths using the appropriate file path separator.
+
+    Args:
+        path_A (str or list): The first path or list of paths to join.
+        path_B (str, optional): The second path to join. Defaults to None.
+    
+    Returns:
+        str: The joined path.
+    """
+    if path_B is not None:  # If path_B is provided, join path_A and path_B
+        return simple_path_join(path_A, path_B)
+    if isinstance(path_A, list):  # If path_A is a list, join all paths in the list
+        path = path_A[0]
+        for k in range(1, len(path_A)):
+            path = simple_path_join(path, path_A[k])
+        return path
+def update_global_variable(name: str, value) -> None:
+    """Updates the global variable with the provided name and value.
+
+    Args:
+        name (str): The name of the global variable.
+        value: The value to assign to the global variable.
+
+    Returns:
+        None
+    """
+    globals()[name] = value
+
+
+def trunc(a: float, x: int) -> float:
+    """
+    Truncates a float number to a specific number of decimal places.
+
+    Args:
+        a (float): The number to truncate.
+        x (int): The number of decimal places to retain.
+
+    Returns:
+        float: The truncated float number.
+    """
+    temp = str(a)
+    for i in range(len(temp)):
+        if temp[i] == '.':
+            try:
+                return float(temp[:i+x+1])
+            except:
+                return float(temp)
+    return float(temp)
+
+
+
+

abstract_utilities/directory_utils/utils.py

@@ -0,0 +1,116 @@
+from ..imports import *
+def split_text(string: str) -> tuple:
+    """
+    Splits a string into its base name and extension and returns them as a tuple.
+
+    Args:
+        string (str): A string to be split, typically representing a file name.
+
+    Returns:
+        tuple: A tuple containing the base name and extension of the input string.
+    """
+    return os.path.splitext(string)
+def get_ext(file_path: str) -> str:
+    """
+    Retrieves and returns the extension of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The extension of the file (including the dot).
+    """
+    return split_text(get_base_name(file_path))[1]
+
+def get_slash():
+    """
+    Returns the appropriate file path separator depending on the current operating system.
+    """
+    slash = '/'  # Assume a Unix-like system by default
+    if slash not in get_current_path():
+        slash = '\\'  # Use backslash for Windows systems
+    return slash
+def get_current_path():
+    """
+    Returns the current working directory.
+    
+    Returns:
+        str: The current working directory.
+    """
+    return os.getcwd()
+
+def get_home_folder():
+    """
+    Returns the path to the home directory of the current user.
+    
+    Returns:
+        str: The path to the home directory.
+    """
+    return os.path.expanduser("~")
+def simple_path_join(path_A:str, path_B:str):
+    """
+    Join two paths using the appropriate file path separator.
+
+    Args:
+        path_A (str): The first path to join.
+        path_B (str): The second path to join.
+    
+    Returns:
+        str: The joined path.
+    """
+    return os.path.join(str(path_A), str(path_B))
+
+def path_join(path_A, path_B=None):
+    """
+    Joins two paths or a list of paths using the appropriate file path separator.
+
+    Args:
+        path_A (str or list): The first path or list of paths to join.
+        path_B (str, optional): The second path to join. Defaults to None.
+    
+    Returns:
+        str: The joined path.
+    """
+    if path_B is not None:  # If path_B is provided, join path_A and path_B
+        return simple_path_join(path_A, path_B)
+    if isinstance(path_A, list):  # If path_A is a list, join all paths in the list
+        path = path_A[0]
+        for k in range(1, len(path_A)):
+            path = simple_path_join(path, path_A[k])
+        return path
+def update_global_variable(name: str, value) -> None:
+    """Updates the global variable with the provided name and value.
+
+    Args:
+        name (str): The name of the global variable.
+        value: The value to assign to the global variable.
+
+    Returns:
+        None
+    """
+    globals()[name] = value
+
+
+def trunc(a: float, x: int) -> float:
+    """
+    Truncates a float number to a specific number of decimal places.
+
+    Args:
+        a (float): The number to truncate.
+        x (int): The number of decimal places to retain.
+
+    Returns:
+        float: The truncated float number.
+    """
+    temp = str(a)
+    for i in range(len(temp)):
+        if temp[i] == '.':
+            try:
+                return float(temp[:i+x+1])
+            except:
+                return float(temp)
+    return float(temp)
+
+
+
+

abstract_utilities/env_utils/imports/imports.py

@@ -1,8 +1,10 @@
-import os
+from ...imports import os
 from dotenv import load_dotenv
-from ...string_clean import eatAll,eatInner,eatOuter,safe_split
+from ...ssh_utils import is_file
+from ...string_utils import eatAll,eatInner,eatOuter
+from ...safe_utils import 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
+from ...directory_utils import get_slash,path_join,if_not_last_child_join,get_home_folder,simple_path_join
 DEFAULT_FILE_NAME = '.env'
 DEFAULT_KEY = 'MY_PASSWORD'

abstract_utilities/error_utils/__init__.py

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

abstract_utilities/error_utils/error_utils.py

@@ -0,0 +1,25 @@
+from .imports import *
+def try_func(func, *args, logger=None, level='error', **kwargs):
+    """
+    Execute a function with try-except and log exceptions.
+    
+    Args:
+        func: Function to execute.
+        *args: Positional arguments for the function.
+        logger: Logger object, logger method (e.g., logger.error), or None.
+        level (str): Logging level for exceptions (e.g., 'error').
+        **kwargs: Keyword arguments for the function.
+    
+    Returns:
+        Result of the function if successful.
+    
+    Raises:
+        Exception: If the function fails and logger is used to log the error.
+    """
+    log_callable = get_logger_callable(logger=logger, level=level)
+    try:
+        return func(*args, **kwargs)
+    except Exception as e:
+        if log_callable:
+            log_callable(f"Exception in {func.__name__}: {str(e)}")
+        raise

abstract_utilities/error_utils/imports/__init__.py

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

abstract_utilities/error_utils/imports/imports.py

@@ -0,0 +1 @@
+

abstract_utilities/error_utils/imports/module_imports.py

@@ -0,0 +1 @@
+from ...log_utils import get_logger_callable

abstract_utilities/file_utils/__init__.py

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

abstract_utilities/file_utils/file_utils/imports/module_imports.py

@@ -6,7 +6,8 @@ from ....ssh_utils import *
 from ....env_utils import *
 from ....read_write_utils import *
 from ....abstract_classes import SingletonMeta
-
+from ....string_utils import get_from_kwargs
+from ....abstract_classes import run_pruned_func
 from ....class_utils import get_caller, get_caller_path, get_caller_dir
 
 

abstract_utilities/file_utils/file_utils/type_checks.py

@@ -1,34 +1,37 @@
 from .imports import *
 
+def get_user_pass_host_key(**kwargs):
+    args = ['password','user_at_host','host','key','user']
+    kwargs['del_kwarg']=kwargs.get('del_kwarg',False)
+    values,kwargs = get_from_kwargs(*args,**kwargs)
+    return values
 
 # --- Base remote checker -----------------------------------------------------
-def _remote_test(path: str, test_flag: str, user_at_host: str, timeout: int = 5) -> bool:
+def _remote_test(path: str, test_flag: str, timeout: int = 5,*args, **kwargs) -> bool:
     """
     Run a remote shell test (e.g. -f, -d) via SSH.
     Returns True if test succeeds, False otherwise.
     """
-    cmd = f"[ {test_flag} {shlex.quote(path)} ] && echo 1 || echo 0"
     try:
-        result = subprocess.check_output(
-            ["ssh", user_at_host, cmd],
-            stderr=subprocess.DEVNULL,
-            text=True,
-            timeout=timeout
-        ).strip()
-        return result == "1"
+        kwargs['cmd']=f"[ {test_flag} {shlex.quote(path)} ] && echo 1 || echo 0"
+        kwargs['text']=True
+        kwargs['timeout']=timeout
+        kwargs['stderr']=subprocess.DEVNULL
+        result = run_pruned_func(run_cmd,**kwargs)
+        return result.strip() == "1"
     except Exception:
         return False
 
 
 # --- Individual path checks --------------------------------------------------
-def is_remote_file(path: str, user_at_host: str) -> bool:
+def is_remote_file(path: str,*args, **kwargs) -> bool:
     """True if remote path is a file."""
-    return _remote_test(path, "-f", user_at_host)
+    return _remote_test(path, "-f", **kwargs)
 
 
-def is_remote_dir(path: str, user_at_host: str) -> bool:
+def is_remote_dir(path: str,*args, **kwargs) -> bool:
     """True if remote path is a directory."""
-    return _remote_test(path, "-d", user_at_host)
+    return _remote_test(path, "-d", **kwargs)
 
 
 def is_local_file(path: str) -> bool:
@@ -42,33 +45,40 @@ def is_local_dir(path: str) -> bool:
 
 
 # --- Unified interface -------------------------------------------------------
-def is_file(path: str,*args, user_at_host: Optional[str] = None,**kwargs) -> bool:
+
+def is_file(path: str,*args,**kwargs) -> bool:
     """Determine if path is a file (works local or remote)."""
-    if user_at_host:
-        return is_remote_file(path, user_at_host)
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_file(path, **kwargs)
     return is_local_file(path)
 
 
-def is_dir(path: str, *args,user_at_host: Optional[str] = None,**kwargs) -> bool:
+def is_dir(path: str, *args,**kwargs) -> bool:
     """Determine if path is a directory (works local or remote)."""
-    if user_at_host:
-        return is_remote_dir(path, user_at_host)
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_dir(path, **kwargs)
     return is_local_dir(path)
 
-
+def is_exists(path: str, *args,**kwargs) -> bool:
+    if is_file(path,**kwargs):
+        return True
+    if is_dir(path,**kwargs):
+        return True
+    return False
 # --- Optional: keep your original all-in-one wrapper ------------------------
 def check_path_type(
     path: str,
-    user_at_host: Optional[str] = None,
+    *args,
+    **kwargs
 ) -> str:
     """
     Return 'file', 'directory', 'missing', or 'unknown'.
     Uses isolated is_file/is_dir functions.
     """
-    if user_at_host:
-        if is_remote_file(path, user_at_host):
+    if get_user_pass_host_key(**kwargs):
+        if is_remote_file(path,**kwargs):
             return "file"
-        elif is_remote_dir(path, user_at_host):
+        elif is_remote_dir(path,**kwargs):
             return "directory"
         else:
             return "missing"

abstract_utilities/file_utils/imports/constants.py

@@ -1,12 +1,40 @@
 from .imports import *
 from .module_imports import *
+# -------------------------
+# Config dataclass
+# -------------------------
+
 @dataclass
 class ScanConfig:
     allowed_exts: Set[str]
-    unallowed_exts: Set[str]
+    exclude_exts: Set[str]
+    allowed_types: Set[str]
     exclude_types: Set[str]
+    allowed_dirs: List[str] = field(default_factory=list)
     exclude_dirs: List[str] = field(default_factory=list)
+    allowed_patterns: List[str] = field(default_factory=list)
     exclude_patterns: List[str] = field(default_factory=list)
+
+@dataclass
+class SearchParams(ScanConfig):
+    directories: List[str] = field(default_factory=list)
+    add: bool = False
+    recursive: bool = True
+    strings: List[str] = field(default_factory=list)
+    total_strings: bool = False
+    parse_lines: bool = False
+    spec_line: Union[bool, int] = False
+    get_lines: bool = False
+
+@dataclass
+class AllParams(SearchParams):
+    cfg = None
+    allowed: Optional[Callable[[str], bool]] = None
+    include_files: bool = True
+    recursive: bool = True
+# -------------------------
+# Default sets
+# -------------------------
 DEFAULT_ALLOWED_EXTS: Set[str] = {
     ".py", ".pyw",                             # python
     ".js", ".jsx", ".ts", ".tsx", ".mjs",      # JS/TS
@@ -24,11 +52,15 @@ DEFAULT_EXCLUDE_TYPES: Set[str] = {
 }
 
 # 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}
+_unallowed = set(get_media_exts(DEFAULT_EXCLUDE_TYPES)) | {
+    ".bak", ".shp", ".cpg", ".dbf", ".shx", ".geojson",
+    ".pyc", ".prj", ".sbn", ".sbx"
+}
+DEFAULT_EXCLUDE_EXTS = {e.split('.')[-1] for e in _unallowed if e not in DEFAULT_ALLOWED_EXTS}
 
 DEFAULT_EXCLUDE_DIRS: Set[str] = {
-    "node_modules", "old","__pycache__", "backups", "backup", "backs", "trash", "depriciated", "old", "__init__"
+    "node_modules", "old","__pycache__", "backups", "backup",
+    "backs", "trash", "depriciated", "old", "__init__"
 }
 
 DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
@@ -37,3 +69,51 @@ DEFAULT_EXCLUDE_PATTERNS: Set[str] = {
 REMOTE_RE = re.compile(r"^(?P<host>[^:\s]+@[^:\s]+):(?P<path>/.*)$")
 AllowedPredicate = Optional[Callable[[str], bool]]
 DEFAULT_EXCLUDE_FILE_PATTERNS=DEFAULT_EXCLUDE_PATTERNS
+DEFAULT_ALLOWED_PATTERNS: List[str] = ["*"]
+DEFAULT_ALLOWED_DIRS: List[str] = ["*"]
+DEFAULT_ALLOWED_TYPES: List[str] = ["*"]
+CANONICAL_MAP = {
+    "directories": ["directory", "directories", "dir","dirs","directory","directories","d","dirname", "paths", "path","roots","root"],
+    "files":["file","filepath","file_path","files","filepaths","file_paths","paths", "path","f"],
+    "allowed_exts": ["allow_ext", "allowed_ext", "include_ext", "include_exts", "exts_allowed"],
+    "exclude_exts": ["exclude_ext", "excluded_ext", "excluded_exts", "unallowed_ext", "unallowed_exts"],
+    "allowed_types": ["allow_type", "allowed_type", "include_type", "include_types", "types_allowed"],
+    "exclude_types": ["exclude_type", "excluded_type", "excluded_types", "unallowed_type", "unallowed_types"],
+    "allowed_dirs": ["allow_dir", "allowed_dir", "include_dir", "include_dirs", "dirs_allowed"],
+    "exclude_dirs": ["exclude_dir", "excluded_dir", "excluded_dirs", "unallowed_dir", "unallowed_dirs"],
+    "allowed_patterns": ["allow_pattern", "allowed_pattern", "include_pattern", "include_patterns", "patterns_allowed"],
+    "exclude_patterns": ["exclude_pattern", "excluded_pattern", "excluded_patterns", "unallowed_pattern", "unallowed_patterns"],
+    "add":["add"],
+    "cfg":["cfg"],
+    "recursive":["recursive"],
+    "strings":["strings"],
+    "total_strings":["total_strings"],
+    "parse_lines":["parse_lines"],
+    "spec_line":["spec_line"],
+    "get_lines":["get_lines"]
+}
+DEFAULT_ALLOWED_EXCLUDE_MAP={
+    "allowed_exts": {"default":DEFAULT_ALLOWED_EXTS,"type":type(DEFAULT_ALLOWED_EXTS),"canonical":CANONICAL_MAP.get("allowed_exts")},
+    "exclude_exts": {"default":DEFAULT_EXCLUDE_EXTS,"type":type(DEFAULT_EXCLUDE_EXTS),"canonical":CANONICAL_MAP.get("exclude_exts")},
+    "allowed_types": {"default":DEFAULT_ALLOWED_TYPES,"type":type(DEFAULT_ALLOWED_TYPES),"canonical":CANONICAL_MAP.get("allowed_types")},
+    "exclude_types": {"default":DEFAULT_EXCLUDE_TYPES,"type":type(DEFAULT_EXCLUDE_TYPES),"canonical":CANONICAL_MAP.get("exclude_types")},
+    "allowed_dirs": {"default":DEFAULT_ALLOWED_DIRS,"type":type(DEFAULT_ALLOWED_DIRS),"canonical":CANONICAL_MAP.get("allowed_dirs")},
+    "exclude_dirs": {"default":DEFAULT_EXCLUDE_DIRS,"type":type(DEFAULT_EXCLUDE_DIRS),"canonical":CANONICAL_MAP.get("exclude_dirs")},
+    "allowed_patterns": {"default":DEFAULT_ALLOWED_PATTERNS,"type":type(DEFAULT_ALLOWED_PATTERNS),"canonical":CANONICAL_MAP.get("allowed_patterns")},
+    "exclude_patterns": {"default":DEFAULT_EXCLUDE_PATTERNS,"type":type(DEFAULT_EXCLUDE_PATTERNS),"canonical":CANONICAL_MAP.get("exclude_patterns")},
+}
+DEFAULT_CANONICAL_MAP={
+    "directories":{"default":[],"type":list,"canonical":CANONICAL_MAP.get("directories")},
+    "files":{"default":[],"type":list,"canonical":CANONICAL_MAP.get("files")},
+    **DEFAULT_ALLOWED_EXCLUDE_MAP,
+    "allowed":{"default":None,"type":bool,"canonical":CANONICAL_MAP.get("allowed")},
+    "add":{"default":False,"type":bool,"canonical":CANONICAL_MAP.get("add")},
+    "recursive":{"default":True,"type":bool,"canonical":CANONICAL_MAP.get("recursive")},
+    "strings":{"default":None,"type":list,"canonical":CANONICAL_MAP.get("strings")},
+    "total_strings":{"default":False,"type":bool,"canonical":CANONICAL_MAP.get("total_strings")},
+    "parse_lines":{"default":False,"type":bool,"canonical":CANONICAL_MAP.get("parse_lines")},
+    "spec_line":{"default":False,"type":bool,"canonical":CANONICAL_MAP.get("spec_line")},
+    "get_lines":{"default":False,"type":bool,"canonical":CANONICAL_MAP.get("get_lines")},
+}
+
+

abstract_utilities/file_utils/imports/imports.py

@@ -6,23 +6,17 @@
 # ============================================================
 
 
-import os
-import sys, importlib,os
-import sys, importlib, os, inspect
+from ...imports import *
 from pathlib import Path
-import os,sys
+
 
 
 
 from typing import *
-import re
 
 from typing import *
 from types import MethodType
-import os,re, sys, importlib, inspect, os, importlib.util, hashlib
-import os,tempfile,shutil,logging,ezodf,fnmatch,pytesseract,pdfplumber
-import pandas as pd
-import geopandas as gpd
+
 from datetime import datetime
 
 from typing import *
@@ -30,8 +24,6 @@ from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
 from pdf2image import convert_from_path   # only used for OCR fallback
 # ---- Core standard library modules -------------------------
-import os, sys, re, shlex, glob, platform, textwrap, subprocess, inspect, json, time
-import tempfile, shutil, logging, pathlib, fnmatch, importlib, importlib.util, types
 
 from datetime import datetime
 from types import ModuleType
@@ -44,18 +36,11 @@ from typing import (
 )
 
 # ---- Common 3rd-party dependencies --------------------------
-import pandas as pd
-import geopandas as gpd
-import pytesseract
-import pdfplumber
-import PyPDF2
-import ezodf
 from pdf2image import convert_from_path
 from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
 
 # ---- Helpers ------------------------------------------------
-import textwrap as tw
 from pprint import pprint
 
 # ============================================================

abstract_utilities/file_utils/imports/module_imports.py

@@ -1,13 +1,8 @@
-from .imports import *
-from ...string_clean import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
 from ...ssh_utils import *
 from ...env_utils import *
-from ...read_write_utils import *
-from ...abstract_classes import SingletonMeta
+from ...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
-from ...ssh_utils import run_cmd
+from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func
 
-__all__ = [name for name in globals() if not name.startswith("_")]

abstract_utilities/file_utils/module_imports.py

@@ -0,0 +1,12 @@
+from .imports import *
+from ...string_clean import eatAll
+from ...list_utils import make_list
+from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
+from ...ssh_utils import *
+from ...env_utils import *
+from ...read_write_utils import *
+from ...abstract_classes import SingletonMeta
+from ...log_utils import get_logFile
+from ...class_utils import get_caller, get_caller_path, get_caller_dir
+from ...ssh_utils import run_cmd
+

abstract_utilities/file_utils/src/__init__.py

@@ -0,0 +1,8 @@
+from .file_filters import *
+from .filter_params import *
+from .map_utils import *
+from .pdf_utils import *
+from .file_reader import *
+from .find_collect import *
+from .initFunctionsGen import call_for_all_tabs,get_for_all_tabs
+