abstract-utilities 0.2.2.627__py3-none-any.whl → 0.2.2.700__py3-none-any.whl

abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py

@@ -0,0 +1,41 @@
+from ...imports import *
+from .nullProxy import nullProxy,nullProxy_logger
+@lru_cache(maxsize=None)
+def lazy_import_single(name: str,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+
+    if name in sys.modules:
+        return sys.modules[name]
+
+    try:
+        module = importlib.import_module(name)
+        return module
+    except Exception as e:
+        nullProxy_logger.warning(
+            "[lazy_import] Failed to import '%s': %s",
+            name,
+            e,
+        )
+        return nullProxy(name,fallback=fallback)
+
+def get_lazy_attr(module_name: str, *attrs,fallback=None):
+    obj = lazy_import(module_name,fallback=fallback)
+
+    for attr in attrs:
+        try:
+            obj = getattr(obj, attr)
+        except Exception:
+            return nullProxy(module_name, attrs,fallback=fallback)
+
+    return obj
+def lazy_import(name: str, *attrs,fallback=None):
+    """
+    Import module safely. If unavailable, return NullProxy.
+    """
+    if attrs:
+        obj = get_lazy_attr(name, *attrs,fallback=fallback)
+    else:
+        obj = lazy_import_single(name,fallback=fallback)
+    return obj

abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py

@@ -0,0 +1,37 @@
+from ...imports import *
+nullProxy_logger = logging.getLogger("abstract.lazy_import")
+
+
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=(),fallback=None):
+        self._name = name
+        self._path = path
+        self.fallback=fallback
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        if self.fallback is not None:
+            try:
+                return self.fallback(*args, **kwargs)
+            except Exception as e:
+                logger.info(f"{e}")
+        nullProxy_logger.warning(
+            "[lazy_import] Call to missing module/attr: %s.%s args=%s kwargs=%s",
+            self._name,
+            ".".join(self._path),
+            args,
+            kwargs,
+        )
+        return None
+
+    def __repr__(self):
+        full = ".".join((self._name, *self._path))
+        return f"<nullProxy {full}>"
+
+    def __bool__(self):
+        return False  # safe in conditionals

abstract_utilities/import_utils/src/nullProxy.py

@@ -0,0 +1,30 @@
+from ...imports import *
+lazy_import_logger = logging.getLogger("abstract.lazy_import")
+class nullProxy:
+    """
+    Safe, chainable, callable placeholder for missing modules/attributes.
+    """
+
+    def __init__(self, name, path=()):
+        self._name = name
+        self._path = path
+
+    def __getattr__(self, attr):
+        return nullProxy(self._name, self._path + (attr,))
+
+    def __call__(self, *args, **kwargs):
+        lazy_import_logger.warning(
+            "[lazy_import] Call to missing module/attr: %s.%s args=%s kwargs=%s",
+            self._name,
+            ".".join(self._path),
+            args,
+            kwargs,
+        )
+        return None
+
+    def __repr__(self):
+        full = ".".join((self._name, *self._path))
+        return f"<nullProxy {full}>"
+
+    def __bool__(self):
+        return False  # safe in conditionals

abstract_utilities/imports.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 import re,pexpect,shlex,ezodf,tiktoken,geopandas as gpd,os,PyPDF2,json,tempfile,requests
 import textwrap,pdfplumber,math,hashlib,pandas as pd,platform,textwrap as tw,glob,asyncio
-import fnmatch,importlib,shutil,sys,time,threading,posixpath,importlib.util,types
+import fnmatch,importlib,shutil,sys,time,threading,posixpath,importlib.util,types, logging
 import subprocess,pytesseract,queue,logging,functools,pathlib,pkgutil,inspect
 from typing import *
 from datetime import timedelta,datetime
 from flask import jsonify
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
-from functools import reduce
+from functools import reduce,lru_cache
 from types import MethodType,ModuleType
 from werkzeug.utils import secure_filename
 from werkzeug.datastructures import FileStorage
@@ -16,3 +16,6 @@ from pdf2image import convert_from_path # only used for OCR fallback
 from dataclasses import dataclass,field,asdict
 from pprint import pprint
 from dotenv import load_dotenv
