rapidfireai 0.10.3rc1__py3-none-any.whl → 0.11.1rc2__py3-none-any.whl

rapidfireai/ml/callbacks.py

@@ -1,14 +1,9 @@
-from typing import Callable, Dict, List, Optional
+from collections.abc import Callable
 
 import torch
 from datasets import Dataset
 from tqdm import tqdm
-from transformers import (
-    TrainerCallback,
-    TrainerControl,
-    TrainerState,
-    TrainingArguments,
-)
+from transformers import TrainerCallback, TrainerControl, TrainerState, TrainingArguments
 from transformers.trainer_utils import IntervalStrategy, SaveStrategy
 
 
@@ -17,7 +12,7 @@ class GenerationMetricsCallback(TrainerCallback):
         self,
         tokenizer,
         eval_dataset: Dataset,
-        generation_config: Optional[Dict] = None,
+        generation_config: dict | None = None,
         compute_metrics: Callable = None,
         batch_size: int = 8,
         metric_logger=None,
@@ -90,9 +85,7 @@ class GenerationMetricsCallback(TrainerCallback):
             elif "prompt" in item and "completion" in item:
                 input_text = item["prompt"]
                 reference = item["completion"][-1]["content"]
-                input_text = self.tokenizer.apply_chat_template(
-                    input_text, tokenize=False
-                )
+                input_text = self.tokenizer.apply_chat_template(input_text, tokenize=False)
             elif "text" in item:
                 # SFT format - use text as input, response as reference
                 input_text = item["text"]
@@ -114,7 +107,7 @@ class GenerationMetricsCallback(TrainerCallback):
 
         return input_texts, references
 
-    def _generate_batch(self, model, input_texts: List[str]) -> torch.Tensor:
+    def _generate_batch(self, model, input_texts: list[str]) -> torch.Tensor:
         """Generate text for a batch of inputs with defensive validation"""
         # Defensive validation for empty inputs
         if not input_texts:
@@ -136,7 +129,7 @@ class GenerationMetricsCallback(TrainerCallback):
             print(f"Warning: Tokenization error in generation callback: {e}")
             return torch.empty((0, 0), dtype=torch.long).to(model.device)
 
-    def _compute_generation_metrics(self, model, step: int) -> Dict[str, float]:
+    def _compute_generation_metrics(self, model, step: int) -> dict[str, float]:
         """Generate text and compute BLEU/ROUGE metrics with batch processing"""
         model.eval()
 
@@ -163,14 +156,10 @@ class GenerationMetricsCallback(TrainerCallback):
             return {}
 
         with torch.no_grad():
-            for i in tqdm(
-                range(0, len(indices), self.batch_size), desc="Generating for metrics"
-            ):
+            for i in tqdm(range(0, len(indices), self.batch_size), desc="Generating for metrics"):
                 input_ids_batch = input_ids[i : i + self.batch_size]
                 with torch.inference_mode(), torch.cuda.amp.autocast():
