abstract-utilities 0.2.2.495__py3-none-any.whl → 0.2.2.504__py3-none-any.whl

abstract_utilities/list_utils/__init__.py

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

abstract_utilities/list_utils/imports/__init__.py

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

abstract_utilities/list_utils/imports/imports.py

@@ -0,0 +1 @@
+

abstract_utilities/list_utils/list_utils.py

@@ -0,0 +1,199 @@
+"""
+list_utils.py
+
+This module provides a set of utility functions tailored for manipulating lists. It offers capabilities to:
+
+- Sort lists and retrieve elements at specific positions.
+- Combine two lists.
+- Ensure that objects are contained within nested lists.
+- Add multiple values to a list.
+
+The `list_utils` module is designed to simplify and abstract common list operations, enhancing code readability and reusability.
+
+Note: While Python's native list methods are comprehensive, the functions here provide additional checks and transformations that might be commonly needed in various applications.
+
+This module is part of the `abstract_utilities` package.
+
+Author: putkoff
+Date: 05/31/2023
+Version: 0.1.2
+"""
+def get_sort(ls: list, k: int = 0):
+    """
+    Sorts a list in ascending order and returns the element at index k.
+
+    Args:
+        ls (list): The list to be sorted.
+        k (int, optional): The index of the element to return. Defaults to 0.
+
+    Returns:
+        any: The element at index k after sorting the list.
+    """
+    ls.sort()
+    return ls[k]
+
+def combineList(ls: list, lsN: list) -> list:
+    """
+    Combines two lists and returns the combined list.
+
+    Args:
+        ls (list): The first list.
+        lsN (list): The second list.
+
+    Returns:
+        list: The combined list.
+    """
+    for k in range(len(lsN)):
+        ls.append(lsN[k])
+    return ls
+
+def find_original_case(input_list, search_string):
+    """
+    Searches for a case-insensitive match of 'search_string' within 'input_list'
+    and returns the first matching element in its original case.
+
+    Args:
+        input_list (list): The list of strings to search within.
+        search_string (str): The case-insensitive string to search for.
+
+    Returns:
+        str or None: The first element in 'input_list' that matches 'search_string'
+        in its original case, or None if no match is found.
+    """
+    for obj in input_list:
+        if obj.lower() == search_string.lower():
+            return obj
+    return None
+
+def ensure_nested_list(obj):
+    """
+    Ensure that the input object is a nested list.
+
+    Args:
+        obj (any): The object to ensure as a nested list.
+
+    Returns:
+        list: A nested list containing the object or the original list if it's already nested.
+    """
+    # Check if the input object is a list
+    if not isinstance(obj, list):
+        # If it's not a list, create a new nested list containing the object
+        return [obj]
+    # If it is a list, check if any of its elements are non-list objects
+    for element in obj:
+        if not isinstance(element, list):
+            # If at least one element is not a list, wrap the original list in a new list
+            return [obj]
+    # If all elements are lists, return the original list
+    return obj
+def make_list_add(obj,values):
+    """
+    Add multiple values to a list and return the resulting list.
+
+    Args:
+        obj (list): The original list.
+        values (iterable): Values to be added to the list.
+
+    Returns:
+        list: The modified list containing the original elements and the added values.
+    """
+    obj = list(obj)
+    for each in list(values):
+        obj.append(each)
+    return obj
+
+def recursive_json_list(json_list:dict,desired_values:dict)->list:
+    """
+    Filters the json list based on the desired_values.
+    
+    Returns:
+    - list: A filtered json list of desired_values held within json object keys.
+    """
+    # Start with the full list of json objects
+    # For each key in the selection values, filter the list if the key's value is set
+    recursed_list=[]
+    for json_obj in json_list:
+        bool_count = 0
+        for desired_key, desired_value in desired_values.items():
+            if desired_key in json_obj:
+                if json_obj[desired_key] == desired_value:
+                    bool_count +=1
+                    static = desired_value
+        if bool_count == len(list(desired_values.keys())):
+            recursed_list.append(json_obj)
+    return recursed_list
+
+def filter_json_list_values(json_list:list,keys:list)->None:
+    """
+    Updates the GUI dropdown lists based on the filtered RPC list.
+    """
+    # Get the filtered list of json values based on current key selections
+    all_keys={}
+    for key in keys:
+        unique_values=[]
+        for json_obj in json_list:
+            if key in json_obj:
+                if json_obj[key] not in unique_values:
+                    unique_values.append(json_obj[key])
+        all_keys[key]= unique_values
+    return all_keys
+def get_highest_value_obj(obj_list, function):
+    return max(obj_list, key=function)
+
+def safe_list_return(current_list,list_num=0):
+    if len(current_list) >= list_num+1:
+        return current_list[int(list_num)]
+def get_actual_number(reference_object,number_value):
+    try:
+        reference_length = len(reference_object)
+    except:
+        reference_length = 0
+    if reference_length ==0:
+        return None
+    return max(0, min(number_value, reference_length-1))
+def compare_lists(list_1,list_2):
+    if len(list_1)>len(list_2):
+        return False
+    for each in list_1:
+        if each not in list_2:
+            return False
+    return True
+def remove_from_list(list_obj, key, value):
+    return [obj for obj in list_obj if not (isinstance(obj, dict) and obj.get(key) == value)]
+
+def list_set(obj):
+    try:
+        obj = list(set(obj))
+    except Exception as e:
+        print(f"{e}")
+    return obj
+
+def get_symetric_difference(obj_1,obj_2):
+    set1 = set(obj_1)
+    set2 = set(obj_2)
+    # Find elements that are unique to each list
+    unique_elements = set1.symmetric_difference(set2)
+    # Convert the set back to a list, if needed
+    return list(unique_elements)
+def make_list(obj:any) -> list:
+    """
+    Converts the input object to a list. If the object is already a list, it is returned as is.
+    
+    Args:
+        obj: The object to convert.
+        
+    Returns:
+        list: The object as a list.
+    """
+    if isinstance(obj,str):
+        if ',' in obj:
+            obj = obj.split(',')
+    if isinstance(obj,set) or isinstance(obj,tuple):
+        return list(obj)
+    if isinstance(obj, list):
+        return obj
+    return [obj]
+
+def make_list_it(obj=None):
+    obj = make_list(obj or [])
+    return obj

