abstract-utilities 0.2.2.448__py3-none-any.whl → 0.2.2.449__py3-none-any.whl

abstract_utilities/__init__.py

@@ -3,9 +3,8 @@ 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 .robust_readers import *
-from .dynimport import get_abstract_import
+from .dynimport import get_abstract_import,import_symbols_to_parent,call_for_all_tabs
+
 from .json_utils import (unified_json_loader,
                          find_keys,
                          get_key_values_from_path,
@@ -41,8 +40,42 @@ from .json_utils import (unified_json_loader,
                          )
 from .read_write_utils import (read_from_file,
                                write_to_file)
-from .path_utils import *
-from .file_utils import *
+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
+                         )
 from .list_utils import (get_highest_value_obj,
                          make_list,
                          safe_list_return,
@@ -87,8 +120,7 @@ from .type_utils import (make_bool,
                          get_numbers,
                          get_numbers_comp,
                          is_any_instance,
-                         break_string,
-                         MIME_TYPES
+                         break_string
                          )
 get_media_types = get_all_types = get_all_file_types
 from .math_utils import (convert_to_percentage,
@@ -100,10 +132,7 @@ from .math_utils import (convert_to_percentage,
                          return_0)
 from .compare_utils import (create_new_name,
                             get_last_comp_list,
-                            get_closest_match_from_list,
-                            get_first_match,
-                            get_all_match,
-                            best_match)
+                            get_closest_match_from_list)
 from .thread_utils import ThreadManager
 from .history_utils import HistoryManager
 from .abstract_classes import *
@@ -117,9 +146,6 @@ 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 .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 .robust_reader import *
+from .robust_readers import *
+

abstract_utilities/abstract_classes.py

@@ -1,4 +1,3 @@
-import inspect
 class SingletonMeta(type):
     _instances = {}
     def __call__(cls, *args, **kwargs):
@@ -23,51 +22,3 @@ def get_inputs(cls, *args, **kwargs):
             values[field] = getattr(cls(), field)  # default from dataclass
 
     return cls(**values)
-
-
-def prune_inputs(func, *args, **kwargs):
-    """
-    Adapt the provided args/kwargs to fit the signature of func.
-    Returns (args, kwargs) suitable for calling func.
-    """
-    sig = inspect.signature(func)
-    params = sig.parameters
-
-    # Handle positional arguments
-    new_args = []
-    args_iter = iter(args)
-    for name, param in params.items():
-        if param.kind in (inspect.Parameter.POSITIONAL_ONLY,
-                          inspect.Parameter.POSITIONAL_OR_KEYWORD):
-            try:
-                new_args.append(next(args_iter))
-            except StopIteration:
-                break
-        elif param.kind == inspect.Parameter.VAR_POSITIONAL:
-            # collect all remaining args
-            new_args.extend(args_iter)
-            break
-        else:
-            break
-
-    # Handle keyword arguments
-    new_kwargs = {}
-    for name, param in params.items():
-        if name in kwargs:
-            new_kwargs[name] = kwargs[name]
-        elif param.default is inspect.Parameter.empty and param.kind == inspect.Parameter.KEYWORD_ONLY:
-            # Required keyword not provided
-            raise TypeError(f"Missing required keyword argument: {name}")
-
-    # Only include keywords func accepts
-    accepted_names = {
-        name for name, p in params.items()
-        if p.kind in (inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                      inspect.Parameter.KEYWORD_ONLY)
-    }
-    new_kwargs = {k: v for k, v in new_kwargs.items() if k in accepted_names}
-
-    return tuple(new_args), new_kwargs
-def run_pruned_func(func, *args, **kwargs):
-   args,kwargs = prune_inputs(func, *args, **kwargs)
-   return func(*args, **kwargs)

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 os,json,functools,inspect
-from typing import *
-
+import inspect
+import json
+import functools
 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,39 +370,3 @@ 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/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/{compare_utils/compare_utils.py → compare_utils.py}

@@ -9,7 +9,7 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import string
-from ..type_utils import is_number,make_list
+from .type_utils import is_number,make_list
 def get_comp(string:str, string_2:str):
     """
     Calculates the similarity between two strings.

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 *
-import importlib, sys, os, sys,inspect
-from typing import Optional
+from typing import Any, Callable, Iterable, Optional
+import inspect, sys
 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,6 +181,14 @@ 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 = get_caller_dir()
+    get_for_all_tabs(root)

abstract_utilities/json_utils.py

@@ -188,41 +188,6 @@ def find_keys(data, target_keys):
     values = []
     _find_keys_recursive(data, target_keys, values)
     return values
-def try_json_dumps_spec(obj, logger=True, level='error', file_path=None, **kwargs):
-    """
-    Attempts to serialize an object to JSON using json.dumps or json.dump.
-    
-    Args:
-        obj: The Python object to serialize (e.g., dict, list, str, int, etc.).
-        logger: Logger object or None to use _default_logger.
-        level: Logging level for errors (default: 'error').
-        file_path: If provided, writes JSON to this file using json.dump.
-        **kwargs: Additional arguments to pass to json.dumps or json.dump (e.g., indent, sort_keys).
-    
-    Returns:
-        str: The JSON-serialized string if file_path is None and serialization succeeds.
-        None: If serialization fails or file_path is provided (in which case it writes to the file).
-    
-    Raises:
-        ValueError: If file_path is provided but the file cannot be written.
-    """
-    
-    try:
-        if file_path:
-            # Use json.dump to write to a file
-            with open(file_path, 'w', encoding='utf-8') as f:
-                json.dump(obj, f, **kwargs)
-            return None
-        else:
-            # Use json.dumps to return a string
-            return json.dumps(obj)
-    except (TypeError, OverflowError, ValueError) as e:
-        if log_callable:
-            print_or_log(f"Exception in json.dumps/dump: {e}")
-        return None
-def run_it(endpoint,**kwargs):
-    response= make_request_link('typicaly',endpoint,data=kwargs)
-    return response
 def get_logNone(e):
     logger(f"{e}")
     return None

abstract_utilities/log_utils.py

@@ -5,17 +5,6 @@ from flask import jsonify
 from .path_utils import mkdirs
 from logging.handlers import RotatingFileHandler
 from .abstract_classes import SingletonMeta
-from pathlib import Path
-
-def _normalize(obj):
-    """Recursively turn PosixPath into str, sets into list, etc."""
-    if isinstance(obj, Path):
-        return str(obj)
-    if isinstance(obj, dict):
-        return {k: _normalize(v) for k, v in obj.items()}
-    if isinstance(obj, (list, tuple, set)):
-        return [_normalize(x) for x in obj]
-    return obj
 
 
 # from abstract_utilities import get_logFile  # Potential conflict - consider removing or renaming
@@ -229,11 +218,11 @@ def initialize_call_log(value=None,
 
     print_or_log(full_message,level=log_level)
     
-def get_json_call_response(value=None, status_code=None, data=None, logMsg=None, callLog=False):
+def get_json_call_response(value, status_code, data=None,logMsg=None,callLog = False):
     response_body = {}
     if status_code == 200:
         response_body["success"] = True
-        response_body["result"] = _normalize(value)
+        response_body["result"] = value
         logMsg = logMsg or "success"
         if callLog:
             initialize_call_log(value=value,
@@ -242,7 +231,7 @@ def get_json_call_response(value=None, status_code=None, data=None, logMsg=None,
                             log_level='info')
     else:
         response_body["success"] = False
-        response_body["error"] = _normalize(value)
+        response_body["error"] = value
         logMsg = logMsg or f"ERROR: {logMsg}"
         initialize_call_log(value=value,
                             data=data,

abstract_utilities/path_utils.py

@@ -23,13 +23,8 @@ Date: 05/31/2023
 Version: 0.1.2
 """
 import os
-from .read_write_utils import read_from_file,write_to_file
-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
-
+import platform
+from .read_write_utils import read_from_file
 def get_os_info():
     """
     Get Operating System Information
@@ -577,87 +572,8 @@ def remove_path(path=None):
             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
-            }
+    dirName = os.path.dirname(path)
+    baseName = os.path.basename(path)
+    fileName, ext = os.path.splitext(baseName)
+    return {"dirName": dirName, "baseName": baseName, "fileName": fileName, "ext": ext}