pawlogger 0.1.0__tar.gz

pawlogger-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: pawlogger
+Version: 0.1.0
+Summary: logging tools
+Author: paw
+Author-email: paw <pawrequest@users.noreply.github.com>
+Requires-Dist: loguru
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# pawlogger
+
+Describe your project here.

pawlogger-0.1.0/README.md

@@ -0,0 +1,3 @@
+# pawlogger
+
+Describe your project here.

pawlogger-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"
+
+
+[project]
+name = "pawlogger"
+version = "0.1.0"
+description = "logging tools"
+authors = [
+    { name = "paw", email = "pawrequest@users.noreply.github.com" }
+]
+readme = "README.md"
+requires-python = ">= 3.8"
+dependencies = [
+    'loguru',
+]
+

pawlogger-0.1.0/src/pawlogger/__init__.py

@@ -0,0 +1,15 @@
+from .config_loguru import get_loguru
+from .config import get_logger
+from .consts import ASCTIME_PATTERN, CONSOLE_FORMAT_STR, FILE_FORMAT_STR, get_format_str
+# ASCTIME_PATTERN = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}"
+# CONSOLE_FORMAT_STR = '{levelname} - {module}:{lineno} - {message}'
+# FILE_FORMAT_STR = '{levelname} - {asctime} - {module}:{lineno} - {message}'
+#
+#
+# def get_format_str(match_regex=False, console_or_file='file'):
+#     ret_str = ''
+#     return ret_str
+
+
+__all__ = ['get_logger', 'get_loguru', 'ASCTIME_PATTERN', 'CONSOLE_FORMAT_STR', 'FILE_FORMAT_STR',
+           'get_format_str']

pawlogger-0.1.0/src/pawlogger/config.py

@@ -0,0 +1,43 @@
+"""
+logging configuration for builtin logger
+"""
+import inspect
+import logging
+
+from . import consts
+
+
+def get_logger(logger_name=None, log_file=None, level=logging.DEBUG):
+    """
+    Configure logging
+
+    :param logger_name: name of logger
+    :param log_file: path to log file
+    :param level: logging level
+    :return: logger
+    """
+    if logger_name is None:
+        frame = inspect.stack()[1]
+        module = inspect.getmodule(frame[0])
+        logger_name = module.__name__ if module else '__main__'
+
+    if log_file is None:
+        log_file = f'{logger_name}.log'
+
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(level)
+
+    file_handler = logging.FileHandler(log_file)
+    console_handler = logging.StreamHandler()
+
+    file_formatter = logging.Formatter(consts.FILE_FORMAT_STR, style='{')
+    console_formatter = logging.Formatter(consts.CONSOLE_FORMAT_STR, style='{')
+
+    file_handler.setFormatter(file_formatter)
+    console_handler.setFormatter(console_formatter)
+
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    logger.debug(f'Logger created: {logger.name}')
+
+    return logger

pawlogger-0.1.0/src/pawlogger/config_loguru.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import functools
+import sys
+from pathlib import Path
+from typing import Literal
+
+import loguru
+from loguru import logger
+
+"""
+functions for configuring loguru
+"""
+CAT_COLOR_DICT = {
+    'episode': 'cyan',
+    'reddit': 'green',
+    'backup': 'magenta',
+}
+
+
+def get_loguru(
+        level: str = 'INFO',
+        log_file : Path | None = None,
+        profile: Literal['local', 'remote', 'default'] = 'local',
+        color_dict: dict | None = None
+) -> logger:
+    """
+    Configure loguru logger
+
+    :param log_file: path to log file
+    :param profile: log profile to use
+    :param color_dict: dictionary of log-category to colour mappings
+    :return: logger
+    """
+    if color_dict:
+        global CAT_COLOR_DICT
+        CAT_COLOR_DICT = color_dict
+
+    if profile == 'local':
+        logger.info('Using local log profile')
+        terminal_format = log_fmt_local_terminal
+    elif profile == 'remote':
+        logger.info('Using remote log profile')
+        terminal_format = log_fmt_server_terminal
+    else:
+        raise ValueError(f'Invalid profile: {profile}')
+
+    logger.remove()
+
+    lvl = level.upper()
+    if log_file:
+        logger.add(log_file, rotation='1 day', delay=True, encoding='utf8', level=lvl)
+    logger.add(sys.stderr, level=lvl, format=terminal_format)
+
+    return logger
+
+
+# def log_fmt_local_terminal(record) -> str:
+#     """
+#     Format for local logging
+# 
+#     :param record: log record
+#     :return: formatted log record
+#     """
+#     category = record['extra'].get('category', 'General')
+#     bot_colour = BOT_COLOR.get(category, 'white')
+#     category = f'{category:<9}'
+#     max_length = 100
+#     file_txt = f"{record['file'].path}:{record['line']}"
+# 
+#     if len(file_txt) > max_length:
+#         file_txt = file_txt[:max_length]
+# 
+#     # clickable link only works at start of line
+#     return f"{file_txt:<{max_length}} | <lvl>{record['level']: <7} | {coloured(category, bot_colour)} | {record['message']}</lvl>\n"
+
+
+def log_fmt_local_terminal(record: loguru.Record) -> str:
+    file_txt = f"{record['file'].path}:{record['line']}"
+
+    category = record['extra'].get('category', 'General')
+    category_txt = f'{category.title():<9}'
+
+    color = CAT_COLOR_DICT.get(category.lower(), 'white')
+    category_txt = f'| {coloured(category_txt, color)}' if category_txt != 'General' else ''
+    lvltext = f'<lvl>{record['level']: <7}</lvl>'
+    msg_txt = f'<lvl>{record['message']}</lvl>'
+    msg_txt = msg_txt.replace('{', '{{').replace('}', '}}')
+    # msg_txt = f'{record['message']}'
+    return f'{lvltext} {category_txt} | {msg_txt} | {file_txt}\n'
+
+
+def coloured(msg: str, colour: str) -> str:
+    """
+    Colour a message
+
+    :param msg: message to colour
+    :param colour: colour to use
+    :return: coloured message
+    """
+    return f'<{colour}>{msg}</{colour}>'
+
+
+def log_fmt_server_terminal(record) -> str:
+    """
+    Format for server-side logging
+
+    :param record: log record
+    :return: formatted log record
+    """
+    category = record['extra'].get('category', 'General')
+    category = f'{category:<9}'
+    colour = CAT_COLOR_DICT.get(category, 'white')
+
+    file_line = f"{record['file']}:{record['line']}- {record['function']}()"
+    bot_says = f"<bold>{coloured(category, colour):<9} </bold> | {coloured(record['message'], colour)}"
+
+    return f"<lvl>{record['level']: <7} </lvl>| {bot_says} | {file_line}\n"
+
+
+def logger_wraps(*, entries=True, exits=True, level='DEBUG') -> callable:
+    """
+    Decorator to log function entry and exit
+
+    :param entries: log entry
+    :param exits: log exit
+    :param level: log level
+    :return: decorator
+    """
+
+    def wrapper(func):
+        name = func.__name__
+
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            logger_ = logger.opt(depth=1)
+            if entries:
+                logger_.log(level, f"Entering '{name}' (args={args}, kwargs={kwargs})")
+            result = func(*args, **kwargs)
+            if exits:
+                logger_.log(level, "Exiting '{}' (result={})", name, result)
+            return result
+
+        return wrapped
+
+    return wrapper