+from types import MethodType
+from datetime import datetime, date
+from decimal import Decimal

abstract_utilities/json_utils/imports/imports.py

@@ -1,2 +1,2 @@
-from ...imports import json,re,os,logging
+from ...imports import *
 from typing import *

abstract_utilities/json_utils/json_utils.py

@@ -26,6 +26,13 @@ from .imports import *
 
 logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+def get_keys(mapping,typ=None):
+    typ = typ or set
+    if isinstance(mapping,dict):
+        mapping = mapping.keys()
+    return typ(mapping)
+def make_key_map(dict_obj):
+    return {k:get_keys(v) for k,v in dict_obj.items()}
 def convert_and_normalize_values(values):
     for value in values:
         if isinstance(value, str):
@@ -116,10 +123,11 @@ def safe_dump_to_file(data, file_path=None, ensure_ascii=False, indent=4, *args,
     else:
         logger.error("file_path and data must be provided to safe_dump_to_file")
 
-def safe_read_from_json(*args,**kwargs):
+def safe_read_from_json(file_path,*args,**kwargs):
     is_read=True
-    file_path = args[0]
-    valid_file_path = get_file_path(*args,is_read=is_read,**kwargs)
+
+
+    valid_file_path = get_file_path(file_path,*args,is_read=is_read,**kwargs)
     if valid_file_path:
         file_path = valid_file_path
     try:
@@ -741,3 +749,29 @@ def flatten_json(data, parent_key='', sep='_'):
         items.append((parent_key, data))
 
     return dict(items)
+
+
+def to_json_safe(obj):
+    if obj is None:
+        return None
+
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+
+    if isinstance(obj, (datetime, date)):
+        return obj.isoformat()
+
+    if isinstance(obj, Decimal):
+        return float(obj)
+
+    if isinstance(obj, Path):
+        return str(obj)
+
+    if isinstance(obj, dict):
+        return {k: to_json_safe(v) for k, v in obj.items()}
+
+    if isinstance(obj, (list, tuple, set)):
+        return [to_json_safe(v) for v in obj]
+
+    # Fallback (yt-dlp objects, enums, etc.)
+    return str(obj)

abstract_utilities/list_utils/list_utils.py

@@ -197,3 +197,6 @@ def make_list(obj:any) -> list:
 def make_list_it(obj=None):
     obj = make_list(obj or [])
     return obj
+
+def get_single_from_list(list_obj,default=None):
+    return make_list(list_obj or default)[0]

abstract_utilities/log_utils/log_file.py

@@ -1,7 +1,8 @@
 from .imports import *
 import os, sys, inspect, logging
 from logging.handlers import RotatingFileHandler
-
+import logging
+from pathlib import Path
 PACKAGE_NAME = "abstract_utilities"   # ← update if needed
 
 
@@ -43,39 +44,93 @@ def _resolve_log_root():
 LOG_ROOT = _resolve_log_root()
 
 
-def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
-    """
-    A logger that always writes to a safe OS-appropriate path.
-    Works even when installed through pip.
-    """
-    if bpName is None:
-        frame_idx = _find_caller_frame_index()
-        frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename
-        bpName = os.path.splitext(os.path.basename(caller_path))[0]
-        del frame_info
-
-    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
-    logger.setLevel(logging.INFO)
-
-    if not logger.handlers:
-        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
-        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+##def get_logFile(bpName=None, maxBytes=100_000, backupCount=3):
+##    """
+##    A logger that always writes to a safe OS-appropriate path.
+##    Works even when installed through pip.
+##    """
+##    if bpName is None:
+##        frame_idx = _find_caller_frame_index()
+##        frame_info = inspect.stack()[frame_idx]
+##        caller_path = frame_info.filename
+##        bpName = os.path.splitext(os.path.basename(caller_path))[0]
+##        del frame_info
+##
+##    logger = logging.getLogger(f"{PACKAGE_NAME}.{bpName}")
+##    logger.setLevel(logging.INFO)
+##
+##    if not logger.handlers:
+##        log_file = os.path.join(LOG_ROOT, f"{bpName}.log")
+##        handler = RotatingFileHandler(log_file, maxBytes=maxBytes, backupCount=backupCount)
+##
+##        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
+##        formatter = logging.Formatter(fmt)
+##        handler.setFormatter(formatter)
+##
+##        logger.addHandler(handler)
+##
+##        # Console handler (optional; can disable for gunicorn)
+##        console = logging.StreamHandler(sys.stdout)
+##        console.setFormatter(formatter)
+##        logger.addHandler(console)
+##
+##    return logger
+LOG_FORMAT = (
+    "[%(asctime)s] "
+    "%(levelname)-8s "
+    "%(name)s:%(lineno)d | "
+    "%(message)s"
+)
+
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+
+
+def get_logFile(
+    name: str,
+    log_dir: str | Path = "logs",
+    level: int = logging.INFO,
+    console: bool = True,
+    max_bytes: int = 5 * 1024 * 1024,
+    backup_count: int = 5,
+):
+    logger = logging.getLogger(name)
+
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(level)
+
+    formatter = logging.Formatter(LOG_FORMAT, DATE_FORMAT)
 
-        fmt = "%(asctime)s - %(levelname)s - %(pathname)s:%(lineno)d - %(message)s"
-        formatter = logging.Formatter(fmt)
-        handler.setFormatter(formatter)
+    try:
+        log_dir = Path(log_dir)
+        log_dir.mkdir(parents=True, exist_ok=True)
+
+        file_handler = RotatingFileHandler(
+            log_dir / f"{name}.log",
+            maxBytes=max_bytes,
+            backupCount=backup_count,
+            encoding="utf-8",
+        )
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
 
-        logger.addHandler(handler)
+    except PermissionError:
+        # 🔒 Import-safe fallback
+        logger.addHandler(logging.NullHandler())
 
-        # Console handler (optional; can disable for gunicorn)
-        console = logging.StreamHandler(sys.stdout)
-        console.setFormatter(formatter)
-        logger.addHandler(console)
+    if console:
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
 
+    logger.propagate = False
     return logger
 
 
+
 def _find_caller_frame_index():
     """Find the correct caller module outside this logger."""
     for idx, frame_info in enumerate(inspect.stack()):

abstract_utilities/path_utils/imports/module_imports.py

@@ -2,7 +2,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,get_slash
-from ...class_utils import get_caller_path,get_caller_dir
+from ...class_utils import get_caller_path,get_caller_dir,get_initial_caller,get_initial_caller_dir
 from ...file_utils import is_file,is_dir,is_exists
 from ...ssh_utils import is_file,is_dir,is_exists
 from ...directory_utils import *

abstract_utilities/path_utils/path_utils.py

@@ -107,17 +107,6 @@ def path_join(*paths, isfile=False):
         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)
