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

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,42 +1,145 @@
 from .imports import *
-def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+import os, sys, inspect, logging
+from logging.handlers import RotatingFileHandler
+import logging
+from pathlib import Path
+PACKAGE_NAME = "abstract_utilities"   # ← update if needed
+
+
+def _resolve_log_root():
     """
-    If bpName is None, use the “caller module’s basename” as the logger name.
-    Otherwise, use the explicitly provided bpName.
+    Returns a safe writable logging directory depending on environment:
+    - If running in a virtualenv → <venv>/.logs/<package>
+    - Else if user writable → ~/.cache/<package>/logs
+    - Else → /var/log/<package>
     """
-    if bpName is None:
-        # Find the first frame outside logging_utils.py
-        frame_idx = _find_caller_frame_index()
-        frame_info = inspect.stack()[frame_idx]
-        caller_path = frame_info.filename  # e.g. "/home/joe/project/app/routes.py"
-        bpName = os.path.splitext(os.path.basename(caller_path))[0]
-        del frame_info
-
-
-
-    logger = logging.getLogger(bpName)
-    logger.setLevel(logging.INFO)
-
-    if not logger.handlers:
-        try:
-            log_dir = mkdirs("logs")
-            log_path = os.path.join(log_dir, f"{bpName}.log")
-            handler = RotatingFileHandler(log_path, maxBytes=maxBytes, backupCount=backupCount)
-            handler.setLevel(logging.INFO)
-
-            fmt = "%(asctime)s - %(levelname)s - %(pathname)s - %(message)s"
-            formatter = logging.Formatter(fmt)
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-
-            console = logging.StreamHandler()
-            console.setLevel(logging.INFO)
-            console.setFormatter(formatter)
-            logger.addHandler(console)
-        except Exception as e:
-            print(f"{e}")
+    # 1) Virtualenv or Conda environment
+    venv = os.getenv("VIRTUAL_ENV") or os.getenv("CONDA_PREFIX")
+    if venv:
+        root = os.path.join(venv, ".logs", PACKAGE_NAME)
+        os.makedirs(root, exist_ok=True)
+        return root
+
+    # 2) User home cache folder
+    home = os.path.expanduser("~")
+    user_cache_root = os.path.join(home, ".cache", PACKAGE_NAME, "logs")
+    try:
+        os.makedirs(user_cache_root, exist_ok=True)
+        return user_cache_root
+    except PermissionError:
+        pass
+
+    # 3) Last resort: system log dir (requires correct service user permissions)
+    system_root = f"/var/log/{PACKAGE_NAME}"
+    try:
+        os.makedirs(system_root, exist_ok=True)
+        return system_root
+    except PermissionError:
+        # Fail-safe fallback to /tmp
+        fallback = f"/tmp/{PACKAGE_NAME}/logs"
+        os.makedirs(fallback, exist_ok=True)
+        return fallback
+
+
+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)
+##
+##        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)
+
+    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)
+
+    except PermissionError:
+        # 🔒 Import-safe fallback
+        logger.addHandler(logging.NullHandler())
+
+    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()):
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        if module and module.__name__ not in (__name__, "logging"):
+            return idx
+    return 1
 def _find_caller_frame_index():
     """
     Scan up the call stack until we find a frame whose module is NOT logging_utils.

abstract_utilities/parse_utils/parse_utils.py

@@ -64,6 +64,29 @@ def detect_language_from_text(text: str):
 
     likely = [lang for lang, score in scores.items() if score == max_score]
     return likely[0] if len(likely) == 1 else 'uncertain'
+def get_tripple_string(string):
+    nustring = ''
+    for i in range(3):
+        nustring +=string
+    return nustring
+def get_within_quotes(text,quotes=None):
+    quotes_strings = quotes or ["'",'"']
+    in_quotes = []
+    for quotes_string in quotes_strings:
+        if not isinstance(quotes_string,list):
+            tripple= get_tripple_string(quotes_string)
+            texts = [text]
+            if tripple in text:
+                texts= text.split(tripple)
+            for text_part in texts:
+                quote_count = len(text_part) - len(text_part.replace(quotes_string,''))
+                quote_spl = text_part.split(quotes_string)
+                in_quotes+=[quote_spl[i] for i in range(quote_count) if ((i == 1 or i%2 != float(0)) and len(quote_spl) > i)]
+        else:
+            texts= text.split(quotes_string[0])
+            for text in texts:
+                in_quotes.append(text.split(quotes_string[1])[0])
+    return in_quotes
 
 def search_code(code_languages, parts):
     return [data for datas in parts for data in make_list(datas)

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

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

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 --------------------------------------------------------
@@ -194,45 +226,114 @@ def write_to_path(
 ##        f.write(str(contents))
 ##    return file_path
 # --- Core functionality -------------------------------------------------------
-def write_to_file(*args, **kwargs):
+##def write_to_file(*args, **kwargs):
+##    """
+##    Write contents to a file (create if missing).
+##
+##    Returns the file_path written.
+##    """
+##    file_path, contents = check_read_write_params(*args, **kwargs)
+##    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
+##    dirname = os.path.dirname(file_path)
+##    
+##    if contents is None:
+##        raise ValueError("Missing contents to write.")
+##    user_at_host = kwargs.get("user_at_host")
+##    if get_user_pass_host_key(**kwargs):
+##        make_dirs(dirname, exist_ok=True,**kwargs)
+##        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
+##        # sanitize for shell safety
+##        quoted_path = shlex.quote(file_path)
+##        quoted_data = shlex.quote(str(contents))
+##        # shell command that fully overwrites
+##        # (no append, replaces contents entirely)
+##        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
+##        if not kwargs.get('password') and not kwargs.get('key'):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##        result = run_pruned_func(run_cmd,**kwargs)
+##        if 'file_path' in kwargs:
+##            del kwargs['file_path']
+##        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
+##            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
+##            result = run_pruned_func(run_cmd,**kwargs)
+##        return result
+##
+##    make_dirs(dirname or ".", exist_ok=True)
+##    with open(file_path, "w", encoding="utf-8") as f:
+##        f.write(str(contents))
+##    return file_path
+
+def _should_use_remote(**kwargs) -> bool:
     """
-    Write contents to a file (create if missing).
+    Only use remote mode IF:
+    - user_at_host is provided
+    - AND password/key is provided
+    Otherwise: local write.
+    """
+    user = kwargs.get("user_at_host")
+    if not user:
+        return False  # not remote
+
+    # If user_at_host is provided, then password or key MUST be present
+    if kwargs.get("password") or kwargs.get("key"):
+        return True
+
+    return False  # user provided but no auth → treat as local
 
