abstract-utilities 0.2.2.507__py3-none-any.whl → 0.2.2.510__py3-none-any.whl

abstract_utilities/import_utils/src/clean_imports.py

@@ -96,7 +96,6 @@ def get_clean_import_string(import_pkg_js,fill_nulines=False,get_locals=False):
     for key,values in import_pkg_js.items():
         if key not in ['context','nulines']:
             imports = None
-            input(values)
             imp_values= values.get('imports')
             if key == 'import':
                 imports = f'import {imp_values}'

abstract_utilities/json_utils/imports/module_imports.py

@@ -1,5 +1,5 @@
 from ...read_write_utils import check_read_write_params, read_from_file, write_to_file
 from ...compare_utils import get_closest_match_from_list
-from ...path_utils import makeAllDirs
+from ...directory_utils import makedirs
 from ...list_utils import make_list
 from ...class_utils import alias

abstract_utilities/json_utils/json_utils.py

@@ -530,7 +530,7 @@ def get_dict_from_string(string, file_path=None):
             if bracket_count == 0 and start_index is not None:
                 json_data = safe_json_loads(string[start_index:i+1])
                 if file_path:
-                    safe_dump_to_file(file_path=makeAllDirs(file_path), data=json_data)
+                    safe_dump_to_file(file_path=mkdirs(file_path), data=json_data)
                 return json_data
     return None
                     

abstract_utilities/log_utils/imports/module_imports.py

@@ -1,2 +1,2 @@
-from ...path_utils import mkdirs
+from ...directory_utils import mkdirs
 from ...class_utils import SingletonMeta

abstract_utilities/path_utils/imports/__init__.py

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

abstract_utilities/path_utils/imports/module_imports.py

@@ -1,6 +1,7 @@
 from ...string_utils import eatAll
 from ...list_utils import make_list
 from ...type_utils import get_media_exts, is_media_type,MIME_TYPES
-from ...safe_utils import safe_join
+from ...safe_utils import safe_join,get_slash
 from ...class_utils import get_caller_path,get_caller_dir
-
+from ...file_utils import is_file,is_dir,is_exists
+from ...ssh_utils import is_file,is_dir,is_exists

abstract_utilities/path_utils/path_utils.py

