olivia_finder.utilities.logger

View Source

  1from __future__ import annotations
  2import logging
  3from typing import Optional
  4from .config import Configuration
  5from .exception import OliviaFinderException
  6from .utilities import setup_path
  7
  8class MyLogger:
  9    
 10    @staticmethod
 11    def configure(config_key: str) -> logging.Logger:
 12        '''
 13        Initializes the logger
 14
 15        Parameters
 16        ----------
 17        config_key : str
 18            Key of the configuration file that contains the logger configuration
 19
 20        Returns
 21        -------
 22        logging.Logger
 23            Logger with the given name
 24        '''
 25
 26        logger_name = Configuration().get_key(config_key, 'name')
 27
 28        # Check if the logger has already been initialized
 29        if logger_name in logging.Logger.manager.loggerDict:
 30            
 31            MyLogger.get_logger(logger_name).warning(
 32                f"The logger with name {logger_name} has already been initialized"
 33            )
 34            return MyLogger.get_logger(logger_name)
 35
 36        # We get the logger
 37        logger = logging.getLogger(logger_name)
 38        
 39        # Check if the logger has file handler
 40        if Configuration().get_key(config_key, 'file_handler').upper() == 'ENABLED':
 41
 42            # Folder where the log files will be stored
 43            log_folder = Configuration().get_key('folders', 'logger')
 44            setup_path(log_folder)
 45
 46            # We enable the file
 47            MyLogger.enable_file(
 48                logger_name=logger_name,
 49                log_file=f'{log_folder}/{logger_name}.log',
 50                log_file_level=Configuration().get_key(config_key, 'level')
 51            )
 52      
 53        # Check if the logger has console handler
 54        if Configuration().get_key(config_key, 'console_handler').upper() == 'ENABLED':
 55            # We enable the console
 56            MyLogger.enable_console(
 57                logger_name=logger_name,
 58                console_level=Configuration().get_key(config_key, 'level')
 59            )
 60
 61        # Disable if configured
 62        olivia_finder_logger_name = Configuration().get_key('olivia_finder_logger', 'name')
 63        if Configuration().get_key('olivia_finder_logger', 'status').upper() == 'DISABLED':
 64            MyLogger().get_logger().disabled = True
 65            MyLogger().get_logger(olivia_finder_logger_name).disabled = True
 66            logger.disabled = True
 67        elif Configuration().get_key(config_key, 'status').upper() == 'DISABLED':
 68            logger.disabled = True
 69
 70
 71        # Dissable propagation 
 72        logger.propagate = False
 73
 74        return logger
 75    
 76    @staticmethod
 77    def get_logger(logger_key: Optional[str] = None) -> logging.Logger:
 78        '''
 79        Returns the logger with the given name
 80
 81        Parameters
 82        ----------
 83        logger_name : str
 84            Name of the logger to return
 85
 86        Returns
 87        -------
 88        logging.Logger
 89            Logger with the given name
 90        '''
 91        
 92        if logger_key is None:
 93            return logging.getLogger()
 94        
 95        # Get the logger name
 96        logger_name = Configuration().get_key(logger_key, 'name')
 97
 98        # Check if the logger has already been initialized
 99        if logger_name not in logging.Logger.manager.loggerDict:
