From 67ad6ccb945eb490fe48e152a38ba35b3a25bdee Mon Sep 17 00:00:00 2001
From: Eishausener <code@eishausener.de>
Date: Fri, 22 Mar 2024 16:06:44 +0100
Subject: [PATCH] added description to __init__.py; removed build and dist
 files

---
 .gitignore                               |   3 +
 build/lib/eh_logging/__init__.py         | 618 -----------------------
 dist/eh_logging-0.1.5-py3-none-any.whl   | Bin 5632 -> 0 bytes
 dist/eh_logging-0.1.5.tar.gz             | Bin 6113 -> 0 bytes
 eh_logging.egg-info/PKG-INFO             | 107 ----
 eh_logging.egg-info/SOURCES.txt          |   9 -
 eh_logging.egg-info/dependency_links.txt |   1 -
 eh_logging.egg-info/requires.txt         |   5 -
 eh_logging.egg-info/top_level.txt        |   1 -
 eh_logging/__init__.py                   |  10 +-
 10 files changed, 12 insertions(+), 742 deletions(-)
 delete mode 100644 build/lib/eh_logging/__init__.py
 delete mode 100644 dist/eh_logging-0.1.5-py3-none-any.whl
 delete mode 100644 dist/eh_logging-0.1.5.tar.gz
 delete mode 100644 eh_logging.egg-info/PKG-INFO
 delete mode 100644 eh_logging.egg-info/SOURCES.txt
 delete mode 100644 eh_logging.egg-info/dependency_links.txt
 delete mode 100644 eh_logging.egg-info/requires.txt
 delete mode 100644 eh_logging.egg-info/top_level.txt

diff --git a/.gitignore b/.gitignore
index 2cbd058..9aa3272 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,6 @@
 /.venv/
 /.idea/
 /test/log/
