abstract-utilities 0.2.2.667__py3-none-any.whl → 0.2.2.680__py3-none-any.whl

abstract_utilities/__init__.py

@@ -32,7 +32,8 @@ from .json_utils import (unified_json_loader,
                          safe_write_to_file,
                          safe_save_updated_json_data,
                          get_result_from_data,
-                         flatten_json
+                         flatten_json,
+                         to_json_safe
                          )
 
 from .directory_utils import *
@@ -45,7 +46,9 @@ from .list_utils import (get_highest_value_obj,
                          compare_lists,
                          get_symetric_difference,
                          list_set,
-                         make_list_it)
+                         make_list_it,
+                         get_single_from_list
+                         )
 from .time_utils import (get_time_stamp,
                          get_sleep,
                          sleep_count_down,

abstract_utilities/file_utils/imports/module_imports.py

@@ -1,5 +1,5 @@
 from ...list_utils import make_list
-from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str
+from ...type_utils import get_media_exts, is_media_type, MIME_TYPES, is_str,if_not_bool_default
 from ...ssh_utils import *
 from ...env_utils import *
 from ...read_write_utils import read_from_file,write_to_file

abstract_utilities/file_utils/src/find_collect.py

@@ -188,3 +188,13 @@ def collect_filepaths(
     ) -> List[str]:
     kwargs['file_type']='f'
     return collect_globs(*args,**kwargs)
+
+def get_filename(path):
+    basename = os.path.basename(path)
+    filename,ext = os.path.splitext(basename)
+    return filename
+def find_files(filename,directory=None,add=None):
+    add = if_not_bool_default(add,default=True)
+    directory = directory or os.getcwd()
+    dirs,files = get_files_and_dirs(directory,add=add)
+    return [file for file in files if get_filename(file) == filename]

abstract_utilities/import_utils/src/import_utils.py

@@ -326,12 +326,14 @@ def initFuncs(self, mode=None):
         existing = set(self.__dict__) | set(dir(self))
 
         for _, module_name, _ in pkgutil.iter_modules(pkg.__path__):
-            mod = importlib.import_module(f"{pkg.__name__}.{module_name}")
-
-            for name, obj in inspect.getmembers(mod, inspect.isfunction):
-                if name not in existing:
-                    setattr(self, name, obj.__get__(self))
+            try:
+                mod = importlib.import_module(f"{pkg.__name__}.{module_name}")
 
+                for name, obj in inspect.getmembers(mod, inspect.isfunction):
+                    if name not in existing:
+                        setattr(self, name, obj.__get__(self))
+            except Exception as e:
+                logger.error(f"initFuncs({mode}) pkgutil error: {e}")
     except Exception as e:
         logger.error(f"initFuncs({mode}) error: {e}")
 

abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py

@@ -1,7 +1,7 @@
 from ...imports import *
 from .nullProxy import nullProxy,nullProxy_logger
 @lru_cache(maxsize=None)
-def lazy_import_single(name: str):
+def lazy_import_single(name: str,fallback=None):
     """
     Import module safely. If unavailable, return NullProxy.
     """
@@ -18,24 +18,24 @@ def lazy_import_single(name: str):
             name,
             e,
         )
-        return nullProxy(name)
+        return nullProxy(name,fallback=fallback)
 
-def get_lazy_attr(module_name: str, *attrs):
-    obj = lazy_import(module_name)
+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)
+            return nullProxy(module_name, attrs,fallback=fallback)
 
     return obj
-def lazy_import(name: str, *attrs):
+def lazy_import(name: str, *attrs,fallback=None):
     """
     Import module safely. If unavailable, return NullProxy.
     """
     if attrs:
-        obj = get_lazy_attr(name, *attrs)
+        obj = get_lazy_attr(name, *attrs,fallback=fallback)
     else:
-        obj = lazy_import_single(name)
+        obj = lazy_import_single(name,fallback=fallback)
     return obj

abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py

@@ -7,14 +7,19 @@ class nullProxy:
     Safe, chainable, callable placeholder for missing modules/attributes.
     """
 
-    def __init__(self, name, path=()):
+    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,

abstract_utilities/imports.py

@@ -17,3 +17,5 @@ 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

@@ -749,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/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,54 +283,53 @@ def _should_use_remote(**kwargs) -> bool:
 
 def _write_to_file(contents: str, file_path: str, **kwargs) -> str:
     """