100            try:
101                MyLogger.configure(logger_key)
102                logging.getLogger(logger_name).propagate = False
103            except OliviaFinderException:
104                return logging.getLogger()
105
106        return logging.getLogger(logger_name)
107
108    @staticmethod
109    def enable_console(logger_name: str, console_level: str) -> None:
110        """
111        Enables the console
112
113        Parameters
114        ----------
115        logger_name : str
116            Name of the logger to enable the console for.
117        
118        console_level : str
119            Log level to configure.
120
121        Examples
122        --------
123        >>> from my_logger import MyLogger
124        >>> MyLogger.enable_console()
125
126        """
127        
128        # The handler is created for the console
129        h = logging.StreamHandler()
130        h.setLevel(console_level.upper())
131        h.setFormatter(ConsoleLogFormatter())
132
133        # The handler is added to the logger
134        logging.getLogger(logger_name).addHandler(h)
135
136        # set the level of the logger (Must be the same as the handler)
137        logging.getLogger(logger_name).setLevel(console_level.upper())
138
139    @staticmethod
140    def enable_file(logger_name: str, log_file: str, log_file_level: str) -> None:
141        """
142        Enables the file
143
144        Parameters
145        ----------
146        logger_name : str
147            Name of the logger to enable the file for.
148
149        log_file : str
150            Name of the file to store the logs in.
151
152        log_file_level : str
153            Log level to configure.
154
155        Examples
156        --------
157        >>> from my_logger import MyLogger
158        >>> MyLogger.enable_file()
159        """
160        
161        # The handler is created for the file
162        h = logging.FileHandler(log_file)
163        h.setLevel(log_file_level.upper())
164        h.setFormatter(FileLogFormatter())
165
166
167        # The handler is added to the logger
168        logging.getLogger(logger_name).addHandler(h)
169        # set the level of the logger (Must be the same as the handler)
170        logging.getLogger(logger_name).setLevel(log_file_level.upper())
171
172    @staticmethod
173    def configure_level(logger_key: str, handler_type: str, level: str) -> None:
174        """
175        Description
176        -----------
177        Configures the log level for the handler of a logger given its name and type.
178        
179        Parameters
180        ----------
181        logger_key : str
182            Name of the logger to configure the level for.
183            
184        handler_type : str
185            Type of handler to configure.
186            
187        level : str
188            Log level to configure.
189            
190    .. note::
191        Valid handler types are: 
192        -   ``console`` for the console handler
193        -   ``file`` for the file handler
194        -   ``all`` for both handlers
195        -   ``global`` for all handlers of all loggers
196        
197        Valid log levels are:
198        -   ``DEBUG`` for debugging messages
199        -   ``INFO`` for informational messages
200        -   ``WARNING`` for warning messages
201        -   ``ERROR`` for error messages
202        -   ``CRITICAL`` for critical messages
203        -   ``NOTSET`` for messages without level
204                                
205        Raises
206        ------
207        NotImplementedError
208            If the specified handler type is not valid
209            If the specified log level is not valid
210                
211        Examples
212        --------
213        >>> from my_logger import MyLogger
214        >>> logger = MyLogger.logger()
215        >>> logger.configure_level("console", "DEBUG")
216        >>> logger.configure_level("file", "DEBUG")
217        """
218        
219        logger = MyLogger.get_logger(logger_key)
220        handler_list = []
221        # Validate the handler type
222        if handler_type == "console":
223            handler_list.append(logger.handlers[0])
224        elif handler_type == "file":
225            handler_list.append(logger.handlers[1])
226        elif handler_type == "all":
227            handler_list = logger.handlers
228        elif handler_type == "global":
229            handler_list = logging.root.handlers
230        else:
231            raise NotImplementedError(
232                "The specified handler type is not valid",
233                "\n",
234                "Valid handler types are: 'console', 'file', 'all', 'global'",
235            )
236
237        for handler in handler_list:
238
239            # Validate the log level
240            if level.upper() == "DEBUG":
241                handler.setLevel(logging.DEBUG)
242            elif level.upper() == "INFO":
243                handler.setLevel(logging.INFO)
244            elif level.upper() == "WARNING":
245                handler.setLevel(logging.WARNING)
246            elif level.upper() == "ERROR":
247                handler.setLevel(logging.ERROR)
248            elif level.upper() == "CRITICAL":
249                handler.setLevel(logging.CRITICAL)
250            elif level.upper() == "NOTSET":
251                handler.setLevel(logging.NOTSET)
252            else:
253                raise NotImplementedError(
254                    "The specified log level is not valid",
255                    "\n",
256                    "Valid log levels are: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'NOTSET'",
257                )
258        
259        # Set the level of the logger
260        logger.setLevel(level.upper())
261
262class ConsoleLogFormatter(logging.Formatter):
263    """
264    Description
265    -----------
266    Custom formatter for console log messages.
267
268    Examples
269    --------
270    >>> from my_logger import MyLogger
271    >>> logger = MyLogger.logger()
272    >>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
273    """
274
275    __COLOR_GREEN = "\x1b[32;20m"
276    __COLOR_BLUE = "\x1b[34;20m"
277    __COLOR_YELLOW = "\x1b[33;20m"
278    __COLOR_ORANGE = "\x1b[38;5;208;20m"
279    __COLOR_RED = "\x1b[31;20m"
280    __COLOR_RESET = "\x1b[0m"
281    
282    # Formato de la cabecera del log
283    # Tiempo [nombre_logger(Nivel)] -> Archivo:Linea
284    __FORMAT_HEADER = "%(asctime)s [%(name)s(%(levelname)s)] -> %(filename)s:%(lineno)d"
285    __FORMAT_MESSAGE = "\n%(message)s"
286
287    __FORMATS = {
288        logging.DEBUG: __COLOR_GREEN + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
289        logging.INFO: __COLOR_BLUE + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
290        logging.WARNING: __COLOR_YELLOW + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
291        logging.ERROR: __COLOR_ORANGE + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
292        logging.CRITICAL: __COLOR_RED + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
293    }
294
295    def format(self, record: logging.LogRecord) -> str:
296        """
297        Description
298        -----------
299        Formats the log message
300
301        Parameters
302        ----------
303        record : logging.LogRecord
304            Log message to format
305            
306        Returns
307        -------
308        str
309            Formatted log message
310
311        Examples
312        --------
313        >>> from my_logger import MyLogger
314        >>> logger = MyLogger.logger()
315        >>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
316        """
317        
318        log_fmt = self.__FORMATS.get(record.levelno)
319        formatter = logging.Formatter(log_fmt)
320        return formatter.format(record)
321
322class FileLogFormatter(logging.Formatter):
323    """
324    Description
325    -----------
326    
327    Custom formatter for file log messages.
328    """
329
330    __DEFAULT_FORMAT = "%(asctime)s [%(name)s(%(levelname)s)] -> %(filename)s:%(lineno)d\n%(message)s"
331
332    def format(self, record: logging.LogRecord) -> str:
333        """
334        Description
335        -----------
336        Formats the log message
337
338        Parameters
339        ----------
340        record : logging.LogRecord
341            Log message to format
342
343        Returns
344        -------
345        str
346            Formatted log message
347
348        Examples
349        --------
350        >>> from my_logger import MyLogger
351        >>> logger = MyLogger.logger()
352        >>> logger.configure_formatter("file", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
353        """
354        
355        formatter = logging.Formatter(self.__DEFAULT_FORMAT)
356        return formatter.format(record)
357

