Skip to content

gc_batch.logger

Logger

A basic Python logger class that provides easy-to-use logging functionality.

Features: - Multiple log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL) - Console and file output - Customizable log format - Automatic log file rotation

Source code in src/gc_batch/logger.py 
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
class Logger:
    """
    A basic Python logger class that provides easy-to-use logging functionality.

    Features:
    - Multiple log levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
    - Console and file output
    - Customizable log format
    - Automatic log file rotation
    """

    def __init__(
        self,
        name: str = "default",
        level: int = logging.INFO,
        log_file: str | Path | None = None,
        console_output: bool = True,
        file_output: bool = False,
        format_string: str | None = None,
    ):
        """
        Initialize the logger.

        Args:
            name: Logger name
            level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
            log_file: Path to log file (if file_output is True)
            console_output: Whether to output to console
            file_output: Whether to output to file
            format_string: Custom format string for log messages
        """
        self.name = name
        self.level = level
        self.log_file = Path(log_file) if log_file else None
        self.console_output = console_output
        self.file_output = file_output

        # Set default format if none provided
        if format_string is None:
            format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

        self.format_string = format_string

        # Create the logger
        self.logger = logging.getLogger(name)
        self.logger.setLevel(level)

        # Clear any existing handlers
        self.logger.handlers.clear()

        # Create formatter
        formatter = logging.Formatter(format_string)

        # Add console handler if requested
        if console_output:
            console_handler = logging.StreamHandler(sys.stdout)
            console_handler.setLevel(level)
            console_handler.setFormatter(formatter)
            self.logger.addHandler(console_handler)

        # Add file handler if requested
        if file_output and self.log_file:
            # Ensure log directory exists
            self.log_file.parent.mkdir(parents=True, exist_ok=True)

            file_handler = logging.FileHandler(self.log_file)
            file_handler.setLevel(level)
            file_handler.setFormatter(formatter)
            self.logger.addHandler(file_handler)

    def debug(self, message: str) -> None:
        """Log a debug message."""
        self.logger.debug(message)

    def info(self, message: str) -> None:
        """Log an info message."""
        self.logger.info(message)

    def warning(self, message: str) -> None:
        """Log a warning message."""
        self.logger.warning(message)

    def error(self, message: str) -> None:
        """Log an error message."""
        self.logger.error(message)

    def critical(self, message: str) -> None:
        """Log a critical message."""
        self.logger.critical(message)

    def log(self, level: int, message: str) -> None:
        """Log a message at the specified level."""
        self.logger.log(level, message)

    def set_level(self, level: int) -> None:
        """Set the logging level."""
        self.level = level
        self.logger.setLevel(level)
        for handler in self.logger.handlers:
            handler.setLevel(level)

    def get_level_name(self) -> str:
        """Get the current logging level name."""
        return logging.getLevelName(self.level)

    def is_enabled_for(self, level: int) -> bool:
        """Check if logging is enabled for the given level."""
        return self.logger.isEnabledFor(level)

console_output = console_output instance-attribute

file_output = file_output instance-attribute

format_string = format_string instance-attribute

level = level instance-attribute

log_file = Path(log_file) if log_file else None instance-attribute

logger = logging.getLogger(name) instance-attribute

name = name instance-attribute

__init__(name='default', level=logging.INFO, log_file=None, console_output=True, file_output=False, format_string=None)

Initialize the logger.

Parameters:

Name Type Description Default
name str

Logger name

 'default'
level int

Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)

 INFO
log_file str | Path | None

Path to log file (if file_output is True)

 None
console_output bool

Whether to output to console

 True
file_output bool

Whether to output to file

 False
format_string str | None

Custom format string for log messages

 None
