Fix linting issues in workflow callback handlers

Co-authored-by: jgbradley1 <654554+jgbradley1@users.noreply.github.com>

Author: Copilot

graphrag/callbacks/blob_workflow_callbacks.py

@@ -12,14 +12,18 @@
 try:
     from azure.identity import DefaultAzureCredential
     from azure.storage.blob import BlobServiceClient
+
     _AZURE_AVAILABLE = True
 except ImportError:
     _AZURE_AVAILABLE = False
+
     # Create dummy classes for type hints when azure is not available
     class DefaultAzureCredential:  # type: ignore
-        pass
+        """Dummy class when Azure is not available."""
+
     class BlobServiceClient:  # type: ignore
-        pass
+        """Dummy class when Azure is not available."""
+
 
 from graphrag.callbacks.workflow_handler_base import WorkflowHandlerBase
 
@@ -42,21 +46,21 @@ def __init__(
     ):
         """Create a new instance of the BlobWorkflowCallbacks class."""
         super().__init__(level)
-        
+
         if not _AZURE_AVAILABLE:
             msg = "Azure dependencies are not installed. Install graphrag with azure extras."
             raise ImportError(msg)
-        
+
         if container_name is None:
             msg = "No container name provided for blob storage."
             raise ValueError(msg)
         if connection_string is None and storage_account_blob_url is None:
             msg = "No storage account blob url provided for blob storage."
             raise ValueError(msg)
-            
+
         self._connection_string = connection_string
         self._storage_account_blob_url = storage_account_blob_url
-        
+
         if self._connection_string:
             self._blob_service_client = BlobServiceClient.from_connection_string(
                 self._connection_string
@@ -92,27 +96,26 @@ def emit(self, record):
                 "type": self._get_log_type(record.levelno),
                 "data": record.getMessage(),
             }
-            
+
             # Add additional fields if they exist
-            if hasattr(record, 'details') and record.details:
+            if hasattr(record, "details") and record.details:
                 log_data["details"] = record.details
             if record.exc_info and record.exc_info[1]:
                 log_data["cause"] = str(record.exc_info[1])
-            if hasattr(record, 'stack') and record.stack:
+            if hasattr(record, "stack") and record.stack:
                 log_data["stack"] = record.stack
-                
+
             self._write_log(log_data)
-        except Exception:
+        except (OSError, ValueError):
             self.handleError(record)
 
     def _get_log_type(self, level: int) -> str:
         """Get log type string based on log level."""
         if level >= logging.ERROR:
             return "error"
-        elif level >= logging.WARNING:
+        if level >= logging.WARNING:
             return "warning"
-        else:
-            return "log"
+        return "log"
 
     def _write_log(self, log: dict[str, Any]):
         """Write log data to blob storage."""

graphrag/callbacks/console_workflow_callbacks.py

@@ -17,23 +17,28 @@ def __init__(self, level: int = logging.NOTSET):
         super().__init__(level)
         # Use a StreamHandler for actual console output
         self._stream_handler = logging.StreamHandler(sys.stdout)
-        
+
         # Set up a formatter for console output
         formatter = logging.Formatter(
-            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
         )
         self._stream_handler.setFormatter(formatter)
 
     def emit(self, record):
         """Emit a log record using the underlying StreamHandler."""
         # For warning records, add color formatting if the message is just a warning
-        if record.levelno == logging.WARNING and hasattr(record, 'details'):
+        if record.levelno == logging.WARNING and hasattr(record, "details"):
             # Apply warning color formatting similar to original
             formatted_msg = f"\033[93m{record.getMessage()}\033[00m"
             # Create a new record with the colored message
             colored_record = logging.LogRecord(
-                record.name, record.levelno, record.pathname, record.lineno,
-                formatted_msg, (), record.exc_info
+                record.name,
+                record.levelno,
+                record.pathname,
+                record.lineno,
+                formatted_msg,
+                (),
+                record.exc_info,
             )
             self._stream_handler.emit(colored_record)
         else:

graphrag/callbacks/file_workflow_callbacks.py

@@ -12,7 +12,7 @@
 
 class WorkflowJSONFileHandler(logging.FileHandler):
     """A FileHandler that formats log records as JSON for workflow callbacks."""
-    
+
     def emit(self, record):
         """Emit a log record as JSON."""
         try:
@@ -21,33 +21,32 @@ def emit(self, record):
                 "type": self._get_log_type(record.levelno),
                 "data": record.getMessage(),
             }
-            
+
             # Add additional fields if they exist