pawlogger-0.1.0/src/pawlogger/consts.py

@@ -0,0 +1,8 @@
+ASCTIME_PATTERN = r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2},\d{3}"
+CONSOLE_FORMAT_STR = '{levelname} - {module}:{lineno} - {message}'
+FILE_FORMAT_STR = '{levelname} - {asctime} - {module}:{lineno} - {message}'
+
+
+def get_format_str(match_regex=False, console_or_file='file'):
+    ret_str = ''
+    return ret_str

pawlogger-0.1.0/src/pawlogger/loggingdecorators/__init__.py

@@ -0,0 +1,12 @@
+# ruff: noqa: F401
+import sys
+
+from .decorators import on_call, on_class
+from .legacy import on_init, on_new, on_init_og, on_call_og
+
+# if sys.version_info >= (3, 12):
+#     from pawlogger.future.on_new_dec_312 import on_new
+# else:
+#     if sys.version_info < (3, 8):
+#         print("Unsupported Python version")
+#     from .decorators import on_new

pawlogger-0.1.0/src/pawlogger/loggingdecorators/consts_formats.py

@@ -0,0 +1,61 @@
+import inspect
+import logging
+from typing import Callable, Union
+
+DFLT_LOGGER_STR = "DEFAULT_LOGGER_STR"
+DFLT_LOG_LEVEL = logging.DEBUG
+LOGGER_CLASS = logging.getLoggerClass()
+LOGGER_LIKE = Union[str, LOGGER_CLASS, Callable]
+
+
+def call_msg(func_name, args=None, kwargs=None, logargs=True, logdefaults=False):
+    if all([args is None, kwargs is None, logargs]):
+        raise ValueError("Must provide either args or kwargs if logargs is True")
+
+    args, kwargs = args or [], kwargs or {}
+
+    arg_details = f": {args}" if args else ""
+    arg_msg = f"{len(args)} arg(s){arg_details}"
+
+    kwarg_details = f" : {kwargs}" if kwargs else ""
+    kwarg_msg = f"{len(kwargs)} kwarg(s){kwarg_details}"
+
+    content = f"calling {func_name} with {arg_msg} and {kwarg_msg}"
+    return content
+
+
+def class_msg2(cls_or_self, use_new=False, args=None, kwargs=None, logargs=True, logdefaults=False):
+    if all([args is None, kwargs is None, logargs]):
+        raise ValueError("Must provide either args or kwargs if logargs is True")
+
+    args, kwargs = args or [], kwargs or {}
+
+    arg_details = f": {args}" if args else ""
+    arg_msg = f"{len(args)} arg(s){arg_details}"
+
+    kwarg_details = f" : {kwargs}" if kwargs else ""
+    kwarg_msg = f"{len(kwargs)} kwarg(s){kwarg_details}"
+
+    method_type = "creating" if use_new else "initializing"
+    content = f"{method_type} {cls_or_self.__class__.__name__} with {arg_msg} and {kwarg_msg}"
+    return content
+
+
+def build_log_msg(obj, args: dict = None, logargs=True, use_new=False):
+    if args is None and logargs:
+        raise ValueError('if want to log args then provide some!')
+    args = {k: v for k, v in args.items() if k not in ['self', 'cls']} if args else {}
+    arg_details = ': ' + ', '.join([f"{k} = {v}" for k, v in args.items()]) if args else ""
+    arg_msg = f"{len(args)} arg(s){arg_details}"
+
+    if inspect.isfunction(obj) or inspect.ismethod(obj):
+        content = f"calling {obj.__name__} with {arg_msg}"
+
+    elif inspect.isclass(obj):
+        method_type = "new:" if use_new else "init:"
+        class_name = obj.__name__ if inspect.isclass(obj) else obj.__class__.__name__
+        content = f"{method_type} {class_name} with {arg_msg}"
+    else:
+        raise TypeError("Unsupported object type for logging")
+
+    return content

pawlogger-0.1.0/src/pawlogger/loggingdecorators/decorators.py