@@ -132,7 +121,7 @@ def get_all_files(directory=None):
 
 def get_all_items(directory):
     dir_list = os.listdir(directory)
-    file_list = [item for item in dir_list if is_path(directory,item)]
+    file_list = [item for item in dir_list if is_exists(directory,item)]
     return file_list
 
 
@@ -176,6 +165,7 @@ def get_safe_splitext(path=None,basename=None):
         basename_str = str(basename)
         filename,ext = os.path.splitext(basename_str)
         return filename,ext
+    return None,None
 def get_safe_filename(path=None,basename=None):
     filename,_ = get_safe_splitext(path=path,basename=basename)
     return filename
@@ -223,6 +213,11 @@ def create_base_dir(directory=None, child=None):
 
 
 
+def get_abs_path(path,i=None):
+    abs_dir = get_initial_caller_dir()
+    return os.path.join(abs_dir,path)
+    
+
 
 def get_file_parts(path):
     if path:

abstract_utilities/read_write_utils/read_write_utils.py

@@ -15,6 +15,38 @@ Usage:
 from .imports import *
 _FILE_PATH_KEYS = ['file', 'filepath', 'file_path', 'path', 'directory', 'f', 'dst', 'dest']
 _CONTENTS_KEYS = ['cont', 'content', 'contents', 'data', 'datas', 'dat', 'src', 'source']