abstract_utilities/log_utils/__init__.py

@@ -0,0 +1,5 @@
+from .abstractLogManager import *
+from .imports import *
+from .call_response import *
+from .log_file import *
+from .logger_callable import *

abstract_utilities/log_utils/abstractLogManager.py

@@ -0,0 +1,64 @@
+from .imports import *      
+class AbstractLogManager(metaclass=SingletonMeta):
+    def __init__(self):
+        # Create a logger; use __name__ to have a module-specific logger if desired.
+        self.logger = logging.getLogger("AbstractLogManager")
+        self.logger.setLevel(logging.DEBUG)  # Set to lowest level to let handlers filter as needed.
+
+        # Create a console handler with a default level.
+        self.console_handler = logging.StreamHandler()
+        # Default level: show warnings and above.
+        self.console_handler.setLevel(logging.WARNING)
+
+        # Formatter for the logs.
+        formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+        self.console_handler.setFormatter(formatter)
+
+        # If there are no handlers already attached, add our console handler.
+        if not self.logger.hasHandlers():
+            self.logger.addHandler(self.console_handler)
+
+    def set_debug(self, enabled: bool) -> None:
+        """
+        Enable or disable DEBUG level messages.
+        When enabled, the console handler will output DEBUG messages and above.
+        When disabled, it falls back to INFO or WARNING (adjust as needed).
+        """
+        if enabled:
+            self.console_handler.setLevel(logging.DEBUG)
+            self.logger.debug("DEBUG logging enabled.")
+        else:
+            # For example, disable DEBUG by raising the level to INFO.
+            self.console_handler.setLevel(logging.INFO)
+            self.logger.info("DEBUG logging disabled; INFO level active.")
+
+    def set_info(self, enabled: bool) -> None:
+        """
+        Enable or disable INFO level messages.
+        When enabled, INFO and above are shown; when disabled, only WARNING and above.
+        """
+        if enabled:
+            # Lower the handler level to INFO if currently higher.
+            self.console_handler.setLevel(logging.INFO)
+            self.logger.info("INFO logging enabled.")
+        else:
+            self.console_handler.setLevel(logging.WARNING)
+            self.logger.warning("INFO logging disabled; only WARNING and above will be shown.")
+
+    def set_warning(self, enabled: bool) -> None:
+        """
+        Enable or disable WARNING level messages.
+        When disabled, only ERROR and CRITICAL messages are shown.
+        """
+        if enabled:
+            # WARNING messages enabled means handler level is WARNING.
+            self.console_handler.setLevel(logging.WARNING)
+            self.logger.warning("WARNING logging enabled.")
+        else:
+            self.console_handler.setLevel(logging.ERROR)
+            self.logger.error("WARNING logging disabled; only ERROR and CRITICAL messages will be shown.")
+
+    def get_logger(self) -> logging.Logger:
+        """Return the configured logger instance."""
+        return self.logger
+

abstract_utilities/log_utils/call_response.py