-                    outputs_batch = model.generate(
-                        input_ids_batch, **self.generation_config
-                    )
+                    outputs_batch = model.generate(input_ids_batch, **self.generation_config)
                 generated_texts = self.tokenizer.batch_decode(
                     outputs_batch[:, input_ids_batch.shape[1] :],
                     skip_special_tokens=True,
@@ -257,7 +246,7 @@ class LogLevelCallback(TrainerCallback):
     A [`TrainerCallback`] that handles the default flow of the training loop for logs, evaluation and checkpoints.
     """
 
-    def __init__(self, global_step_args: Dict):
+    def __init__(self, global_step_args: dict):
         self.eval_first_step = global_step_args.get("eval_first_step", 0)
         self.actual_steps = global_step_args.get("actual_steps", 0)
         self.log_first_step = global_step_args.get("log_first_step", 0)
@@ -315,10 +304,7 @@ class LogLevelCallback(TrainerCallback):
             control.should_log = True
 
         # Evaluate
-        if (
-            args.eval_strategy == IntervalStrategy.EPOCH
-            and args.eval_delay <= state.epoch
-        ):
+        if args.eval_strategy == IntervalStrategy.EPOCH and args.eval_delay <= state.epoch:
             control.should_evaluate = True
 
         # Save

rapidfireai/ml/trainer.py

@@ -1,4 +1,3 @@
-import logging
 import math
 import os
 
@@ -7,11 +6,7 @@ from peft import LoraConfig, get_peft_model_state_dict, set_peft_model_state_dic
 from transformers.utils.logging import set_verbosity_error
 from trl import DPOConfig, DPOTrainer, GRPOConfig, GRPOTrainer, SFTConfig, SFTTrainer
 
-from rapidfireai.ml.callbacks import (
-    GenerationMetricsCallback,
-    MLflowLoggingCallback,
-    LogLevelCallback,
-)
+from rapidfireai.ml.callbacks import GenerationMetricsCallback, LogLevelCallback, MLflowLoggingCallback
 from rapidfireai.ml.checkpoint_utils import (
     ensure_gradient_compatibility,
     load_checkpoint_from_disk,
@@ -51,21 +46,15 @@ def create_trainer_instance(
     compute_metrics = additional_trainer_kwargs.get("compute_metrics", None)
 
     # Configure training arguments
-    training_args, global_step_args = _configure_training_args(
-        training_args, trainer_config
-    )
+    training_args, global_step_args = _configure_training_args(training_args, trainer_config)
     trainer_config_obj = _create_trainer_config_object(trainer_type, training_args)
     # check if peft params is empty dict
     is_peft = bool(config_leaf.get("peft_params"))
     # Load model and tokenizer
     if use_shared_memory:
-        model_instance, tokenizer = load_checkpoint_from_shared_memory(
-            trainer_config, shm_manager, is_peft=is_peft
-        )
+        model_instance, tokenizer = load_checkpoint_from_shared_memory(trainer_config, shm_manager, is_peft=is_peft)
     else:
-        model_instance, tokenizer = load_checkpoint_from_disk(
-            trainer_config, is_peft=is_peft
-        )
+        model_instance, tokenizer = load_checkpoint_from_disk(trainer_config, is_peft=is_peft)
     # add model name to model config
     config_leaf["model_name"] = model_instance.config._name_or_path
 
@@ -84,30 +73,26 @@ def create_trainer_instance(
 
     model_instance = model_instance.to(device)
 
-    trainer_kwargs, formatting_func, additional_trainer_kwargs = (
-        _prepare_trainer_kwargs(
-            model_instance,
-            trainer_config_obj,
-            tokenizer,
-            trainer_config,
-            additional_trainer_kwargs,
-            ref_model_instance,
-            config_leaf,
-        )
+    trainer_kwargs, formatting_func, additional_trainer_kwargs = _prepare_trainer_kwargs(
+        model_instance,
+        trainer_config_obj,
+        tokenizer,
+        trainer_config,
+        additional_trainer_kwargs,
+        ref_model_instance,
+        config_leaf,
     )
 
-    callbacks, additional_trainer_kwargs = (
-        _setup_callbacks(  # FIXME: avoid returning additional_trainer_kwargs
-            metric_logger,
-            trainer_config,
-            chunk_id,
-            compute_metrics,
-            additional_trainer_kwargs,
-            tokenizer,
-            training_args,
-            formatting_func,
-            global_step_args,
-        )
+    callbacks, additional_trainer_kwargs = _setup_callbacks(  # FIXME: avoid returning additional_trainer_kwargs
+        metric_logger,
+        trainer_config,
+        chunk_id,
+        compute_metrics,
+        additional_trainer_kwargs,
+        tokenizer,
+        training_args,
+        formatting_func,
+        global_step_args,
     )
 
     if callbacks:
@@ -116,29 +101,22 @@ def create_trainer_instance(
     trainer_kwargs.update(additional_trainer_kwargs)
     trainer_kwargs = {k: v for k, v in trainer_kwargs.items() if v is not None}
 
-    trainer = _create_trainer_by_type(
-        trainer_type, trainer_kwargs, trainer_config, use_shared_memory, shm_manager
-    )
+    trainer = _create_trainer_by_type(trainer_type, trainer_kwargs, trainer_config, use_shared_memory, shm_manager)
     return trainer, config_leaf["model_name"]
 
 
-def _configure_training_args(
-    training_args: dict, trainer_config: TrainerConfig
-) -> dict:
+def _configure_training_args(training_args: dict, trainer_config: TrainerConfig) -> dict:
     """Configure training arguments with default values."""
     completed_steps = trainer_config.completed_steps
     per_device_train_batch_size = training_args.get("per_device_train_batch_size", 1)
     gradient_accumulation_steps = training_args.get("gradient_accumulation_steps", 1)
-    len_dataloader = math.ceil(
-        trainer_config.train_dataset.num_rows / per_device_train_batch_size
-    )
+    len_dataloader = math.ceil(trainer_config.train_dataset.num_rows / per_device_train_batch_size)
     steps_per_epoch = max(
-        len_dataloader // gradient_accumulation_steps
-        + int(len_dataloader % gradient_accumulation_steps > 0),
+        len_dataloader // gradient_accumulation_steps + int(len_dataloader % gradient_accumulation_steps > 0),
         1,
     )
 
-    if trainer_config.config_leaf.get("trainer_type","SFT") == "GRPO":
+    if trainer_config.config_leaf.get("trainer_type", "SFT") == "GRPO":
         num_generations = training_args.get("num_generations", 8)
         steps_per_epoch = (num_generations * trainer_config.train_dataset.num_rows) // (
             gradient_accumulation_steps * per_device_train_batch_size
@@ -215,10 +193,7 @@ def _setup_reference_model(
         if model_adapter_name is not None and ref_adapter_name is not None:
             if use_shared_memory:
                 peft_config = LoraConfig(**config_leaf["peft_params"])
-                if (
-                    trainer_config.completed_steps == 0
-                    and trainer_config.warm_started_from is None
-                ):
+                if trainer_config.completed_steps == 0 and trainer_config.warm_started_from is None:
                     reference_state_dict = get_peft_model_state_dict(model_instance)
                     reference_state_dict = move_tensors_to_cpu(reference_state_dict)
                     shm_manager.save_model_object(
@@ -230,14 +205,10 @@ def _setup_reference_model(
                     reference_state_dict = shm_manager.load_model_object(
                         trainer_config.run_id, SHMObjectType.REF_STATE_DICT
                     )
-                    reference_state_dict = move_tensors_to_device(
-                        reference_state_dict, device
-                    )
+                    reference_state_dict = move_tensors_to_device(reference_state_dict, device)
                 model_instance.add_adapter(ref_adapter_name, peft_config)
                 model_instance.set_adapter(ref_adapter_name)
-                set_peft_model_state_dict(
-                    model_instance, reference_state_dict, adapter_name=ref_adapter_name
-                )
+                set_peft_model_state_dict(model_instance, reference_state_dict, adapter_name=ref_adapter_name)
                 model_instance.set_adapter(model_adapter_name)
             else:
                 base_run_path = DataPath.base_run_path(trainer_config.run_id)
@@ -289,9 +260,7 @@ def _prepare_trainer_kwargs(
 
     if additional_trainer_kwargs.get("formatting_func") is not None:
         formatting_func = additional_trainer_kwargs.get("formatting_func")
-        train_dataset = train_dataset.map(
-            formatting_func
-        )  # FIXME: add try exception with batched/unbatched
+        train_dataset = train_dataset.map(formatting_func)  # FIXME: add try exception with batched/unbatched
         if eval_dataset is not None:
             eval_dataset = eval_dataset.map(formatting_func)
         additional_trainer_kwargs_copy = additional_trainer_kwargs.copy()
@@ -337,10 +306,7 @@ def _setup_callbacks(
         )
         callbacks.append(mlflow_callback)
 
-    if (
-        compute_metrics is not None
-        and additional_trainer_kwargs.get("generation_config") is not None
-    ):
+    if compute_metrics is not None and additional_trainer_kwargs.get("generation_config") is not None:
         compute_metrics_function = compute_metrics
         if formatting_func is not None:
             formatted_eval_dataset = trainer_config.eval_dataset.map(formatting_func)
@@ -365,15 +331,11 @@ def _setup_callbacks(
     return callbacks, additional_trainer_kwargs
 
 
-def _create_trainer_by_type(
-    trainer_type, trainer_kwargs, trainer_config, use_shared_memory, shm_manager
-):
+def _create_trainer_by_type(trainer_type, trainer_kwargs, trainer_config, use_shared_memory, shm_manager):
     """Create trainer instance based on type with proper state restoration."""
     if trainer_type == "SFT":
         dummy_trainer = SFTTrainer(**trainer_kwargs)
-        dummy_trainer.create_optimizer_and_scheduler(
-            num_training_steps=trainer_config.total_steps
-        )
+        dummy_trainer.create_optimizer_and_scheduler(num_training_steps=trainer_config.total_steps)
         trainer = SFTTrainer(
             **trainer_kwargs,
             optimizers=(dummy_trainer.optimizer, dummy_trainer.lr_scheduler),
@@ -382,9 +344,7 @@ def _create_trainer_by_type(
 
     elif trainer_type == "DPO":
         dummy_trainer = DPOTrainer(**trainer_kwargs)
-        dummy_trainer.create_optimizer_and_scheduler(
-            num_training_steps=trainer_config.total_steps
-        )
+        dummy_trainer.create_optimizer_and_scheduler(num_training_steps=trainer_config.total_steps)
         trainer = DPOTrainer(
             **trainer_kwargs,
             optimizers=(dummy_trainer.optimizer, dummy_trainer.lr_scheduler),
@@ -393,9 +353,7 @@ def _create_trainer_by_type(
 
     elif trainer_type == "GRPO":
         dummy_trainer = GRPOTrainer(**trainer_kwargs)
-        dummy_trainer.create_optimizer_and_scheduler(
-            num_training_steps=trainer_config.total_steps
-        )
+        dummy_trainer.create_optimizer_and_scheduler(num_training_steps=trainer_config.total_steps)
         trainer = GRPOTrainer(
             **trainer_kwargs,
             optimizers=(dummy_trainer.optimizer, dummy_trainer.lr_scheduler),
@@ -406,9 +364,7 @@ def _create_trainer_by_type(
 
     if trainer_config.completed_steps > 0:
         if use_shared_memory:
-            trainer = restore_trainer_from_shared_memory(
-                trainer, trainer_config, shm_manager
-            )
+            trainer = restore_trainer_from_shared_memory(trainer, trainer_config, shm_manager)
         else:
             trainer = restore_trainer_from_disk(trainer, trainer_config)
 

rapidfireai/utils/constants.py

@@ -1,8 +1,9 @@
-from enum import Enum
 import os
+from enum import Enum
 
 MLFLOW_URL = "http://127.0.0.1:5002"
 
+
 # Tracking Backend Configuration
 def get_tracking_backend() -> str:
     """
@@ -17,6 +18,7 @@ def get_tracking_backend() -> str:
     backend = os.getenv("RF_TRACKING_BACKEND", "mlflow")
     return backend
 
+
 # Backwards compatibility: Keep constant but it will be stale if env var changes after import
 TRACKING_BACKEND = get_tracking_backend()  # Options: 'mlflow', 'tensorboard', 'both'
 TENSORBOARD_LOG_DIR = os.getenv("RF_TENSORBOARD_LOG_DIR", None)  # Default set by experiment path

rapidfireai/utils/interactive_controller.py

@@ -6,18 +6,14 @@ Provides UI controls for managing training runs similar to the frontend.
 import json
 import threading
 import time
-from typing import Any, Dict, Optional
 
 import requests
-from IPython.display import clear_output, display
+from IPython.display import display
 
 try:
     import ipywidgets as widgets
-except ImportError:
-    raise ImportError(
-        "ipywidgets is required for InteractiveController. "
-        "Install with: pip install ipywidgets"
-    )
+except ImportError as e:
+    raise ImportError("ipywidgets is required for InteractiveController. Install with: pip install ipywidgets") from e
 
 
 class InteractiveController:
@@ -25,8 +21,8 @@ class InteractiveController:
 
     def __init__(self, dispatcher_url: str = "http://127.0.0.1:8081"):
         self.dispatcher_url = dispatcher_url.rstrip("/")
-        self.run_id: Optional[int] = None
-        self.config: Optional[Dict] = None
+        self.run_id: int | None = None
+        self.config: dict | None = None
         self.status: str = "Unknown"
         self.chunk_number: int = 0
 
@@ -37,22 +33,16 @@ class InteractiveController:
         """Create ipywidgets UI components"""
         # Run selector
         self.run_selector = widgets.Dropdown(
-            options=[],
-            description='',
-            disabled=False,
-            layout=widgets.Layout(width='300px')
+            options=[], description="", disabled=False, layout=widgets.Layout(width="300px")
         )
         self.load_btn = widgets.Button(
-            description="Load Run",
-            button_style="primary",
-            tooltip="Load the selected run",
-            icon="download"
+            description="Load Run", button_style="primary", tooltip="Load the selected run", icon="download"
         )
         self.refresh_selector_btn = widgets.Button(
             description="Refresh List",
             button_style="info",
             tooltip="Refresh the list of available runs",
-            icon="refresh"
+            icon="refresh",
         )
 
         # Status display
@@ -67,12 +57,7 @@ class InteractiveController:
             tooltip="Resume this run",
             icon="play",
         )