class MyLogger: View Source

  9class MyLogger:
 10    
 11    @staticmethod
 12    def configure(config_key: str) -> logging.Logger:
 13        '''
 14        Initializes the logger
 15
 16        Parameters
 17        ----------
 18        config_key : str
 19            Key of the configuration file that contains the logger configuration
 20
 21        Returns
 22        -------
 23        logging.Logger
 24            Logger with the given name
 25        '''
 26
 27        logger_name = Configuration().get_key(config_key, 'name')
 28
 29        # Check if the logger has already been initialized
 30        if logger_name in logging.Logger.manager.loggerDict:
 31            
 32            MyLogger.get_logger(logger_name).warning(
 33                f"The logger with name {logger_name} has already been initialized"
 34            )
 35            return MyLogger.get_logger(logger_name)
 36
 37        # We get the logger
 38        logger = logging.getLogger(logger_name)
 39        
 40        # Check if the logger has file handler
 41        if Configuration().get_key(config_key, 'file_handler').upper() == 'ENABLED':
 42
 43            # Folder where the log files will be stored
 44            log_folder = Configuration().get_key('folders', 'logger')
 45            setup_path(log_folder)
 46
 47            # We enable the file
 48            MyLogger.enable_file(
 49                logger_name=logger_name,
 50                log_file=f'{log_folder}/{logger_name}.log',
 51                log_file_level=Configuration().get_key(config_key, 'level')
 52            )
 53      
 54        # Check if the logger has console handler
 55        if Configuration().get_key(config_key, 'console_handler').upper() == 'ENABLED':
 56            # We enable the console
 57            MyLogger.enable_console(
 58                logger_name=logger_name,
 59                console_level=Configuration().get_key(config_key, 'level')
 60            )
 61
 62        # Disable if configured
 63        olivia_finder_logger_name = Configuration().get_key('olivia_finder_logger', 'name')
 64        if Configuration().get_key('olivia_finder_logger', 'status').upper() == 'DISABLED':
 65            MyLogger().get_logger().disabled = True
 66            MyLogger().get_logger(olivia_finder_logger_name).disabled = True
 67            logger.disabled = True
 68        elif Configuration().get_key(config_key, 'status').upper() == 'DISABLED':
 69            logger.disabled = True
 70
 71
 72        # Dissable propagation 
 73        logger.propagate = False
 74
 75        return logger
 76    
 77    @staticmethod
 78    def get_logger(logger_key: Optional[str] = None) -> logging.Logger:
 79        '''
 80        Returns the logger with the given name
 81
 82        Parameters
 83        ----------
 84        logger_name : str
 85            Name of the logger to return
 86
 87        Returns
 88        -------
 89        logging.Logger
 90            Logger with the given name
 91        '''
 92        
 93        if logger_key is None:
 94            return logging.getLogger()
 95        
 96        # Get the logger name
 97        logger_name = Configuration().get_key(logger_key, 'name')
 98
 99        # Check if the logger has already been initialized