@@ -0,0 +1,188 @@
+import inspect
+import logging
+from functools import wraps
+
+from .consts_formats import DFLT_LOGGER_STR, LOGGER_CLASS, LOGGER_LIKE, \
+    build_log_msg
+
+
+# from src.pawlogger.legacy import log_object
+
+
+def on_call(logger: LOGGER_LIKE, level=logging.DEBUG, logargs=True,
+            logdefaults=False, msg: str = "",
+            depth=0):
+    """
+    Decorate a function with a wrapper which logs the call at the specified level.
+    Increase depth by 1 for each level of decorator nesting.
+    """
+    const_depth = 2
+    total_depth = const_depth + depth
+
+    def decorator(func):
+
+        if not callable(func):
+            raise TypeError(f"{func} does not appear to be callable.")
+
+        if getattr(func, "__name__") == "__repr__":
+            raise RuntimeError("Cannot apply to __repr__ as this will cause infinite recursion!")
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            _logger = _get_logger(func, logger)
+            logger.debug(f'logger {logger.name}')
+
+            if not isinstance(_logger, LOGGER_CLASS):
+                raise TypeError(
+                    f"logger argument had unexpected type {type(_logger)}, expected {LOGGER_CLASS}")
+
+            result = func(*args, **kwargs)
+            if logargs:
+                log_agnostic(_logger, func, level, total_depth, logargs=logargs, args=args,
+                             kwargs=kwargs, logdefaults=logdefaults)
+            else:
+                log_agnostic(_logger, func, level, logargs=False, depth=total_depth)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+#
+# def on_class(logger: LOGGER_LIKE = DFLT_LOGGER_STR,
+#              level=logging.DEBUG,
+#              logargs=True,
+#              logdefaults=False,
+#              depth=0,
+#              decorate_init=True,
+#              decorate_new=False):
+#     """
+#     Unified decorator for logging calls to a class's __init__ and/or __new__ methods.
+#     """
+#     const_depth = 2
+#     total_depth = const_depth + depth
+#
+#     def decorator(cls):
+#         if not inspect.isclass(cls):
+#             raise TypeError("on_class decorator can only be applied to classes.")
+#
+#         original_init = cls.__init__ if decorate_init and hasattr(cls, '__init__') else None
+#         original_new = cls.__new__ if decorate_new and hasattr(cls, '__new__') else None
+#
+#         def wrap_function(original_function, method_name):
+#             @wraps(original_function)
+#             def wrapper(*args, **kwargs):
+#                 _logger = _get_logger(cls, logger)
+#                 if logargs:
+#                     bound_arguments = get_bound(cls, use_new=use_new,
+#                                                 logdefault=logdefaults, args=args, kwargs=kwargs)
+#                     log_msg = build_log_msg(cls, args=bound_arguments.arguments,
+#                                             use_new=(method_name == 'new'))
+#                 else:
+#                     log_msg = build_log_msg(cls, logargs=False, use_new=(method_name == 'new'))
+#
+#                 _logger.log(level=level, msg=log_msg, stacklevel=total_depth)
+#                 return original_function(*args, **kwargs)
+#
+#             return wrapper
+#
+#         if original_init:
+#             cls.__init__ = wrap_function(original_init, 'init')
+#         if original_new:
+#             cls.__new__ = wrap_function(original_new, 'new')
+#
+#         return cls
+#
+#     return decorator
+#
+def on_class[T](logger: LOGGER_LIKE = DFLT_LOGGER_STR,
+                level=logging.DEBUG,
+                logargs=True,
+                logdefaults=False,
+                depth=0,
+                decorate_init=True,
+                decorate_new=False) -> T:
+    """
+    Decorator for logging calls to a class's __init__ and/or __new__ methods.
+    If decorate_init is True, replace the class __init__ method with a wrapped version.
+    If decorate_new is True, do the same for the __new__ method.
+    """
+
+    def decorator(cls):
+        if not inspect.isclass(cls):
+            raise TypeError("on_class decorator can only be applied to classes.")
+
+        if decorate_init and hasattr(cls, '__init__'):
+            original_init = cls.__init__
+            wrapped_init = on_call(logger, level, logargs, logdefaults, depth=depth + 1)(
+                original_init)
+            cls.__init__ = wrapped_init
+
+        if decorate_new and hasattr(cls, '__new__'):
+            original_new = cls.__new__
+            wrapped_new = on_call(logger, level, logargs, logdefaults, depth=depth + 1)(
+                original_new)
+            cls.__new__ = wrapped_new
+
+        return cls
+
+    return decorator
+
+
+def get_bound(obj, use_new=False, logdefault=False, args=None, kwargs=None):
+    args = args or ()
+    kwargs = kwargs or {}
+
+    if inspect.isclass(obj):
+        init_or_new = obj.__new__ if use_new else obj.__init__
+        signature_ = inspect.signature(init_or_new)
+        args = obj, *args
+    elif callable(obj):
+        signature_ = inspect.signature(obj)
+    else:
+        raise TypeError()
+
+    bound_arguments = signature_.bind(*args, **kwargs)
+    if logdefault:
+        bound_arguments.apply_defaults()
+
+    return bound_arguments
+
+
+def log_agnostic(_logger, obj, level, depth, args=None, kwargs=None, logargs=True,
+                 logdefaults=False,
+                 use_new=False):
+    if logargs and args is None:
+        raise ValueError("if logargs then provide them")
+    args, kwargs = args or (), kwargs or {}
+    if logargs:
+        bound_arguments = get_bound(obj=obj, use_new=use_new, logdefault=logdefaults, args=args,
+                                    kwargs=kwargs)
+        log_msg = build_log_msg(obj, args=bound_arguments.arguments, use_new=use_new)
+    else:
+        log_msg = build_log_msg(obj, logargs=False, use_new=use_new)
+
+    _logger.log(level=level, msg=log_msg, stacklevel=depth)
+    ...
+
+
+def _get_logger(objec, loggerlike: LOGGER_LIKE):
+    if isinstance(loggerlike, LOGGER_CLASS):
+        _logger = loggerlike
+
+    elif isinstance(loggerlike, str):
+        _logger = getattr(objec, loggerlike, None)
+        _logger = _logger or logging.getLogger(loggerlike)
+
+    elif callable(loggerlike):
+        _logger = loggerlike()
+
+    else:
+        raise TypeError(
+            f"logger argument had unexpected type {type(loggerlike)}, expected {LOGGER_CLASS}")
+
+    if not isinstance(_logger, LOGGER_CLASS):
+        raise ValueError(f'Unable to get logger {loggerlike}')
+
+    return _logger

pawlogger-0.1.0/src/pawlogger/loggingdecorators/legacy.py

