chore: ruff formatting

Author: lfoppiano

delft/applications/dataseerClassifier.py

@@ -53,7 +53,14 @@ def configure(
     if learning_rate is not None:
         o_learning_rate = learning_rate
 
-    return o_batch_size, o_maxlen, o_patience, o_early_stop, o_max_epoch, o_learning_rate
+    return (
+        o_batch_size,
+        o_maxlen,
+        o_patience,
+        o_early_stop,
+        o_max_epoch,
+        o_learning_rate,
+    )
 
 
 def train(

delft/applications/licenseClassifier.py

@@ -88,7 +88,14 @@ def configure(
     if learning_rate is not None:
         o_learning_rate = learning_rate
 
-    return o_batch_size, o_maxlen, o_patience, o_early_stop, o_max_epoch, o_learning_rate
+    return (
+        o_batch_size,
+        o_maxlen,
+        o_patience,
+        o_early_stop,
+        o_max_epoch,
+        o_learning_rate,
+    )
 
 
 def train(

delft/applications/onnx_export.py

@@ -91,7 +91,7 @@ class TransformerEncoderWrapper(torch.nn.Module):
     def __init__(self, model):
         super().__init__()
         self.model = model
-        self.accepts_token_type_ids = getattr(model, 'accepts_token_type_ids', True)
+        self.accepts_token_type_ids = getattr(model, "accepts_token_type_ids", True)
 
     def forward(self, input_ids, attention_mask, token_type_ids=None):
         """Run transformer encoder to get emissions.
@@ -130,7 +130,7 @@ def export_crf_params(model, output_path: str):
     # Handle different CRF implementations
     # Standard Contract: crf_params.json MUST contain "transitions" in [from_tag][to_tag] orientation.
     # Java Code (CRFDecoder.java) iterates as transitions[prevTag][currentTag].
-    
+
     if hasattr(crf, "crf"):
         # Using pytorch-crf wrapper (standard CRF class)
         # pytorch-crf stores transitions as [from_tag, to_tag]
@@ -254,15 +254,18 @@ def export_classification_config(model_config, output_path: str):
     print(f"Exported classification config to {output_path}")
 
 
-
 def export_class_labels(model_config, output_path: str):
     """
     Export class labels for text classification model.
     """
     labels = {
         "labels": model_config.list_classes,
-        "labelToIndex": {label: idx for idx, label in enumerate(model_config.list_classes)},
-        "indexToLabel": {idx: label for idx, label in enumerate(model_config.list_classes)},
+        "labelToIndex": {
+            label: idx for idx, label in enumerate(model_config.list_classes)
+        },
+        "indexToLabel": {
+            idx: label for idx, label in enumerate(model_config.list_classes)
+        },
     }
 
     with open(output_path, "w") as f:
@@ -288,13 +291,15 @@ def export_tokenizer(tokenizer, output_dir: str):
     os.makedirs(output_dir, exist_ok=True)
     tokenizer.save_pretrained(output_dir)
     print(f"Exported tokenizer to {output_dir}")
-    
+
     # List exported files
     for f in os.listdir(output_dir):
         print(f"  - {f}")
 
 
-def export_transformer_config(model_config, preprocessor, accepts_token_type_ids: bool, output_path: str):
+def export_transformer_config(
+    model_config, preprocessor, accepts_token_type_ids: bool, output_path: str
+):
     """
     Export transformer model configuration for Java runtime.
 
@@ -309,15 +314,16 @@ def export_transformer_config(model_config, preprocessor, accepts_token_type_ids
         "architecture": model_config.architecture,
         "transformerName": model_config.transformer_name,
         "maxSequenceLength": model_config.max_sequence_length,
-        "useCRF": "CRF" in model_config.architecture or "ChainCRF" in model_config.architecture,
+        "useCRF": "CRF" in model_config.architecture
+        or "ChainCRF" in model_config.architecture,
         "useChainCRF": "ChainCRF" in model_config.architecture,
         "useFeatures": "FEATURES" in model_config.architecture,
         "useChar": "CHAR" in model_config.architecture,
         "acceptsTokenTypeIds": accepts_token_type_ids,
     }
 
     # Add label mappings
-    if hasattr(preprocessor, 'vocab_tag'):
+    if hasattr(preprocessor, "vocab_tag"):
         config["labelVocab"] = preprocessor.vocab_tag
         config["labelIndex"] = {str(k): v for k, v in preprocessor.indice_tag.items()}
         config["numLabels"] = len(preprocessor.vocab_tag)
@@ -723,7 +729,7 @@ def export_transformer_to_onnx(
     seq_len = max_seq_length
     dummy_input_ids = torch.zeros(batch_size, seq_len, dtype=torch.long)
     dummy_attention_mask = torch.ones(batch_size, seq_len, dtype=torch.long)
-    
+
     # Prepare inputs and names based on model requirements
     if accepts_token_type_ids:
         dummy_token_type_ids = torch.zeros(batch_size, seq_len, dtype=torch.long)
@@ -768,23 +774,27 @@ def export_transformer_to_onnx(
     print("ONNX transformer model exported successfully")
 
     # Export CRF params if applicable
-    if hasattr(model, 'crf'):
+    if hasattr(model, "crf"):
         crf_path = os.path.join(output_dir, "crf_params.json")
         export_crf_params(model, crf_path)
     else:
         print("No CRF layer found (softmax output model)")
 
     # Export tokenizer
     tokenizer_dir = os.path.join(output_dir, "tokenizer")
-    if hasattr(preprocessor, 'tokenizer') and preprocessor.tokenizer is not None:
+    if hasattr(preprocessor, "tokenizer") and preprocessor.tokenizer is not None:
         export_tokenizer(preprocessor.tokenizer, tokenizer_dir)
     else:
         print("Warning: No tokenizer found in preprocessor, skipping tokenizer export")
-        print("  You may need to load the tokenizer separately using the transformer name")
+        print(
+            "  You may need to load the tokenizer separately using the transformer name"
+        )
 
     # Export config
     config_path = os.path.join(output_dir, "config.json")
-    export_transformer_config(model_config, preprocessor, accepts_token_type_ids, config_path)
+    export_transformer_config(
+        model_config, preprocessor, accepts_token_type_ids, config_path
+    )
 
     # Verify ONNX model
     try:
@@ -807,7 +817,7 @@ def export_transformer_to_onnx(
                 print(f"      - {sub_item}")
         else:
             # Show file size for ONNX file
-            if item.endswith('.onnx'):
+            if item.endswith(".onnx"):
                 size_mb = os.path.getsize(item_path) / (1024 * 1024)
                 print(f"  - {item} ({size_mb:.1f} MB)")
             else:
@@ -887,7 +897,9 @@ def export_transformer_to_onnx(
 
 def main():
     parser = argparse.ArgumentParser(description="Export DeLFT model to ONNX format")
-    parser.add_argument("model", help="Name of the model (e.g., header, date, dataseer-binary)")
+    parser.add_argument(
+        "model", help="Name of the model (e.g., header, date, dataseer-binary)"
+    )
     parser.add_argument(
         "--architecture",
         required=True,

delft/sequenceLabelling/data_loader.py

@@ -448,6 +448,7 @@ def create_dataloader(
     num_batches = max(1, len(dataset) // batch_size)
     if num_workers > num_batches:
         import logging
+
         logging.getLogger(__name__).warning(
             f"Reducing num_workers from {num_workers} to {num_batches} "
             f"(dataset has {len(dataset)} samples, {num_batches} batches)"
@@ -465,14 +466,16 @@ def create_dataloader(
     # Each worker must reopen the LMDB environment to get its own handle.
     worker_init = None
     if embeddings is not None and num_workers > 0:
+
         def lmdb_worker_init_fn(worker_id):
             """Reopen LMDB environment in each worker process for fork safety."""
             # Get the dataset from the worker's DataLoader
             worker_info = torch.utils.data.get_worker_info()
             if worker_info is not None:
                 dataset = worker_info.dataset
-                if hasattr(dataset, 'embeddings') and dataset.embeddings is not None:
+                if hasattr(dataset, "embeddings") and dataset.embeddings is not None:
                     dataset.embeddings.reopen_lmdb()
+
         worker_init = lmdb_worker_init_fn
 
     return DataLoader(

delft/textClassification/data_loader.py

@@ -130,6 +130,7 @@ def create_dataloader(
     num_batches = max(1, len(dataset) // batch_size)
     if num_workers > num_batches:
         import logging
+
         logging.getLogger(__name__).warning(
             f"Reducing num_workers from {num_workers} to {num_batches} "
             f"(dataset has {len(dataset)} samples, {num_batches} batches)"
@@ -141,13 +142,15 @@ def create_dataloader(
     # Each worker must reopen the LMDB environment to get its own handle.
     worker_init = None
     if embeddings is not None and num_workers > 0:
+
         def lmdb_worker_init_fn(worker_id):
             """Reopen LMDB environment in each worker process for fork safety."""
             worker_info = torch.utils.data.get_worker_info()
             if worker_info is not None:
                 dataset = worker_info.dataset
-                if hasattr(dataset, 'embeddings') and dataset.embeddings is not None:
+                if hasattr(dataset, "embeddings") and dataset.embeddings is not None:
                     dataset.embeddings.reopen_lmdb()
+
         worker_init = lmdb_worker_init_fn
 
     loader = DataLoader(

delft/textClassification/trainer.py

@@ -137,7 +137,7 @@ def evaluate(self, dataloader):
         # Calculate ROC-AUC per class with fallback for classes with single label value
         total_roc_auc = 0.0
         num_classes = y_true.shape[1]
-        
+
         for j in range(num_classes):
             if len(np.unique(y_true[:, j])) == 1:
                 # roc_auc_score sklearn implementation doesn't work when a class has only one label value
@@ -151,8 +151,7 @@ def evaluate(self, dataloader):
                 except ValueError:
                     class_roc_auc = 0.0
             total_roc_auc += class_roc_auc
-        
+
         roc_auc = total_roc_auc / num_classes
 
         return {"loss": avg_val_loss, "roc_auc": roc_auc}
-

delft/textClassification/wrapper.py

@@ -177,7 +177,7 @@ def train_single(
             indices = np.random.permutation(len(x_train))
             x_train = x_train[indices]
             y_train = y_train[indices]
-            
+
             split_idx = int(len(x_train) * 0.9)
             x_valid = x_train[split_idx:]
             y_valid = y_train[split_idx:]
@@ -481,12 +481,14 @@ def save(self, dir_path="data/models/textClassification/"):
 
         # Save PyTorch model
         torch.save(self.model.state_dict(), os.path.join(directory, self.weight_file))
-        
+
         # Remove the best model checkpoint if it exists
-        best_model_checkpoint = os.path.join(directory, f"{self.model_config.model_name}_best_model.pth")
+        best_model_checkpoint = os.path.join(
+            directory, f"{self.model_config.model_name}_best_model.pth"
+        )
         if os.path.exists(best_model_checkpoint):
             os.remove(best_model_checkpoint)
-        
+
         print(f"Model saved to {directory}")
 
     def load(self, dir_path="data/models/textClassification/"):

delft/utilities/Embeddings.py

@@ -369,22 +369,22 @@ def get_word_vector_in_memory(self, word):
     def reopen_lmdb(self):
         """
         Reopen the LMDB environment. This is required for fork-safe multiprocessing.
-        
+
         LMDB environments opened before fork() cannot be safely used in child processes.
         Call this method in each worker process (e.g., via DataLoader's worker_init_fn)
         to create a fresh LMDB environment handle for the worker.
-        
+
         This is a no-op if embeddings are not using LMDB (e.g., in-memory or bin format).
         """
         if self.env is None or self.embedding_lmdb_path is None:
             # Not using LMDB, nothing to do
             return
-        
+
         try:
             self.env.close()
         except:
             pass  # May already be closed or invalid after fork
-        
+
         envFilePath = os.path.join(self.embedding_lmdb_path, self.name)
         self.env = lmdb.open(
             envFilePath,