Logging Utilities¶

dnallm.utils.logger ¶

DNALLM Logging Configuration

This module provides a centralized logging configuration for the DNALLM project. It replaces print statements with proper logging for better production readiness.

Classes¶

ColoredFormatter ¶

Bases: Formatter

Custom formatter with colored output for console.

Functions¶

format ¶

format(record)

Format log record with colors.

Source code in dnallm/utils/logger.py

def format(self, record):
    """Format log record with colors."""
    log_color = self.COLORS.get(record.levelname, "")
    record.levelname = f"{log_color}{record.levelname}{Style.RESET_ALL}"
    return super().format(record)

DNALLMLogger ¶

DNALLMLogger(name='dnallm', level='INFO')

Centralized logger for DNALLM with colored output and structured logging.

Initialize the DNALLM logger.

Parameters:

Name	Type	Description	Default
`name`	`str`	Logger name	`'dnallm'`
`level`	`str`	Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)	`'INFO'`

Source code in dnallm/utils/logger.py

def __init__(self, name: str = "dnallm", level: str = "INFO"):
    """
    Initialize the DNALLM logger.

    Args:
        name: Logger name
        level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
    """
    self.logger = logging.getLogger(name)
    self.logger.setLevel(getattr(logging, level.upper()))

    # Prevent duplicate handlers
    if not self.logger.handlers:
        self._setup_handlers()

Functions¶

critical ¶

critical(message, **kwargs)

Log critical message.

Source code in dnallm/utils/logger.py

def critical(self, message: str, **kwargs):
    """Log critical message."""
    self.logger.critical(message, **kwargs)

debug ¶

debug(message, **kwargs)

Log debug message.

Source code in dnallm/utils/logger.py

def debug(self, message: str, **kwargs):
    """Log debug message."""
    self.logger.debug(message, **kwargs)

error ¶

error(message, **kwargs)

Log error message.

Source code in dnallm/utils/logger.py

def error(self, message: str, **kwargs):
    """Log error message."""
    self.logger.error(message, **kwargs)

failure ¶

failure(message, **kwargs)

Log failure message with red color.

Source code in dnallm/utils/logger.py

def failure(self, message: str, **kwargs):
    """Log failure message with red color."""
    self.logger.error(f"{Fore.RED}❌ {message}{Style.RESET_ALL}", **kwargs)

info ¶

info(message, **kwargs)

Log info message.

Source code in dnallm/utils/logger.py

def info(self, message: str, **kwargs):
    """Log info message."""
    self.logger.info(message, **kwargs)

info_icon ¶

info_icon(message, **kwargs)

Log info message with cyan color and icon.

Source code in dnallm/utils/logger.py

def info_icon(self, message: str, **kwargs):
    """Log info message with cyan color and icon."""
    self.logger.info(f"{Fore.CYAN}i  {message}{Style.RESET_ALL}", **kwargs)

progress ¶

progress(message, **kwargs)

Log progress message with blue color.

Source code in dnallm/utils/logger.py

def progress(self, message: str, **kwargs):
    """Log progress message with blue color."""
    self.logger.info(f"{Fore.BLUE}🔄 {message}{Style.RESET_ALL}", **kwargs)

success ¶

success(message, **kwargs)

Log success message with green color.

Source code in dnallm/utils/logger.py

def success(self, message: str, **kwargs):
    """Log success message with green color."""
    self.logger.info(
        f"{Fore.GREEN}✅ {message}{Style.RESET_ALL}", **kwargs
    )

warning ¶

warning(message, **kwargs)

Log warning message.

Source code in dnallm/utils/logger.py

def warning(self, message: str, **kwargs):
    """Log warning message."""
    self.logger.warning(message, **kwargs)

warning_icon ¶

warning_icon(message, **kwargs)

Log warning message with yellow color and icon.

Source code in dnallm/utils/logger.py