@@ -0,0 +1,254 @@
+import inspect
+import logging
+from functools import wraps
+from typing import Callable, Union
+
+from .consts_formats import DFLT_LOGGER_STR, LOGGER_CLASS, LOGGER_LIKE
+from .decorators import _get_logger, log_agnostic
+
+loggerClass = logging.getLoggerClass()
+
+
+def on_call_og(logger: Union[loggerClass, Callable], level=logging.DEBUG, logargs=True,
+               msg: str = "", depth=0):
+    """
+    When applied to a function, decorate it with a wrapper which logs the call using the given logger at the specified
+    level.
+
+    The "logger" argument must be an instance of a logger from the logging library, or a function which returns an
+    instance of a logger.
+
+    If logargs is True, log the function arguments, one per line.
+
+    If the decorated function is to be nested inside other decorators, increase the depth argument by 1 for each
+    additional level of nesting in order for the messages emitted to contain the correct source file name & line number.
+    """
+    const_depth = 2
+    total_depth = const_depth + depth
+
+    def decorator(func):
+
+        if not callable(func):
+            raise TypeError(f"{func} does not appear to be callable.")
+
+        if getattr(func, "__name__") == "__repr__":
+            raise RuntimeError("Cannot apply to __repr__ as this will cause infinite recursion!")
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+
+            _logger = logger() if inspect.isfunction(logger) else logger
+
+            if not isinstance(_logger, loggerClass):
+                raise TypeError(
+                    f"logger argument had unexpected type {type(_logger)}, expected {loggerClass}")
+
+            content = f"calling {func} with {len(args)} arg(s) and {len(kwargs)} kwarg(s) "
+            if msg:
+                content = f"{content} ({msg})"
+            _logger.log(level, content, stacklevel=total_depth)
+            if logargs:
+                for n, arg in enumerate(args):
+                    _logger.log(level, f" - arg {n:>2}: {type(arg)} {arg}", stacklevel=total_depth)
+                for m, (key, item) in enumerate(kwargs.items()):
+                    _logger.log(level, f" - kwarg {m:>2}: {type(item)} {key}={item}",
+                                stacklevel=total_depth)
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def on_init_og(logger: Union[str, loggerClass, Callable] = "logger", level=logging.DEBUG,
+               logargs=True, depth=0):
+    """
+    When applied to a class or an __init__ method, decorate it with a wrapper which logs the __init__ call using the
+    given logger at the specified level.
+
+    If "logger" is a string, look up an attribute of this name in the initialised object and use it to log the message.
+    If "logger" is a function, call it to obtain a reference to a logger instance.
+    Otherwise, assume "logger" is an instance of a logger from the logging library and use it to log the message.
+
+    If logargs is True, the message contains the arguments passed to __init__.
+
+    If the decorated class or __init__ method is to be nested inside other decorators, increase the depth argument by 1
+    for each additional level of nesting in order for the messages emitted to contain the correct source file name &
+    line number.
+    """
+
+    const_depth = 2
+    total_depth = const_depth + depth
+
+    def decorator(constructor):
+
+        if not callable(constructor):
+            raise TypeError(f"{constructor} does not appear to be callable.")
+
+        is_class = inspect.isclass(constructor)
+
+        to_call = getattr(constructor, "__init__") if is_class else constructor
+
+        @wraps(constructor)
+        def init_wrapper(self, *args, **kwargs):
+
+            _logger = getattr(self, logger) if isinstance(logger, str) \
+                else logger() if inspect.isfunction(logger) \
+                else logger
+
+            if not isinstance(_logger, loggerClass):
+                raise TypeError(
+                    f"logger argument had unexpected type {type(_logger)}, expected {loggerClass}")
+
+            if logargs:
+                _logger.log(level, f"init: {self.__class__.__name__}({args=}, {kwargs=})",
+                            stacklevel=total_depth)
+            else:
+                _logger.log(level, f"init: {self.__class__.__name__}()", stacklevel=total_depth)
+
+            to_call(self, *args, **kwargs)
+
+        if is_class:
+            setattr(constructor, "__init__", init_wrapper)
+            return constructor
+        else:
+            return init_wrapper
+
+    return decorator
+
+
+def on_init[T](logger: LOGGER_LIKE = DFLT_LOGGER_STR,
+               level=logging.DEBUG,
+               logargs=True,
+               logdefaults=False,
+               use_new=False,
+               depth=0
+               ) -> [T]:
+    """
+    Decorator for logging initialization calls to a class's __init__ method.
+    """
+    const_depth = 2
+    total_depth = const_depth + depth
+
+    def decorator(constructor):
+        if inspect.isclass(constructor):
+            original_thing = constructor.__init__
+        else:
+            original_thing = constructor
+
+        @wraps(original_thing)
+        def wrapper(self, *args, **kwargs):
+            _logger = _get_logger(self, logger)
+            classname = self.__class__.__name__
+            result = original_thing(self, *args, **kwargs)
+            if logargs:
+                log_agnostic(_logger, args, kwargs, self, logdefaults, level, total_depth)
+            else:
+                log_agnostic(_logger, obj=self, logdefaults=logdefaults, logargs=False,
+                             use_new=use_new)
+                # log_object(_logger, classname, level, total_depth, 'init')
+            return result
+
+        if inspect.isclass(constructor):
+            constructor.__init__ = wrapper
+        else:
+            constructor = wrapper
+
+        return constructor
+
+    return decorator
+
+
+def on_new(logger: LOGGER_LIKE = DFLT_LOGGER_STR,
+           level=logging.DEBUG,
+           logargs=True,
+           logdefaults=False,
+           depth=0):
+    """
+    Decorator for logging calls to a class's __new__ method.
+    """
+    const_depth = 2
+    total_depth = const_depth + depth
+
+    def decorator(constructor):
+        if inspect.isclass(constructor):
+            original_thing = constructor.__new__
+        else:
+            original_thing = constructor
+
+        @wraps(original_thing)
+        def wrapper(cls, *args, **kwargs):
+            _logger = _get_logger(cls, logger)
+            classname = cls.__name__ if inspect.isclass(cls) else cls.__class__.__name__
+            if logargs:
+                log_agnostic(_logger, args, classname, kwargs, cls, original_thing, logdefaults,
+                             level, total_depth)
+            else:
+                log_object(_logger, classname, level, total_depth, 'new')
+            return original_thing(cls, *args, **kwargs)
+
+        if inspect.isclass(constructor):
+            setattr(constructor, "__new__", wrapper)
+        else:
+            constructor = wrapper
+
+        return constructor
+
+    return decorator
+
+
+# def log_with_args_cl(_logger, args, kwargs, callable_func, logdefaults, level, depth):
+#     callable_name = callable_func.__name__
+#     bound_arguments = get_bound_args(args, kwargs, callable_func)
+#     formatted_args = format_bound_args(bound_arguments, logdefaults)
+#     log_object(_logger, callable_name, level, depth, formatted_args)
+
+
+# if not inspect.isclass(obj) and hasattr(obj, '__init__'):
+#     callable_obj = obj.__init__
+# elif hasattr(obj, '__call__'):
+#     callable_obj = obj.__call__
+# else:
+#     callable_obj = obj
+#
+# signature_ = inspect.signature(callable_obj)
+# bound_arguments = signature_.bind(*args, **kwargs)
+# return bound_arguments
+
+
+# def binder_func(obj, use_new = False, *args, **kwargs):
+#     # args = args or ()
+#     # kwargs = kwargs or {}
+#     args = args
+#     if inspect.isclass(obj):
+#         # args = (obj, *args)
+#         signature_ = inspect.signature(obj.__new__) if use_new else inspect.signature(obj.__init__)
+#     else:
+#         signature_ = inspect.signature(obj)
+#     res = signature_.bind(*args, **kwargs)
+#     return res
+
+
+def get_bound_args(args, kwargs, cls_or_self, init_or_new):
+    init_signature = inspect.signature(init_or_new)
+    bound_arguments = init_signature.bind(cls_or_self, *args, **kwargs)
+    return bound_arguments
+
+
+def format_bound_args(bound_arguments, logdefaults):
+    if logdefaults:
+        bound_arguments.apply_defaults()
+    formatted_args = ', '.join(f"{k}={v.__class__.__name__ if k == 'self' or v == 'cls' else v}"
+                               for k, v in bound_arguments.arguments.items())
+    return formatted_args
+
+
+def log_object_cl(_logger: LOGGER_CLASS, callable_name: str, level, depth, formatted_args=None):
+    formatted_args = formatted_args or ''
+    _logger.log(level, f"{callable_name}({formatted_args})", stacklevel=depth)
+
+
+def log_object(_logger: LOGGER_CLASS, classname: str, level, depth, msg_prefix: str,
+               formatted_args=None):
+    formatted_args = formatted_args or ''
+    _logger.log(level, f"{msg_prefix}: {classname}({formatted_args})", stacklevel=depth)