-        self.stop_btn = widgets.Button(
-            description="Stop", 
-            button_style="danger", 
-            tooltip="Stop this run", 
-            icon="stop"
-        )
+        self.stop_btn = widgets.Button(description="Stop", button_style="danger", tooltip="Stop this run", icon="stop")
         self.delete_btn = widgets.Button(
             description="Delete",
             button_style="danger",
@@ -97,32 +82,28 @@ class InteractiveController:
             value=False,
             description="Warm Start (continue from previous checkpoint)",
             disabled=True,
-            style={'description_width': 'initial'},
-            layout=widgets.Layout(margin='10px 0px')
+            style={"description_width": "initial"},
+            layout=widgets.Layout(margin="10px 0px"),
         )
         self.clone_btn = widgets.Button(
             description="Clone",
             button_style="primary",
             tooltip="Clone this run with modifications",
         )
-        self.submit_clone_btn = widgets.Button(
-            description="✓ Submit Clone", button_style="success", disabled=True
-        )
-        self.cancel_clone_btn = widgets.Button(
-            description="✗ Cancel", button_style="", disabled=True
-        )
+        self.submit_clone_btn = widgets.Button(description="✓ Submit Clone", button_style="success", disabled=True)
+        self.cancel_clone_btn = widgets.Button(description="✗ Cancel", button_style="", disabled=True)
 
         # Status message box
         self.status_message = widgets.HTML(
-            value='',
+            value="",
             layout=widgets.Layout(
-                width='100%',
-                min_height='40px',
-                padding='10px',
-                margin='10px 0px',
-                border='2px solid #ddd',
-                border_radius='5px'
-            )
+                width="100%",
+                min_height="40px",
+                padding="10px",
+                margin="10px 0px",
+                border="2px solid #ddd",
+                border_radius="5px",
+            ),
         )
 
         # Experiment status display (live progress)
