abstract-utilities 0.2.2.492__py3-none-any.whl → 0.2.2.513__py3-none-any.whl

abstract_utilities/path_utils/path_utils.py

@@ -0,0 +1,251 @@
+"""
+path_utils.py
+
+This module provides a collection of utility functions related to file and directory path management. 
+Its features include, but are not limited to:
+
+Usage:
+    import abstract_utilities.path_utils as path_utils
+
+- Determining appropriate file path separators based on the operating system.
+- Joining paths using the correct file path separator.
+- Fetching the current working directory and user's home folder.
+- Checking if a path corresponds to a file or directory and if they exist.
+- Fetching file sizes and determining the size of directories.
+- Creating multiple nested directories if they do not exist.
+- Retrieving creation time of files.
+- Converting sizes to GB with options for truncation.
+
+This module is part of the `abstract_utilities` package.
+
+Author: putkoff
+Date: 05/31/2023
+Version: 0.1.2
+"""
+from .imports import *
+
+
+def get_files(directory):
+    file_list = []
+    for root,dirs,files in os.walk(directory):
+        for file in files:
+            file_list.append(os.path.join(root,file))
+    return file_list
+
+def get_folders(directory):
+    directory_list = []
+    for root,dirs,files in os.walk(directory):
+        for folder in dirs:
+            directory_list.append(os.path.join(root,folder))
+    return directory_list
+
+def break_down_find_existing(path):
+    slash = get_slash()
+    test_path=''
+    found_path=None
+    for part in path.split(slash):
+        test_path=os.path.join(test_path,part)
+        if not os.path.exists(test_path):
+            return found_path
+        found_path = test_path
+    return found_path
+
+def get_directory_items(directory):
+    if not os.path.isdir(directory):
+        return []
+    return os.listdir(directory)
+
+def get_directory_files(directory):
+    if not os.path.isdir(directory):
+        return []
+    return get_files(directory)
+
+def get_all_item_paths(directory):
+    directory_items = get_directory_items(directory)
+    item_paths = [os.path.join(directory,item) for item in directory_items if item]
+    return item_paths
+
+def get_all_file_paths(directory):
+    item_paths = get_directory_files(directory) 
+    return item_paths
+
+def get_directory(directory):
+    if not os.path.isdir(directory):
+        os.makedirs(directory,exist_ok=True)
+    return directory
+
+def create_directory(directory,path):
+    directory = os.path.join(directory,path)
+    return get_directory(directory)
+
+
+def initialize_file(directory,basename):
+    directory = get_directory(directory)
+    file_path = create_directory(directory,basename)
+    return get_file_path(file_path)
+
+def join_path(directory,basename):
+    file_path = os.path.join(directory,basename)
+    return file_path
+
+def is_last_itter(i,*itters):
+    itter_len = len(itters)
+    if i+1 == itter_len:
+        return True
+    return False
+
+def path_join(*paths, isfile=False):
+    final_path = os.path.join(*paths)
+    paths_len = len(paths)
+    for i, path in enumerate(paths):
+        if i == 0:
+            final_path = path  # Note: Fixed bug; original code had `final_path = paths`
+        else:
+            final_path = os.path.join(final_path, path)
+        if isfile and is_last_itter(i, paths_len):  # Note: `is_last_itter` is undefined; assuming it checks if last iteration
+            break
+        os.makedirs(final_path, exist_ok=True)      
+    return final_path
+
+def is_file(*paths):
+    item_path = os.path.join(*paths)
+    return os.path.isfile(item_path)
+
+def is_dir(*paths):
+    item_path = os.path.join(*paths)
+    return os.path.isdir(item_path)
+
+def is_path(*paths):
+    item_path = os.path.join(*paths)
+    return item_path if os.path.exists(item_path) else None
+
+def get_all_directories(directory):
+    dir_list = os.listdir(directory)
+    directory_list = [item for item in dir_list if is_dir(directory,item)]
+    return directory_list
+
+def get_all_files(directory=None):
+    directory = directory or os.getcwd()
+    dir_list = os.listdir(directory)
+    file_list = [item for item in dir_list if is_file(directory,item)]
+    return file_list
+
+def get_all_items(directory):
+    dir_list = os.listdir(directory)
+    file_list = [item for item in dir_list if is_path(directory,item)]
+    return file_list
+
+
+def get_dirlist(directory):
+    path = get_directory(directory)
+    if not path:
+        return path
+    dir_list=[]
+    if is_dir(path):
+        dir_list = os.listdir(path)
+    elif is_file(path):
+        dir_list = [os.path.basename(path)]
+    return dir_list
+
+
+def is_directory_in_paths(path,directory):
+    return directory in path 
+
+def remove_directory(directory,paths=None):
+    paths = make_list_it(paths)
+    shutil.rmtree(audio_dir)
+    for path in paths:
+        remove_path(path=path)
+def remove_path(path=None):
+    if path and os.path.exists(path):
+        if os.path.isdir(path):
+            remove_directory(path)
+        else:
+            os.remove(path)
+def get_safe_dirname(path=None):
+    if path:
+        path_str = str(path)
+        return os.path.dirname(path_str)
+def get_safe_basename(path=None):
+    if path:
+        path_str = str(path)
+        return os.path.basename(path_str)
+def get_safe_splitext(path=None,basename=None):
+    basename = basename or get_safe_basename(path=path)
+    if basename:
+        basename_str = str(basename)
+        filename,ext = os.path.splitext(basename_str)
+        return filename,ext
+def get_safe_filename(path=None,basename=None):
+    filename,_ = get_safe_splitext(path=path,basename=basename)
+    return filename
+def get_safe_ext(path=None,basename=None):
+    _,ext = get_safe_splitext(path=path,basename=basename)
+    return ext
+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
+
+
+def create_dirs(directory, child=None):
+    """Create directory and optional child path safely."""
+    full_path = os.path.abspath(safe_join(directory, child))
+    if not os.path.exists(full_path):
+        raw_create_dirs(full_path)
+    return full_path
+
+
+def get_base_dir(directory=None):
+    """Return given directory or _BASE_DIR fallback."""
+    return directory or _BASE_DIR
+
+
+def create_base_path(directory=None, child=None):
+    """Join base dir with child."""
+    directory = get_base_dir(directory)
+    return safe_join(directory, child)
+
+
+def create_base_dir(directory=None, child=None):
+    """Ensure existence of base directory path."""
+    full_path = create_base_path(directory, child)
+    if not os.path.exists(full_path):
+        raw_create_dirs(full_path)
+    return full_path
+
+
+
+
+
+def get_file_parts(path):
+    
+    basename = get_safe_basename(path)
+    filename, ext = get_safe_splitext(basename=basename)
+
+    dirname = get_safe_dirname(path)
+    dirbase = get_safe_basename(dirname)
+    
+    parent_dirname = get_safe_dirname(dirname)
+    parent_dirbase = get_safe_basename(parent_dirname)
+    
+    super_dirname = get_safe_dirname(parent_dirname)
+    super_dirbase = get_safe_basename(super_dirname)
+
+    return {"dirname": dirname,
+            "basename": basename,
+            "filename": filename,
+            "ext": ext,
+            "dirbase":dirbase,
+            "parent_dirname":parent_dirname,
+            "parent_dirbase":parent_dirbase,
+            "super_dirname":super_dirname,
+            "super_dirbase":super_dirbase
+            }
+