100        if logger_name not in logging.Logger.manager.loggerDict:
101            try:
102                MyLogger.configure(logger_key)
103                logging.getLogger(logger_name).propagate = False
104            except OliviaFinderException:
105                return logging.getLogger()
106
107        return logging.getLogger(logger_name)
108
109    @staticmethod
110    def enable_console(logger_name: str, console_level: str) -> None:
111        """
112        Enables the console
113
114        Parameters
115        ----------
116        logger_name : str
117            Name of the logger to enable the console for.
118        
119        console_level : str
120            Log level to configure.
121
122        Examples
123        --------
124        >>> from my_logger import MyLogger
125        >>> MyLogger.enable_console()
126
127        """
128        
129        # The handler is created for the console
130        h = logging.StreamHandler()
131        h.setLevel(console_level.upper())
132        h.setFormatter(ConsoleLogFormatter())
133
134        # The handler is added to the logger
135        logging.getLogger(logger_name).addHandler(h)
136
137        # set the level of the logger (Must be the same as the handler)
138        logging.getLogger(logger_name).setLevel(console_level.upper())
139
140    @staticmethod
141    def enable_file(logger_name: str, log_file: str, log_file_level: str) -> None:
142        """
143        Enables the file
144
145        Parameters
146        ----------
147        logger_name : str
148            Name of the logger to enable the file for.
149
150        log_file : str
151            Name of the file to store the logs in.
152
153        log_file_level : str
154            Log level to configure.
155
156        Examples
157        --------
158        >>> from my_logger import MyLogger
159        >>> MyLogger.enable_file()
160        """
161        
162        # The handler is created for the file
163        h = logging.FileHandler(log_file)
164        h.setLevel(log_file_level.upper())
165        h.setFormatter(FileLogFormatter())
166
167
168        # The handler is added to the logger
169        logging.getLogger(logger_name).addHandler(h)
170        # set the level of the logger (Must be the same as the handler)
171        logging.getLogger(logger_name).setLevel(log_file_level.upper())
172
173    @staticmethod
174    def configure_level(logger_key: str, handler_type: str, level: str) -> None:
175        """
176        Description
177        -----------
178        Configures the log level for the handler of a logger given its name and type.
179        
180        Parameters
181        ----------
182        logger_key : str
183            Name of the logger to configure the level for.
184            
185        handler_type : str
186            Type of handler to configure.
187            
188        level : str
189            Log level to configure.
190            
191    .. note::
192        Valid handler types are: 
193        -   ``console`` for the console handler
194        -   ``file`` for the file handler
195        -   ``all`` for both handlers
196        -   ``global`` for all handlers of all loggers
197        
198        Valid log levels are:
199        -   ``DEBUG`` for debugging messages
200        -   ``INFO`` for informational messages
201        -   ``WARNING`` for warning messages
202        -   ``ERROR`` for error messages
203        -   ``CRITICAL`` for critical messages
204        -   ``NOTSET`` for messages without level
205                                
206        Raises
207        ------
208        NotImplementedError
209            If the specified handler type is not valid
210            If the specified log level is not valid
211                
212        Examples
213        --------
214        >>> from my_logger import MyLogger
215        >>> logger = MyLogger.logger()
216        >>> logger.configure_level("console", "DEBUG")
217        >>> logger.configure_level("file", "DEBUG")
218        """
219        
220        logger = MyLogger.get_logger(logger_key)
221        handler_list = []
222        # Validate the handler type
223        if handler_type == "console":
224            handler_list.append(logger.handlers[0])
225        elif handler_type == "file":
226            handler_list.append(logger.handlers[1])
227        elif handler_type == "all":
228            handler_list = logger.handlers
229        elif handler_type == "global":
230            handler_list = logging.root.handlers
231        else:
232            raise NotImplementedError(
233                "The specified handler type is not valid",
234                "\n",
235                "Valid handler types are: 'console', 'file', 'all', 'global'",
236            )
237
238        for handler in handler_list:
239
240            # Validate the log level
241            if level.upper() == "DEBUG":
242                handler.setLevel(logging.DEBUG)
243            elif level.upper() == "INFO":
244                handler.setLevel(logging.INFO)
245            elif level.upper() == "WARNING":
246                handler.setLevel(logging.WARNING)
247            elif level.upper() == "ERROR":
248                handler.setLevel(logging.ERROR)
249            elif level.upper() == "CRITICAL":
250                handler.setLevel(logging.CRITICAL)
251            elif level.upper() == "NOTSET":
252                handler.setLevel(logging.NOTSET)
253            else:
254                raise NotImplementedError(
255                    "The specified log level is not valid",
256                    "\n",
257                    "Valid log levels are: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'NOTSET'",
258                )
259        
260        # Set the level of the logger
261        logger.setLevel(level.upper())