-            if hasattr(record, 'details') and record.details:
+            if hasattr(record, "details") and record.details:
                 log_data["details"] = record.details
             if record.exc_info and record.exc_info[1]:
                 log_data["source"] = str(record.exc_info[1])
-            if hasattr(record, 'stack') and record.stack:
+            if hasattr(record, "stack") and record.stack:
                 log_data["stack"] = record.stack
-                
+
             # Write JSON to file
             json_str = json.dumps(log_data, indent=4, ensure_ascii=False) + "\n"
-            
+
             if self.stream is None:
                 self.stream = self._open()
             self.stream.write(json_str)
             self.flush()
-        except Exception:
+        except (OSError, ValueError):
             self.handleError(record)
-    
+
     def _get_log_type(self, level: int) -> str:
         """Get log type string based on log level."""
         if level >= logging.ERROR:
             return "error"
-        elif level >= logging.WARNING:
+        if level >= logging.WARNING:
             return "warning"
-        else:
-            return "log"
+        return "log"
 
 
 class FileWorkflowCallbacks(WorkflowHandlerBase):
@@ -56,23 +55,23 @@ class FileWorkflowCallbacks(WorkflowHandlerBase):
     def __init__(self, directory: str, level: int = logging.NOTSET):
         """Create a new file-based workflow handler."""
         super().__init__(level)
-        
+
         # Ensure directory exists
         Path(directory).mkdir(parents=True, exist_ok=True)
-        
+
         # Create the JSON file handler
         log_file_path = Path(directory) / "logs.json"
-        self._file_handler = WorkflowJSONFileHandler(str(log_file_path), mode='a')
-        
+        self._file_handler = WorkflowJSONFileHandler(str(log_file_path), mode="a")
+
         # Also create a regular logger for backwards compatibility
         self._logger = logging.getLogger(__name__)
 
     def emit(self, record):
         """Emit a log record using the underlying FileHandler."""
         # Emit to the JSON file
         self._file_handler.emit(record)
-        
-        # Also emit to regular logger for backwards compatibility  
+
+        # Also emit to regular logger for backwards compatibility
         if record.levelno >= logging.WARNING:
             self._logger.log(record.levelno, record.getMessage())
 

graphrag/callbacks/workflow_handler_base.py

@@ -4,7 +4,6 @@
 """Base class for workflow callbacks that inherit from logging.Handler."""
 
 import logging
-from typing import Any
 
 from graphrag.callbacks.workflow_callbacks import WorkflowCallbacks
 from graphrag.index.typing.pipeline_run_result import PipelineRunResult
@@ -17,7 +16,7 @@ class WorkflowHandlerBase(logging.Handler, WorkflowCallbacks):
     def __init__(self, level: int = logging.NOTSET):
         """Initialize the handler."""
         super().__init__(level)
-        
+
     def pipeline_start(self, names: list[str]) -> None:
         """Execute this callback to signal when the entire pipeline starts."""
         record = logging.LogRecord(
@@ -95,7 +94,7 @@ def error(
         full_message = message
         if details:
             full_message = f"{message} details={details}"
-        
+
         record = logging.LogRecord(
             name="graphrag.error",
             level=logging.ERROR,
@@ -105,21 +104,21 @@ def error(
             args=(),
             exc_info=(type(cause), cause, None) if cause else None,
         )
-        
+
         # Add custom attributes for stack and details
         if stack:
             record.stack = stack  # type: ignore
         if details:
             record.details = details  # type: ignore
-            
+
         self.emit(record)
 
     def warning(self, message: str, details: dict | None = None) -> None:
         """Handle when a warning occurs."""
         full_message = message
         if details:
             full_message = f"{message} details={details}"
-            
+
         record = logging.LogRecord(
             name="graphrag.warning",
             level=logging.WARNING,
@@ -129,18 +128,18 @@ def warning(self, message: str, details: dict | None = None) -> None:
             args=(),
             exc_info=None,
         )
-        
+
         if details:
             record.details = details  # type: ignore
-            
+
         self.emit(record)
 
     def log(self, message: str, details: dict | None = None) -> None:
         """Handle when a log message occurs."""
         full_message = message
         if details:
             full_message = f"{message} details={details}"
-            
+
         record = logging.LogRecord(
             name="graphrag.log",
             level=logging.INFO,
@@ -150,8 +149,8 @@ def log(self, message: str, details: dict | None = None) -> None:
             args=(),
             exc_info=None,
         )
-        
+
         if details:
             record.details = details  # type: ignore
-            
-        self.emit(record)
+
+        self.emit(record)