-    Returns the file_path written.
+
+def _write_to_file(contents: str, file_path: str, **kwargs) -> str:
     """
-    file_path, contents = check_read_write_params(*args, **kwargs)
-    values,kwargs = get_from_kwargs(['file_path','contents'],del_kwarg=True,**kwargs)
-    dirname = os.path.dirname(file_path)
-    
-    if contents is None:
-        raise ValueError("Missing contents to write.")
-    user_at_host = kwargs.get("user_at_host")
-    if get_user_pass_host_key(**kwargs):
-        make_dirs(dirname, exist_ok=True,**kwargs)
-        kwargs["cwd"] = kwargs.get('cwd') or os.path.dirname(file_path)
-        # sanitize for shell safety
-        quoted_path = shlex.quote(file_path)
-        quoted_data = shlex.quote(str(contents))
-        # shell command that fully overwrites
-        # (no append, replaces contents entirely)
-        kwargs["cmd"] = f'sh -c "echo {quoted_data} > {quoted_path}"'
-        if not kwargs.get('password') and not kwargs.get('key'):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-        result = run_pruned_func(run_cmd,**kwargs)
-        if 'file_path' in kwargs:
-            del kwargs['file_path']
-        if not is_file(file_path,**kwargs) or str(contents) != read_from_file(file_path,**kwargs):
-            kwargs["cmd"]=f'sudo {kwargs["cmd"]}'
-            result = run_pruned_func(run_cmd,**kwargs)
-        return result
-
-    make_dirs(dirname or ".", exist_ok=True)
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(str(contents))
-    return file_path
-
-
-def read_from_file(file_path,**kwargs):
+    Unified writer using stage → install model.
+    """
+
+    remote = _should_use_remote(**kwargs)
+
+    # --- Remote path (unchanged conceptually) ---
+    if remote:
+        tmp_path = _stage_file(contents)
+
+        user_at_host = kwargs["user_at_host"]
+        password = kwargs.get("password")
+        key = kwargs.get("key")
+
+        # 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=scp_cmd,
+            password=password,
+            key=key,
+            **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 public writer.
+    """
+    try:
+        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=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 *