@staticmethod

def configure(config_key: str) -> logging.Logger: View Source

11    @staticmethod
12    def configure(config_key: str) -> logging.Logger:
13        '''
14        Initializes the logger
15
16        Parameters
17        ----------
18        config_key : str
19            Key of the configuration file that contains the logger configuration
20
21        Returns
22        -------
23        logging.Logger
24            Logger with the given name
25        '''
26
27        logger_name = Configuration().get_key(config_key, 'name')
28
29        # Check if the logger has already been initialized
30        if logger_name in logging.Logger.manager.loggerDict:
31            
32            MyLogger.get_logger(logger_name).warning(
33                f"The logger with name {logger_name} has already been initialized"
34            )
35            return MyLogger.get_logger(logger_name)
36
37        # We get the logger
38        logger = logging.getLogger(logger_name)
39        
40        # Check if the logger has file handler
41        if Configuration().get_key(config_key, 'file_handler').upper() == 'ENABLED':
42
43            # Folder where the log files will be stored
44            log_folder = Configuration().get_key('folders', 'logger')
45            setup_path(log_folder)
46
47            # We enable the file
48            MyLogger.enable_file(
49                logger_name=logger_name,
50                log_file=f'{log_folder}/{logger_name}.log',
51                log_file_level=Configuration().get_key(config_key, 'level')
52            )
53      
54        # Check if the logger has console handler
55        if Configuration().get_key(config_key, 'console_handler').upper() == 'ENABLED':
56            # We enable the console
57            MyLogger.enable_console(
58                logger_name=logger_name,
59                console_level=Configuration().get_key(config_key, 'level')
60            )
61
62        # Disable if configured
63        olivia_finder_logger_name = Configuration().get_key('olivia_finder_logger', 'name')
64        if Configuration().get_key('olivia_finder_logger', 'status').upper() == 'DISABLED':
65            MyLogger().get_logger().disabled = True
66            MyLogger().get_logger(olivia_finder_logger_name).disabled = True
67            logger.disabled = True
68        elif Configuration().get_key(config_key, 'status').upper() == 'DISABLED':
69            logger.disabled = True
70
71
72        # Dissable propagation 
73        logger.propagate = False
74
75        return logger

Initializes the logger

Parameters

config_key (str): Key of the configuration file that contains the logger configuration

