abstract-utilities 0.2.2.398__tar.gz → 0.2.2.485__tar.gz

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/PKG-INFO

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

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_utilities',
-    version='0.2.2.398',
+    version='0.2.2.485',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description='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.',

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/src/abstract_utilities/__init__.py

@@ -3,8 +3,9 @@ from datetime import timedelta
 from datetime import datetime
 from typing import *
 from .hash_utils import *
-from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
-
+##from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
+from .robust_readers import *
+from .dynimport import get_abstract_import
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,
@@ -40,45 +41,8 @@ from .json_utils import (unified_json_loader,
                          )
 from .read_write_utils import (read_from_file,
                                write_to_file)
-from .path_utils import (get_file_create_time,
-                         get_files,
-                         get_folders,
-                         path_join,
-                         mkdirs,
-                         split_text,
-                         get_all_item_paths,
-                         get_directory_items,
-                         get_files,
-                         get_folders,
-                         break_down_find_existing,
-                         get_directory_items,
-                         get_directory_files,
-                         get_all_item_paths,
-                         get_all_file_paths,
-                         get_directory,
-                         create_directory,
-                         initialize_file,
-                         join_path,
-                         is_last_itter,
-                         path_join,
-                         is_file,
-                         is_dir,
-                         is_path,
-                         get_all_directories,
-                         get_all_files,
-                         get_all_items,
-                         collate_text_docs,
-                         get_dirlist,
-                         get_content,
-                         is_directory_in_paths,
-                         make_dirs,
-                         remove_directory,
-                         remove_path,
-                         get_file_parts,
-                         get_file_map,
-                         get_file_type,
-                         MIME_TYPES
-                         )
+from .path_utils import *
+from .file_utils import *
 from .list_utils import (get_highest_value_obj,
                          make_list,
                          safe_list_return,
@@ -123,7 +87,8 @@ from .type_utils import (make_bool,
                          get_numbers,
                          get_numbers_comp,
                          is_any_instance,
-                         break_string
+                         break_string,
+                         MIME_TYPES
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -151,7 +116,10 @@ from .parse_utils import (num_tokens_from_string,
 
 from .log_utils import get_caller_info,get_logFile,print_or_log,get_json_call_response,initialize_call_log
 from .error_utils import try_func
-from .class_utils import alias,get_class_inputs,get_set_attr
-from .robust_reader import *
-from .robust_readers import *
-
+from .ssh_utils import *
+from .env_utils import *
+from .path_utils import *
+from .file_utils import *
+from .file_utils import call_for_all_tabs
+from .string_utils import *
+from .class_utils import alias,get_class_inputs,get_set_attr,get_caller_path,get_caller_dir

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/src/abstract_utilities/class_utils.py

@@ -44,9 +44,9 @@ Dependencies:
 Each function is furnished with its own docstring that elaborates on its purpose, expected inputs, and outputs.
 
 """
-import inspect
-import json
-import functools
+import os,json,functools,inspect
+from typing import *
+
 def get_type_list() -> list:
     """Get a list of common Python types."""
     return ['None','str','int','float','bool','list','tuple','set','dict','frozenset','bytearray','bytes','memoryview','range','enumerate','zip','filter','map','property','slice','super','type','Exception','object']
@@ -370,3 +370,38 @@ def get_class_inputs(cls, *args, **kwargs):
         else:
             values[field] = getattr(cls(), field)
     return cls(**values)
+def get_caller(i: Optional[int] = None) -> str:
+    """
+    Return the filename of the calling frame.
+
+    Args:
+        i: Optional stack depth offset. 
+           None = immediate caller (depth 1).
+
+    Returns:
+        Absolute path of the file for the stack frame.
+    """
+    depth = 1 if i is None else int(i)
+    stack = inspect.stack()
+    if depth >= len(stack):
+        depth = len(stack) - 1
+    return stack[depth].filename
+
+
+def get_caller_path(i: Optional[int] = None) -> str:
+    """
+    Return the absolute path of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    file_path = get_caller(depth + 1)
+    return os.path.realpath(file_path)
+
+
+def get_caller_dir(i: Optional[int] = None) -> str:
+    """
+    Return the absolute directory of the caller's file.
+    """
+    depth = 1 if i is None else int(i)
+    abspath = get_caller_path(depth + 1)
+    return os.path.dirname(abspath)
+

abstract_utilities-0.2.2.485/src/abstract_utilities/cmd_utils/imports/__init__.py

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

abstract_utilities-0.2.2.485/src/abstract_utilities/cmd_utils/imports/imports.py

@@ -0,0 +1,10 @@
+# remote_fs.py
+from __future__ import annotations
+from typing import *
+import subprocess, shlex, os, fnmatch, glob, posixpath, re
+# ---- import your existing pieces ----
+from ...type_utils import make_list  # whatever you already have
+from ...time_utils import get_sleep
+from ...ssh_utils import *
+from ...env_utils import *
+from ...string_clean import eatOuter

abstract_utilities-0.2.2.485/src/abstract_utilities/cmd_utils/pexpect_utils.py

@@ -0,0 +1,310 @@
+
+from .ssh_utils import *
+from ..env_utils import *
+# pexpect is optional; import lazily if you prefer
+
+# keep your execute_cmd; add a thin wrapper that supports stdin text cleanly
+def execute_cmd_input(
+    *args,
+    input_text: str | None = None,
+    outfile: str | None = None,
+    **kwargs
+) -> str:
+    """
+    Like execute_cmd, but lets you pass text to stdin (subprocess.run(input=...)).
+    """
+    if input_text is not None:
+        kwargs["input"] = input_text
+        # ensure text mode so Python passes str not bytes
+        kwargs.setdefault("text", True)
+    return execute_cmd(*args, outfile=outfile, **kwargs)
+
+# -------------------------
+# Core: capture + printing
+# -------------------------
+def exec_sudo_capture(
+    cmd: str,
+    *,
+    password: str | None = None,
+    key: str | None = None,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False,
+) -> str:
+    """
+    Run a sudo command and return its output (no temp file).
+    """
+    if password is None:
+        password = get_env_value(key=key) if key else get_sudo_password()
+
+    sudo_cmd = f"sudo -S -k {cmd}"
+
+    if user_at_host:
+        # build the remote command (bash -lc + optional cd)
+        remote = get_remote_cmd(cmd=sudo_cmd, user_at_host=user_at_host, cwd=cwd)
+        # feed password to remote's stdin (ssh forwards stdin)
+        out = execute_cmd_input(remote, input_text=password + "\n",
+                                shell=True, text=True, capture_output=True)
+    else:
+        out = execute_cmd_input(sudo_cmd, input_text=password + "\n",
+                                shell=True, text=True, capture_output=True, cwd=cwd)
+
+    if print_output:
+        print_cmd(cmd, out or "")
+    return out or ""
+
+
+
+# ---------------------------------------------------
+# SUDO helpers (local + SSH) with env/password options
+# ---------------------------------------------------
+def exec_sudo(
+    cmd: str,
+    *,
+    password: Optional[str] = None,
+    key: Optional[str] = None,
+    user_at_host: Optional[str] = None,
+    cwd: Optional[str] = None,
+    outfile: Optional[str] = None,
+    print_output: bool = False,
+) -> str:
+    """
+    Execute `cmd` via sudo either locally or on remote.
+    Password order of precedence:
+      1) `password` arg
+      2) `key` -> get_env_value(key)
+      3) get_sudo_password()
+
+    Uses: sudo -S -k    (-S read password from stdin, -k invalidate cached timestamp)
+    """
+    if password is None:
+        if key:
+            password = get_env_value(key=key)
+        else:
+            password = get_sudo_password()
+
+    # Compose the sudo command that reads from stdin
+    sudo_cmd = f"sudo -S -k {cmd}"
+
+    if user_at_host:
+        # For remote: the password is piped to SSH stdin, which flows to remote sudo's stdin.
+        remote = get_remote_cmd(cmd=sudo_cmd, user_at_host=user_at_host, cwd=cwd)
+        full = f"printf %s {shlex.quote(password)} | {remote}"
+        out = execute_cmd(full, shell=True, text=True, capture_output=True, outfile=outfile)
+    else:
+        # Local
+        full = f"printf %s {shlex.quote(password)} | {sudo_cmd}"
+        out = execute_cmd(full, shell=True, text=True, capture_output=True, outfile=outfile)
+
+    if print_output:
+        print_cmd(cmd, out or "")
+    return out or ""
+
+
+# -------------------------------------------------
+# Fire-and-forget (file-backed) compatible runner
+# -------------------------------------------------
+def cmd_run(
+    cmd: str,
+    output_text: str | None = None,
+    print_output: bool = False,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+) -> str | None:
+    """
+    If output_text is None → capture+return output (no file).
+    If output_text is provided → legacy file-backed behavior.
+    """
+    if output_text is None:
+        # capture mode
+        if user_at_host:
+            remote = get_remote_cmd(cmd=cmd, user_at_host=user_at_host, cwd=cwd)
+            out = execute_cmd(remote, shell=True, text=True, capture_output=True)
+        else:
+            out = execute_cmd(cmd, shell=True, text=True, capture_output=True, cwd=cwd)
+        if print_output:
+            print_cmd(cmd, out or "")
+        return out or ""
+
+    # ---- legacy file-backed path (unchanged in spirit) ----
+    # Clear output file
+    with open(output_text, 'w'):
+        pass
+
+    # Append redirection + sentinel
+    full_cmd = f'{cmd} >> {output_text}; echo END_OF_CMD >> {output_text}'
+
+    # Execute local/remote
+    if user_at_host:
+        remote_line = get_remote_cmd(cmd=full_cmd, user_at_host=user_at_host, cwd=cwd)
+        subprocess.call(remote_line, shell=True)
+    else:
+        subprocess.call(full_cmd, shell=True, cwd=cwd)
+
+    # Wait for sentinel
+    while True:
+        get_sleep(sleep_timer=0.5)
+        with open(output_text, 'r') as f:
+            lines = f.readlines()
+            if lines and lines[-1].strip() == 'END_OF_CMD':
+                break
+
+    if print_output:
+        with open(output_text, 'r') as f:
+            print_cmd(full_cmd, f.read().strip())
+
+    try:
+        os.remove(output_text)
+    except OSError:
+        pass
+
+    return None
+
+
+# ----------------------------------------------------
+# pexpect wrappers (local + SSH) for interactive flows
+# ----------------------------------------------------
+def exec_expect(
+    command: str,
+    child_runs: List[Dict[str, Any]],
+    *,
+    user_at_host: Optional[str] = None,
+    cwd: Optional[str] = None,
+    print_output: bool = False,
+) -> int:
+    """
+    Run `command` and answer interactive prompts.
+
+    child_runs: list of dicts like:
+      { "prompt": r"Password:", "pass": "xyz" }
+      { "prompt": r"Enter passphrase:", "key": "MY_KEY", "env_path": "/path/for/.env" }
+    If "pass" is None, we resolve via get_env_value(key=..., start_path=env_path).
+
+    Returns exitstatus (0=success).
+    """
+    if user_at_host:
+        # Wrap command for remote execution
+        remote_line = get_remote_cmd(cmd=command, user_at_host=user_at_host, cwd=cwd)
+        spawn_cmd = f"{remote_line}"
+    else:
+        spawn_cmd = f"bash -lc {shlex.quote((f'cd {shlex.quote(cwd)} && {command}') if cwd else command)}"
+
+    child = pexpect.spawn(spawn_cmd)
+
+    for each in child_runs:
+        child.expect(each["prompt"])
+
+        if each.get("pass") is not None:
+            pass_phrase = each["pass"]
+        else:
+            args = {}
+            if "key" in each and each["key"] is not None:
+                args["key"] = each["key"]
+            if "env_path" in each and each["env_path"] is not None:
+                args["start_path"] = each["env_path"]
+            pass_phrase = get_env_value(**args)
+
+        child.sendline(pass_phrase)
+        if print_output:
+            print("Answered prompt:", each["prompt"])
+
+    child.expect(pexpect.EOF)
+    out = child.before.decode("utf-8", errors="ignore")
+    if print_output:
+        print_cmd(command, out)
+
+    return child.exitstatus if child.exitstatus is not None else 0
+
+
+# ---------------------------------------
+# Convenience shims to mirror your names
+# ---------------------------------------
+def cmd_run_sudo(
+    cmd: str,
+    password: str | None = None,
+    key: str | None = None,
+    output_text: str | None = None,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False,
+) -> str | None:
+    """
+    If output_text is None → capture sudo output and return it.
+    If output_text is provided → legacy file-backed behavior feeding sudo via stdin.
+    """
+    if output_text is None:
+        return exec_sudo_capture(
+            cmd,
+            password=password,
+            key=key,
+            user_at_host=user_at_host,
+            cwd=cwd,
+            print_output=print_output,
+        )
+
+    # ---- legacy file-backed path ----
+    # build the underlying sudo command
+    sudo_cmd = f"sudo -S -k {cmd}"
+    pw = password if password is not None else (get_env_value(key=key) if key else get_sudo_password())
+
+    # We need to feed password to stdin in the same shell that runs sudo.
+    # For file-backed mode we’ll inline a small shell that reads from a here-string.
+    # Local:
+    if not user_at_host:
+        full = f'bash -lc {shlex.quote((f"cd {shlex.quote(cwd)} && " if cwd else "") + f"printf %s {shlex.quote(pw)} | {sudo_cmd}")}'
+        return cmd_run(full, output_text=output_text, print_output=print_output)
+    # Remote:
+    # On remote, do the same in the remote bash -lc
+    remote_sudo_line = f'printf %s {shlex.quote(pw)} | {sudo_cmd}'
+    remote_full = get_remote_cmd(cmd=remote_sudo_line, user_at_host=user_at_host, cwd=cwd)
+    return cmd_run(remote_full, output_text=output_text, print_output=print_output)
+def pexpect_cmd_with_args(
+    command: str,
+    child_runs: list,
+    output_text: str | None = None,
+    *,
+    user_at_host: str | None = None,
+    cwd: str | None = None,
+    print_output: bool = False
+) -> int:
+    """
+    If output_text is None → return output string via print_output, else write to file then remove (legacy).
+    """
+    if user_at_host:
+        spawn_cmd = get_remote_cmd(cmd=command, user_at_host=user_at_host, cwd=cwd)
+    else:
+        spawn_cmd = f"bash -lc {shlex.quote((f'cd {shlex.quote(cwd)} && {command}') if cwd else command)}"
+
+    child = pexpect.spawn(spawn_cmd)
+
+    for each in child_runs:
+        child.expect(each["prompt"])
+        if each.get("pass") is not None:
+            pass_phrase = each["pass"]
+        else:
+            args = {}
+            if "key" in each and each["key"] is not None:
+                args["key"] = each["key"]
+            if "env_path" in each and each["env_path"] is not None:
+                args["start_path"] = each["env_path"]
+            pass_phrase = get_env_value(**args)
+        child.sendline(pass_phrase)
+        if print_output:
+            print("Answered prompt:", each["prompt"])
+
+    child.expect(pexpect.EOF)
+    out = child.before.decode("utf-8", errors="ignore")
+
+    if output_text:
+        with open(output_text, "w") as f:
+            f.write(out)
+        if print_output:
+            print_cmd(command, out)
+        # keep legacy? your old code removed the file; here we’ll keep it (safer).
+        # If you want the old behavior, uncomment:
+        # os.remove(output_text)
+    else:
+        if print_output:
+            print_cmd(command, out)

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/src/abstract_utilities/cmd_utils/user_utils.py

@@ -1,4 +1,4 @@
-from ..string_clean import eatOuter
+
 def get_user_input(text,default='y'):
     choices = '(y/n)' if default in ['y','n'] else ''
     response = input(f"{text} {choices}:({default}) ") or default

{abstract_utilities-0.2.2.398 → abstract_utilities-0.2.2.485}/src/abstract_utilities/dynimport.py

@@ -1,12 +1,12 @@
 # abstract_utilities/dynimport.py
 from __future__ import annotations
-import importlib, sys, os
 from functools import lru_cache
-from typing import Any, Callable, Iterable, Optional
-import inspect, sys
+from typing import *
+import importlib, sys, os, sys,inspect
+from typing import Optional
 from importlib import import_module
 from .type_utils import make_list
-from .robust_readers import get_for_all_tabs,call_for_all_tabs
+
 class _LazyAttr:
     """Lazy resolver proxy to avoid import-time cycles.
     First use triggers actual import & attribute lookup.
@@ -181,14 +181,6 @@ def get_many_module_imports(*args):
             all_modules[symbol] = get_abstract_import(module = module,symbol=symbol)
     import_symbols(all_modules)
     return all_modules
-def get_caller_path():
-    frame = inspect.stack()[1]
-    return os.path.abspath(frame.filename)
-def get_caller_dir():
-    frame = inspect.stack()[1]
-    abspath = os.path.abspath(frame.filename)
-    return os.path.dirname(abspath)
-def call_for_all_tabs(root=None):
-    
-    root = root or get_caller_dir()
-    get_for_all_tabs(root)
+
+
+

abstract_utilities-0.2.2.485/src/abstract_utilities/env_utils/__init__.py

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

abstract_utilities-0.2.2.485/src/abstract_utilities/env_utils/abstractEnv.py

@@ -0,0 +1,129 @@
+from .imports import *
+class abstractEnv:
+    def __init__(self,key='MY_PASSWORD',file_name=None,path=os.getcwd(),deep_scan=False):
+        file_name = file_name or '.env'
+        self.re_initialize(file_name=file_name,key=key,path=path,deep_scan=deep_scan)
+    def re_initialize(self,key='MY_PASSWORD',file_name='.env',path=os.getcwd(),deep_scan=False):
+        """
+        Initializes an AbstractEnv object to manage environment variables.
+
+        Args:
+            key (str, optional): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+            file_name (str, optional): The name of the .env file. Defaults to '.env'.
+            path (str, optional): The path where the .env file is located. Defaults to the current working directory.
+        """
+
+        self.key = key or 'MY_PASSWORD'
+
+        file_name = file_name or '.env'
+        self.key = key or 'MY_PASSWORD'
+        self.deep_scan=deep_scan
+        self.current_folder = os.getcwd()
+        if path and os.path.isfile(path):
+            self.file_name = os.path.basename(path)
+            self.path = os.path.dirname(path)
+        else:
+            self.path = path or self.current_folder
+            self.file_name = file_name or '.env'
+        self.start_path_env = os.path.join(self.path,self.file_name)
+        self.home_folder = os.path.expanduser("~")
+        self.envy_all = os.path.join(self.home_folder,'.envy_all')
+        self.directories = self.get_directories()
+        self.env_value = self.find_and_read_env_file(key=self.key,file_name=self.file_name, path=self.path,initialize=False)
+
+    def find_and_read_env_file(self,key:str=None, file_name:str=None, path=None,initialize=True,deep_scan=False):
+        """
+        Search for an environment file and read a specific key from it.
+
+        Args:
+            file_name (str): Name of the .env file to be searched. Defaults to '.env'.
+            key (str): Key to be retrieved from the .env file. Defaults to 'MY_PASSWORD'.
+            start_path (str): Directory path to start the search from. If None, search starts from current directory. 
+
+        Returns:
+            str: The value corresponding to the key if found, otherwise None.
+        """
+        # Set the default start_path to the current directory if it's None
+        # Try to find the file in the start_path
+        key = key or self.key
+        path = path or self.start_path_env
+        file_name = file_name or self.file_name
+        if initialize:
+            self.re_initialize(key=key,file_name=file_name,path=path)
+        for directory in self.directories:
+            if directory and os.path.isdir(directory) and self.file_name:
+                env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(env_path):
+                    value = self.search_for_env_key(key=key,path=env_path)
+                self.env_path = os.path.join(directory,self.file_name)
+                if os.path.isfile(self.env_path):
+                    value = self.search_for_env_key(key=key,path=self.env_path,deep_scan=deep_scan)
+                    if value:
+                        return value
+    def get_directories(self):
+        """
+        Retrieves a list of directories to search for the .env file.
+
+        Returns:
+            list: A list of directories including the specified path, current folder, home folder, and '.envy_all' directory.
+        """
+        directories=[]
+        for directory in [self.path,self.current_folder,self.home_folder,self.envy_all]:
+            if os.path.isdir(directory) and directory not in directories:
+                directories.append(directory)
+        return directories
+    
+
+    def search_for_env_key(self,key:str=None,path:str=None,deep_scan=False):
+
+        """
+        Retrieves the value of a specified environment variable from a .env file.
+
+        Args:
+            key (str, optional): The key to search for in the .env file. Defaults to None.
+            path (str, optional): The path to the .env file. Defaults to None.
+            file_name (str, optional): The name of the .env file. Defaults to None.
+
+        Returns:
+            str: The value of the environment variable if found, otherwise None.
+        """
+
+        highest = [None,0,0.0]
+        key = key or self.default_env_key
+        path = path or self.start_path_env
+        if path and os.path.isfile(path):
+            with open(path, "r") as f:
+                for line in f:
+                    line_key,line_value = split_eq(line)
+                    # If the line contains the key, return the value after stripping extra characters
+                    if line_key == key:
+                        return line_value
+                    if deep_scan:
+                        line_keys = []
+                        key_parts=0
+                        for key_part in key.split('_'):
+                            line_keys.append([])
+                            if key_part in line_key:
+                                line_keys[-1].append(line_key)
+                                key_parts+=len(key_part)
+                        if float(key_parts/len(key))>=0.5 and key_parts >highest[1]:
+                            highest = [line_value,key_parts]
+                    if deep_scan and highest[0] != None:
+                        return line_value
+    def get_env_value(key:str=None,path:str=os.getcwd(),file_name:str=None):
+        """
+        Retrieves the value of the specified environment variable.
+
+        Args:
+            path (str): The path to the environment file. Defaults to None.
+            file_name (str): The name of the environment file. Defaults to '.env'.
+            key (str): The key to search for in the .env file. Defaults to 'MY_PASSWORD'.
+
+        Returns:
+            str: The value of the environment variable if found, otherwise None.
+        """
+        if safe_env_load(path):
+            return os.getenv(key)
+        return find_and_read_env_file(file_name=file_name, key=key, path=path_ls)
+
+AbstractEnv = abstractEnv