Delete settings.py

settings.py

@@ -1,222 +0,0 @@
-from enum import Enum
-from json import loads
-from typing import Annotated, Any
-
-from dotenv import find_dotenv
-from pydantic import (
-    BeforeValidator,
-    Field,
-    HttpUrl,
-    SecretStr,
-    TypeAdapter,
-    computed_field,
-)
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from models import (
-    AllModelEnum,
-    AnthropicModelName,
-    AWSModelName,
-    AzureOpenAIModelName,
-    DeepseekModelName,
-    FakeModelName,
-    GoogleModelName,
-    GroqModelName,
-    OllamaModelName,
-    OpenAICompatibleName,
-    OpenAIModelName,
-    Provider,
-    VertexAIModelName,
-)
-
-
-# Create a compatible StrEnum alternative for Python 3.10
-class DatabaseType(str, Enum):
-    SQLITE = "sqlite"
-    POSTGRES = "postgres"
-    MONGO = "mongo"
-
-
-def check_str_is_http(x: str) -> str:
-    http_url_adapter = TypeAdapter(HttpUrl)
-    return str(http_url_adapter.validate_python(x))
-
-
-class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_file=find_dotenv(),
-        env_file_encoding="utf-8",
-        env_ignore_empty=True,
-        extra="ignore",
-        validate_default=False,
-    )
-    MODE: str | None = None
-
-    HOST: str = "0.0.0.0"
-    PORT: int = 8080
-
-    AUTH_SECRET: SecretStr | None = None
-
-    OPENAI_API_KEY: SecretStr | None = None
-    DEEPSEEK_API_KEY: SecretStr | None = None
-    ANTHROPIC_API_KEY: SecretStr | None = None
-    GOOGLE_API_KEY: SecretStr | None = None
-    GOOGLE_APPLICATION_CREDENTIALS: SecretStr | None = None
-    GROQ_API_KEY: SecretStr | None = None
-    USE_AWS_BEDROCK: bool = False
-    OLLAMA_MODEL: str | None = None
-    OLLAMA_BASE_URL: str | None = None
-    USE_FAKE_MODEL: bool = True  # Set to True by default for testing without API keys
-
-    # If DEFAULT_MODEL is None, it will be set in model_post_init
-    DEFAULT_MODEL: AllModelEnum | None = None  # type: ignore[assignment]
-    AVAILABLE_MODELS: set[AllModelEnum] = set()  # type: ignore[assignment]
-
-    # Set openai compatible api, mainly used for proof of concept
-    COMPATIBLE_MODEL: str | None = None
-    COMPATIBLE_API_KEY: SecretStr | None = None
-    COMPATIBLE_BASE_URL: str | None = None
-
-    OPENWEATHERMAP_API_KEY: SecretStr | None = None
-
-    LANGCHAIN_TRACING_V2: bool = False
-    LANGCHAIN_PROJECT: str = "default"
-    LANGCHAIN_ENDPOINT: Annotated[str, BeforeValidator(check_str_is_http)] = (
-        "https://api.smith.langchain.com"
-    )
-    LANGCHAIN_API_KEY: SecretStr | None = None
-
-    # Database Configuration
-    DATABASE_TYPE: DatabaseType = (
-        DatabaseType.SQLITE
-    )  # Options: DatabaseType.SQLITE or DatabaseType.POSTGRES
-    SQLITE_DB_PATH: str = "checkpoints.db"
-
-    # PostgreSQL Configuration
-    POSTGRES_USER: str | None = None
-    POSTGRES_PASSWORD: SecretStr | None = None
-    POSTGRES_HOST: str | None = None
-    POSTGRES_PORT: int | None = None
-    POSTGRES_DB: str | None = None
-
-    # MongoDB Configuration
-    MONGO_HOST: str | None = None
-    MONGO_PORT: int | None = None
-    MONGO_DB: str | None = None
-    MONGO_USER: str | None = None
-    MONGO_PASSWORD: SecretStr | None = None
-    MONGO_AUTH_SOURCE: str | None = None
-
-    # Azure OpenAI Settings
-    AZURE_OPENAI_API_KEY: SecretStr | None = None
-    AZURE_OPENAI_ENDPOINT: str | None = None
-    AZURE_OPENAI_API_VERSION: str = "2024-02-15-preview"
-    AZURE_OPENAI_DEPLOYMENT_MAP: dict[str, str] = Field(
-        default_factory=dict, description="Map of model names to Azure deployment IDs"
-    )
-
-    def model_post_init(self, __context: Any) -> None:
-        api_keys = {
-            Provider.OPENAI: self.OPENAI_API_KEY,
-            Provider.OPENAI_COMPATIBLE: self.COMPATIBLE_BASE_URL and self.COMPATIBLE_MODEL,
-            Provider.DEEPSEEK: self.DEEPSEEK_API_KEY,
-            Provider.ANTHROPIC: self.ANTHROPIC_API_KEY,
-            Provider.GOOGLE: self.GOOGLE_API_KEY,
-            Provider.VERTEXAI: self.GOOGLE_APPLICATION_CREDENTIALS,
-            Provider.GROQ: self.GROQ_API_KEY,
-            Provider.AWS: self.USE_AWS_BEDROCK,
-            Provider.OLLAMA: self.OLLAMA_MODEL,
-            Provider.FAKE: self.USE_FAKE_MODEL,
-            Provider.AZURE_OPENAI: self.AZURE_OPENAI_API_KEY,
-        }
-        active_keys = [k for k, v in api_keys.items() if v]
-        
-        # Use fake model when no API keys are available
-        if not active_keys:
-            print("No LLM API keys provided. Using fake model for testing purposes.")
-            self.USE_FAKE_MODEL = True
-            active_keys = [Provider.FAKE]
-
-        for provider in active_keys:
-            match provider:
-                case Provider.OPENAI:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = OpenAIModelName.GPT_4O_MINI
-                    self.AVAILABLE_MODELS.update(set(OpenAIModelName))
-                case Provider.OPENAI_COMPATIBLE:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = OpenAICompatibleName.OPENAI_COMPATIBLE
-                    self.AVAILABLE_MODELS.update(set(OpenAICompatibleName))
-                case Provider.DEEPSEEK:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = DeepseekModelName.DEEPSEEK_CHAT
-                    self.AVAILABLE_MODELS.update(set(DeepseekModelName))
-                case Provider.ANTHROPIC:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = AnthropicModelName.HAIKU_3
-                    self.AVAILABLE_MODELS.update(set(AnthropicModelName))
-                case Provider.GOOGLE:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = GoogleModelName.GEMINI_20_FLASH
-                    self.AVAILABLE_MODELS.update(set(GoogleModelName))
-                case Provider.VERTEXAI:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = VertexAIModelName.GEMINI_20_FLASH
-                    self.AVAILABLE_MODELS.update(set(VertexAIModelName))
-                case Provider.GROQ:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = GroqModelName.LLAMA_31_8B
-                    self.AVAILABLE_MODELS.update(set(GroqModelName))
-                case Provider.AWS:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = AWSModelName.BEDROCK_HAIKU
-                    self.AVAILABLE_MODELS.update(set(AWSModelName))
-                case Provider.OLLAMA:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = OllamaModelName.OLLAMA_GENERIC
-                    self.AVAILABLE_MODELS.update(set(OllamaModelName))
-                case Provider.FAKE:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = FakeModelName.FAKE
-                    self.AVAILABLE_MODELS.update(set(FakeModelName))
-                case Provider.AZURE_OPENAI:
-                    if self.DEFAULT_MODEL is None:
-                        self.DEFAULT_MODEL = AzureOpenAIModelName.AZURE_GPT_4O_MINI
-                    self.AVAILABLE_MODELS.update(set(AzureOpenAIModelName))
-                    # Validate Azure OpenAI settings if Azure provider is available
-                    if not self.AZURE_OPENAI_API_KEY:
-                        raise ValueError("AZURE_OPENAI_API_KEY must be set")
-                    if not self.AZURE_OPENAI_ENDPOINT:
-                        raise ValueError("AZURE_OPENAI_ENDPOINT must be set")
-                    if not self.AZURE_OPENAI_DEPLOYMENT_MAP:
-                        raise ValueError("AZURE_OPENAI_DEPLOYMENT_MAP must be set")
-
-                    # Parse deployment map if it's a string
-                    if isinstance(self.AZURE_OPENAI_DEPLOYMENT_MAP, str):
-                        try:
-                            self.AZURE_OPENAI_DEPLOYMENT_MAP = loads(
-                                self.AZURE_OPENAI_DEPLOYMENT_MAP
-                            )
-                        except Exception as e:
-                            raise ValueError(f"Invalid AZURE_OPENAI_DEPLOYMENT_MAP JSON: {e}")
-
-                    # Validate required deployments exist
-                    required_models = {"gpt-4o", "gpt-4o-mini"}
-                    missing_models = required_models - set(self.AZURE_OPENAI_DEPLOYMENT_MAP.keys())
-                    if missing_models:
-                        raise ValueError(f"Missing required Azure deployments: {missing_models}")
-                case _:
-                    raise ValueError(f"Unknown provider: {provider}")
-
-    @computed_field  # type: ignore[prop-decorator]
-    @property
-    def BASE_URL(self) -> str:
-        return f"http://{self.HOST}:{self.PORT}"
-
-    @computed_field  # type: ignore[prop-decorator]
-    @property
-    def is_dev(self) -> bool:
-        return self.MODE and self.MODE.lower() == "dev"
-
-
-settings = Settings()