@@ -24,405 +24,6 @@ Version: 0.1.2
 """
 from .imports 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 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 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_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 file_path[:-len(get_base_name(file_path))]
-
-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)
-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_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_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 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 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 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 is_file(path: str) -> bool:
-    """Checks if the provided path is a file.
-
-    Args:
-        path (str): The path to check.
-
-    Returns:
-        bool: True if the path is a file, False otherwise.
-    """
-    return os.path.isfile(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 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 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)
-
-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)
-
-
-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 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 makeAllDirs(path: str) -> str:
-    def make_list(obj):
-        if not isinstance(obj,list):
-            obj = [obj]
-        return obj
-    
-    slash = get_slash()
-    path_parts = path.split(slash)
-    path=''
-    if path_parts:
-        last_part = path_parts[-1]
-        for i,part in enumerate(path_parts):
-            if part == '':
-                part = slash
-            path = os.path.join(path,part)
-            if not os.path.exists(path):
-                if '.' in part and abs(len(path_parts)-1) == i:
-                    return path
-                os.makedirs(path)
-            else:
-                if os.path.isfile(path):
-                    return path
-    return path
-            
-        
-def mkdirs(path: str) -> str:
-    """
-    Creates a directory and any necessary intermediate directories.
-
-    Args:
-        path (str): The directory path to create.
-
-    Returns:
-        str: The created directory path.
-    """
-    os.makedirs(path, exist_ok=True)
-    return path
-def make_dirs(*paths):
-    path = path_join(*paths)
-    if not os.path.isfile(path):
-        mkdirs(path)
-    return path
-def file_exists(file_path: str) -> bool:
-    """
-    Checks if a file exists at the specified path.
-
-    Args:
-        file_path (str): The path to the file.
-
-    Returns:
-        bool: True if the file exists, False otherwise.
-    """
-    return os.path.exists(file_path)
-
-def dir_exists(path: str) -> bool:
-    """
-    Checks if a directory exists at the specified path.
-
-    Args:
-        path (str): The path to the directory.
-
-    Returns:
-        bool: True if the directory exists, False otherwise.
-    """
-    return os.path.isdir(path)
-def file_size(path:str):
-    if is_file(path):
-        return os.path.getsize(path)
-    return 0
-def get_file_create_time(path):
-    return os.path.getctime(path)
-def get_size(path: str) -> int:
-    """
-    Calculates the size of a file or a directory.
-
-    Args:
-        path (str): The path of the file or directory.
-
-    Returns:
-        int: The size of the file or directory in bytes.
-    """
-    total_size = file_size(path)
-    if dir_exists(path):
-        total_size = 0
-        for dirpath, dirnames, filenames in os.walk(path):
-            for file in filenames:
-                total_size += file_size(simple_path_join(dirpath, file))
-    return total_size
-
-def get_total_size(folder_path: str) -> int:
-    """
-    Calculates the total size of a directory and its subdirectories.
-
-    Args:
-        folder_path (str): The path of the directory.
-
-    Returns:
-        int: The total size of the directory and its subdirectories in bytes.
-    """
-    total_size = 0
-    if os.path.exists(folder_path) and os.path.isdir(folder_path):
-        for item in os.listdir(folder_path):
-            item_path = os.path.join(folder_path, item)
-            total_size += get_size(item_path)
-    return total_size
 
 def get_files(directory):
     file_list = []
@@ -621,73 +222,7 @@ def create_base_dir(directory=None, child=None):
 
 
 
-# --- Individual path checks --------------------------------------------------
-def is_remote_file(path: str,*args, **kwargs) -> bool:
-    """True if remote path is a file."""
-    return _remote_test(path, "-f", **kwargs)
-
 
-def is_remote_dir(path: str,*args, **kwargs) -> bool:
-    """True if remote path is a directory."""
-    return _remote_test(path, "-d", **kwargs)
-
-
-def is_local_file(path: str) -> bool:
-    """True if local path is a file."""
-    return os.path.isfile(path)
-
-
-def is_local_dir(path: str) -> bool:
-    """True if local path is a directory."""
-    return os.path.isdir(path)
-
-
-# --- Unified interface -------------------------------------------------------
-
-def is_file(path: str,*args,**kwargs) -> bool:
-    """Determine if path is a file (works local or remote)."""
-    if get_user_pass_host_key(**kwargs):
-        return is_remote_file(path, **kwargs)
-    return is_local_file(path)
-
-
-def is_dir(path: str, *args,**kwargs) -> bool:
-    """Determine if path is a directory (works local or remote)."""
-    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,
-    *args,
-    **kwargs
-) -> str:
-    """
-    Return 'file', 'directory', 'missing', or 'unknown'.
-    Uses isolated is_file/is_dir functions.
-    """
-    if get_user_pass_host_key(**kwargs):
-        if is_remote_file(path,**kwargs):
-            return "file"
-        elif is_remote_dir(path,**kwargs):
-            return "directory"
-        else:
-            return "missing"
-    else:
-        if os.path.isfile(path):
-            return "file"
-        elif os.path.isdir(path):
-            return "directory"
-        elif not os.path.exists(path):
-            return "missing"
-        return "unknown"
 
 def get_file_parts(path):
     
@@ -713,3 +248,4 @@ def get_file_parts(path):
             "super_dirname":super_dirname,
             "super_dirbase":super_dirbase
             }
+

abstract_utilities/read_write_utils/imports/module_imports.py

@@ -1,5 +1,5 @@
-from ...ssh_utils import get_user_pass_host_key,run_cmd,get_print_sudo_cmd,run_local_cmd,run_remote_cmd
+from ...ssh_utils import is_file,is_dir,is_exists,get_user_pass_host_key,run_cmd,get_print_sudo_cmd,run_local_cmd,run_remote_cmd
 from ...class_utils import run_pruned_func
 from ...string_utils import *
-from ...path_utils import get_all_files,is_file,is_dir,is_exists
+
 

abstract_utilities/safe_utils/imports/imports.py

@@ -1 +1,2 @@
+from ...imports import *
 from typing import *

abstract_utilities/safe_utils/safe_utils.py

@@ -128,3 +128,9 @@ def safe_get(
         return obj[key]
     except Exception:
         return obj if default is True else default if default else None
+def get_slash(path):
+    if '/' in path:
+        return '/'
+    else:
+        return '//'
+join_path=safe_join

abstract_utilities/ssh_utils/__init__.py

@@ -2,3 +2,4 @@ from .imports import *
 from .classes import *
 from .cmd_utils import *
 from .pexpect_utils import *
+from .type_checks import *

abstract_utilities/ssh_utils/imports/module_imports.py

@@ -1,5 +1,6 @@
-from ...class_utils import SingletonMeta,run_pruned_func
-from ...string_utils import get_from_kwargs,eatOuter
+from ...string_utils import get_from_kwargs,eatAll,eatOuter
 from ...type_utils import make_list  # whatever you already have
 from ...time_utils import get_sleep
-from ...env_utils import *
+from abstract_security import *
+
+from ...class_utils import get_caller, get_caller_path, get_caller_dir,SingletonMeta,run_pruned_func

abstract_utilities/ssh_utils/type_checks.py

@@ -0,0 +1,92 @@
+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, timeout: int = 5,*args, **kwargs) -> bool:
+    """
+    Run a remote shell test (e.g. -f, -d) via SSH.
+    Returns True if test succeeds, False otherwise.
+    """
+    try:
+        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,*args, **kwargs) -> bool:
+    """True if remote path is a file."""
+    return _remote_test(path, "-f", **kwargs)
+
+
+def is_remote_dir(path: str,*args, **kwargs) -> bool:
+    """True if remote path is a directory."""
+    return _remote_test(path, "-d", **kwargs)
+
+
+def is_local_file(path: str) -> bool:
+    """True if local path is a file."""
+    return os.path.isfile(path)
+
+
+def is_local_dir(path: str) -> bool:
+    """True if local path is a directory."""
+    return os.path.isdir(path)
+
+
+# --- Unified interface -------------------------------------------------------
+
+def is_file(path: str,*args,**kwargs) -> bool:
+    """Determine if path is a file (works local or remote)."""
+    if get_user_pass_host_key(**kwargs):
+        return is_remote_file(path, **kwargs)
+    return is_local_file(path)
+
+
+def is_dir(path: str, *args,**kwargs) -> bool:
+    """Determine if path is a directory (works local or remote)."""
+    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,
+    *args,
+    **kwargs
+) -> str:
+    """
+    Return 'file', 'directory', 'missing', or 'unknown'.
+    Uses isolated is_file/is_dir functions.
+    """
+    if get_user_pass_host_key(**kwargs):
+        if is_remote_file(path,**kwargs):
+            return "file"
+        elif is_remote_dir(path,**kwargs):
+            return "directory"
+        else:
+            return "missing"
+    else:
+        if os.path.isfile(path):
+            return "file"
+        elif os.path.isdir(path):
+            return "directory"
+        elif not os.path.exists(path):
+            return "missing"
+        return "unknown"

abstract_utilities/string_utils/replace_utils.py

@@ -22,6 +22,6 @@ def replace_all(string,*args,**kwargs):
     values,kwargs = get_from_kwargs('item','replace',**kwargs)
     if values:
         string = for_replace(string,**values)
-    for item,replace in kwargs.items():
+    for item,rep in kwargs.items():
         string = for_replace(string,item,rep)
     return string

{abstract_utilities-0.2.2.507.dist-info → abstract_utilities-0.2.2.510.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.507
+Version: 0.2.2.510
 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