Source code in src/gc_batch/logger.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def __init__(
    self,
    name: str = "default",
    level: int = logging.INFO,
    log_file: str | Path | None = None,
    console_output: bool = True,
    file_output: bool = False,
    format_string: str | None = None,
):
    """
    Initialize the logger.

    Args:
        name: Logger name
        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
        log_file: Path to log file (if file_output is True)
        console_output: Whether to output to console
        file_output: Whether to output to file
        format_string: Custom format string for log messages
    """
    self.name = name
    self.level = level
    self.log_file = Path(log_file) if log_file else None
    self.console_output = console_output
    self.file_output = file_output

    # Set default format if none provided
    if format_string is None:
        format_string = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

    self.format_string = format_string

    # Create the logger
    self.logger = logging.getLogger(name)
    self.logger.setLevel(level)

    # Clear any existing handlers
    self.logger.handlers.clear()

    # Create formatter
    formatter = logging.Formatter(format_string)

    # Add console handler if requested
    if console_output:
        console_handler = logging.StreamHandler(sys.stdout)
        console_handler.setLevel(level)
        console_handler.setFormatter(formatter)
        self.logger.addHandler(console_handler)

    # Add file handler if requested
    if file_output and self.log_file:
        # Ensure log directory exists
        self.log_file.parent.mkdir(parents=True, exist_ok=True)

        file_handler = logging.FileHandler(self.log_file)
        file_handler.setLevel(level)
        file_handler.setFormatter(formatter)
        self.logger.addHandler(file_handler)

critical(message)

Log a critical message.

Source code in src/gc_batch/logger.py 
92
93
94
def critical(self, message: str) -> None:
    """Log a critical message."""
    self.logger.critical(message)

debug(message)

Log a debug message.

Source code in src/gc_batch/logger.py 
76
77
78
def debug(self, message: str) -> None:
    """Log a debug message."""
    self.logger.debug(message)

error(message)

Log an error message.

Source code in src/gc_batch/logger.py 
88
89
90
def error(self, message: str) -> None:
    """Log an error message."""
    self.logger.error(message)

get_level_name()

Get the current logging level name.

Source code in src/gc_batch/logger.py 
107
108
109
def get_level_name(self) -> str:
    """Get the current logging level name."""
    return logging.getLevelName(self.level)

info(message)

Log an info message.

Source code in src/gc_batch/logger.py 
80
81
82
def info(self, message: str) -> None:
    """Log an info message."""
    self.logger.info(message)

is_enabled_for(level)

Check if logging is enabled for the given level.

Source code in src/gc_batch/logger.py 
111
112
113
def is_enabled_for(self, level: int) -> bool:
    """Check if logging is enabled for the given level."""
    return self.logger.isEnabledFor(level)

log(level, message)

Log a message at the specified level.

Source code in src/gc_batch/logger.py 
96
97
98
def log(self, level: int, message: str) -> None:
    """Log a message at the specified level."""
    self.logger.log(level, message)

set_level(level)

Set the logging level.

Source code in src/gc_batch/logger.py 
100
101
102
103
104
105
def set_level(self, level: int) -> None:
    """Set the logging level."""
    self.level = level
    self.logger.setLevel(level)
    for handler in self.logger.handlers:
        handler.setLevel(level)

warning(message)

Log a warning message.

Source code in src/gc_batch/logger.py 
84
85
86
def warning(self, message: str) -> None:
    """Log a warning message."""
    self.logger.warning(message)

get_logger(name='default', level=logging.INFO, log_file=None, console_output=True, file_output=False)

Get a logger instance with the specified configuration.

Parameters:

Name Type Description Default
name str

Logger name

 'default'
level int

Logging level

 INFO
log_file str | Path | None

Path to log file

 None
console_output bool

Whether to output to console

 True
file_output bool

Whether to output to file

 False

Returns:

Type Description
Logger

Logger instance
Source code in src/gc_batch/logger.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
def get_logger(
    name: str = "default",
    level: int = logging.INFO,
    log_file: str | Path | None = None,
    console_output: bool = True,
    file_output: bool = False,
) -> Logger:
    """
    Get a logger instance with the specified configuration.

    Args:
        name: Logger name
        level: Logging level
        log_file: Path to log file
        console_output: Whether to output to console
        file_output: Whether to output to file

    Returns:
        Logger instance
    """
    return Logger(
        name=name,
        level=level,
        log_file=log_file,
        console_output=console_output,
        file_output=file_output,
    )