+/build/
+/dist/
+/eh_logging.egg-info/
diff --git a/build/lib/eh_logging/__init__.py b/build/lib/eh_logging/__init__.py
deleted file mode 100644
index ee079ef..0000000
--- a/build/lib/eh_logging/__init__.py
+++ /dev/null
@@ -1,618 +0,0 @@
-from __future__ import annotations
-
-from functools import wraps
-from logging import *
-from logging import __all__ as logging__all__
-from logging import handlers
-from pathlib import Path as Path_
-import os
-import time
-
-__all__ = tuple(logging__all__ + [
-    'Decorator',
-    'FormatterColor',
-    'StreamHandlerFormatted',
-    'add_default_handler',
-    'critical',
-    'debug',
-    'error',
-    'get_default_logger',
-    'get_default_logger_child',
-    'get_formatted_logger',
-    'info',
-    'log',
-    'set_default_level',
-    'set_default_logger',
-    'warning',
-])
-__version__ = '0.1.5'
-__author__ = 'Eishausener <code@eishausener.de>'
-__name__ = 'eh_logging'
-
-##########
-# config #
-##########
-
-
-# debug print (not formatted)
-_DEBUG = False
-
-
-class DEFAULT:
-    # -- Default Logger Name -- #
-    LOGGER_NAME = 'eh_logging'
-    # -- Logger Space -- #
-    SPACE_LOGGER_NAME = 11
-    SPACE_LEVEL = 8
-    SPACE_TIME = 19
-
-
-####################
-# helper functions #
-####################
-
-
-def Path(*args, **kwargs):
-    """
-    Returns the Path from the pathlib module as String
-    :param args:
-    :param kwargs:
-    :return:
-    """
-    return str(Path_(*args, **kwargs))
-
-
-def print_debug(*args, **kwargs):
-    """
-    only print to console if _DEBUG is True
-    :param args:
-    :param kwargs:
-    """
-    if _DEBUG:
-        print(*args, **kwargs)
-
-
-class _DefaultLogger:
-    """
-    Helper class to hold only one instance of the default logger
-    """
-    logger: Logger | None = None
-
-    def get(self):
-        print_debug(f'[get] addr: {id(self.logger)}, logger: {self.logger}')
-        return self.logger
-
-    def set(self, logger: Logger) -> None:
-        print_debug(f'[set] addr: {id(self.logger)}, logger: {self.logger}')
-        self.logger = logger
-
-
-_default_logger = _DefaultLogger()
-
-
-def _init():
-    """
-    Initialize a logger with StreamHandler and set as default logger (without formatting).
-    If during the initialization process of the module console outputs must be done, this logger is used. In the end,
-    it is replaced with a formatted logger
-    """
-    _changed = False
-    _logger = _default_logger.get()
-    if not _logger:
-        print_debug('[DEBUG] creating new logger')
-        _logger = getLogger(DEFAULT.LOGGER_NAME)
-        _changed = True
-
-    if not _logger.handlers:
-        print_debug(f'[DEBUG] adding stream handler to logger. (addr: {id(_logger)})')
-        _handler = StreamHandler()
-        _handler.name = 'eh_logging-stream-helper'  # should not be displayed. only for internal use
-        _logger.addHandler(_handler)
-        _changed = True
-
-    if _changed:
-        _default_logger.set(_logger)
-
-
-_init()
-
-
-############################
-# default logger functions #
-############################
-
-
-def get_default_logger() -> Logger:
-    """
-    Returns the default logger
-    :return:
-    """
-    return _default_logger.get()
-
-
-def set_default_logger(logger: Logger) -> None:
-    """
-    Sets the default logger
-    :param logger:
-    :return:
-    """
-    _default_logger.set(logger)
-
-
-def add_default_handler(handler: Handler) -> None:
-    """
-    Adds the handler to the default logger
-    :param handler:
-    :return:
-    """
-    logger = _default_logger.get()
-    logger.addHandler(handler)
-    _default_logger.set(logger)
-
-
-def set_default_level(level: int) -> None:
-    """
-    Sets the default logger level
-    :param level:
-    :return:
-    """
-    logger = _default_logger.get()
-    logger.setLevel(level)
-    _default_logger.set(logger)
-
-
-def get_default_logger_child(suffix: str) -> Logger:
-    """
-    Returns a child logger of the default logger
-    :param suffix:
-    :return:
-    """
-    logger = _default_logger.get()
-    return logger.getChild(suffix=suffix)
-
-
-#########################
-# root logger functions #
-#########################
-
-
-def log(level, msg, *args, **kwargs):
-    """
-    Log 'msg % args' with the integer severity 'level' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.log(level, msg, *args, **kwargs)
-
-
-def debug(msg, *args, **kwargs):
-    """
-    Log a message with severity 'DEBUG' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.debug(msg, *args, **kwargs)
-
-
-def info(msg, *args, **kwargs):
-    """
-    Log a message with severity 'INFO' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.info(msg, *args, **kwargs)
-
-
-def warning(msg, *args, **kwargs):
-    """
-    Log a message with severity 'WARNING' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.warning(msg, *args, **kwargs)
-
-
-def error(msg, *args, **kwargs):
-    """
-    Log a message with severity 'ERROR' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.error(msg, *args, **kwargs)
-
-
-def critical(msg, *args, **kwargs):
-    """
-    Log a message with severity 'CRITICAL' on the default logger.
-    """
-    _logger = _default_logger.get()
-    _logger.critical(msg, *args, **kwargs)
-
-
-#############
-# Decorator #
-#############
-
-
-def _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                            level, function, *args, **kwargs):
-    """
-    Executes the function and returns the result of the function and does all the logging stuff
-    :param logger:
-    :param arg:
-    :param kwarg:
-    :param return_value:
-    :param return_value_type:
-    :param decimal_places:
-    :param level:
-    :param function:
-    :param args:
-    :param kwargs:
-    :return:
-    """
-    if logger is None:
-        logger = _default_logger.get()
-    fname = function.__name__
-    msg = f'Function \x1b[3m{fname}\x1b[0m started'
-    if arg:
-        msg += f' with args: {args}'
-    if kwarg and not arg:
-        msg += f' with kwargs: {kwargs}'
-    if kwarg and arg:
-        msg += f' and with kwargs: {kwargs}'
-    logger.log(level, msg)
-    time_start = time.time()
-    value = function(*args, **kwargs)
-    time_needed = time.time() - time_start
-    if isinstance(time_needed, int):
-        time_needed = round(time_needed, decimal_places)
-    msg = f'Function \x1b[3m{fname}\x1b[0m finished in {time_needed}sec'
-    if return_value_type:
-        msg += f' with return value type {type(value)}'
-    if return_value and return_value_type:
-        msg += f' and value {value}'
-    if return_value and not return_value_type:
-        msg += f' with return value {value}'
-    logger.log(level, msg)
-    return value
-
-
-class Decorator:
-    """
-    Decorators to log
-    """
-
-    @staticmethod
-    def func_logger(logger: Logger = None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-                    return_value_type: bool = False, decimal_places: int = 2, level: int = DEBUG):
-        """
-        Decorator to add logging to a function
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :param level:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               level, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def debug(logger: Logger = None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-              return_value_type: bool = False, decimal_places: int = 2):
-        """
-        Decorator to add logging to a function with the Level DEBUG
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               DEBUG, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def info(logger=None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-             return_value_type: bool = False, decimal_places: int = 2):
-        """
-        Decorator to add logging to a function with the Level INFO
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               INFO, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def warning(logger=None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-                return_value_type: bool = False, decimal_places: int = 2):
-        """
-        Decorator to add logging to a function with the Level WARNING
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               WARNING, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def error(logger=None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-              return_value_type: bool = False, decimal_places: int = 2):
-        """
-        Decorator to add logging to a function with the Level ERROR
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               ERROR, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-    @staticmethod
-    def critical(logger=None, arg: bool = False, kwarg: bool = False, return_value: bool = False,
-                 return_value_type: bool = False, decimal_places: int = 2):
-        """
-        Decorator to add logging to a function with the Level CRITICAL
-        :param logger:
-        :param arg:
-        :param kwarg:
-        :param return_value:
-        :param return_value_type:
-        :param decimal_places:
-        :return:
-        """
-
-        def decorator(function):
-            @wraps(function)
-            def wrapper(*args, **kwargs):
-                nonlocal logger
-                return _decorator_log_by_level(logger, arg, kwarg, return_value, return_value_type, decimal_places,
-                                               CRITICAL, function, *args, **kwargs)
-
-            return wrapper
-
-        return decorator
-
-
-#############
-# Formatter #
-#############
-
-
-class FormatterColor(Formatter):
-    space_logger_name: int | None
-    space_level: int | None
-    space_time: int | None
-    time_format: str
-
-    def __init__(self, space_logger_name: int = None, space_level: int = None, space_time: int = None,
-                 time_format: str = '%Y-%m-%d %H:%M:%S'):
-        """
-
-        :param space_logger_name:
-        :param space_level:
-        :param space_time:
-        :param time_format:
-        """
-        super().__init__()
-
-        temp_logger = getLogger('FormatterColor')
-        # space_logger_name
-        if space_logger_name is not None:
-            try:
-                self.space_logger_name = int(space_logger_name)
-            except ValueError:
-                self.space_logger_name = DEFAULT.SPACE_LOGGER_NAME
-                temp_logger.warning(
-                    f'the type of space_logger_name must be int not {type(space_logger_name)}! Set to default '
-                    f'value of 10')
-        else:
-            self.space_logger_name = DEFAULT.SPACE_LOGGER_NAME
-        # space_level
-        if space_level is not None:
-            try:
-                self.space_level = int(space_level)
-            except ValueError:
-                self.space_level = DEFAULT.SPACE_LEVEL
-                temp_logger.warning(
-                    f'the type of space_level must be int not {type(space_logger_name)}! Set to default value of 8')
-        else:
-            self.space_level = DEFAULT.SPACE_LEVEL
-        # space_time
-        if space_time is not None:
-            try:
-                self.space_time = int(space_time)
-            except ValueError:
-                self.space_time = DEFAULT.SPACE_TIME
-                temp_logger.warning(
-                    f'the type of space_time must be int not {type(space_logger_name)}! Set to default value of 19')
-        else:
-            self.space_time = DEFAULT.SPACE_TIME
-        # time_format
-        if time_format is not None:
-            self.time_format = time_format
-
-        # https://en.wikipedia.org/wiki/ANSI_escape_code
-        self.color_by_level = (
-            (DEBUG, '\033[38;5;85;1m'),  # 85 Bold
-            (INFO, '\033[96;1m'),  # LIGHTCYAN_EX Bold
-            (WARNING, '\033[93;1m'),  # LIGHTYELLOW_EX Bold
-            (ERROR, '\033[31;1m'),  # RED Bold
-            (CRITICAL, '\033[31;1;3;5m'),  # RED Bold/Italic/blinking
-        )
-
-        self.formats = {
-            level: Formatter(
-                f'\x1b[30;1m%(asctime)-{self.space_time}s\x1b[0m {colour}%(levelname)-{self.space_level}s\x1b[0m '
-                f'\x1b[36m%(name)-{self.space_logger_name}s\x1b[0m %(message)s',
-                self.time_format,
-            )
-            for level, colour in self.color_by_level
-        }
-
-    def format(self, record: LogRecord):
-        formatter = self.formats.get(record.levelno)
-        if formatter is None:
-            formatter = self.formats[DEBUG]
-        output = formatter.format(record)
-        return output
-
-
-class StreamHandlerFormatted(StreamHandler):
-
-    def __init__(self, level: int = None, stream=None):
-        """
-        when the logger this handler will be added,
-        has a higher level, then this handler,
-        it will not log (this is normal)
-        the best is to set the logger to 1 (not 0)
-
-        :param level:
-        :param stream:
-        """
-        super().__init__(stream=stream)
-        # set Formatter
-        self.formatter = FormatterColor()
-
-        # set level if it is available
-        if level is not None:
-            self.level = level
-
-
-def get_formatted_logger(name: str, console=True, console_level: int = INFO, file=False, file_path: str = None,
-                         file_level: int = WARNING, file_backup_count: int = None,
-                         file_rotate: str = 'midnight', file_interval: int = 1, logger_level: int = 1,
-                         space_logger_name: int = None, space_level: int = None, space_time: int = None,
-                         time_format: str = '%Y-%m-%d %H:%M:%S') -> Logger:
-    """
-
-
-    :param name:                the name of the logger
-    :param console:             if a StreamHandler should be added
-    :param console_level:       the minimum level who will be in the console
-    :param file:                if a FileHandler should be added
-    :param file_path:           the full path of the logfile
-    :param file_level:          the minimum level who will be in the logfile
-    :param file_backup_count:
-    :param file_rotate:
-    :param file_interval:
-    :param logger_level:        should be lower or equal than handlers of it
-    :param space_logger_name:
-    :param space_level:
-    :param space_time:
-    :param time_format:
-    :return:
-    """
-    logger = getLogger(name)
-    logger.setLevel(logger_level)
-    if console:
-        handler = StreamHandler()
-        handler.setFormatter(FormatterColor(space_logger_name, space_level, space_time, time_format))
-        handler.setLevel(console_level)
-        logger.addHandler(handler)
-        if console_level < logger_level:
-            get_default_logger_child('get_formatted_logger').warning(
-                f'the console (level {console_level}) will not log all, because of the logger level is {logger_level}')
-    if file:
-        if file_path is None:
-            get_default_logger_child('get_formatted_logger').warning(f'file_path is None. No file handler added')
-        else:
-            # check if log dir exists if not create it
-            file_path = os.path.abspath(file_path)
-            file_name = os.path.split(file_path)[-1]
-            if not file_name.endswith('.log'):
-                file_name += '.log'
-                file_path += '.log'
-                get_default_logger_child('get_formatted_logger').warning(f'file_path should be end with .log. adding '
-                                                                         f'.log to {file_name}')
-            if not os.path.exists((path := os.path.dirname(file_path))):
-                os.makedirs(path)
-            if file_backup_count is not None:
-                handler = handlers.TimedRotatingFileHandler(file_path, backupCount=file_backup_count,
-                                                            when=file_rotate, interval=file_interval)
-                handler.namer = lambda name_logfile: name_logfile.replace('.log', '') + '.log'
-            else:
-                handler = FileHandler(file_path)
-            handler.setFormatter(FormatterColor())
-            handler.setLevel(file_level)
-            logger.addHandler(handler)
-            if file_level < logger_level:
-                get_default_logger_child('get_formatted_logger').warning(
-                    f'the file (level {file_level}) will not log all, because of the logger level is {logger_level}')
-
-    return logger
-
-
-def _init_default_logger():
-    """
-    Initialize the default logger with a formatted logger
-    :return:
-    """
-    _logger = getLogger(DEFAULT.LOGGER_NAME)
-    _formatter = FormatterColor()
-    _handler = StreamHandler()
-    _handler.setFormatter(_formatter)
-    _handler.name = 'eh_logging-stream-default'  # should not be displayed. only for internal use
-    # remove all handlers to prevent duplicate handlers
-    for handler in _logger.handlers:
-        _logger.removeHandler(handler)
-    _logger.addHandler(_handler)
-    _default_logger.set(_logger)
-
-
-_init_default_logger()
diff --git a/dist/eh_logging-0.1.5-py3-none-any.whl b/dist/eh_logging-0.1.5-py3-none-any.whl
deleted file mode 100644
index 4c02c66979b0f907a034484ee581b6ec801144f2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5632
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
Gfd2t3zBxMp

