fix(config): use single (renamed) settings

Author: dineshpinto

src/flare_ai_consensus/config.py

@@ -1,11 +1,7 @@
 from .aggregator import async_centralized_llm_aggregator, centralized_llm_aggregator
-from .config import AggregatorConfig, ConsensusConfig, ModelConfig
 from .consensus import send_round
 
 __all__ = [
-    "AggregatorConfig",
-    "ConsensusConfig",
-    "ModelConfig",
     "async_centralized_llm_aggregator",
     "centralized_llm_aggregator",
     "send_round",

src/flare_ai_consensus/consensus/__init__.py

@@ -1,13 +1,12 @@
-from flare_ai_consensus.consensus.config import AggregatorConfig
 from flare_ai_consensus.router import (
     AsyncOpenRouterProvider,
     ChatRequest,
-    Message,
     OpenRouterProvider,
 )
+from flare_ai_consensus.settings import AggregatorConfig, Message
 
 
-def concatenate_aggregator(responses: dict[str, str]) -> str:
+def _concatenate_aggregator(responses: dict[str, str]) -> str:
     """
     Aggregate responses by concatenating each model's answer with a label.
 
@@ -35,7 +34,7 @@ def centralized_llm_aggregator(
     messages.extend(aggregator_config.context)
 
     # Add a system message with the aggregated responses.
-    aggregated_str = concatenate_aggregator(aggregated_responses)
+    aggregated_str = _concatenate_aggregator(aggregated_responses)
     messages.append(
         {"role": "system", "content": f"Aggregated responses:\n{aggregated_str}"}
     )

src/flare_ai_consensus/consensus/aggregator.py

@@ -2,14 +2,14 @@
 
 import structlog
 
-from flare_ai_consensus.consensus.config import ConsensusConfig, ModelConfig
-from flare_ai_consensus.router import AsyncOpenRouterProvider, ChatRequest, Message
+from flare_ai_consensus.router import AsyncOpenRouterProvider, ChatRequest
+from flare_ai_consensus.settings import ConsensusConfig, Message, ModelConfig
 from flare_ai_consensus.utils import parse_chat_response
 
 logger = structlog.get_logger(__name__)
 
 
-def build_improvement_conversation(
+def _build_improvement_conversation(
     consensus_config: ConsensusConfig, aggregated_response: str
 ) -> list[Message]:
     """Build an updated conversation using the consensus configuration.
@@ -35,7 +35,7 @@ def build_improvement_conversation(
     return conversation
 
 
-async def get_response_for_model(
+async def _get_response_for_model(
     provider: AsyncOpenRouterProvider,
     consensus_config: ConsensusConfig,
     model: ModelConfig,
@@ -57,7 +57,7 @@ async def get_response_for_model(
         logger.info("sending initial prompt", model_id=model.model_id)
     else:
         # Build the improvement conversation.
-        conversation = build_improvement_conversation(
+        conversation = _build_improvement_conversation(
             consensus_config, aggregated_response
         )
         logger.info("sending improvement prompt", model_id=model.model_id)
@@ -89,7 +89,7 @@ async def send_round(
     :return: A dictionary mapping model IDs to their response texts.
     """
     tasks = [
-        get_response_for_model(provider, consensus_config, model, aggregated_response)
+        _get_response_for_model(provider, consensus_config, model, aggregated_response)
         for model in consensus_config.models
     ]
     results = await asyncio.gather(*tasks)

src/flare_ai_consensus/consensus/config.py

@@ -2,13 +2,12 @@
 
 import structlog
 
-from flare_ai_consensus.config import config
 from flare_ai_consensus.consensus import (
-    ConsensusConfig,
     async_centralized_llm_aggregator,
     send_round,
 )
 from flare_ai_consensus.router import AsyncOpenRouterProvider
+from flare_ai_consensus.settings import ConsensusConfig, settings
 from flare_ai_consensus.utils import load_json, save_json
 
 logger = structlog.get_logger(__name__)
@@ -56,7 +55,7 @@ async def run_consensus(
         response_data[f"aggregate_{i + 1}"] = aggregated_response
 
     # Step 3: Save final consensus.
-    output_file = config.data_path / "final_consensus.json"
+    output_file = settings.data_path / "final_consensus.json"
     save_json(
         response_data,
         output_file,
@@ -69,16 +68,17 @@ async def run_consensus(
 
 def main() -> None:
     # Load the consensus configuration from input.json
-    config_json = load_json(config.input_path / "input.json")
-    consensus_config = ConsensusConfig.load_parameters(config_json)
+    config_json = load_json(settings.input_path / "input.json")
+    settings.load_consensus_config(config_json)
 
     # Initialize the OpenRouter provider.
     provider = AsyncOpenRouterProvider(
-        api_key=config.open_router_api_key, base_url=config.open_router_base_url
+        api_key=settings.open_router_api_key, base_url=settings.open_router_base_url
     )
 
     # Run the consensus learning process with synchronous requests.
-    asyncio.run(run_consensus(provider, consensus_config))
+    if settings.consensus_config:
+        asyncio.run(run_consensus(provider, settings.consensus_config))
 
 
 if __name__ == "__main__":

src/flare_ai_consensus/consensus/consensus.py

@@ -1,10 +1,9 @@
-from .base_router import ChatRequest, CompletionRequest, Message
+from .base_router import ChatRequest, CompletionRequest
 from .openrouter import AsyncOpenRouterProvider, OpenRouterProvider
 
 __all__ = [
     "AsyncOpenRouterProvider",
     "ChatRequest",
     "CompletionRequest",
-    "Message",
     "OpenRouterProvider",
 ]

src/flare_ai_consensus/main.py

@@ -1,8 +1,10 @@
-from typing import Any, Literal, TypedDict
+from typing import Any, TypedDict
 
 import httpx
 import requests
 
+from flare_ai_consensus.settings import Message
+
 
 class CompletionRequest(TypedDict):
     model: str
@@ -11,11 +13,6 @@ class CompletionRequest(TypedDict):
     temperature: float
 
 
-class Message(TypedDict):
-    role: Literal["user", "assistant", "system"]
-    content: str
-
-
 class ChatRequest(TypedDict):
     model: str
     messages: list[Message]

src/flare_ai_consensus/router/__init__.py

@@ -0,0 +1,120 @@
+from pathlib import Path
+from typing import Literal, TypedDict
+
+import structlog
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+logger = structlog.get_logger(__name__)
+
+
+def create_path(folder_name: str) -> Path:
+    """Creates and returns a path for storing data or logs."""
+    path = Path(__file__).parent.resolve().parent / f"{folder_name}"
+    path.mkdir(exist_ok=True)
+    return path
+
+
+class Message(TypedDict):
+    role: str
+    content: str
+
+
+class ModelConfig(BaseModel):
+    """Configuration for individual models"""
+
+    model_id: str
+    max_tokens: int = 50
+    temperature: float = 0.7
+
+
+class AggregatorConfig(BaseModel):
+    """Configuration for the aggregator"""
+
+    model: ModelConfig
+    approach: str
+    context: list[Message]
+    prompt: list[Message]
+
+
+class ConsensusConfig(BaseModel):
+    """Configuration for the consensus mechanism"""
+
+    models: list[ModelConfig]
+    aggregator_config: AggregatorConfig
+    initial_prompt: list[Message]
+    improvement_prompt: str
+    iterations: int
+    aggregated_prompt_type: Literal["user", "assistant", "system"]
+
+    @classmethod
+    def from_json(cls, json_data: dict) -> "ConsensusConfig":
+        """Create ConsensusConfig from JSON data"""
+        # Parse the list of models
+        models = [
+            ModelConfig(
+                model_id=m["id"],
+                max_tokens=m["max_tokens"],
+                temperature=m["temperature"],
+            )
+            for m in json_data.get("models", [])
+        ]
+
+        # Parse the aggregator configuration
+        aggr_data = json_data.get("aggregator", [])[0]
+        aggr_model_data = aggr_data.get("model", {})
+        aggregator_model = ModelConfig(
+            model_id=aggr_model_data["id"],
+            max_tokens=aggr_model_data["max_tokens"],
+            temperature=aggr_model_data["temperature"],
+        )
+
+        aggregator_config = AggregatorConfig(
+            model=aggregator_model,
+            approach=aggr_data.get("approach", ""),
+            context=aggr_data.get("aggregator_context", []),
+            prompt=aggr_data.get("aggregator_prompt", []),
+        )
+
+        return cls(
+            models=models,
+            aggregator_config=aggregator_config,
+            initial_prompt=json_data.get("initial_conversation", []),
+            improvement_prompt=json_data.get("improvement_prompt", ""),
+            iterations=json_data.get("iterations", 1),
+            aggregated_prompt_type=json_data.get("aggregated_prompt_type", "system"),
+        )
+
+
+class Settings(BaseSettings):
+    """
+    Application settings model that provides configuration for all components.
+    Combines both infrastructure and consensus settings.
+    """
+
+    # OpenRouter Settings
+    open_router_base_url: str = "https://openrouter.ai/api/v1"
+    open_router_api_key: str = ""
+
+    # Path Settings
+    data_path: Path = create_path("data")
+    input_path: Path = create_path("flare_ai_consensus")
+
+    # Consensus Settings
+    consensus_config: ConsensusConfig | None = None
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    def load_consensus_config(self, json_data: dict) -> None:
+        """Load consensus configuration from JSON data"""
+        self.consensus_config = ConsensusConfig.from_json(json_data)
+        logger.info("loaded consensus configuration")
+
+
+# Create a global settings instance
+settings = Settings()
+logger.debug("settings initialized", settings=settings.model_dump())