abstract_utilities/path_utils.py

@@ -22,14 +22,15 @@ Author: putkoff
 Date: 05/31/2023
 Version: 0.1.2
 """
-import os
-from .read_write_utils import read_from_file,write_to_file
+import os,shlex
+from .ssh_utils import run_cmd
 from .string_clean 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 .class_utils import get_caller_path,get_caller_dir
-
+from .abstract_classes import SingletonMeta,run_pruned_func
+from .string_utils import get_from_kwargs
 def get_os_info():
     """
     Get Operating System Information
@@ -540,8 +541,6 @@ def get_all_items(directory):
     file_list = [item for item in dir_list if is_path(directory,item)]
     return file_list
 
-def collate_text_docs(directory=None):
-    return [read_from_file(item) for item in get_all_files(directory=directory)]
 
 def get_dirlist(directory):
     path = get_directory(directory)
@@ -553,15 +552,7 @@ def get_dirlist(directory):
     elif is_file(path):
         dir_list = [os.path.basename(path)]
     return dir_list
-def get_content(*paths):
-    item_path = os.path.join(*paths)
-    if os.path.isfile(item_path):
-        try:
-            content = read_from_file(item_path)
-            return content
-        except:
-            pass
-    return None
+
 
 def is_directory_in_paths(path,directory):
     return directory in path 
@@ -636,6 +627,96 @@ def create_base_dir(directory=None, child=None):
     return full_path
 
 
+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"
 
 def get_file_parts(path):
     

abstract_utilities/read_write_utils/__init__.py

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

abstract_utilities/read_write_utils/imports/__init__.py

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

abstract_utilities/read_write_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from ...imports import os,shlex
+

abstract_utilities/read_write_utils/imports/module_imports.py

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