osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/utils/Python_Logger.py

@@ -0,0 +1,301 @@
+import inspect
+import logging
+import sys
+import types
+from logging          import Logger, StreamHandler, FileHandler
+from logging.handlers import MemoryHandler
+
+from osbot_utils.decorators.lists.group_by import group_by
+from osbot_utils.decorators.lists.index_by import index_by
+from osbot_utils.decorators.methods.cache_on_function import cache_on_function
+from osbot_utils.decorators.methods.cache_on_self import cache_on_self
+from osbot_utils.utils.Misc import random_string
+from osbot_utils.utils.Files import temp_file
+from osbot_utils.utils.Objects import obj_dict
+
+DEFAULT_LOG_LEVEL         = logging.DEBUG
+DEFAULT_LOG_FORMAT        = '%(asctime)s\t|\t%(name)s\t|\t%(levelname)s\t|\t%(message)s'
+MEMORY_LOGGER_CAPACITY    = 1024*10
+MEMORY_LOGGER_FLUSH_LEVEL = logging.ERROR
+
+# for reference here are the log levels
+# CRITICAL    50
+# ERROR       40
+# WARNING     30
+# INFO        20
+# DEBUG       10
+# NOTSET      0
+
+class Python_Logger_Config:
+
+    def __init__(self):
+        self.elastic_host           = None
+        self.elastic_password       = None
+        self.elastic_port           = None
+        self.elastic_username       = None
+        #self.log_to_aws_s3          = False                     # todo
+        #self.log_to_aws_cloud_trail = False                     # todo
+        #self.log_to_aws_firehose    = False                     # todo
+        self.log_to_console         = False                     # todo
+        self.log_to_file            = False                     # todo
+        #self.log_to_elastic         = False                     # todo
+        self.log_to_memory          = False
+        self.path_logs              = None
+        self.log_format             = DEFAULT_LOG_FORMAT
+        self.log_level              = DEFAULT_LOG_LEVEL
+
+
+class Python_Logger:
+    config      : Python_Logger_Config
+    logger      : Logger
+    logger_name : str
+    critical    : types.FunctionType        # these will be replaced by Python_Logger_Config.setup_log_methods
+    debug       : types.FunctionType
+    error       : types.FunctionType
+    exception   : types.FunctionType
+    info        : types.FunctionType
+    ok          : types.FunctionType
+    warning     : types.FunctionType
+
+    def __init__(self, logger_name= None, logger_config : Python_Logger_Config = None):
+        self.set_logger_name(logger_name)
+        #self.logger_name = logger_name or random_string(prefix="Python_Logger_")
+        self.set_config(logger_config)
+        # self.logger = None
+        self.setup()                            # todo: understand side effect of setting up logger on __init__
+
+    def disable(self):
+        self.logger.disabled = True
+        return self
+
+    def set_logger_name(self, logger_name):
+        if logger_name:                                     # if the value is provided, use it
+            self.logger_name = logger_name
+            return self
+        for frame_info in inspect.stack():                  # Look for the first frame that is outside this Python_Logger class
+            if 'self' in frame_info.frame.f_locals:
+                caller_self = frame_info.frame.f_locals['self']
+                caller_module = caller_self.__class__.__name__
+                if caller_module != 'Python_Logger':
+                    self.logger_name = 'Python_Logger__' + caller_module
+                    return self
+
+        self.logger_name = random_string(prefix="Python_Logger_")
+        return self
+
+    def manager_get_loggers(self):
+        return Logger.manager.loggerDict
+
+    def manager_remove_logger(self):
+        logger_dict = Logger.manager.loggerDict
+        if self.logger_name in logger_dict:                 # need to do it manually here since Logger.manager doesn't seem to have a way to remove loggers
+            del logger_dict[self.logger_name]
+            return True
+        return False
+
+    def setup(self, logger_name=None, log_level=None,add_console_logger=False, add_memory_logger=True):
+        if logger_name:
+            self.logger_name = logger_name
+        self.logger =  logging.getLogger(self.logger_name)
+        self.setup_log_methods()
+        self.set_log_level(log_level)
+        if add_console_logger:
+            self.add_console_logger()
+        if add_memory_logger:
+            self.add_handler_memory()
+        return self
+
+    def setup_log_methods(self):
+        # adds these helper methods like this so that the filename and function values are accurate
+        setattr(self, "critical"  , self.logger.critical  )
+        setattr(self, "debug"     , self.logger.debug     )
+        setattr(self, "error"     , self.logger.error     )
+        setattr(self, "exception" , self.logger.exception )
+        setattr(self, "info"      , self.logger.info      )
+        setattr(self, "ok"        , self.logger.info      )
+        setattr(self, "warning"   , self.logger.warning   )
+
+
+
+
+
+        # self.info       = self.logger.info
+        # self.warning    = self.logger.warning
+        # self.error      = self.logger.error
+        # self.exception  = self.logger.exception
+        # self.critical   = self.logger.critical
+
+
+    # Setters
+    def set_config(self, config):
+        if type(config) is Python_Logger_Config:
+            self.config = config
+        else:
+            self.config = Python_Logger_Config()
+        return self.config
+
+    def set_log_format(self, log_format):
+        if log_format:
+            self.config.log_format = log_format
+
+    def set_log_level(self, level=None):
+        level = level or self.config.log_level
+        if self.logger:
+            self.logger.setLevel(level)
+            return True
+        return False
+
+    # Getters
+
+    def log_handler(self, handler_type):
+        for handler in self.log_handlers():
+            if type(handler) is handler_type:
+                return handler
+        return None
+
+    def log_handler_console(self):
+        return self.log_handler(StreamHandler)
+
+    def log_handler_file(self):
+        return self.log_handler(logging.FileHandler)
+
+    def log_handler_memory(self):
+        return self.log_handler(MemoryHandler)
+
+    def log_handlers(self):
+        if self.logger:
+            return self.logger.handlers
+        return []
+
+    def log_handlers_remove(self, handler):
+        if handler and handler in self.log_handlers():
+            self.logger.removeHandler(handler)
+            return True
+        return False
+
+    def log_handlers_remove_type(self, handler_type):
+        handler = self.log_handler(handler_type)
+        return self.log_handlers_remove(handler)
+
+    def log_formatter(self):
+        return logging.Formatter(self.config.log_format)
+
+    def log_level(self):
+        return self.config.log_level
+
+    # Actions
+
+    def add_console_logger(self):
+        self.config.log_to_console = True
+        return self.add_handler_console()
+
+    def add_memory_logger(self):
+        self.config.log_to_memory = True
+        return self.add_handler_memory()
+
+    def add_file_logger(self,path_log_file=None):
+        self.config.log_to_file = True
+        return self.add_handler_file(path_log_file=path_log_file)
+
+    def remove_memory_logger(self):
+        memory_logger = self.log_handler_memory()
+        if self.log_handlers_remove(memory_logger):
+            self.config.log_to_file = False
+            return True
+        return False
+
+
+    # Handlers
+    def add_handler_console(self):
+        if self.logger and self.config.log_to_console:
+            handler = StreamHandler(sys.stdout)
+            handler.setLevel(logging.DEBUG)
+            handler.setFormatter(self.log_formatter())
+            self.logger.addHandler(handler)
+            return True
+        return False
+
+    def add_handler_file(self, path_log_file=None):
+        if self.logger and self.config.log_to_file:
+            if path_log_file is None:
+                path_log_file = temp_file(extension='.log')
+            handler = FileHandler(path_log_file)
+            handler.setLevel(self.log_level())
+            handler.setFormatter(self.log_formatter())
+            self.logger.addHandler(handler)
+            return True
+        return False
+
+    def add_handler_memory(self, memory_capacity=None):
+        if self.log_handler_memory() is None:
+            if self.logger and self.config.log_to_memory:
+                capacity       = memory_capacity or MEMORY_LOGGER_CAPACITY
+                flush_level    = MEMORY_LOGGER_FLUSH_LEVEL
+                target         = None                       # we want the messages to only be kept in memory
+                memory_handler = MemoryHandler(capacity=capacity, flushLevel=flush_level, target=target,flushOnClose=True)
+                memory_handler.setLevel(self.log_level())
+                self.logger.addHandler(memory_handler)
+                return True
+        return False
+
+    # Utils
+    def memory_handler(self) -> MemoryHandler:
+        return self.log_handler_memory()
+
+    def memory_handler_buffer(self):
+        if self.config.log_to_memory:
+            return self.memory_handler().buffer
+        return []
+
+    def memory_handler_clear(self):
+        if self.config.log_to_memory:
+            memory_handler = self.memory_handler()
+            memory_handler.buffer = []
+            return True
+        return False
+    def memory_handler_exceptions(self):
+        return self.memory_handler_logs(index_by='levelname').get('EXCEPTIONS', {})
+
+    @index_by
+    @group_by
+    def memory_handler_logs(self):
+        logs = []
+        for log_record in self.memory_handler_buffer():
+            logs.append(obj_dict(log_record))
+        return logs
+
+    def memory_handler_last_log_entry(self):
+        memory_buffer = self.memory_handler_buffer()
+        if memory_buffer:                               # Check if the buffer is not empty
+            last_log_record = memory_buffer[-1]         # get the last record
+            return obj_dict(last_log_record)            # convert record into a nice json object
+        return {}
+
+    def memory_handler_messages(self):
+        return [log_entry.get('message') for log_entry in self.memory_handler_logs()]
+
+    # Logging methods
+
+    # def debug    (self, msg='', *args, **kwargs): return self._log('debug'     , msg, *args, **kwargs)
+    # #def info     (self, msg='', *args, **kwargs): return self.__log__('info'      , msg, *args, **kwargs)
+    # def warning  (self, msg='', *args, **kwargs): return self._log('warning'   , msg, *args, **kwargs)
+    # def error    (self, msg='', *args, **kwargs): return self._log('error'     , msg, *args, **kwargs)
+    # def exception(self, msg='', *args, **kwargs): return self._log('exception' , msg, *args, **kwargs)
+    # def critical (self, msg='', *args, **kwargs): return self._log('critical'  , msg, *args, **kwargs)
+    #
+    # def __log__(self, level, msg, *args, **kwargs):
+    #     if self.logger:
+    #         log_method = getattr(self.logger, level)
+    #         log_method(msg, *args, **kwargs)
+    #         return True
+    #     return False
+
+@cache_on_function
+def logger_info():
+    python_logger = Python_Logger().setup()
+    return python_logger.logger.info
+
+@cache_on_function
+def logger_error():
+    python_logger = Python_Logger().setup()
+    return python_logger.logger.error

