abstract-utilities 0.2.2.442__py3-none-any.whl → 0.2.2.688__py3-none-any.whl

abstract_utilities/directory_utils/src/directory_utils.py

@@ -0,0 +1,110 @@
+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
+
+    This function uses the os.walk method to traverse through a directory tree and returns a list of immediate subdirectories
+    within the specified path.
+
+    Parameters:
+    - path (str): The path for which subdirectories need to be retrieved.
+
+    Returns:
+    - subdirectories (list): A list of immediate subdirectories within the specified path.
+
+    Example:
+    subdirs = get_dirs("/path/to/directory")
+    print("Immediate Subdirectories:", subdirs)
+    """
+    from os import walk
+    for (dirpath, dirnames, filenames) in walk(path):
+        return dirnames
+def get_directory(file_path: str) -> str:
+    """
+    Extracts and returns the directory path from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The directory path extracted from the file path.
+    """
+    return os.path.dirname(file_path)
+def if_not_last_child_join(path:str,child:str):
+    """
+    Adds a child path to the given path if it's not already present at the end.
+
+    Args:
+        path (str): The parent path.
+        child (str): The child path to add.
+    
+    Returns:
+        str: The updated path.
+    """
+    if path.endswith(child):
+        return path
+    return simple_path_join(path, child)
+def createFolds(ls: list) -> None:
+    """
+    Creates multiple directories.
+
+    Args:
+        ls (list): The list of directory paths to create.
+    """
+    for k in range(len(ls)):
+        mkdirs(ls[k])
+def list_directory_contents(path: str) -> list:
+    """Returns a list of directory contents or a list with a single file, if the path is a file.
+
+    Args:
+        path (str): The path of the directory or file.
+
+    Returns:
+        list: A list of directory contents or a list with a single file path.
+    """
+    if is_file(path):
+        return [path]
+    elif is_valid_path(path):
+        return os.listdir(path)
+    return [path]
+def is_string_in_dir(path,strings,**kwargs):
+    dirname =  path
+    if is_file(path,**kwargs):
+        dirname = os.path.dirname(path)
+    pieces = [pa for pa in dirname.split('/') if pa and pa in strings]
+    if pieces:
+        return True
+    return False
+def raw_create_dirs(*paths):
+    """Recursively create all directories along the given path."""
+    full_path = os.path.abspath(safe_join(*paths))
+    sub_parts = [p for p in full_path.split(os.sep) if p]
+
+    current_path = "/" if full_path.startswith(os.sep) else ""
+    for part in sub_parts:
+        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/directory_utils/src/name_utils.py

@@ -0,0 +1,43 @@
+from ..imports import *
+from .directory_utils import *
+def get_file_name(file_path: str) -> str:
+    """
+    Retrieves and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file (without extension).
+    """
+    return split_text(get_base_name(file_path))[0]
+def get_abs_name_of_this():
+    """
+    Returns the absolute name of the current module.
+
+    Returns:
+        Path: The absolute name of the current module.
+    """
+    return os.path.abspath(__name__)
+def sanitize_filename(name: str):
+    """
+    Sanitize a filename by removing invalid characters.
+    
+    Args:
+    name (str): Filename to sanitize.
+    
+    Returns:
+    str: Sanitized filename.
+    """
+    return re.sub(r'[\\/*?:"<>|]', "", name)
+def get_base_name(file_path: str) -> str:
+    """
+    Extracts and returns the base name of a file from a given file path.
+
+    Args:
+        file_path (str): A string representing the file path.
+
+    Returns:
+        str: The base name of the file.
+    """
+    return os.path.basename(file_path)

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/dynimport.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 from functools import lru_cache
 from typing import *
-import importlib, sys, os, sys
+import importlib, sys, os, sys,inspect
 from typing import Optional
 from importlib import import_module
 from .type_utils import make_list

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/__init__.py

@@ -4,3 +4,5 @@ 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_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:

abstract_utilities/file_utils/file_utils/find_collect.py

@@ -0,0 +1,154 @@
+from .imports import *
+from .filter_params import *
+from .file_filters import enumerate_source_files
+
+
+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_find_cmd(
+    directory: str,
+    *,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,  # 'f' or 'd'
+    name: Optional[str] = None,
+    size: Optional[str] = None,
+    mtime: Optional[str] = None,
+    perm: Optional[str] = None,
+    user: Optional[str] = None,
+    **kwargs
+) -> str:
+    """Constructs a Unix `find` command string from keyword args."""
+    cmd = [f"find {directory}"]
+
+    if depth is not None:
+        cmd += [f"-mindepth {depth}", f"-maxdepth {depth}"]
+    else:
+        if mindepth is not None:
+            cmd.append(f"-mindepth {mindepth}")
+        if maxdepth is not None:
+            cmd.append(f"-maxdepth {maxdepth}")
+
+    if file_type in ("f", "d"):
+        cmd.append(f"-type {file_type}")
+    if name:
+        cmd.append(f"-name '{name}'")
+    if size:
+        cmd.append(f"-size {size}")
+    if mtime:
+        cmd.append(f"-mtime {mtime}")
+    if perm:
+        cmd.append(f"-perm {perm}")
+    if user:
+        cmd.append(f"-user {user}")
+
+    return " ".join(cmd)
+
+
+def collect_globs(
+    directory: str,
+    cfg: Optional["ScanConfig"] = None,
+    *,
+    exts: Optional[Set[str]] = None,
+    patterns: Optional[List[str]] = None,
+    mindepth: Optional[int] = None,
+    maxdepth: Optional[int] = None,
+    depth: Optional[int] = None,
+    file_type: Optional[str] = None,
+    user_at_host: Optional[str] = None,
+    add: bool = False,
+    **kwargs
+) -> List[str]:
+    """
+    Collect file or directory paths using either:
+      - local recursive logic (rglob)
+      - or remote shell call (find via run_cmd)
+    """
+    cfg = cfg or define_defaults(add=add)
+    directory = str(directory)
+    exts = ensure_exts(exts)
+    patterns = ensure_patterns(patterns)
+
+    # Remote path via SSH
+    if user_at_host:
+        find_cmd = get_find_cmd(
+            directory,
+            mindepth=mindepth,
+            maxdepth=maxdepth,
+            depth=depth,
+            file_type=file_type,
+            **{k: v for k, v in kwargs.items() if v},
+        )
+        return run_cmd(find_cmd, user_at_host=user_at_host)
+
+    # Local path (Python-native walk)
+    root = Path(directory)
+    results = []
+    for p in root.rglob("*"):
+        if file_type == "f" and not p.is_file():
+            continue
+        if file_type == "d" and not p.is_dir():
+            continue
+        if exts and p.suffix.lower() not in exts:
+            continue
+        if patterns and not any(p.match(pat) for pat in patterns):
+            continue
+        results.append(str(p.resolve()))
+
+    return sorted(results)

abstract_utilities/file_utils/file_utils/imports/__init__.py

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