@@ -148,7 +129,7 @@ class InteractiveController:
         self.cancel_clone_btn.on_click(lambda b: self._handle_cancel_clone())
 
         # Auto-load run when dropdown selection changes
-        self.run_selector.observe(self._on_run_selected, names='value')
+        self.run_selector.observe(self._on_run_selected, names="value")
 
     def _show_message(self, message: str, message_type: str = "info"):
         """Display a status message with styling"""
@@ -156,23 +137,23 @@ class InteractiveController:
             "success": {"bg": "#d4edda", "border": "#28a745", "text": "#155724"},
             "error": {"bg": "#f8d7da", "border": "#dc3545", "text": "#721c24"},
             "info": {"bg": "#d1ecf1", "border": "#17a2b8", "text": "#0c5460"},
-            "warning": {"bg": "#fff3cd", "border": "#ffc107", "text": "#856404"}
+            "warning": {"bg": "#fff3cd", "border": "#ffc107", "text": "#856404"},
         }
 
         style = colors.get(message_type, colors["info"])
 
-        self.status_message.value = f'''
+        self.status_message.value = f"""
             <div style="
-                background-color: {style['bg']};
-                border: 2px solid {style['border']};
-                color: {style['text']};
+                background-color: {style["bg"]};
+                border: 2px solid {style["border"]};
+                color: {style["text"]};
                 padding: 10px;
                 border-radius: 5px;
                 font-weight: 600;
             ">
                 {message}
             </div>
-        '''
+        """
 
     def _update_experiment_status(self):
         """Update experiment status display with live progress"""
@@ -186,8 +167,8 @@ class InteractiveController:
 
             if runs:
                 total_runs = len(runs)
-                completed_runs = sum(1 for r in runs if r.get('status') == 'COMPLETED')
-                ongoing_runs = sum(1 for r in runs if r.get('status') == 'ONGOING')
+                completed_runs = sum(1 for r in runs if r.get("status") == "COMPLETED")
+                ongoing_runs = sum(1 for r in runs if r.get("status") == "ONGOING")
 
                 # Determine status color and icon
                 if completed_runs == total_runs:
@@ -212,16 +193,16 @@ class InteractiveController:
                 self.experiment_status.value = (
                     f'<div style="padding: 10px; background-color: {bg_color}; '
                     f'border: 2px solid {border_color}; border-radius: 5px; color: {text_color};">'
-                    f'<b>{icon} Experiment Status:</b> {status_text}<br>'
-                    f'<b>Progress:</b> {completed_runs}/{total_runs} runs completed'
-                    '</div>'
+                    f"<b>{icon} Experiment Status:</b> {status_text}<br>"
+                    f"<b>Progress:</b> {completed_runs}/{total_runs} runs completed"
+                    "</div>"
                 )
             else:
                 self.experiment_status.value = (
                     '<div style="padding: 10px; background-color: #f8f9fa; '
                     'border: 2px solid #dee2e6; border-radius: 5px;">'
-                    '<b>Experiment Status:</b> No runs found'
-                    '</div>'
+                    "<b>Experiment Status:</b> No runs found"
+                    "</div>"
                 )
 
         except requests.RequestException:
@@ -240,8 +221,7 @@ class InteractiveController:
 
             if runs:
                 # Create options as (label, value) tuples
-                options = [(f"Run {run['run_id']} - {run.get('status', 'Unknown')}", run['run_id'])
-                          for run in runs]
+                options = [(f"Run {run['run_id']} - {run.get('status', 'Unknown')}", run["run_id"]) for run in runs]
                 self.run_selector.options = options
                 self._show_message(f"Found {len(runs)} runs", "success")
             else:
@@ -257,8 +237,8 @@ class InteractiveController:
 
     def _on_run_selected(self, change):
         """Handle dropdown selection change - auto-load run"""
-        if change['new'] is not None:
-            self.load_run(change['new'])
+        if change["new"] is not None:
+            self.load_run(change["new"])
 
     def _handle_load(self):
         """Handle load button click"""
@@ -397,6 +377,7 @@ class InteractiveController:
 
             # Enable custom widget manager for ipywidgets to work in Colab
             from google.colab import output
+
             output.enable_custom_widget_manager()
         except ImportError:
             # Not in Colab, no action needed
@@ -455,9 +436,7 @@ class InteractiveController:
             ]
         )
 
-        actions = widgets.HBox(
-            [self.resume_btn, self.stop_btn, self.delete_btn, self.refresh_btn]
-        )
+        actions = widgets.HBox([self.resume_btn, self.stop_btn, self.delete_btn, self.refresh_btn])
 
         config_section = widgets.VBox(
             [

rapidfireai/utils/logging.py

@@ -1,7 +1,6 @@
 import os
 import threading
 from abc import ABC, abstractmethod
-from typing import Dict
 
 from loguru import logger
 
@@ -13,7 +12,7 @@ class BaseRFLogger(ABC):
     """Base class for RapidFire loggers"""
 
     _experiment_name = ""
-    _initialized_loggers: Dict[str, bool] = {}
+    _initialized_loggers: dict[str, bool] = {}
     _lock = threading.Lock()
 
     def __init__(self, level: str = "DEBUG"):

rapidfireai/utils/mlflow_manager.py

@@ -1,4 +1,5 @@
 """This module contains the MLflowManager class which is responsible for managing the MLflow runs."""
+
 import mlflow
 from mlflow.tracking import MlflowClient
 

rapidfireai/utils/ping.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python
-import socket
 import argparse
+import socket
+
 
 def ping_server(server: str, port: int, timeout=3):
-    """ping server:port """
+    """ping server:port"""
     try:
         socket.setdefaulttimeout(timeout)
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -14,6 +15,7 @@ def ping_server(server: str, port: int, timeout=3):
         s.close()
         return True
 
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Ping a server port")
     parser.add_argument("server", type=str, help="Server to ping")

rapidfireai/version.py

@@ -2,5 +2,5 @@
 Version information for RapidFire AI
 """
 
-__version__ = "0.10.3rc1"
-__version_info__ = (0, 10, "3rc1") 
+__version__ = "0.11.1rc2"
+__version_info__ = (0, 11, "1rc2") 

{rapidfireai-0.10.3rc1.dist-info → rapidfireai-0.11.1rc2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidfireai
-Version: 0.10.3rc1
+Version: 0.11.1rc2
 Summary: RapidFire AI: Rapid Experimentation Engine for Customizing LLMs
 Author-email: "RapidFire AI Inc." <support@rapidfire.ai>
 License: Apache-2.0