pawlogger-0.1.0/src/pawlogger/tests/loggingdecorators/conftest.py

@@ -0,0 +1,115 @@
+import logging
+import uuid
+
+import pytest
+
+from pawlogger import DFLT_LOG_LEVEL
+
+ARG1 = "value 1 for test"
+ARG2 = "value 2 for test"
+DFLT_ARG1 = "default value 1"
+DFLT_ARG2 = "default value 2"
+
+
+@pytest.fixture
+def test_logger():
+    logger_name = "test_logger_" + str(uuid.uuid4())
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(DFLT_LOG_LEVEL)
+    yield logger
+    logger.handlers.clear()
+    logger = None
+
+
+class DummyClass:
+    logger_cls_attr = logging.getLogger('logger_cls_attr')
+    logger_cls_attr.setLevel(DFLT_LOG_LEVEL)
+
+    def __init__(self, arg1, arg2, arg3=DFLT_ARG1):
+        self.arg1 = arg1
+        self.arg2 = arg2
+        self.arg3 = arg3
+        self.logger_inst_attr = logging.getLogger('logger_attr')
+        self.logger_inst_attr.setLevel(DFLT_LOG_LEVEL)
+
+    # def __new__(cls, arg1, arg2, arg3=DFLT_ARG1):
+    #     return super().__new__(cls)
+
+    def dummy_instance_method(self, arg1, arg2):
+        return self, arg1, arg2
+
+    @staticmethod
+    def dummy_static_method(arg1, arg2):
+        return arg1, arg2
+
+    @classmethod
+    def dummy_class_method(cls, arg1, arg2):
+        return cls, arg1, arg2
+
+
+class DummyNewWithArgs(DummyClass):
+    def __new__(cls, arg1, arg2, arg3=DFLT_ARG1):
+        return super().__new__(cls)
+
+
+# todo move these
+INIT_MSG = f"init: {DummyClass.__name__}"
+NEW_MSG = f"new: {DummyClass.__name__}"
+
+
+def dummy_func(arg1, arg2):
+    return arg1, arg2
+
+
+def dummy_func_noargs():
+    return "No args"
+
+
+def dummy_func_kwargs(arg1, arg2, kwarg3, kwarg4_with_def=None):
+    return arg1, arg2, kwarg3, kwarg4_with_def
+
+
+@pytest.fixture
+def dummy_func_fxt():
+    return dummy_func
+
+
+@pytest.fixture
+def dummy_func_noargs_fxt():
+    return dummy_func_noargs
+
+
+@pytest.fixture
+def dummy_func_kwargs_fxt():
+    return dummy_func_kwargs
+
+
+@pytest.fixture
+def dummy_class_fxt():
+    return DummyClass
+
+
+class DummyClassNoArgs:
+    def __init__(self):
+        self.value = "No args init"
+
+    def __new__(cls):
+        return super().__new__(cls)
+
+
+class DummyClassDefaultArgs:
+    def __init__(self, arg1=DFLT_ARG1, arg2=DFLT_ARG2):
+        self.arg1 = arg1
+        self.arg2 = arg2
+
+    def __new__(cls, arg1=DFLT_ARG1, arg2=DFLT_ARG2):
+        return super().__new__(cls)
+
+
+class DummyInheritedClass(DummyClass):
+    def __init__(self, arg1, arg2, extra_arg):
+        super().__init__(arg1, arg2)
+        self.extra_arg = extra_arg
+
+    def __new__(cls, arg1, arg2, extra_arg):
+        return super().__new__(cls)