-    Safe writer that handles arbitrarily large files.
-    Uses native I/O for local writes and streams for remote.
+    Unified writer using stage → install model.
     """
 
     remote = _should_use_remote(**kwargs)
-    dirname = os.path.dirname(file_path)
-    make_dirs(dirname, exist_ok=True, **kwargs)
 
-    # --- Local write (always robust) ---
-    if not remote:
+    # --- 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(contents)
+            f.write(str(contents))
         return file_path
 
-    # --- Remote write ---
-    # Stream data through SSH using base64 chunks instead of huge one-liner
-    import io
-    import base64
-
-    # Write to a temporary file locally first
-    tmp_path = "/tmp/_abstract_write.tmp"
-    with open(tmp_path, "w", encoding="utf-8") as tmpf:
-        tmpf.write(contents)
-
-    user_at_host = kwargs["user_at_host"]
-    password = kwargs.get("password")
-    key = kwargs.get("key")
-
-    # Use scp for remote write — no shell arg limits
-    scp_cmd = f"scp {shlex.quote(tmp_path)} {user_at_host}:{shlex.quote(file_path)}"
-    return run_pruned_func(
-        run_local_cmd,
-        cmd=scp_cmd,
-        password=password,
-        key=key,
-        **kwargs
-    )
+    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}")

abstract_utilities/type_utils/get_type.py

@@ -114,3 +114,7 @@ def is_strings_in_string(strings, 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-0.2.2.667.dist-info → abstract_utilities-0.2.2.680.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_utilities
-Version: 0.2.2.667
+Version: 0.2.2.680
 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.667.dist-info → abstract_utilities-0.2.2.680.dist-info}/RECORD

@@ -1,4 +1,4 @@
-abstract_utilities/__init__.py,sha256=kQ_uhBIlyECizBuYLMRHtwgO4fnlKaGbnXki5jM94IM,5258
+abstract_utilities/__init__.py,sha256=dHCOxtfHTIgNEXqpvJ7kUPGi7io935nlViOuA7zZDhU,5370
 abstract_utilities/abstract_classes.py,sha256=A6-FNDQb2P_jcyt01Kc5SuY2QawLVKNjQ-rDGfsn4rA,2461
 abstract_utilities/circular_import_finder.py,sha256=bs1O4NjSDrJ2cC8whPfZPouNDr1oxdMCFKUIfRyIEB4,8415
 abstract_utilities/circular_import_finder2.py,sha256=n6OFjiIsxxw2u_bf8wcQ81fzQzXhsD4VYWzOC9pDYXw,3869
@@ -10,7 +10,7 @@ abstract_utilities/error_utils.py,sha256=dSMIM3TKe4e9i_akObyjDwy3Zu4fnoWRK9hucg_
 abstract_utilities/global_utils.py,sha256=UkCS1nE561bVbxWsH-YQdFPSeZFMYXV7xg-DAtGUvrI,2204
 abstract_utilities/hash_utils.py,sha256=u7t209ERD9aGONZHqmkYtiQRRadD2qG5ICSTxlYlZMc,206
 abstract_utilities/history_utils.py,sha256=2bG8hMSRzLWMae4mpd2sf1esYtqT2D_3MDxeJnAE2Jw,1633
-abstract_utilities/imports.py,sha256=vhZLc7hzcpkeZJSAo8HjoM-nW7ld4cvlxxJqB1ZfRxU,916
+abstract_utilities/imports.py,sha256=cPUHsQFHxJANgX2SHNK3aMQAPO446GgSWNh-4_kbk5s,980
 abstract_utilities/json_utils.py,sha256=YA4zoBRAsVjdU-BjFd1L5z81Y5X-NuwKrQW5L992EY4,27609
 abstract_utilities/list_utils.py,sha256=i1fZ_kZ0mf_ei6w0MOkuEieRiyF-ReeAXzIdoRI1cvo,6298
 abstract_utilities/log_utils.py,sha256=W74Y-CmdQP4Kj88HmAgejVxWgyWlvgCKMwLvOfyFf9c,9393
@@ -94,13 +94,13 @@ abstract_utilities/file_utils/imports/clean_imps.py,sha256=DB_NEKR8YLla5qCkTMuNs
 abstract_utilities/file_utils/imports/constants.py,sha256=uPsIYVRs1Rf0SQ4pRdAke-tuc28LtgaSHSDS4_seaMk,5997
 abstract_utilities/file_utils/imports/file_functions.py,sha256=brQha7TV9DaJe-hZSuHoFZBUI_45hxrGOIBTAojPWU8,297
 abstract_utilities/file_utils/imports/imports.py,sha256=OQKsPec2raa55hxGUeTo0yDqzw-xBsshljFxG69rHk0,1504
-abstract_utilities/file_utils/imports/module_imports.py,sha256=Mol48vj-m2204MCJgStUyAw8DbH-HFVs21rnGpx5HyI,420
+abstract_utilities/file_utils/imports/module_imports.py,sha256=UGWoPUZ_AUzo9n2wejlwupOEQqEb6ZPt18pdQJXdxrk,440
 abstract_utilities/file_utils/src/__init__.py,sha256=kgjkZ6IWDR_fQJTAQTinUBKUPLurekgdZ15ZT1wm20E,203
 abstract_utilities/file_utils/src/file_filters.py,sha256=n8efrxxJRRd6dT4E5PbGoyGGKe1LU1cYy-b443XhqAo,6355
 abstract_utilities/file_utils/src/file_reader.py,sha256=9fZ2dEXFRYhJNUsUYQO3hGs2uWrHu2o4FacVhfhdefE,22320
 abstract_utilities/file_utils/src/file_utils.py,sha256=jgxMKeOAhYB2dxoqtudo4DKXctRE1TdcSbFcJmHcoiI,5766
 abstract_utilities/file_utils/src/filter_params.py,sha256=tO5PJvYpd3bHQejulDVGHandR-_8w3VPnjiCayrLW9g,6774
-abstract_utilities/file_utils/src/find_collect.py,sha256=wV6u9AsVeJxMCHwyf3NGvzA-QbA_OgLRfQUhjSrLjew,5796
+abstract_utilities/file_utils/src/find_collect.py,sha256=AmgIzO42wuhzs8Q_5Z9iRs2lu-HNypsUSDcAWINTVYc,6189
 abstract_utilities/file_utils/src/find_content.py,sha256=3UI8HsTHR0UnuqybeYW4rxHvER7-SK42_hNZih-LfUU,6806
 abstract_utilities/file_utils/src/initFunctionsGen.py,sha256=WyWv3Gt33QzvI8IxZCGLqAqsramAyoRbpvMTiuJeSTE,10418
 abstract_utilities/file_utils/src/initFunctionsGens.py,sha256=A-I2dL2G58LfpCSI6c_aLbDtAsYvG0wwY37joYnqGcw,9804
@@ -160,14 +160,14 @@ abstract_utilities/import_utils/src/clean_imports.py,sha256=awpVFI-DMd8oOtx3JcUi
 abstract_utilities/import_utils/src/dot_utils.py,sha256=oahEkVmexO-a2F3DKYQP5IrCvKJi9tjM_rjCImM_KCY,2793
 abstract_utilities/import_utils/src/extract_utils.py,sha256=YuDVWbCKDrVDh9M7aZHdsrEoh_infJ3BUv46J6K-UYg,1705
 abstract_utilities/import_utils/src/import_functions.py,sha256=5GxFh32e-DWDZ5IR-LnQTOiEmv15tjb3Fn_yhgnu7q8,4408
-abstract_utilities/import_utils/src/import_utils.py,sha256=v5s1gV5535Wli4SM1dEfbunj1-eW9NTN7u-tYVLiAQs,13128
+abstract_utilities/import_utils/src/import_utils.py,sha256=B0ghZBrv1Gs3l3312UPbCn6TSKKDslegt2hpJcS0IyA,13265
 abstract_utilities/import_utils/src/nullProxy.py,sha256=pYzP_tBJHduqc8IqdvjtRs1miYSab6NzHYiIqYGpduA,849
 abstract_utilities/import_utils/src/package_utils.py,sha256=9qjBzIApDhV7kOdSRgZA9k-EncBNAg3mZZodgsiUNM4,5861
 abstract_utilities/import_utils/src/pkg_utils.py,sha256=tSLaqFgitwswSuGhv-UnONT3rpri9DjK9ALt_0t5I30,7617
 abstract_utilities/import_utils/src/sysroot_utils.py,sha256=k9sNVvp3zYrPV62rsaFLfCzXhaIQc61XJreog0RvOIc,3696
 abstract_utilities/import_utils/src/layze_import_utils/__init__.py,sha256=lhbmFdYlyzCRo9cA_bAnjVwPjsCDKlKe1KKG-oa1A70,51
-abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py,sha256=DzDlmrmSec5uoZ1mfyBzzbANO9zgZ0WkjCMQtKuS1B0,1020
-abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py,sha256=b8wE8bq0R97MPygRjlMsXr0ULgcUUxQmOaNF8bt2X58,847
+abstract_utilities/import_utils/src/layze_import_utils/lazy_utils.py,sha256=B1UKuWfVZnAWAEtvy-97mU-7xwrQDGDbiZYUzSSL6-I,1152
+abstract_utilities/import_utils/src/layze_import_utils/nullProxy.py,sha256=wosvIciVBUWlhBBgHvbkMOR9X3DKGQwgcy3UTG7wKEU,1071
 abstract_utilities/import_utils/src/package_utils/__init__.py,sha256=xV_XKJSLcXf4qRQSRseWLV_iqCqijPm4zvrs-tjNb2M,4618
 abstract_utilities/import_utils/src/package_utils/context_utils.py,sha256=8USSB6LR047k8fqge8J2jEM_StPEZ3cI1OKB3UENN8w,1177
 abstract_utilities/import_utils/src/package_utils/import_collectors.py,sha256=kueQead4CW6FGmHHiXpQilE8spbnt2mSK93dJ3bpeW4,2365
@@ -179,19 +179,19 @@ abstract_utilities/import_utils/src/package_utilss/import_collectors.py,sha256=k
 abstract_utilities/import_utils/src/package_utilss/path_utils.py,sha256=RTbfI4r2XF5mPn9GSS5ZNdmT0h5qM-8uG78pD3X-6-Q,926
 abstract_utilities/import_utils/src/package_utilss/safe_import.py,sha256=2xqu37hRuUwZvNYhvwbzORIdBxzhnJJByF2I4-uzwpg,828
 abstract_utilities/json_utils/__init__.py,sha256=_wzyTwWiqV9fxk85SOsaTXNWY6zDTlALYFix0h3afeo,49
-abstract_utilities/json_utils/json_utils.py,sha256=CEX9r73B8MmGHZLp4dsd2-23YlRp-vqsns_QN3KS8HQ,27521
+abstract_utilities/json_utils/json_utils.py,sha256=12yp8yisclMaHJFp6OtkcGMYpzRmt7-EnYu84LwSnKs,28092
 abstract_utilities/json_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
-abstract_utilities/json_utils/imports/imports.py,sha256=7Z-WJ_nhiAEGJWR05BzKU1M6cDxw8pLMwQqMPCH8Egw,63
+abstract_utilities/json_utils/imports/imports.py,sha256=BfaNN4bs2pvgxVU8XQ_r0uDzxm4alw5H52bZHHcLNyc,46
 abstract_utilities/json_utils/imports/module_imports.py,sha256=jTwYq8g13yHcFkKKVB8jBlYXMt3JsiqN4-yBGeGFApI,253
 abstract_utilities/list_utils/__init__.py,sha256=6Ya5OVuv9QWiDlLFRBDY3bTqgSR0E0tck-ugUzKvlq0,49
-abstract_utilities/list_utils/list_utils.py,sha256=i1fZ_kZ0mf_ei6w0MOkuEieRiyF-ReeAXzIdoRI1cvo,6298
+abstract_utilities/list_utils/list_utils.py,sha256=qcoVZcsrSH3VWIA8jGku_WNllYVbWhOhR8B8HBm8xMw,6393
 abstract_utilities/list_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
 abstract_utilities/list_utils/imports/imports.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 abstract_utilities/list_utils/imports/module_imports.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 abstract_utilities/log_utils/__init__.py,sha256=QzmY8RLyegJsq9Id06dHMiJAit5jxUzwhkY5-qgqxBU,141
 abstract_utilities/log_utils/abstractLogManager.py,sha256=EF4GkNbeCUh_RStN2Sf_PmxgyUmxeB5RJT7P-SHGZ3w,2823
 abstract_utilities/log_utils/call_response.py,sha256=E_QdT6R5REuXxeUuEXLwjUh8D0Lk0vair2ryRj4zocY,2518
-abstract_utilities/log_utils/log_file.py,sha256=5W3Ia5RLGho6WbQNnqZTmQbRiEzUqGYIMlbEyzKElQg,3769
+abstract_utilities/log_utils/log_file.py,sha256=80QQ7LGKhyZ8Gtm4Mczit5qZQcaFwdfTbfSh7Gf-edw,5071
 abstract_utilities/log_utils/logger_callable.py,sha256=9STZtZrmUlXmakxhwmXNPpCSQC10aCTMNjXbhaWZ7_8,1629
 abstract_utilities/log_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
 abstract_utilities/log_utils/imports/imports.py,sha256=TGhATFGyhvovFFKYH-CbCnEQK0WCkmA1C5LqvmmzlrQ,189
@@ -213,7 +213,7 @@ abstract_utilities/path_utils/imports/__init__.py,sha256=wBNCq8vHWdl7DleRNq0UK_-
 abstract_utilities/path_utils/imports/imports.py,sha256=R7rno0pnzOU9XpzPhco0Wp9aIR73w_BGqCLdYpAHowI,32
 abstract_utilities/path_utils/imports/module_imports.py,sha256=q5v_tXKEltMCD6-tJbs9KW7SFuwGaBDSko7SwEh6xlk,418
 abstract_utilities/read_write_utils/__init__.py,sha256=MYC2oSY2NEbnu-iwX55t9m_rFRVxwILY_oUbBCpGJkw,32
-abstract_utilities/read_write_utils/read_write_utils.py,sha256=UA6sGdrrs5eKivQJMjhSiqHNu9a2I_R6vRkrdepki9E,12919
+abstract_utilities/read_write_utils/read_write_utils.py,sha256=0Tyf1PbfUAsRSB0y6ECw9dKm1yIgYDGsKQznoNlFQPU,13741
 abstract_utilities/read_write_utils/imports/__init__.py,sha256=sUUAr6PY1SMtVjSTsb08dFU6mF-Ug4usnbh908q4Jq0,53
 abstract_utilities/read_write_utils/imports/imports.py,sha256=zN1zEfAJ-UbJB34wxm2oVuAiDmyqS12dSoIzojUrsiM,46
 abstract_utilities/read_write_utils/imports/module_imports.py,sha256=cwmzuy1RKPyq2rQtMU6KSMSjDE9jUhPzHPjRTdTXcto,204
@@ -271,7 +271,7 @@ abstract_utilities/time_utils/imports/imports.py,sha256=mQn1yOBb8Oqw3TpmtQctHfLA
 abstract_utilities/time_utils/imports/module_imports.py,sha256=4dCrHHXmZBmJpmWuMIq9MIHOIB8YZvPQyb8_M234lzE,46
 abstract_utilities/type_utils/__init__.py,sha256=_0s-am2TO3lAkMc9IsKb3pnw8kEODQ1Ubw-T_sZe-bI,173
 abstract_utilities/type_utils/alpha_utils.py,sha256=MuuW6LoXN0hp61ejqffyRdG5yRO71N-5aOvIlvvEDEw,1553
-abstract_utilities/type_utils/get_type.py,sha256=O367FC7kNWe1WIYXQGqia96qf7IVbgsrQ0YJTtmOXJ4,3636
+abstract_utilities/type_utils/get_type.py,sha256=bjJbRYxWGvKQR_1D_deOd2vLPmirl0u3v-rvI_OdUE8,3757
 abstract_utilities/type_utils/is_type.py,sha256=mHqgkQnxxI3XYWAXKW7MixYX_TtaemiWKpnt4F_QuHQ,11280
 abstract_utilities/type_utils/make_type.py,sha256=c85YNwBeNiJxvs4Hw31FTKn5mgccKORL9HUfamNR-GA,3297
 abstract_utilities/type_utils/mime_types.py,sha256=Th7Ij3txFgDT3_7MOC4ZALbf55_KnoXduEU0JER_h4w,2237
@@ -282,7 +282,7 @@ abstract_utilities/type_utils/imports/constants.py,sha256=HUCD5R1URZLuG1hHOinDR8
 abstract_utilities/type_utils/imports/imports.py,sha256=C_ZAQO-y7R31BYxTuaHJCEQE9IZSU1JgCtdHNWxZKhY,77
 abstract_utilities/type_utils/imports/module_imports.py,sha256=qWWGttKQ1_P_miOGExuen9nvIlSeLBcQ7tzw49G1vhc,707
 imports/__init__.py,sha256=2PSEAwZY88J2NHt98XCO5drFNok5ctiJ8LE02kwABP4,944
-abstract_utilities-0.2.2.667.dist-info/METADATA,sha256=iC3qmUGBUBNFjzpZokPWr2ZFxAfQP1Vs8YuvKpGL4qg,28108
-abstract_utilities-0.2.2.667.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_utilities-0.2.2.667.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
-abstract_utilities-0.2.2.667.dist-info/RECORD,,
+abstract_utilities-0.2.2.680.dist-info/METADATA,sha256=SvLFZK26s6bxaFzrPS6WeOQofjQb0XrITx_oLbP3AbM,28108
+abstract_utilities-0.2.2.680.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_utilities-0.2.2.680.dist-info/top_level.txt,sha256=BF0GZ0xVFfN1K-hFIWPO3viNsOs1sSF86n1vHBg39FM,19
+abstract_utilities-0.2.2.680.dist-info/RECORD,,