osbot_utils/utils/Status.py

@@ -0,0 +1,79 @@
+# todo refactor into Status class
+import traceback
+
+from osbot_utils.utils.Python_Logger import Python_Logger
+
+class Status:
+    def __init__(self):
+        self.logger               = Python_Logger().setup()
+        self.call_logger_method   = False
+        self.root_logger_handlers = None
+        #self.logger.add_memory_logger()
+
+    def root_logger(self):
+        return self.logger.logger.parent
+
+    def clear_root_logger_handlers(self):
+        self.root_logger_handlers = self.root_logger().handlers
+        self.root_logger().handlers = []
+
+    def restore_root_logger_handlers(self):
+        if self.root_logger_handlers:
+            self.root_logger().handlers = self.root_logger_handlers
+    def status_message(self, status, message:str=None, data=None, error=None):
+        return  {  'data'   : data    ,
+                   'error'  : error   ,
+                   'message': message ,
+                   'status' : status
+                }
+
+    def last_message(self):
+        return self.logger.memory_handler_last_log_entry()
+
+    def log_message(self, status, message:str='', data=None, error=None, stacklevel=3):          # stacklevel is usually 3 because we want to get the caller of the method that called this on
+        logger_message = f'[osbot] [{status}] ' + str(message)
+        logger_method  = self.logger.__getattribute__(status)
+        status_message = self.status_message(status=status, message=message, data=data, error=error)
+        if self.call_logger_method:
+            kwargs = {}                                                 # todo: add option to capture stack trace and other helpful debug data
+            if status =='exception':
+                kwargs = dict(exc_info=True, stacklevel=stacklevel)
+            logger_method(logger_message, **kwargs)
+        return status_message
+
+
+
+
+osbot_status = Status()                 # todo map out the performatin implications of doing this
+osbot_logger = osbot_status.logger
+
+def status_critical (message:str='', data=None,error=None): return osbot_status.log_message(status='critical' , message=message, data=data, error=error)
+def status_debug    (message:str='', data=None,error=None): return osbot_status.log_message(status='debug'    , message=message, data=data, error=error)
+def status_error    (message:str='', data=None,error=None): return osbot_status.log_message(status='error'    , message=message, data=data, error=error)
+def status_exception(message:str='', data=None,error=None): return osbot_status.log_message(status='exception', message=message, data=data, error=error)
+def status_info     (message:str='', data=None,error=None): return osbot_status.log_message(status='info'     , message=message, data=data, error=error)
+def status_ok       (message:str='', data=None,error=None): return osbot_status.log_message(status='ok'       , message=message, data=data, error=error)
+def status_warning  (message:str='', data=None,error=None): return osbot_status.log_message(status='warning'  , message=message, data=data, error=error)
+
+log_critical  = status_critical   # level 50
+log_error     = status_error      # level 40
+log_exception = status_exception  # level 40
+log_warning   = status_warning    # level 30
+log_info      = status_info       # level 20
+log_ok        = status_ok         # level 20
+log_debug     = status_debug      # level 10
+
+
+def send_status_to_logger(value: bool = True):
+    osbot_status.call_logger_method = value
+
+#def log_error   (message):#logger().error   (message) # level 40
+#def log_info    (message): logger().info    (message) # level 20
+#def log_warning (message): logger().warning (message) # level 30
+
+
+# def status_info   (message:str='', data=None,error=None): osbot_logger.info   ('[osbot] [info]  ' + str(message)); return status_message('info', message=message, data=data, error=error)
+# def status_ok     (message:str='', data=None,error=None): osbot_logger.info   ('[osbot] [ok]    ' + str(message)); return status_message('ok', message=message, data=data, error=error)
+# def status_warning(message:str='', data=None,error=None): osbot_logger.warning('[osbot] [warning] ' + str(message)); return status_message('warning', message=message, data=data, error=error)
+
+#todo: add status_exception that automatically picks up the exception from the stack trace