pawlogger-0.1.0/src/pawlogger/tests/loggingdecorators/test_on_call.py

@@ -0,0 +1,89 @@
+import copy
+import logging
+
+import pytest
+
+from pawlogger import DFLT_LOGGER_STR, DFLT_LOG_LEVEL, build_log_msg
+from pawlogger.loggingdecorators.decorators import on_call
+from tests.loggingdecorators.conftest import ARG1, ARG2, dummy_func, dummy_func_kwargs, dummy_func_noargs
+
+
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+def test_on_call_with_various_loggers(caplog, logger_input):
+    logger_name, logger = logger_input
+    dummy = copy.copy(dummy_func)
+    decorated_test_function = on_call(logger=logger)(dummy)
+    argdict = {
+        'arg1': ARG1,
+        'arg2': ARG2,
+    }
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        decorated_test_function(**argdict)
+
+    content = build_log_msg(dummy, args=argdict)
+    assert content in caplog.text
+
+
+
+# Test functions with different argument types
+@pytest.mark.parametrize("func, args, kwargs", [
+    (dummy_func, ('arg1', 'arg2'), {}),
+    (dummy_func_noargs, (), {}),
+    (dummy_func_kwargs, ('arg1', 'arg2'), {'kwarg3': 'value3', 'kwarg4_with_def': 'value4'}),
+])
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+def test_on_call_functions(caplog, logger_input, func, args, kwargs):
+    logger_name, logger = logger_input
+    decorated_function = on_call(logger=logger)(func)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        result = decorated_function(*args, **kwargs)
+
+    # Build log message
+    args_dict = dict(zip(func.__code__.co_varnames, args))
+    args_dict.update(kwargs)
+    expected_log = build_log_msg(func, args=args_dict)
+    assert expected_log in caplog.text
+
+
+@pytest.mark.parametrize("method_name, args, kwargs", [
+    ('dummy_instance_method', ('arg1', 'arg2'), {}),
+    ('dummy_static_method', ('arg1', 'arg2'), {}),
+    ('dummy_class_method', ('arg1', 'arg2'), {}),
+])
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+def test_on_call_class_methods(caplog, logger_input, method_name, args, kwargs, dummy_class_fxt):
+    logger_name, logger = logger_input
+    dummy_class = dummy_class_fxt
+    method = getattr(dummy_class, method_name)
+    decorated_method = on_call(logger=logger)(method)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        if 'instance' in method_name:
+            # Create an instance of DummyClass for instance method test
+            instance = dummy_class(ARG1, ARG2)
+            result = decorated_method(instance, *args, **kwargs)
+        else:
+            result = decorated_method(*args, **kwargs)
+
+    # Build log message
+    full_args = (dummy_class,) + args if 'class' in method_name else args
+    full_args = (instance,) + args if 'instance' in method_name else full_args
+    args_dict = dict(zip(method.__code__.co_varnames[:len(full_args)], full_args))
+    args_dict.update(kwargs)
+    expected_log = build_log_msg(method, args=args_dict)
+
+    assert expected_log in caplog.text
+

pawlogger-0.1.0/src/pawlogger/tests/loggingdecorators/test_on_class.py