Returns

logging.Logger: Logger with the given name

@staticmethod

def get_logger(logger_key: Optional[str] = None) -> logging.Logger: View Source

 77    @staticmethod
 78    def get_logger(logger_key: Optional[str] = None) -> logging.Logger:
 79        '''
 80        Returns the logger with the given name
 81
 82        Parameters
 83        ----------
 84        logger_name : str
 85            Name of the logger to return
 86
 87        Returns
 88        -------
 89        logging.Logger
 90            Logger with the given name
 91        '''
 92        
 93        if logger_key is None:
 94            return logging.getLogger()
 95        
 96        # Get the logger name
 97        logger_name = Configuration().get_key(logger_key, 'name')
 98
 99        # Check if the logger has already been initialized
100        if logger_name not in logging.Logger.manager.loggerDict:
101            try:
102                MyLogger.configure(logger_key)
103                logging.getLogger(logger_name).propagate = False
104            except OliviaFinderException:
105                return logging.getLogger()
106
107        return logging.getLogger(logger_name)

Returns the logger with the given name

Parameters

logger_name (str): Name of the logger to return

Returns

logging.Logger: Logger with the given name

@staticmethod

def enable_console(logger_name: str, console_level: str) -> None: View Source

109    @staticmethod
110    def enable_console(logger_name: str, console_level: str) -> None:
111        """
112        Enables the console
113
114        Parameters
115        ----------
116        logger_name : str
117            Name of the logger to enable the console for.
118        
119        console_level : str
120            Log level to configure.
121
122        Examples
123        --------
124        >>> from my_logger import MyLogger
125        >>> MyLogger.enable_console()
126
127        """
128        
129        # The handler is created for the console
130        h = logging.StreamHandler()
131        h.setLevel(console_level.upper())
132        h.setFormatter(ConsoleLogFormatter())
133
134        # The handler is added to the logger
135        logging.getLogger(logger_name).addHandler(h)
136
137        # set the level of the logger (Must be the same as the handler)
138        logging.getLogger(logger_name).setLevel(console_level.upper())

Enables the console

Parameters

logger_name (str): Name of the logger to enable the console for.
console_level (str): Log level to configure.

Examples

>>> from my_logger import MyLogger
>>> MyLogger.enable_console()

@staticmethod

def enable_file(logger_name: str, log_file: str, log_file_level: str) -> None: View Source

140    @staticmethod
141    def enable_file(logger_name: str, log_file: str, log_file_level: str) -> None:
142        """
143        Enables the file
144
145        Parameters
146        ----------
147        logger_name : str
148            Name of the logger to enable the file for.
149
150        log_file : str
151            Name of the file to store the logs in.
152
153        log_file_level : str
154            Log level to configure.
155
156        Examples
157        --------
158        >>> from my_logger import MyLogger
159        >>> MyLogger.enable_file()
160        """
161        
162        # The handler is created for the file
163        h = logging.FileHandler(log_file)
164        h.setLevel(log_file_level.upper())
165        h.setFormatter(FileLogFormatter())
166
167
168        # The handler is added to the logger
169        logging.getLogger(logger_name).addHandler(h)
170        # set the level of the logger (Must be the same as the handler)
171        logging.getLogger(logger_name).setLevel(log_file_level.upper())

Enables the file

Parameters

logger_name (str): Name of the logger to enable the file for.
log_file (str): Name of the file to store the logs in.
log_file_level (str): Log level to configure.

Examples

>>> from my_logger import MyLogger
>>> MyLogger.enable_file()

@staticmethod

def configure_level(logger_key: str, handler_type: str, level: str) -> None: View Source

