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

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

@@ -0,0 +1,4 @@
+from .imports import *
+from .clean_utils import *
+from .eat_utils import *
+from .replace_utils import *

abstract_utilities/string_utils/clean_utils.py

@@ -0,0 +1,28 @@
+from .eat_utils import eatAll
+def clean_spaces(obj: str) -> str:
+    """
+    Removes leading spaces and tabs from a string.
+
+    Args:
+        obj (str): The input string.
+
+    Returns:
+        str: The string with leading spaces and tabs removed.
+    """
+    if len(obj) == 0:
+        return obj
+    while obj[0] in [' ', '\t']:
+        obj = obj[1:]
+    return obj
+def clean_line(line):
+    return eatAll(line,[' ','','\t','\n'])
+def url_join(*paths):
+    final_url = os.path.join(*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 = eatOuter(final_path, '/')
+            path = eatInner(path, '/')
+            final_path = f"{final_path}/{path}"
+    return final_path

abstract_utilities/string_utils/eat_utils.py

@@ -0,0 +1,103 @@
+from .imports import *
+def eatInner(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from the inner part of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        for char in string:
+            if string:
+                if char not in list_objects:
+                    return string
+                string = string[1:]
+    return string
+
+
+def eatOuter(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from the outer part of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        for i in range(len(string)):
+            if string:
+                if string[-1] not in list_objects:
+                    return string
+                string = string[:-1]
+    return string
+def eatAll(string: str, list_objects:(str or list)) -> any:
+    """
+    Removes characters from both the inner and outer parts of a string or list.
+
+    Args:
+        x (str or list): The input string or list.
+        ls (list): The list of characters to remove.
+
+    Returns:
+        any: The modified string or list.
+    """
+    if not isinstance(list_objects,list):
+        list_objects = [list_objects]
+    if not isinstance(string,str):
+        string = str(string)
+    if string and list_objects:
+        string = eatInner(string, list_objects)
+    if string and list_objects:
+        string = eatOuter(string, list_objects)
+    return string
+
+
+
+def eatElse(
+    stringObj,
+    chars=None,
+    ints=True,
+    alpha=True,
+    lower=True,
+    capitalize=True,
+    string=True,
+    listObj=True
+):
+    alpha_ints = get_alpha_ints(
+        ints=True,
+        alpha=True,
+        lower=True,
+        capitalize=True,
+        string=True,
+        listObj=True
+        )
+    chars = make_list(chars or [])+alpha_ints
+
+    while True:
+        if stringObj:
+            str_0 = stringObj[0] not in chars
+            str_1 = stringObj[-1] not in chars
+            str_eat = str_0 or str_1
+            if not str_eat:
+                return stringObj
+            if stringObj and str_0:
+                stringObj = stringObj[1:] if len(stringObj) !=1 else ""
+            if stringObj and str_1:
+                stringObj = stringObj[:-1] if len(stringObj) !=1 else ""   
+        else:
+            return stringObj

abstract_utilities/string_utils/imports/__init__.py

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

abstract_utilities/string_utils/imports/imports.py

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

abstract_utilities/string_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...list_utils import make_list
+from ...type_utils import get_alpha_ints

abstract_utilities/string_utils/imports/utils.py

@@ -0,0 +1,81 @@
+def quoteIt(st: str, ls: list) -> str:
+    """
+    Quotes specific elements in a string.
+
+    Args:
+        st (str): The input string.
+        ls (list): The list of elements to quote.
+
+    Returns:
+        str: The modified string with quoted elements.
+    """
+    lsQ = ["'", '"']
+    for i in range(len(ls)):
+        for k in range(2):
+            if lsQ[k] + ls[i] in st:
+                st = st.replace(lsQ[k] + ls[i], ls[i])
+            if ls[i] + lsQ[k] in st:
+                st = st.replace(ls[i] + lsQ[k], ls[i])
+        st = st.replace(ls[i], '"' + str(ls[i]) + '"')
+    return st
+
+def truncate_text(text, max_chars):
+    """
+    Truncates a text to a specified maximum number of characters, preserving the last complete sentence or word.
+
+    Args:
+        text (str): The input text.
+        max_chars (int): The maximum number of characters.
+
+    Returns:
+        str: The truncated text.
+    """
+    if len(text) <= max_chars:
+        return text
+    truncated = text[:max_chars]
+    # Find the last complete sentence
+    last_sentence_end = max(truncated.rfind('.'), truncated.rfind('!'), truncated.rfind('?'))
+    # If a complete sentence is found, truncate up to its end
+    if last_sentence_end != -1:
+        truncated = truncated[:last_sentence_end + 1]
+    else:
+        # If no complete sentence is found, find the last complete word
+        last_word_end = truncated.rfind(' ')
+
+        # If a complete word is found, truncate up to its end
+        if last_word_end != -1:
+            truncated = truncated[:last_word_end]
+    return truncated
+def capitalize(string):
+    return string[:1].upper() + string[1:].lower() if string else string
+def get_from_kwargs(*args,**kwargs):
+    del_kwarg = kwargs.get('del_kwargs',False)
+    values = {}
+    for key in args:
+        if key:
+            key = str(key)
+            if key in kwargs:
+                values[key] = kwargs.get(key)
+                if del_kwarg:
+                    del kwargs[key]
+    return values,kwargs
+def get_lines(string,strip=True):
+    lines = string.split('\n')
+    if strip:
+        lines = [line for line in lines if line]
+    return lines
+def clean_spaces(obj: str) -> str:
+    """
+    Removes leading spaces and tabs from a string.
+
+    Args:
+        obj (str): The input string.
+
+    Returns:
+        str: The string with leading spaces and tabs removed.
+    """
+    if len(obj) == 0:
+        return obj
+    while obj[0] in [' ', '\t']:
+        obj = obj[1:]
+    return obj

abstract_utilities/string_utils/replace_utils.py

@@ -0,0 +1,27 @@
+from .imports import *
+def replace_it(string,item,rep):
+    if item in string:
+        string = string.replace(item,rep)
+    return string
+def while_replace(string,item,rep):
+    while True:
+        string = replace_it(string,item,rep)
+        if item not in string or item in rep:
+            return string
+def for_replace(string,item,replace):
+    replace = make_list(replace)
+    for rep in replace:
+        string = while_replace(string,item,rep)
+    return string
+def replace_all(string,*args,**kwargs):
+    for items in args:
+        if items and isinstance(items,list):
+            item = items[0]
+            replace = items[1:] if len(items)>1 else items[-1]
+            string = for_replace(string,item,replace)
+    values,kwargs = get_from_kwargs('item','replace',**kwargs)
+    if values:
+        string = for_replace(string,**values)
+    for item,rep in kwargs.items():
+        string = for_replace(string,item,rep)
+    return string

abstract_utilities/thread_utils/__init__.py

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

abstract_utilities/thread_utils/imports/__init__.py

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

abstract_utilities/thread_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from ...imports import threading
+from ...imports import queue

abstract_utilities/thread_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...compare_utils import create_new_name,get_last_comp_list
+

abstract_utilities/thread_utils/thread_utils.py

@@ -0,0 +1,140 @@
+"""
+thread_utils.py - Thread Utilities Module
+
+This module provides utility functions for working with threads in Python.
+
+Usage:
+    import abstract_utilities.thread_utils as thread_utils
+
+Example:
+    # Creating a thread
+    my_thread = thread_utils.get_thread(target=my_function, args=(arg1, arg2), daemon=True)
+
+    # Starting the thread
+    thread_utils.start_thread(my_thread)
+
+    # Verifying if a given object is a valid thread
+    is_valid = thread_utils.verify_thread(my_thread)
+
+    # Checking if a thread is alive
+    if thread_utils.thread_alive(my_thread):
+        print("Thread is alive")
+    else:
+        print("Thread is not alive")
+
+This module is part of the `abstract_utilities` package.
+
+Author: putkoff
+Date: 10/25/2023
+Version: 0.1.2
+"""
+from .imports import *
+class ThreadedEvent:
+    def __init__(self, target_function,termination_result=None,function_args={},daemon=True):
+        self._event = threading.Event()
+        self._queue = queue.Queue()  # Add a queue for return values
+        self._thread = threading.Thread(target=self._run, args=(target_function,termination_result,function_args),daemon=daemon)
+    def _run(self, target_function, termination_result, function_args):
+        print(f"Thread starting with event status: {self._event.is_set()}")
+        while not self._event.is_set():
+            print(f"In loop. Event status: {self._event.is_set()}")
+            result = target_function(**function_args)
+            if result:
+                self._queue.put(result)  # Store the return value in the queue
+            self._event.wait(1)  # This will wait for 1 second or until interrupted by calling `stop`.
+        print(f"Thread {self._thread.name} is exiting.")
+    def get_result(self):
+        """Retrieve the result from the queue. Returns None if no result available."""
+        if not self._queue.empty():
+            return self._queue.get()
+        return None
+    def start(self):
+        """Starts the thread."""
+        self._thread.start()
+    def stop(self):
+        print(f"Attempting to stop thread {self._thread.name}")
+        self._event.set()
+        #  # Optionally, you can wait for the thread to finish.
+    def wait(self,n=0):
+        self._thread.wait(n)
+    def join(self):
+        self._thread.join()
+    def is_alive(self):
+        """Returns whether the thread is still running."""
+        return self._thread.is_alive()
+class ThreadManager:
+    def __init__(self):
+        self.threads = {}
+        self.thread_name_list=[]
+    def add_thread(self,name=None,target_function=None,termination_result=None,function_args={},overwrite=False,make_default=True,daemon=True):
+        if name == None:
+            if make_default:
+                name = 'Default_Thread_name'
+            else:
+                return
+        if target_function == None:
+            return
+        if overwrite==False:
+            name=create_new_name(name=name,names_list=self.all_thread_names())
+        if name in self.thread_name_list:
+            self.thread_name_list.remove(name)
+        self.thread_name_list.append(name)
+        """Add a thread with a name and target function."""
+        self.threads[name] = ThreadedEvent(target_function=target_function,termination_result=termination_result,function_args=function_args,daemon=daemon)
+        return name
+    def start(self, name,overwrite=False):
+        """Start a specific thread by name."""
+        if self.is_alive(name)==False:
+            self.threads[name].start()
+    def wait(self,name,n=0):
+        self.threads[name].wait(n)
+    def join(self,name):
+        self.threads[name].join()
+    def stop(self, name, result=None):
+        if self.check_name(name):
+            if result:
+                self.threads[name]._queue.put(result)
+            self.threads[name].stop()
+        return True
+    def stop_last(self,name=None,result=None):
+        str_name = f"for {name}" if name else ""
+        if name ==None:
+            name=get_last_comp_list(name,self.all_thread_names())
+        if self.check_name(name):
+            return self.stop(name,result=result)
+        return False
+    def start_all(self):
+        """Start all threads."""
+        for thread in self.threads.values():
+            thread.start()
+
+    def stop_all(self):
+        """Stop all threads."""
+        for thread in self.threads.values():
+            thread.stop()
+
+    def is_alive(self, name):
+        """Check if a specific thread is alive by name."""
+        if self.check_name(name):
+            status = self.threads[name].is_alive()
+            return status
+        return False
+    def all_alive(self):
+        """Return a dictionary indicating if each thread is alive."""
+        return {name: thread.is_alive() for name, thread in self.threads.items()}
+    def all_thread_names(self):
+        return self.threads.keys()
+    def get_last_result(self,name=None):
+        str_name = f"for {name}" if name else ""
+        result = None
+        if name:
+            result_name=get_last_comp_list(name,self.all_thread_names())
+            if self.check_name(name):
+                result = self.threads[result_name].get_result()
+        elif len(self.thread_name_list)>0:
+            result = self.threads[self.thread_name_list[-1]].get_result()
+        return result
+    def check_name(self,name):
+        if name in self.all_thread_names():
+            return True
+        return False

abstract_utilities/time_utils/__init__.py

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

abstract_utilities/time_utils/imports/__init__.py

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

abstract_utilities/time_utils/imports/imports.py

@@ -0,0 +1,3 @@
+from ...imports import os,time
+from typing import *
+from datetime import datetime, timedelta

abstract_utilities/time_utils/imports/module_imports.py

@@ -0,0 +1 @@
+from ...type_utils import is_number,make_list