diff --git a/dist/eh_logging-0.1.5.tar.gz b/dist/eh_logging-0.1.5.tar.gz
deleted file mode 100644
index de106ff38e2caa9c04ab8dfb36db2b222d70f107..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6113
zcmai&RZN@>w6$?}DO%j2xKrHS-HN-r4#kQVw{`|8ZY>loPH`{pP$=%MGxMJBPyWl3
zoMdHRt&5fHXJ70^n~Z@W_7UcQ1UNWbyL&k~xp+Fg<K^b#7UK4|@kKb7bn#mk&4rm7
z!tqzy^|Cu0Oh4_*Qv|fI`VcLPtL8y2R=I<cG?UW@aTQ%v#z#V-+hq9YnCZn#>zP>;
z$lv)D!T9)>2sBY6!-00MdDf8A#}yx+y8$z~thk>}O{=S8k@DfStDY?&nPutsviU=a
z#2E*m;KGvbG?qk>e%O*#a%^DRs>hj#1o{+AYag8${tuaEJyMi1q~E!A)mf-x-E9}>
z?(X)5v-X-xY<72RHT`N@MuT5o5Wz1g;nrc!;bb?x`q{ucMxaOmetEnHdMyt5FbFhd
z1HJIa&ia38UefjXKu}Q7#8Yo)=lt{-@Wx(Qa{zF|r}f@#*V=W5eJ)+Wj-hcCF{8>!
zn?`xmQKF{G5rkxpDeb!p7l_Vk;zL5Rs?%o4U-hX=m=qYnbZ3J!Ayo0RgQ`Sl3{~h1
z-@KzU`IP3r+Eb$?7^kt6NZej4?MI0Ao9jC%P|~uF30`=3rFE5k><&Jgw59%AwX-{M
zUV0W`j&|d%<eD0)qNWU@isgnY*6%oF1Ym1Z&s@@L7N(9TiuB29$UJ*PLrQPlNZ>p)
zOy<3i!n<^`5rLG<QHt;(T^M46=RD<Z>bTo>qMesY!=ikb?80e@w$sRww|MGr_2@1d
zR9Pl3gRQ^81R?XWDI-g#yei)5?h!o&L@LDL5ce#f=aYD2#JJ}<KcB7uf6Wi)^hh&G
z`y_zhfg;mQDj93pXb#z5V+?t`h09Vhruk&K@3nlx@ZT1ET8{HfII#A7Qn)Z_=2{iB
z%k1PMT2~Zr^X0(A!q+5Y1*L<^*EFIRzfvNlE0C7uzg0y$0xh*fqT(+@u@yV4$DZUF
zG@sjoL*L>uoH3D$4Z+1fs;k+qIlMtNgx)V(*8$C)%~I7{B>t>QSQuRe;f(+7WcXm}
zL9ri=0!O0AVzY{ls4l$A&<Qh!H$k5EQCeA`PH9!DXE4&*0Df?E+1ve3EWXeTY3sZ?
zE9Esq@dhaHs*|P31qVegKA_qxtS->RHqjji?Ps%TV3@ruk=N8F&g%JCId2Y;HR&#j
zcLcKCJBpU$mg0-XU$?q``DVq76TmEcIQ=eoUjgy>>-RHhJZ)(j5O|yW^Eci(QYmps
zn7?=%TZT}gh<CW<@p9!zQJOVv;V7vNQQW7#(qwd-J*L>K?--qb*w!q?ozv)C7(7)r
z<(&>#qa6}ZZ0uxC<Cn?pNTxH7Qw-RTVn~`pWR=7W<9uD^%w*9O{{7ObI`=e)RCObG
zUeS@5O&}D03C)3hPAE=6dY!v=0$-FwdhI?vECiv6UbJBll;JWcv5%kcaFIv#{lM#H
z)57plm@d;2R}P*a^^(p+v%PuB5GGv?O_?^eb54w|v*4)xas2^}Ax5NImmR^bd!&cf
zEWq9}F5~id8p;Uf`w*)eKb(*k7rd9Vrf_u~Y+d^_(#TT+5E3bSvo<~2ZEC$f4tFtt
zSRhL5@%|IEAl;tgB}8y3!zN{){2#>%XsuK6ReNLwR5%EqH#(E9hjnX}x@btxEW`am
z{htm7bnSMf3SggjU%8ur=6;j~2I#iu#TohQjD9SuX;v>Lx<OE37HtzI-l##$(I}5$
z-k=kT@j9>XVZjBE4+Fd^0HIeP480S5Dkfqebw(FZXE`yv0bmcndS|DEBLJ+9f|}s3
zR!g9B2rQxrE^t#c4qAUe;%Ph|zH>}H?S*XO5k6EyFOh&CRm3KESdvVhSF0qLxd~%k
zSfrYf6+^C7trT12OY)kqjhC@~M-td&l6dH68Y`?St<_`XQI)eGq;TY@DGkzh@58i)
zAm4sznXq6z#<_r^EwPD$@$ZgxR4B@-c};mNh0DFxb^eIef7;`v`rK?~p}sBr7gaZ2
z1p5nDVuL`)OdoN`hTy8trhi!CBfTc^R~Hu)p{z<T|F7H;RAa9O;}6j+V>Bs}+lKtv
z=d)%FLODGuUonhqoHUBQEe*G^?7-A<uOi0ql6Ao52H#Em$&U)K-*jFjpuHm$C7!%-
z@*Vr86esv+3c^bs%Gg{zEbtF`i06xvReCW;$;o6aV)4(Z-%_EcPkfGwXx<FS-D06(
zPwQh&J^Brat*w8kdiH~UbJ2P$p?woE&CSxj+<FUHqs5n|CjF~f`&V(MVp@hf?BR6h
zl+nDtWKnPKbELF5edDX|-l1LYZPcS7F#_^NI^zS2Eva@$O8*vCgF%b^{N7M9+1UvD
zretFE^`{$KN37kHad(-%(pa0S5X|xWqb;m6U{I1dzJ+mj<v^oHx5t5)RX67*0&(1I
z30wR?cs<^1p@8?wOEiP2WTjeui@*o#+7_i#_wiWPEXWL7J4)s&hYT}u@zhvqhDOiy
zqq~Nw5z@8jo#j#@Z{Jy&nv4n;_02oOfF`r*B*h054>)#2EXT_o;$ImW8CF8JMe^4H
zvmPqyA^B6V{d07}9b?O8DEHLnhsEWK6Bqe5J?Psr|HQSyzm8+RuY6v;g)!~%t&tUd
zxdWuqc--uTmv{oB2~Zto235mP^&A<D5KTku>>v$W$&p7m{%3@1*CV{zZ}vx~bfT9s
z`RqY^C0M@(OgUCCN*5`+F6e!o`a-g?-p>*lo}no3AP}GI2>vcGOqY`2CoIJ*pew<a
zlSAnb$ec}9?A#;ESn`ayi!zEr&f`Sk`8bF%|JFS3et6csn=_d1WCBx(Nr-e<P*}b$
z$#n(%V@VGUxqn(;ZM09k^8HgB1O)+%@{|<AfFHQT;PNqz!59r!Rc?Zrf3zUwkL)5r
zR)H_a{uQA(>XEHD)D{or{WPcCVoIim?2u47_BS1C=5IAD+Q<fVH4UvM^X3{}CdD1L
zavv1>WI$1Gy7F<(aZ@Bo#q8}deKJh-{yxbNquL8&3?iY;Ug=?wuoKPQ_#@cL7Jn3A
zwrln+XX6~97I<fnspwz|PBg4mnZx!pbvqfn3GX)kje?ZDOI<H+ZB%hzv}2E_q0z~H
zW{6bj>7U(?$SZXFj|22TP?@Etf^V58%i%MO)Tg-VM{lk4host+`Jg=Xhgdio5Y{L6
z_?FfuR*Qz&Y_+CCElP6iLzlM5#2dE7U}5UeWk~{W^{d1fXLiI}FedJ$^bhzf#$W0@
z=C0i0%cc<q3S=Y}tbs7KJe*Hu<nrNfHFtH7#VVSuQF2BZ#AemS#ae#e=F$}+M&~am
z85N7zFDe@cDMYyutd08J^J8R9mrbFHpVG{St3OW45(kcE2XLNZ8G=ub#;FmStp3;)
zrd^_d6D*Z!$NMKb=%(LD_mDx^Zp6j;$wupV&WdmUg~`n*{wSsOLzoQBDEt)}t~^M1
z9&qO%l}~xBk``0Osw#qAeQc{LcH(Nip>o*#e5@PkZ6GO7)3Z7@)$ASJTsXxX@G+U2
zzJ`nuNPwU@oS2f7p0=obIaL%z1N*_s?fvBS$hmV9B+%Vov;`-@$HuPFe@y5W*eK}t
z*+~pte<rnBJ#)n<CQ98KeK@#|pW_f{YqgG-`V?-+_`wxJpFtgsRF$Z{&6XVA<!K2H
zVrgsMcpKrCS*@_E@L^fgX55?8^%=8fhtuMSv?FfB(kS*J7f*nz@W7~#FvfEg--FqK
zRA#M9t+}Is5&LXU_?$C;bW9x?j%lEGlCD$DXI7qrLf+|5!MYgTT81`96VlkAYgnEc
zAda3ZUbRFS*VJctTPtYRxqO8;CeBBb^`#qOQ>|rdC^&tmCq-2dd9*SG$1Xj`Kpk%E
zqHwNdUCG4$MhHpFw7~o&-<VNnU0&AMtw>qimv1PPyDX@%aXvQRT(Hdl;Wm$4xDbsP
zoFXsM1V?;6UT)qnPz{j7w~Q^}(NM9F-(w{GSXFUsC{LL7i_$NXs4AbS^_0zgH6tjn
zO@%UsgcHjVfzLj!z!fPt=R0KrRJ^`;5r=urrYGJ+PMvFxgn8{7+r1wOozi;<qJiR}
z!-lS2iA1{T&o64MtxN;iIvR<1dGZ8kkt!AZ<6nNNpl*9R-lUHur5IEbQ}g(8Xsd>`
zMbYlBOKSHg;_vq>-<Y>XS2z+34*;GT&g~vT8^ag#5!jxk$-$91o|aq>5O4AoS)3S2
zZM2w1fCb9zuI}d8c=>6f9Wu?kc55#v1>KHa&WHJJf*&AP6fF!?++l?lO6b7XD-+i|
z>t4B6D^X2%KXS*g!bz54Pz1DMbzE)cQ=Yp6pIcREQrDLrtc?+GY7^>AjH*+~zZsxw
z#(cfpNwA3q3U(l0>RQX{tVHOZoRls*ckq>64)X_$QY}OjA$qsM5jQ1Xd>pVu*z?HJ
z#MqKLS$Ft$*mKF_&16lEK#b@=-Kb_R^{p#5R=osl7ycAxB#uHv#zjhYILU9dEBhJ=
zh5TL(y6YpyMrG4)B3u=}TggqH{LJl|pO2IV=I$`u8ox;4n6wZS5z{_}Mpa_Iylub7
zaP)d~kpV-vz&<=n^fug^=gSixOHiYWJR4)h?-KNDWj;r-w&Lrb9d3g9$2fGjZ1p!d
z+|oT#)0fONLymZLeZ>6Vqmh2)-#KxPI_Vfmk*b%W2s*Z3mRANFe>tVwFg1B*o3Ege
z>N)1U*tR3dJKm~bG89BcpG~6>F|(o(P6*zpy5?B4>W5?+rcrn}qslLdn?z3L9&J=`
zo#xPI?H;C3cxX<q8FOZv6T#(t{<PopgzBG#YB8oLtzWf9JYAoy3}5#Z*iv1{?SH4i
zk+CkD=bY2Pdo=XSZ-u)DiXTE?#+$~ko5uBthPCqRua<X@e}eoR^6OJc#a5<#i>Q0U
zfaiPKPqgQyz-*4XCVH1MtMOf0X;zjtz{WmltU&$8$ms6wD3u!|Ts@K0b<%ZmknBOr
z`uP&Kl_#9%>C2X2ba9nqlBV!`KG}cuYm`N6Wv*uOJMzhInVpG7t&JeTGQYe}g_VPY
z8b$5AvF${XFRXrc`>E}y1yVxx+s4;7nBTdMJJn?^-uxV&iC(m=wPHYK(wlM^QzaGM
zoOz@$b^6;C8_(UO7j(mvCDdP;PdHg=*<l^51{(M4wh=G5;AB+9e`v_WjUQ^LXmB%X
z2sU%J8iEch<`!6ner#g=hB7n$m1oP4s8F$KtOxGtY?v5tm8UfjAmDD6|9w~8c*@w0
zTE)t3)$py45`6qNf}qD<DAm%XeFP8OKoeHVr-d$NL+Vgo4z>DSgSArNXi)xKmB92i
z$B7VO4E1w0w9Lwc7`2_CWyNFCQB$Co=WDCJAeSWPp@|)SK&xi4>Z%1N4SD0<8&4s_
z3i)^8Qo?&dg<$oOTL`u_1d;1YbK|RnMQf#&Pm|ppDs7p&kCM2NF)XEqTL~5S+LH9@
z-S|8HYHQs_EKc)=a_YT(&MB_Zkdbf6Z$7F)CNG^k$icy$G6{rG`#Jm2+JqyJu9N!4
zlKw}RDK{tB#9A1)*L@xhiieMxQ`7+!9ks$T5tO|8;03u7p@ogwa&nV(PoyJO<If^}
zdS;6xJy@u~2hK#qs)3q3Vvo;LU5I@Twbf=*@KPP;zf#$&*|imAte20DB^b5fs`qzT
z-O667NDt#HAP(T8XLg$E-=a>Skb+)earY=-{P$7z(c7@9NHWUwb}MuPdbU*TEy>xd
z3To%{$=r+fEcj!&I_=s_0pgv*>{Z4~I@mw>lfI^uUASN55^ti`v8C_`gjrtrXl~=2
zM*n7Mfg<kTnA^HqKbOJ1I4G+0D(<**wkG5~rYTeFX9nL{3v<Sq)}TySY8u{r)+X@(
zi2fHWoAbWFu`{Pcn@4+KV^TjpYedJByP#gOy-B`SCm;q|iCf{XP(Bguu*X7~a{ZT6
zI_|SY+SOJIS(XrT@B9QLF-+C7ut0cQ*=8fk8uySP-bqNa)@9uLHJy!EJAx-e4eZs@
zQ&lcX?XrW0w?QtfQ1j*<^Lx{Y(>s{L9nq9gW@4a?Rz*&V4$I#L(N4T6p+T6_>6Qe-
zzKu#4Qq%N03HCTH2(!|bU?su0mSn|BSTvThxLxqQ(A!qkhs4_)uG`Y~8j8Sv^q(vR
z0`dmTCF$_g83nyxl?(dXyqV1|Xw)_qYrox2Zo2>2!+ccYg_N!JLIRisEv#pQTIRO?
zoE|RJMhpD%ek<PD_-pH&-3#|ZJ4!$Jt*JfBeO9iL5LZ2ePI3)(`h;_iSqMc1!_QyJ
z+=u+)aur$3*@H=>iWOW{P?9eUF^)p6a(=7Ahy119zal@Q<4)lo|Jq_5_iWsrK#!FK
zjkTvJqnWFFm<~O=?`u&7U(%kn*kq*)F?9{z$(e~yF=hHuX7Dk}jY9~}1rhG^ejO4y
zGR&&;g9`sW$T2m>t9j1x_)|BQ(Iz0>lk?0E15MX}$P92B*%a{Sy)%_m$QE3hDp+tW
zIvIVP^DprF4B9&O4@w1`{sF5gfc`58?b!<|P4)a^6i|*Neu>-$#a{ycL4oGOz^y*Y
zEzIfvlpVnLKueqg`?Lm{mVyPoyd2eKSg^V^0D=;bZZOQL&7%i^3ev+~eB-`vQq6x&
zf@6E<gv9rcBh}1SbOt9OlcC2@QF)#ZmQyf#+Otii$Lb5;mWauKJO_G5BHO0V0CJeu
zT`%U06>!RQk97}fTGhJ;b^e;aAcp}Y{S6(nfD%CU|17gW`HQtxRJ{#s`|Rvs83?m%
zf`cewpo`rJ9@0>ZVmXm#&Q+G44CMds$DA<-I3E^;jzGW9YT(;$LQ~H(tTdp3J0$?b
z2=lrCA|zlxx`Aae=Zl~enc&YaMIOlb@uiD5fCX&Z<M0A#2~znv3uqHek1@@}t8V3`
zs_mwnB~ygEcc-m<#a3o{t-|~?i}T~Z{7V3Ed<tTSpL*Fo0&)t$X2pPcm_5Ac1b9;i
ztb6d|^1c9=NZopQrqJgctT)I~Cdax@{l-qQ$Hzf|jCM&eHT&@~!4i^E80hPawP<8K
z@sc~&d~^Z{XEhA%hMo!vGrZCraq3i5IqHEU+4k9WI;~TsJO9q{x?2in`fTYTuZntl
zL!Y)qR;JN<`w$x=PB1b-2VkMO!<i268F2J=n^CZ_uEpAl0#auL>hhwQW!hk*)HkLg
z$q$cm$0GqRJlSC-Ji!H~dyn<6)=4A{0(Fn8@`+8y^=m!lzYICCUeCDQwqLxVV)F3_
zj-dkgRY6eMPzm9!gFNS-`S6ef{c*F4i#q2MY>?J!xz*QVh70wJzwh>=e=N!`#r$|m
zV!52Nx(O?5T`@W@!uCFbteP;fA!Gz%kRQI;tS)_2`_P0JX}{r?7<zH^mgYa?ZUCEy
zq6696zW+*+eP~)?p|vEiJp<_1cFyy|izZ*T|AYHG@U?SF%MG+$2NZQft<TS^72!pJ
zPcOae|D8b4m_@@Py*}Z8h$J<v1R!m+pocb;@@gn>ht5jg4{|N7?U|knk7c54$Og^N
zFeTYv2*pYLVWQceFK{Dy`k}4~E4rfXc)u}*8F4fxpv|(IH(Gwze55FGUPB4FCDrv8
zvf%n1R$zIPx0ae5pd%0$H&WyRx4KZLQWvcuXvG_w?;I8y^1Wd9U0H~#eX?G9ibeQI
z7?Kx=p!;OPoBBgFVFGG9imTI$_q#Oa=9+8uI%ZS{OMr1*S<c+sZgyc{hLTgRCmSDI
zSMIXy+oXId4Z)XY1{|!V#kTB7YFnXHK8j+mr1JWz5`+Asb+s(oIg7>~1EkrFt0_+S
zxsw@IPvvy)V;7fngR-W%nta>`XWy!V<<w7m{V2qbF3~X)lU|7xQn-9mZdU4qFLfP+
zkUVQ?4vP;VSMQ`8xzR=fay_)Ec^W)wSr-GWcidFV>kL(FAf<GWCc5fPG+NfDJ$4w&
zc6y{6D$YtHw7Z@eiZS)bT=vLX7XC?~&-lUOoj878S;L=7?X(FnLtZ#fJ((A_zb9b{
z|FN5+2deEGfu{Zy%=RCwL)B&{>ZyUFU(hp`3f5wxY>L9z<w_Is+x?e>db>5pAd3}R
dI{B9h`5&S&S^k#+T<iddR^c?;2v-OQ{{z7X8E60i

diff --git a/eh_logging.egg-info/PKG-INFO b/eh_logging.egg-info/PKG-INFO
deleted file mode 100644
index e8b7e4a..0000000
--- a/eh_logging.egg-info/PKG-INFO
+++ /dev/null
@@ -1,107 +0,0 @@
-Metadata-Version: 2.1
-Name: eh_logging
-Version: 0.1.5
-Summary: Simple helper to get easier formatted logger from the python logging module
-Home-page: https://git.eishausener.dev/Eishausener/eh_logging
-Author: Eishausener <code@eishausener.de>
-Author-email: code@eishausener.de
-License: MIT
-Project-URL: issue tracker, https://git.eishausener.dev/Eishausener/eh_logging/issues
-Classifier: License :: OSI Approved :: MIT License
-Description-Content-Type: text/markdown
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: wheel; extra == "dev"
-Requires-Dist: setuptools; extra == "dev"
-
-
-# eh_logging
-
-> Simple helper to get easier formatted logger from the python logging module
-
-# install
-
-pip install git+https://git.eishausener.dev/Eishausener/eh_logging \
-or \
-pip install git+https://github.com/Eishausener/eh_logging
-
-# usage
-
-import eh-logging, create a formatted logger and use the logger
-
-```python
-# import
-import eh_logging as logging
-
-# create formatted logger
-formatted_logger = logging.get_formatted_logger(
-    'formatted_logger',
-    console=True,
-    console_level=logging.DEBUG,
-    file=True,
-    file_path=r'log\formatted_logger.log',
-    file_level=logging.DEBUG,
-    file_backup_count=5,
-    file_rotate='h',
-)
-
-# use the logger
-formatted_logger.debug('Example formatted DEBUG Message')
-formatted_logger.info('Example formatted INFO Message')
-formatted_logger.warning('Example formatted WARNING Message')
-formatted_logger.error('Example formatted ERROR Message')
-formatted_logger.critical('Example formatted CRITICAL Message')
-
-```
-
-use the decorator with the INFO level
-
-```python
-# import
-import eh_logging as logging
-
-# set default logger to DEBUG level to see output
-logging.set_default_level(logging.DEBUG)
-
-
-# use logging decorator with default logger
-@logging.Decorator.info(arg=True, kwarg=True, return_value=True, decimal_places=1)
-def example_function(first_param, second_param, *args, **kwargs):
-    return first_param, second_param, *args, *kwargs
-
-
-# execute function
-example_function('Hello', 'world', 'test', 'example', hello='world', world='test')
-
-```
-
-use the decorator with own logger
-
-```python
-# import
-import eh_logging as logging
-
-
-# create formatted logger
-formatted_logger = logging.get_formatted_logger(
-    'example_decorator_logger',
-    console=True,
-    console_level=logging.DEBUG,
-    file=True,
-    file_path=r'log\decorator_logger.log',
-    file_level=logging.DEBUG,
-    file_backup_count=5,
-    file_rotate='h',
-)
-
-
-# use logging decorator with custom logger
-@logging.Decorator.debug(logger=formatted_logger, arg=True, kwarg=True, return_value=True, decimal_places=1)
-def example_function(first_param, second_param, *args, **kwargs):
-    return first_param, second_param, *args, *kwargs
-
-
-# execute function
-example_function('Hello', 'world', 'test', 'example', hello='world', world='test')
-
-```
diff --git a/eh_logging.egg-info/SOURCES.txt b/eh_logging.egg-info/SOURCES.txt
deleted file mode 100644
index 447d9e7..0000000
--- a/eh_logging.egg-info/SOURCES.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-README.md
-setup.py
-eh_logging/__init__.py
-eh_logging.egg-info/PKG-INFO
-eh_logging.egg-info/SOURCES.txt
-eh_logging.egg-info/dependency_links.txt
-eh_logging.egg-info/requires.txt
-eh_logging.egg-info/top_level.txt
-test/test.py
\ No newline at end of file
diff --git a/eh_logging.egg-info/dependency_links.txt b/eh_logging.egg-info/dependency_links.txt
deleted file mode 100644
index 8b13789..0000000
--- a/eh_logging.egg-info/dependency_links.txt
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/eh_logging.egg-info/requires.txt b/eh_logging.egg-info/requires.txt
deleted file mode 100644
index 0556cc8..0000000
--- a/eh_logging.egg-info/requires.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-
-[dev]
-twine
-wheel
-setuptools
diff --git a/eh_logging.egg-info/top_level.txt b/eh_logging.egg-info/top_level.txt
deleted file mode 100644
index 36ef05c..0000000
--- a/eh_logging.egg-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-eh_logging
diff --git a/eh_logging/__init__.py b/eh_logging/__init__.py
index ee079ef..250411e 100644
--- a/eh_logging/__init__.py
+++ b/eh_logging/__init__.py
@@ -1,3 +1,11 @@
+"""
+eh_logging
+^^^^^^^^^^
+
+Simple helper to get easier formatted logger from the python logging module
+"""
+
+
 from __future__ import annotations
 
 from functools import wraps
@@ -25,7 +33,7 @@ __all__ = tuple(logging__all__ + [
     'set_default_logger',
     'warning',
 ])
-__version__ = '0.1.5'
+__version__ = '0.1.6'
 __author__ = 'Eishausener <code@eishausener.de>'
 __name__ = 'eh_logging'