173    @staticmethod
174    def configure_level(logger_key: str, handler_type: str, level: str) -> None:
175        """
176        Description
177        -----------
178        Configures the log level for the handler of a logger given its name and type.
179        
180        Parameters
181        ----------
182        logger_key : str
183            Name of the logger to configure the level for.
184            
185        handler_type : str
186            Type of handler to configure.
187            
188        level : str
189            Log level to configure.
190            
191    .. note::
192        Valid handler types are: 
193        -   ``console`` for the console handler
194        -   ``file`` for the file handler
195        -   ``all`` for both handlers
196        -   ``global`` for all handlers of all loggers
197        
198        Valid log levels are:
199        -   ``DEBUG`` for debugging messages
200        -   ``INFO`` for informational messages
201        -   ``WARNING`` for warning messages
202        -   ``ERROR`` for error messages
203        -   ``CRITICAL`` for critical messages
204        -   ``NOTSET`` for messages without level
205                                
206        Raises
207        ------
208        NotImplementedError
209            If the specified handler type is not valid
210            If the specified log level is not valid
211                
212        Examples
213        --------
214        >>> from my_logger import MyLogger
215        >>> logger = MyLogger.logger()
216        >>> logger.configure_level("console", "DEBUG")
217        >>> logger.configure_level("file", "DEBUG")
218        """
219        
220        logger = MyLogger.get_logger(logger_key)
221        handler_list = []
222        # Validate the handler type
223        if handler_type == "console":
224            handler_list.append(logger.handlers[0])
225        elif handler_type == "file":
226            handler_list.append(logger.handlers[1])
227        elif handler_type == "all":
228            handler_list = logger.handlers
229        elif handler_type == "global":
230            handler_list = logging.root.handlers
231        else:
232            raise NotImplementedError(
233                "The specified handler type is not valid",
234                "\n",
235                "Valid handler types are: 'console', 'file', 'all', 'global'",
236            )
237
238        for handler in handler_list:
239
240            # Validate the log level
241            if level.upper() == "DEBUG":
242                handler.setLevel(logging.DEBUG)
243            elif level.upper() == "INFO":
244                handler.setLevel(logging.INFO)
245            elif level.upper() == "WARNING":
246                handler.setLevel(logging.WARNING)
247            elif level.upper() == "ERROR":
248                handler.setLevel(logging.ERROR)
249            elif level.upper() == "CRITICAL":
250                handler.setLevel(logging.CRITICAL)
251            elif level.upper() == "NOTSET":
252                handler.setLevel(logging.NOTSET)
253            else:
254                raise NotImplementedError(
255                    "The specified log level is not valid",
256                    "\n",
257                    "Valid log levels are: 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', 'NOTSET'",
258                )
259        
260        # Set the level of the logger
261        logger.setLevel(level.upper())

Description ----------- Configures the log level for the handler of a logger given its name and type.

Parameters
----------
logger_key : str
    Name of the logger to configure the level for.

handler_type : str
    Type of handler to configure.

level : str
    Log level to configure.

Valid handler types are:

console for the console handler
file for the file handler
all for both handlers
global for all handlers of all loggers

Valid log levels are:

DEBUG for debugging messages
INFO for informational messages
WARNING for warning messages
ERROR for error messages
CRITICAL for critical messages
NOTSET for messages without level

Raises

NotImplementedError: If the specified handler type is not valid If the specified log level is not valid

Examples

>>> from my_logger import MyLogger
>>> logger = MyLogger.logger()
>>> logger.configure_level("console", "DEBUG")
>>> logger.configure_level("file", "DEBUG")

class ConsoleLogFormatter(logging.Formatter): View Source

263class ConsoleLogFormatter(logging.Formatter):
264    """
265    Description
266    -----------
267    Custom formatter for console log messages.
268
269    Examples
270    --------
271    >>> from my_logger import MyLogger
272    >>> logger = MyLogger.logger()
273    >>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
274    """
275
276    __COLOR_GREEN = "\x1b[32;20m"
277    __COLOR_BLUE = "\x1b[34;20m"
278    __COLOR_YELLOW = "\x1b[33;20m"
279    __COLOR_ORANGE = "\x1b[38;5;208;20m"
280    __COLOR_RED = "\x1b[31;20m"
281    __COLOR_RESET = "\x1b[0m"
282    
283    # Formato de la cabecera del log
284    # Tiempo [nombre_logger(Nivel)] -> Archivo:Linea
285    __FORMAT_HEADER = "%(asctime)s [%(name)s(%(levelname)s)] -> %(filename)s:%(lineno)d"
286    __FORMAT_MESSAGE = "\n%(message)s"
287
288    __FORMATS = {
289        logging.DEBUG: __COLOR_GREEN + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
290        logging.INFO: __COLOR_BLUE + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
291        logging.WARNING: __COLOR_YELLOW + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
292        logging.ERROR: __COLOR_ORANGE + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
293        logging.CRITICAL: __COLOR_RED + __FORMAT_HEADER + __COLOR_RESET + __FORMAT_MESSAGE,
294    }
295
296    def format(self, record: logging.LogRecord) -> str:
297        """
298        Description
299        -----------
300        Formats the log message
301
302        Parameters
303        ----------
304        record : logging.LogRecord
305            Log message to format
306            
307        Returns
308        -------
309        str
310            Formatted log message
311
312        Examples
313        --------
314        >>> from my_logger import MyLogger
315        >>> logger = MyLogger.logger()
316        >>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
317        """
318        
319        log_fmt = self.__FORMATS.get(record.levelno)
320        formatter = logging.Formatter(log_fmt)
321        return formatter.format(record)