+from pathlib import Path
+import uuid
+import shlex
+
+_STAGE_ROOT = Path("/var/tmp/abstract_stage")
+
+
+def _stage_file(contents: str, suffix=".tmp") -> Path:
+    """
+    Write contents to a local staging file.
+    """
+    _STAGE_ROOT.mkdir(parents=True, exist_ok=True)
+    path = _STAGE_ROOT / f"{uuid.uuid4().hex}{suffix}"
+    path.write_text(str(contents), encoding="utf-8")
+    return path
+
+
+def _install_file(staged: Path, dest: str, **kwargs) -> str:
+    """
+    Atomically install a staged file to destination using sudo install.
+    """
+    cmd = (
+        f"sudo install -D -m 0644 "
+        f"{shlex.quote(str(staged))} "
+        f"{shlex.quote(dest)}"
+    )
+    return run_local_cmd(
+        cmd=cmd,
+        password=kwargs.get("password"),
+        key=kwargs.get("key"),
+        env_path=kwargs.get("env_path"),
+    )
 
             
 # --- Helper utilities --------------------------------------------------------
@@ -251,56 +283,57 @@ def _should_use_remote(**kwargs) -> bool:
 
 def _write_to_file(contents: str, file_path: str, **kwargs) -> str:
     """
-    Universal safe writer for any file content.
-    Works locally and remotely without breaking quotes.
+    Unified writer using stage → install model.
     """
 
-    # --- Decode mode selection ---
     remote = _should_use_remote(**kwargs)
 
-    # Create directory path
-    dirname = os.path.dirname(file_path)
-    make_dirs(dirname, exist_ok=True, **kwargs)
-
-    # Base64 encoding ensures zero escaping issues
-    b64 = base64.b64encode(contents.encode("utf-8")).decode("utf-8")
+    # --- Remote path (unchanged conceptually) ---
+    if remote:
+        tmp_path = _stage_file(contents)
 
-    # Build decode + tee command
-    cmd = (
-        f"echo '{b64}' | base64 -d | "
-        f"sudo tee {shlex.quote(file_path)} > /dev/null"
-    )
+        user_at_host = kwargs["user_at_host"]
+        password = kwargs.get("password")
+        key = kwargs.get("key")
 
-    # --- Local write ---
-    if not remote:
+        # copy staged file
+        scp_cmd = (
+            f"scp {shlex.quote(str(tmp_path))} "
+            f"{shlex.quote(user_at_host)}:{shlex.quote(file_path)}"
+        )
         return run_pruned_func(
             run_local_cmd,
-            cmd=cmd,
+            cmd=scp_cmd,
+            password=password,
+            key=key,
             **kwargs
         )
 
-    # --- Remote write ---
-    return run_pruned_func(
-        run_remote_cmd,
-        user_at_host=kwargs["user_at_host"],
-        cmd=cmd,
-        **kwargs
-    )
+    # --- Local path ---
+    try:
+        # Attempt direct write for non-privileged paths
+        os.makedirs(os.path.dirname(file_path) or ".", exist_ok=True)
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(str(contents))
+        return file_path
+
+    except (PermissionError, FileNotFoundError):
+        # Privileged path → stage + install
+        staged = _stage_file(contents)
+        return _install_file(staged, file_path, **kwargs)
+
 
 
 def write_to_file(*, contents: str, file_path: str, **kwargs):
     """
-    Error-handled wrapper.
+    Error-handled public writer.
     """
-
     try:
-        result = _write_to_file(contents=contents, file_path=file_path, **kwargs)
-        return result
-
+        return _write_to_file(contents=contents, file_path=file_path, **kwargs)
     except Exception as e:
         print("WRITE ERROR:", e)
         raise RuntimeError(f"Failed writing: {file_path}")
-def read_from_file(file_path,**kwargs):
+def read_from_file(file_path=None,**kwargs):
     if get_user_pass_host_key(**kwargs):
         kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
         basename = os.path.basename(file_path)

abstract_utilities/type_utils/__init__.py

@@ -1,3 +1,7 @@
+from .imports import *
 from .alpha_utils import *
 from .num_utils import *
-from .type_utils import *
+from .is_type import *
+from .make_type import *
+from .get_type import *
+from .mime_types import *