@@ -0,0 +1,68 @@
+from .imports import *
+from .logger_callable import *
+def initialize_call_log(value=None,
+                        data=None,
+                        logMsg=None,
+                        log_level=None):
+    """
+    Inspect the stack to find the first caller *outside* this module,
+    then log its function name and file path.
+    """
+    # Grab the current stack
+    stack = inspect.stack()
+    caller_name = "<unknown>"
+    caller_path = "<unknown>"
+    log_level = log_level or 'info'
+    try:
+        # Starting at index=1 to skip initialize_call_log itself
+        for frame_info in stack[1:]:
+            modname = frame_info.frame.f_globals.get("__name__", "")
+            # Skip over frames in your logging modules:
+            if not modname.startswith("abstract_utilities.log_utils") \
+               and not modname.startswith("abstract_flask.request_utils") \
+               and not modname.startswith("logging"):
+                caller_name = frame_info.function
+                caller_path = frame_info.filename
+                break
+    finally:
+        # Avoid reference cycles
+        del stack
+
+    logMsg = logMsg or "initializing"
+    full_message = (
+        f"{logMsg}\n"
+        f"calling_function: {caller_name}\n"
+        f"path: {caller_path}\n"
+        f"data: {data}"
+    )
+
+    print_or_log(full_message,level=log_level)
+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
+def get_json_call_response(value=None, status_code=None, data=None, logMsg=None, callLog=False):
+    response_body = {}
+    if status_code == 200:
+        response_body["success"] = True
+        response_body["result"] = _normalize(value)
+        logMsg = logMsg or "success"
+        if callLog:
+            initialize_call_log(value=value,
+                            data=data,
+                            logMsg=logMsg,
+                            log_level='info')
+    else:
+        response_body["success"] = False
+        response_body["error"] = _normalize(value)
+        logMsg = logMsg or f"ERROR: {logMsg}"
+        initialize_call_log(value=value,
+                            data=data,
+                            logMsg=logMsg,
+                            log_level='error')
+    return jsonify(response_body), status_code

abstract_utilities/log_utils/imports/__init__.py

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

abstract_utilities/log_utils/imports/imports.py

@@ -0,0 +1,7 @@
+from ...imports import logging
+from ...imports import os
+from ...imports import inspect
+from flask import jsonify
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+

abstract_utilities/log_utils/imports/module_imports.py

@@ -0,0 +1,2 @@
+from ...path_utils import mkdirs
+from ...class_utils import SingletonMeta

abstract_utilities/log_utils/log_file.py

@@ -0,0 +1,56 @@
+from .imports import *
+def get_logFile(bpName: str = None, maxBytes: int = 100_000, backupCount: int = 3) -> logging.Logger:
+    """
+    If bpName is None, use the “caller module’s basename” as the logger name.
+    Otherwise, use the explicitly provided bpName.
+    """
+    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
+
+    log_dir = mkdirs("logs")
+    log_path = os.path.join(log_dir, f"{bpName}.log")
+
+    logger = logging.getLogger(bpName)
+    logger.setLevel(logging.INFO)
+
+    if not logger.handlers:
+        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)
+
+    return logger
+
+def _find_caller_frame_index():
+    """
+    Scan up the call stack until we find a frame whose module is NOT logging_utils.
+    Return that index in inspect.stack().
+    """
+    for idx, frame_info in enumerate(inspect.stack()):
+        # Ignore the very first frame (idx=0), which is this function itself.
+        if idx == 0:
+            continue
+        module = inspect.getmodule(frame_info.frame)
+        # If module is None (e.g. interactive), skip it;
+        # else get module.__name__ and compare:
+        module_name = module.__name__ if module else None
+
+        # Replace 'yourpackage.logging_utils' with whatever your actual module path is:
+        if module_name != __name__ and not module_name.startswith("logging"):
+            # We found a frame that isn’t in this helper module or the stdlib logging.
+            return idx
+    # Fallback to 1 (the immediate caller) if nothing else matches:
+    return 1

abstract_utilities/log_utils/logger_callable.py

@@ -0,0 +1,49 @@
+from .imports import *
+from .log_file import *
+def get_logger_callable(logger, level="info"):
+    if logger is None:
+        return None
+    elif isinstance(logger, logging.Logger):
+        return getattr(logger, level.lower(), None)
+    elif callable(logger) and hasattr(logger, "__self__") and isinstance(logger.__self__, logging.Logger):
+        return logger
+    else:
+        return None
+
+
+def _find_caller_frame_index():
+    """
+    Return the index in inspect.stack() of the first frame
+    that’s not in this module or the logging stdlib.
+    """
+    for idx, frame_info in enumerate(inspect.stack()):
+        fn = frame_info.filename
+        if not fn.endswith("logging_utils.py") and "logging" not in os.path.basename(fn):
+            return idx
+    return 0  # fallback
+
+def get_caller_info():
+    """
+    Returns (caller_path, caller_idx).
+    caller_idx is the index into inspect.stack() where the call came from.
+    """
+    idx = _find_caller_frame_index()
+    frame = inspect.stack()[idx]
+    return frame.filename, idx
+
+def print_or_log(message, logger=True, level="info"):
+    # 1) grab both the path and the numeric index
+    caller_path, caller_idx = get_caller_info()
+
+    # 2) decide which logger object to use
+    if logger is True:
+        bpName = os.path.splitext(os.path.basename(caller_path))[0]
+        logger = get_logFile(bpName)
+
+    # 3) pick the right logging method
+    log_callable = get_logger_callable(logger, level=level)
+    if log_callable:
+        # pass the integer stacklevel = caller_idx + 1
+        log_callable(message, stacklevel=caller_idx + 1)
+    else:
+        print(message)

abstract_utilities/math_utils/__init__.py

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

abstract_utilities/math_utils/imports/__init__.py

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

abstract_utilities/math_utils/imports/imports.py

@@ -0,0 +1,2 @@
+from ...imports import math
+from functools import reduce

abstract_utilities/math_utils/imports/module_imports.py

@@ -0,0 +1 @@
+from ...type_utils import det_bool_T,is_number