Description

Custom formatter for console log messages.

Examples

>>> from my_logger import MyLogger
>>> logger = MyLogger.logger()
>>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")

def format(self, record: logging.LogRecord) -> str: View Source

296    def format(self, record: logging.LogRecord) -> str:
297        """
298        Description
299        -----------
300        Formats the log message
301
302        Parameters
303        ----------
304        record : logging.LogRecord
305            Log message to format
306            
307        Returns
308        -------
309        str
310            Formatted log message
311
312        Examples
313        --------
314        >>> from my_logger import MyLogger
315        >>> logger = MyLogger.logger()
316        >>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
317        """
318        
319        log_fmt = self.__FORMATS.get(record.levelno)
320        formatter = logging.Formatter(log_fmt)
321        return formatter.format(record)

Description

Formats the log message

Parameters

record (logging.LogRecord): Log message to format

Returns

str: Formatted log message

Examples

>>> from my_logger import MyLogger
>>> logger = MyLogger.logger()
>>> logger.configure_formatter("console", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")

Inherited Members

logging.Formatter: Formatter; converter; formatTime; formatException; usesTime; formatMessage; formatStack

class FileLogFormatter(logging.Formatter): View Source

323class FileLogFormatter(logging.Formatter):
324    """
325    Description
326    -----------
327    
328    Custom formatter for file log messages.
329    """
330
331    __DEFAULT_FORMAT = "%(asctime)s [%(name)s(%(levelname)s)] -> %(filename)s:%(lineno)d\n%(message)s"
332
333    def format(self, record: logging.LogRecord) -> str:
334        """
335        Description
336        -----------
337        Formats the log message
338
339        Parameters
340        ----------
341        record : logging.LogRecord
342            Log message to format
343
344        Returns
345        -------
346        str
347            Formatted log message
348
349        Examples
350        --------
351        >>> from my_logger import MyLogger
352        >>> logger = MyLogger.logger()
353        >>> logger.configure_formatter("file", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
354        """
355        
356        formatter = logging.Formatter(self.__DEFAULT_FORMAT)
357        return formatter.format(record)

Description

Custom formatter for file log messages.

def format(self, record: logging.LogRecord) -> str: View Source

333    def format(self, record: logging.LogRecord) -> str:
334        """
335        Description
336        -----------
337        Formats the log message
338
339        Parameters
340        ----------
341        record : logging.LogRecord
342            Log message to format
343
344        Returns
345        -------
346        str
347            Formatted log message
348
349        Examples
350        --------
351        >>> from my_logger import MyLogger
352        >>> logger = MyLogger.logger()
353        >>> logger.configure_formatter("file", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
354        """
355        
356        formatter = logging.Formatter(self.__DEFAULT_FORMAT)
357        return formatter.format(record)

Description

Formats the log message

Parameters

record (logging.LogRecord): Log message to format

Returns

str: Formatted log message

Examples

>>> from my_logger import MyLogger
>>> logger = MyLogger.logger()
>>> logger.configure_formatter("file", "%(asctime)s - %(name)s - %(levelname)s - %(message)s")

Inherited Members

logging.Formatter: Formatter; converter; formatTime; formatException; usesTime; formatMessage; formatStack