@@ -0,0 +1,139 @@
+import logging
+
+import pytest
+
+from pawlogger import DFLT_LOGGER_STR, build_log_msg
+from pawlogger.loggingdecorators.decorators import on_class
+from tests.loggingdecorators.conftest import (ARG1, ARG2, DFLT_LOG_LEVEL, DummyClass, DummyClassDefaultArgs,
+                                              DummyClassNoArgs,
+                                              DummyInheritedClass, DummyNewWithArgs)
+
+
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+def test_on_class_init(caplog, logger_input):
+    logger_name, logger = logger_input
+    DecoratedClass = on_class(logger=logger, decorate_init=True, decorate_new=False)(DummyClass)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        instance = DecoratedClass(ARG1, ARG2)  # noqa 481
+
+    expected_log = f'calling __init__ with 2 arg(s): arg1 = {ARG1}, arg2 = {ARG2}'
+    assert expected_log in caplog.text
+
+
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+def test_on_class_new(caplog, logger_input):
+    logger_name, logger = logger_input
+    DecoratedClass = on_class(logger=logger, decorate_init=False, decorate_new=True)(
+        DummyNewWithArgs)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        instance = DecoratedClass(ARG1, ARG2)
+
+    expected_log = f'calling __new__ with 2 arg(s): arg1 = {ARG1}, arg2 = {ARG2}'
+    assert expected_log in caplog.text
+#
+#
+# @pytest.mark.parametrize("decorate_init, decorate_new", [
+#     (True, False),
+#     # (False, True),
+#     # (True, True)
+# ])
+# @pytest.mark.parametrize("class_type, init_args", [
+#     (DummyClassNoArgs, ()),
+#     # (DummyClassDefaultArgs, ()),
+#     # (DummyInheritedClass, (ARG1, ARG2, "Extra Arg")),
+# ])
+# @pytest.mark.parametrize("logger_input", [
+#     (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+#     # ("test_logger_obj", logging.getLogger("test_logger_obj")),
+#     # ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+# ])
+# def test_on_class_various_types(caplog, logger_input, class_type, init_args, decorate_init, decorate_new):
+#     logger_name, logger = logger_input
+#     DecoratedClass = on_class(logger=logger, decorate_init=decorate_init, decorate_new=decorate_new)(class_type)
+#
+#     with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+#         instance = DecoratedClass(*init_args)
+#
+#     # args_dict = dict(zip(func.__code__.co_varnames, args))
+#     # args_dict.update(kwargs)
+#     # expected_log = build_log_msg(func, args=args_dict)
+#
+#     method_name = "__init__" if decorate_init else "__new__"
+#     arg_details = ', '.join([f'arg{i+1} = {arg}' for i, arg in enumerate(init_args)])
+#     expected_log = f'calling {method_name} with {len(init_args)} arg(s): {arg_details}'
+#     assert expected_log in caplog.text
+
+
+@pytest.mark.parametrize("decorate_init, decorate_new", [
+    (True, False),
+    (False, True),
+    (True, True)
+])
+@pytest.mark.parametrize("class_type, init_args", [
+    (DummyClassNoArgs, ()),
+    (DummyClassDefaultArgs, ()),
+    (DummyInheritedClass, (ARG1, ARG2, "Extra Arg")),
+])
+@pytest.mark.parametrize("logger_input", [
+    (DFLT_LOGGER_STR, DFLT_LOGGER_STR),
+    ("test_logger_obj", logging.getLogger("test_logger_obj")),
+    ("test_logger_callable", lambda: logging.getLogger("test_logger_callable")),
+])
+
+def test_on_class_various_types(caplog, logger_input, class_type, init_args, decorate_init, decorate_new):
+    logger_name, logger = logger_input
+    DecoratedClass = on_class(logger=logger, decorate_init=decorate_init, decorate_new=decorate_new)(class_type)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+        instance = DecoratedClass(*init_args)
+
+    # Determine the actual method and its class
+    method = DecoratedClass.__init__ if decorate_init else DecoratedClass.__new__
+    method_class = type(method)
+
+    # Construct args_dict based on method and class
+    arg_names = method.__code__.co_varnames[1:method.__code__.co_argcount]
+    args_dict = dict(zip(arg_names, init_args))
+    if decorate_init:
+        args_dict = {'self': instance, **args_dict}
+    else:
+        args_dict = {'cls': DecoratedClass, **args_dict}
+
+    expected_log = build_log_msg(method, args=args_dict)
+
+    assert expected_log in caplog.text
+
+# def test_on_class_various_types(caplog, logger_input, class_type, init_args, decorate_init, decorate_new):
+#     logger_name, logger = logger_input
+#     DecoratedClass = on_class(logger=logger, decorate_init=decorate_init, decorate_new=decorate_new)(class_type)
+#
+#     with caplog.at_level(DFLT_LOG_LEVEL, logger=logger_name):
+#         instance = DecoratedClass(*init_args)
+#
+#     # Choose the method (__init__ or __new__) from the decorated class
+#     method = DecoratedClass.__init__ if decorate_init else DecoratedClass.__new__
+#     method_name = "__init__" if decorate_init else "__new__"
+#
+#     # Extract argument names (excluding 'self' and 'cls')
+#     arg_names = method.__code__.co_varnames[1:method.__code__.co_argcount]
+#
+#     # Construct the args_dict with correct argument names and values
+#     args_dict = dict(zip(arg_names, init_args))
+#     if decorate_init:
+#         args_dict = {'self': instance, **args_dict}
+#     else:  # If decorate_new is True
+#         args_dict = {'cls': DecoratedClass, **args_dict}
+#
+#     expected_log = build_log_msg(method, args=args_dict)
+#
+#     assert expected_log in caplog.text

pawlogger-0.1.0/src/pawlogger/tests/loggingdecorators/test_on_init.py

@@ -0,0 +1,121 @@
+import logging
+
+import pytest
+
+from pawlogger import on_init
+from pawlogger import DFLT_LOGGER_STR, DFLT_LOG_LEVEL
+from tests.loggingdecorators.conftest import ARG1, ARG2, DFLT_ARG1, DummyClass
+
+
+def test_on_init_dflt(caplog):
+    decorated_class = on_init()(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger=DFLT_LOGGER_STR):
+        instance = decorated_class(ARG1, ARG2)  # noqa: F841
+    msg = caplog.messages[-1]
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+    assert ARG2 in msg
+    assert DFLT_ARG1 not in msg
+    caplog.clear()
+
+
+@pytest.mark.parametrize("logger_input", [
+    ("default_logger", DFLT_LOGGER_STR),
+    ("test_logger_instance", "test_logger"),
+])
+def test_on_init_with_various_loggers(caplog, test_logger, logger_input):
+    logger_type, logger = logger_input
+    logger = test_logger if logger == "test_logger" else logger
+    decorated_class = on_init(logger=logger)(DummyClass)
+    with caplog.at_level(logging.DEBUG,
+                         logger=test_logger.name if logger_type == "test_logger_instance" else DFLT_LOGGER_STR):
+        instance = decorated_class(ARG1, arg2=ARG2)  # noqa: F841
+    msg = caplog.messages[-1]
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+    assert ARG2 in msg
+    assert DFLT_ARG1 not in msg
+    caplog.clear()
+
+
+
+def test_on_init_with_exception(caplog, test_logger):
+    class DummyClassExcepts:
+        def __init__(self, arg1):
+            raise ValueError("Init error")
+
+    decorated_class = on_init(logger=test_logger)(DummyClassExcepts)
+
+    with caplog.at_level(logging.DEBUG, logger=test_logger.name):
+        with pytest.raises(ValueError):
+            instance = decorated_class(ARG1)  # noqa: F841
+
+
+def test_on_init_with_depth(caplog, test_logger):
+    def dummy_decorator(func):
+        def wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    @dummy_decorator
+    @on_init(logger=test_logger, depth=1)
+    class DummyClassDecorated(DummyClass):
+        pass
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=test_logger.name):
+        instance = DummyClassDecorated(ARG1, ARG2)  # noqa: F841
+    msg = caplog.messages[-1]
+
+    assert INIT_MSG + 'Decorated' in msg
+    assert ARG1 in msg
+
+
+def test_on_init_with_callable_logger(caplog):
+    def logger_callable():
+        return logging.getLogger('callable_logger')
+
+    decorated_test_class = on_init(logger=logger_callable)(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger='callable_logger'):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+
+    msg = caplog.messages[-1]
+
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+
+
+def test_on_init_with_class_attribute_logger(caplog, test_logger):
+    logger = DummyClass.logger_cls_attr
+    decorated_test_class = on_init(logger=logger.name)(DummyClass)
+
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=logger.name):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+
+    msg = caplog.messages[-1]
+
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+
+
+def test_on_init_with_instance_attribute_logger(caplog, test_logger):
+    decorated_test_class = on_init(logger='logger_attr')(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger='logger_attr'):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+
+    msg = caplog.messages[-1]
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+    assert ARG2 in msg
+
+
+def test_on_init_log_defaults(caplog, test_logger):
+    decorated_test_class = on_init(logger=test_logger, logdefaults=True)(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger=test_logger.name):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+    msg = caplog.messages[-1]
+
+    assert INIT_MSG in msg
+    assert ARG1 in msg
+    assert f"arg3={DFLT_ARG1}" in msg
+    caplog.clear()