osbot_utils/utils/Str.py

@@ -0,0 +1,63 @@
+import textwrap
+from html import escape, unescape
+
+from osbot_utils.utils.Files import safe_file_name
+
+
+def html_escape(value):
+    return escape(value)
+
+def html_unescape(value):
+    return unescape(value)
+
+def str_dedent(value, strip=True):
+    result = textwrap.dedent(value)
+    if strip:
+        result = result.strip()
+    return result
+
+def str_index(target:str, source:str):
+    try:
+        return target.index(source)
+    except:
+        return -1
+
+def str_join(delimiter, values):
+    return delimiter.join(values)
+
+def str_max_width(target, value):
+    return str(target)[:value]
+
+def str_safe(value):
+    return safe_file_name(value)
+
+def str_starts_with(source, prefix):
+    if source is None or prefix is None:
+        return False
+    else:
+        return source.startswith(prefix)
+
+def str_unicode_escape(target):
+    return str(target).encode('unicode_escape').decode("utf-8")
+
+def str_cap_snake_case(snake_str):
+    """
+    Converts a snake_case string to Capitalized_Snake_Case.
+
+    Args:
+        snake_str (str): The snake_case string to be converted.
+
+    Returns:
+        str: The converted string in Capitalized_Snake_Case.
+    """
+    return "_".join(word.capitalize() for word in snake_str.split("_"))
+
+
+def trim(target):
+    if type(target) is str:
+        return target.strip()
+    return ""
+
+html_encode = html_escape
+html_decode = html_unescape
+safe_str    = str_safe