def warning_icon(self, message: str, **kwargs):
    """Log warning message with yellow color and icon."""
    self.logger.warning(
        f"{Fore.YELLOW}⚠️  {message}{Style.RESET_ALL}", **kwargs
    )

LoggingContext ¶

LoggingContext(level)

Context manager for temporary logging level changes.

Source code in dnallm/utils/logger.py

def __init__(self, level: str):
    self.level = level
    self.original_level: int | None = None

Functions¶

get_logger ¶

get_logger(name='dnallm', level='INFO')

Get or create a logger instance.

Parameters:

Name	Type	Description	Default
`name`	`str`	Logger name	`'dnallm'`
`level`	`str`	Logging level	`'INFO'`

Returns:

Type	Description
`DNALLMLogger`	DNALLMLogger instance

Source code in dnallm/utils/logger.py

def get_logger(name: str = "dnallm", level: str = "INFO") -> DNALLMLogger:
    """
    Get or create a logger instance.

    Args:
        name: Logger name
        level: Logging level

    Returns:
        DNALLMLogger instance
    """
    global _logger_instance
    if _logger_instance is None:
        _logger_instance = DNALLMLogger(name, level)
    return _logger_instance

log_debug ¶

log_debug(message)

Log debug message.

Source code in dnallm/utils/logger.py

def log_debug(message: str):
    """Log debug message."""
    get_logger().debug(message)

log_error ¶

log_error(message)

Log error message.

Source code in dnallm/utils/logger.py

def log_error(message: str):
    """Log error message."""
    get_logger().error(message)

log_failure ¶

log_failure(message)

Log failure message.

Source code in dnallm/utils/logger.py

def log_failure(message: str):
    """Log failure message."""
    get_logger().failure(message)

log_function_call ¶

log_function_call(func)

Decorator to log function calls.

Source code in dnallm/utils/logger.py

def log_function_call(func):
    """Decorator to log function calls."""

    def wrapper(*args, **kwargs):
        logger = get_logger()
        logger.debug(
            f"Calling {func.__name__} with args={args}, kwargs={kwargs}"
        )
        try:
            result = func(*args, **kwargs)
            logger.debug(f"{func.__name__} completed successfully")
            return result
        except Exception as e:
            logger.error(f"{func.__name__} failed with error: {e}")
            raise

    return wrapper

log_info ¶

log_info(message)

Log info message.

Source code in dnallm/utils/logger.py

def log_info(message: str):
    """Log info message."""
    get_logger().info(message)

log_progress ¶

log_progress(message)

Log progress message.

Source code in dnallm/utils/logger.py

def log_progress(message: str):
    """Log progress message."""
    get_logger().progress(message)

log_success ¶

log_success(message)

Log success message.

Source code in dnallm/utils/logger.py

def log_success(message: str):
    """Log success message."""
    get_logger().success(message)

log_warning ¶

log_warning(message)

Log warning message.

Source code in dnallm/utils/logger.py

def log_warning(message: str):
    """Log warning message."""
    get_logger().warning(message)

setup_logging ¶

setup_logging(level='INFO', log_file=None)

Set up logging configuration for the entire application.

Parameters:

Name	Type	Description	Default
`level`	`str`	Logging level	`'INFO'`
`log_file`	`str \| None`	Optional log file path	`None`

Source code in dnallm/utils/logger.py

def setup_logging(level: str = "INFO", log_file: str | None = None):
    """
    Set up logging configuration for the entire application.

    Args:
        level: Logging level
        log_file: Optional log file path
    """
    logger = get_logger(level=level)

    if log_file:
        # Add additional file handler
        file_handler = logging.FileHandler(log_file)
        file_handler.setLevel(logging.DEBUG)
        file_formatter = logging.Formatter(
            "%(asctime)s - %(name)s - %(levelname)s - "
            "%(filename)s:%(lineno)d - %(message)s",
            datefmt="%Y-%m-%d %H:%M:%S",
        )
        file_handler.setFormatter(file_formatter)
        logger.logger.addHandler(file_handler)

    return logger