pawlogger-0.1.0/src/pawlogger/tests/loggingdecorators/test_on_new.py

@@ -0,0 +1,68 @@
+# ruff: noqa: F841
+import copy
+import logging
+
+import pytest
+
+from pawlogger import on_new
+from pawlogger import DFLT_LOGGER_STR, DFLT_LOG_LEVEL
+from tests.loggingdecorators.conftest import ARG1, ARG2, DFLT_ARG1, DFLT_ARG2, DummyClass, NEW_MSG
+
+
+def test_with_logger_object(caplog, test_logger, dummy_class_fxt):
+    decorated_test_class = on_new(logger=test_logger)(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger=test_logger.name):
+        instance = decorated_test_class(ARG1, arg2=ARG2)  # noqa: F841
+    msg = caplog.records[0].msg
+    assert NEW_MSG in msg
+    caplog.clear()
+
+
+def test_with_callable(caplog, test_logger):
+    def logger_callable():
+        return test_logger
+
+    decorated_test_class = on_new(logger=logger_callable)(DummyClass)
+    with caplog.at_level(logging.DEBUG, logger=test_logger.name):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+    msg = caplog.records[0].msg
+    assert NEW_MSG in msg
+    caplog.clear()
+
+
+def test_no_logargs(caplog, test_logger):
+    caplog.clear()
+    decorated_test_class = on_new(logger=test_logger, logargs=False)(DummyClass)
+    with caplog.at_level(DFLT_LOG_LEVEL, logger=test_logger.name):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+    msg = caplog.records[0].msg
+    assert NEW_MSG in msg
+    assert ARG1 not in msg
+    assert ARG2 not in msg
+    assert DFLT_ARG1 not in msg
+    assert DFLT_ARG2 not in msg
+    caplog.clear()
+
+
+def test_default_dec(caplog, test_logger):
+    dummy = copy.copy(DummyClass)
+    decorated_test_class = on_new()(dummy)
+    with caplog.at_level(logging.DEBUG, logger=DFLT_LOGGER_STR):
+        instance = decorated_test_class(ARG1, ARG2)  # noqa: F841
+    msg = caplog.records[-1].msg
+
+    assert NEW_MSG in msg
+    assert ARG1 in msg
+    assert ARG2 in msg
+    assert DFLT_ARG1 not in msg
+    assert DFLT_ARG2 not in msg
+    caplog.clear()
+
+
+def test_invalid_logger(caplog, test_logger):
+    dummy = copy.copy(DummyClass)
+    with pytest.raises(TypeError):
+        decorated_test_class = on_new(logger=123)(dummy)
+        with caplog.at_level(logging.DEBUG, logger=test_logger.name):
+            instance = decorated_test_class(ARG1)  # noqa: F841
+            caplog.clear()

pawlogger-0.1.0/src/pawlogger/tests/pawlogger/test_l_config.py

@@ -0,0 +1,63 @@
+import logging
+import os
+import re
+from pathlib import Path
+
+import pytest
+from pawlogger.consts import ASCTIME_PATTERN
+from pawlogger import get_logger
+
+test_params = [
+    (logging.DEBUG, 'Debug message', 'DEBUG', [42]),
+    (logging.INFO, 'Info message with number: {}', 'INFO', [42]),
+    (logging.WARNING, 'Warning message with float: {:.2f}', 'WARNING', [3.14159]),
+    (logging.ERROR, 'Error message with object: {}', 'ERROR', [Exception('Test error')]),
+    (logging.CRITICAL, 'Critical message with multiline\nNew line included', 'CRITICAL', (21,)),
+]
+
+
+@pytest.mark.parametrize('log_level, log_message, level_name, format_args', test_params)
+def test_logging(caplog, tmp_path: Path, log_level, log_message, level_name, format_args):
+    log_file = tmp_path / 'test.log'
+    logger = get_logger(str(log_file.name), level=log_level, log_file=log_file)
+    logger.log(log_level, log_message.format(*format_args))
+
+    formatted_message = log_message.format(*format_args)
+    assert formatted_message in caplog.messages[-1]
+    assert any(level_name in record.levelname for record in caplog.records)
+
+    assert os.path.exists(log_file)
+    with open(log_file) as file:
+        log_contents = file.read()
+
+    expected_pattern = re.compile(
+        f'{level_name} - {ASCTIME_PATTERN} - test_l_config:\\d{{2}} - {re.escape(formatted_message)}\n'
+    )
+    assert expected_pattern.search(log_contents)
+
+
+@pytest.fixture
+def logger_from_factory(tmp_path: Path):
+    log_file = tmp_path / 'factory_logger.log'
+    return get_logger(log_file=str(log_file))
+
+
+def test_logging_from_different_sources(caplog, tmp_path: Path, logger_from_factory):
+    # Logger from the test module
+    log_file_test = tmp_path / 'test_logger.log'
+    logger_test = get_logger(log_file=str(log_file_test))
+
+    # Log a message from the test module logger
+    test_message = 'Log message from test module'
+    logger_test.info(test_message)
+
+    # Log a message from the factory logger
+    factory_message = 'Log message from factory'
+    logger_from_factory.info(factory_message)
+
+    # Assertions
+    assert test_message in caplog.text
+    assert factory_message in caplog.text
+    assert os.path.exists(log_file_test) and os.path.exists(tmp_path / 'factory_logger.log')
+
+    # You can add more assertions to check the content of the log files