osbot_utils/utils/Version.py

@@ -0,0 +1,16 @@
+import osbot_utils
+from osbot_utils.utils.Files import file_contents, path_combine
+
+class Version:
+
+    FILE_NAME_VERSION = 'version'
+
+    def path_code_root(self):
+        return osbot_utils.path
+
+    def path_version_file(self):
+        return path_combine(self.path_code_root(), self.FILE_NAME_VERSION)
+
+    def value(self):
+        version = file_contents(self.path_version_file()) or ""
+        return version.strip()

osbot_utils/utils/Zip.py

@@ -0,0 +1,97 @@
+import io
+import os
+import shutil
+import zipfile
+from os.path import abspath
+
+from osbot_utils.utils.Files import temp_folder, folder_files, temp_file, is_file
+
+
+def unzip_file(zip_file, target_folder=None, format='zip'):
+    target_folder = target_folder or temp_folder()
+    shutil.unpack_archive(zip_file, extract_dir=target_folder, format=format)
+    return target_folder
+
+def zip_bytes_add_file(zip_bytes, zip_file_path, file_contents):
+    if type(file_contents) is str:
+        file_contents = file_contents.encode('utf-8')
+    elif type(file_contents) is not bytes:
+        return None
+    zip_buffer = io.BytesIO(zip_bytes)
+    with zipfile.ZipFile(zip_buffer, 'a', zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(zip_file_path, file_contents)
+
+    return zip_buffer.getvalue()
+
+def zip_bytes_get_file(zip_bytes, zip_file_path):
+    zip_buffer = io.BytesIO(zip_bytes)
+    with zipfile.ZipFile(zip_buffer, 'r') as zf:
+        return zf.read(zip_file_path)
+
+def zip_bytes_file_list(zip_bytes):
+    zip_buffer_from_bytes = io.BytesIO(zip_bytes)
+    with zipfile.ZipFile(zip_buffer_from_bytes, 'r') as zf:
+        return sorted(zf.namelist())
+
+def zip_bytes_to_file(zip_bytes, target_file=None):
+    if target_file is None:
+        target_file = temp_file(extension='.zip')
+    with open(target_file, 'wb') as f:
+        f.write(zip_bytes)
+    return target_file
+
+def zip_files_to_bytes(target_files, root_folder=None):
+    zip_buffer = io.BytesIO()                                                   # Create a BytesIO buffer to hold the zipped file
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:          # Create a ZipFile object with the buffer as the target
+        for entry in target_files:
+            if type(entry) is str:                                              # if entry is a string, assume it's a file path
+                file_path = entry
+                file_root_folder = root_folder
+            else:
+                file_path = entry.get('file')
+                file_root_folder = entry.get('root_folder') or root_folder
+            if file_root_folder:
+                arcname = file_path.replace(file_root_folder,'')                      # Define the arcname, which is the name inside the zip file
+            else:
+                arcname = file_path                                                 # if root_path is not provided, use the full file path
+            zf.write(file_path, arcname)                                            # Add the file to the zip file
+    zip_buffer.seek(0)
+    return zip_buffer
+
+def zip_folder(root_dir, format='zip'):
+    return shutil.make_archive(base_name=root_dir, format=format, root_dir=root_dir)
+
+def zip_folder_to_bytes(root_dir):      # todo add unit test
+    zip_buffer = io.BytesIO()                                                   # Create a BytesIO buffer to hold the zipped file
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:          # Create a ZipFile object with the buffer as the target
+        for foldername, subfolders, filenames in os.walk(root_dir):             # Walk the root_dir and add all files and folders to the zip file
+            for filename in filenames:
+                absolute_path = os.path.join(foldername, filename)              # Create the complete filepath
+                arcname = os.path.relpath(absolute_path, root_dir)              # Define the arcname, which is the name inside the zip file
+                zf.write(absolute_path, arcname)                                # Add the file to the zip file
+    zip_buffer.seek(0)                                                          # Reset buffer position
+    return zip_buffer
+
+def zip_file_list(path):
+    if is_file(path):
+        with zipfile.ZipFile(path) as zip_file:
+            return sorted(zip_file.namelist())
+    return []
+
+def zip_files(base_folder, file_pattern="*.*", target_file=None):
+    base_folder = abspath(base_folder)
+    file_list   = folder_files(base_folder, file_pattern)
+
+    if len(file_list):                                                  # if there were files found
+        target_file = target_file or temp_file(extension='zip')
+        with zipfile.ZipFile(target_file,'w') as zip:
+            for file_name in file_list:
+                zip_file_path = file_name.replace(base_folder,'')
+                zip.write(file_name, zip_file_path)
+
+        return target_file
+
+
+# extra function's mappings
+file_unzip  = unzip_file
+folder_zip  = zip_folder

osbot_utils/utils/__init__.py

@@ -0,0 +1,16 @@
+"""
+In this class you will find the following helper classes:
+
+- Assert
+- Dev
+- Files
+- Http
+- Json
+- Lists
+- Misc
+- Png
+- Process
+- Temp_File
+- Unzip_File
+- Zip_Folder
+"""

osbot_utils/version

@@ -0,0 +1 @@
+v1.7.7