abstract_utilities/type_utils/get_type.py

@@ -0,0 +1,120 @@
+from .imports import *
+from .alpha_utils import *
+from .num_utils import *
+from .is_type import *
+from .make_type import *
+def get_obj_obj(obj_type: str, obj: any) -> any:
+    """
+    Returns the object converted according to the given type string.
+    
+    Args:
+        obj_type: The string representing the type to convert to.
+        obj: The object to convert.
+        
+    Returns:
+        any: The object converted to the specified type.
+    """
+    if obj_type == 'str':
+        return make_str(obj)
+    elif obj_type == 'bool':
+        return make_bool(obj)
+    elif obj_type == 'float':
+        return make_float(obj)
+    elif obj_type == 'int':
+        try:
+            return int(obj)
+        except (TypeError, ValueError):
+            return obj
+    else:
+        return obj
+def get_len_or_num(obj: any) -> int:
+    """
+    Returns the length of the object if it can be converted to a string, else the integer representation of the object.
+    
+    Args:
+        obj: The object to process.
+        
+    Returns:
+        int: The length of the object as a string or the integer representation of the object.
+    """
+    if is_int(obj) or is_float(obj):
+        return int(obj)
+    else:
+        try:
+            return len(str(obj))
+        except (TypeError, ValueError):
+            return 0
+def get_types_list()->list:
+    return ['list', 'bool', 'str', 'int', 'float', 'set', 'dict', 'frozenset', 'bytearray', 'bytes', 'memoryview', 'range', 'enumerate', 'zip', 'filter', 'map', 'property', 'slice', 'super', 'type', 'Exception', 'NoneType']
+
+
+def str_lower(obj):
+    try:
+        obj=str(obj).lower()
+    except Exception as e:
+        print(f"{e}")
+    return obj
+
+def get_bool_response(bool_response,json_data):
+    if not is_instance(bool_response,bool):
+        try:
+            bool_response = json_data.get(bool_response) in [None,'',[],"",{}]
+        except:
+            pass       
+    return bool_response
+def get_alphabet_str():
+  return 'abcdefghijklmnopqrstuvwxyz'
+def get_alphabet_upper_str():
+  alphabet_str = get_alphabet_str()
+  return alphabet_str.upper()
+def get_alphabet_comp_str():
+  return get_alphabet_str() + get_alphabet_upper_str()
+
+def get_alphabet():
+  alphabet_str = get_alphabet_str()
+  return break_string(alphabet_str)
+def get_alphabet_upper():
+  alphabet_upper_str = get_alphabet_upper_str()
+  return break_string(alphabet_upper_str)
+def get_alphabet_comp():
+  alphabet_comp_str = get_alphabet_comp_str()
+  return break_string(alphabet_comp_str)
+def get_numbers_str():
+  return '0123457890'
+def get_numbers_int():
+  numbers_str = get_numbers_str()
+  return [int(number) for number in numbers_str]
+def get_numbers():
+  numbers_str = get_numbers_str()
+  return break_string(numbers_str)
+def get_numbers_comp():
+  numbers_str = get_numbers()
+  numbers_int = get_numbers_int()
+  return numbers_str + numbers_int
+def break_string(string):
+  string_str = str(string)
+  return list(string_str)
+def get_alpha_ints(ints=True,alpha=True,lower=True,capitalize=True,string=True,listObj=True):
+    objs = [] if listObj else ""
+    if ints:
+        objs+=getInts(string=string,listObj=listObj)
+    if alpha:
+        objs+=getAlphas(lower=lower,capitalize=capitalize,listObj=listObj)
+    return objs
+def if_true_get_string(data, key):
+    return key if data.get(key) else None
+def find_for_string(string, parts):
+    return [part for part in parts if string.lower() in str(part).lower()]
+
+
+def is_strings_in_string(strings, parts):
+    strings = make_list(strings)
+    for string in strings:
+        parts = find_for_string(string, parts)
+        if not parts:
+            return []
+    return parts
+def if_not_bool_default(value,default=None):
+    if not isinstance(value,bool):
+        value = default
+    return value

abstract_utilities/type_utils/imports/__init__.py

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