232 lines
7.1 KiB
Python
232 lines
7.1 KiB
Python
"""Configuration settings for AI Software Factory."""
|
|
|
|
import os
|
|
from typing import Optional
|
|
from pathlib import Path
|
|
from pydantic import Field
|
|
from pydantic_settings import BaseSettings, SettingsConfigDict
|
|
|
|
|
|
class Settings(BaseSettings):
|
|
"""Application settings loaded from environment variables."""
|
|
|
|
model_config = SettingsConfigDict(
|
|
env_file=".env",
|
|
env_file_encoding="utf-8",
|
|
extra="ignore",
|
|
)
|
|
|
|
# Server settings
|
|
HOST: str = "0.0.0.0"
|
|
PORT: int = 8000
|
|
LOG_LEVEL: str = "INFO"
|
|
|
|
# Ollama settings computed from environment
|
|
OLLAMA_URL: str = "http://ollama:11434"
|
|
OLLAMA_MODEL: str = "llama3"
|
|
|
|
# Gitea settings
|
|
GITEA_URL: str = "https://gitea.yourserver.com"
|
|
GITEA_TOKEN: str = ""
|
|
GITEA_OWNER: str = "ai-software-factory"
|
|
GITEA_REPO: str = ""
|
|
|
|
# n8n settings
|
|
N8N_WEBHOOK_URL: str = ""
|
|
N8N_API_URL: str = ""
|
|
N8N_API_KEY: str = ""
|
|
N8N_TELEGRAM_CREDENTIAL_NAME: str = "AI Software Factory Telegram"
|
|
N8N_USER: str = ""
|
|
N8N_PASSWORD: str = ""
|
|
|
|
# Runtime integration settings
|
|
BACKEND_PUBLIC_URL: str = "http://localhost:8000"
|
|
PROJECTS_ROOT: str = ""
|
|
|
|
# Telegram settings
|
|
TELEGRAM_BOT_TOKEN: str = ""
|
|
TELEGRAM_CHAT_ID: str = ""
|
|
|
|
# PostgreSQL settings
|
|
POSTGRES_HOST: str = "localhost"
|
|
POSTGRES_PORT: int = 5432
|
|
POSTGRES_USER: str = "postgres"
|
|
POSTGRES_PASSWORD: str = ""
|
|
POSTGRES_DB: str = "ai_software_factory"
|
|
POSTGRES_TEST_DB: str = "ai_software_factory_test"
|
|
POSTGRES_URL: Optional[str] = None # Optional direct PostgreSQL connection URL
|
|
|
|
# SQLite settings for testing
|
|
USE_SQLITE: bool = True # Enable SQLite by default for testing
|
|
SQLITE_DB_PATH: str = "sqlite.db"
|
|
|
|
# Database connection pool settings (only for PostgreSQL)
|
|
DB_POOL_SIZE: int = 10
|
|
DB_MAX_OVERFLOW: int = 20
|
|
DB_POOL_RECYCLE: int = 3600
|
|
DB_POOL_TIMEOUT: int = 30
|
|
|
|
@property
|
|
def postgres_url(self) -> str:
|
|
"""Get PostgreSQL URL with trimmed whitespace."""
|
|
return (self.POSTGRES_URL or "").strip()
|
|
|
|
@property
|
|
def postgres_env_configured(self) -> bool:
|
|
"""Whether PostgreSQL was explicitly configured via environment variables."""
|
|
if self.postgres_url:
|
|
return True
|
|
postgres_env_keys = (
|
|
"POSTGRES_HOST",
|
|
"POSTGRES_PORT",
|
|
"POSTGRES_USER",
|
|
"POSTGRES_PASSWORD",
|
|
"POSTGRES_DB",
|
|
)
|
|
return any(bool(os.environ.get(key, "").strip()) for key in postgres_env_keys)
|
|
|
|
@property
|
|
def use_sqlite(self) -> bool:
|
|
"""Whether SQLite should be used as the active database backend."""
|
|
if not self.USE_SQLITE:
|
|
return False
|
|
return not self.postgres_env_configured
|
|
|
|
@property
|
|
def pool(self) -> dict:
|
|
"""Get database pool configuration."""
|
|
return {
|
|
"pool_size": self.DB_POOL_SIZE,
|
|
"max_overflow": self.DB_MAX_OVERFLOW,
|
|
"pool_recycle": self.DB_POOL_RECYCLE,
|
|
"pool_timeout": self.DB_POOL_TIMEOUT
|
|
}
|
|
|
|
@property
|
|
def database_url(self) -> str:
|
|
"""Get database connection URL."""
|
|
if self.use_sqlite:
|
|
return f"sqlite:///{self.SQLITE_DB_PATH}"
|
|
if self.postgres_url:
|
|
return self.postgres_url
|
|
return (
|
|
f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}"
|
|
f"@{self.POSTGRES_HOST}:{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
|
|
)
|
|
|
|
@property
|
|
def test_database_url(self) -> str:
|
|
"""Get test database connection URL."""
|
|
if self.use_sqlite:
|
|
return f"sqlite:///{self.SQLITE_DB_PATH}"
|
|
if self.postgres_url:
|
|
return self.postgres_url
|
|
return (
|
|
f"postgresql://{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}"
|
|
f"@{self.POSTGRES_HOST}:{self.POSTGRES_PORT}/{self.POSTGRES_TEST_DB}"
|
|
)
|
|
|
|
@property
|
|
def ollama_url(self) -> str:
|
|
"""Get Ollama URL with trimmed whitespace."""
|
|
return self.OLLAMA_URL.strip()
|
|
|
|
@property
|
|
def gitea_url(self) -> str:
|
|
"""Get Gitea URL with trimmed whitespace."""
|
|
return self.GITEA_URL.strip()
|
|
|
|
@property
|
|
def gitea_token(self) -> str:
|
|
"""Get Gitea token with trimmed whitespace."""
|
|
return self.GITEA_TOKEN.strip()
|
|
|
|
@property
|
|
def gitea_owner(self) -> str:
|
|
"""Get Gitea owner/organization with trimmed whitespace."""
|
|
return self.GITEA_OWNER.strip()
|
|
|
|
@property
|
|
def gitea_repo(self) -> str:
|
|
"""Get the optional fixed Gitea repository name with trimmed whitespace."""
|
|
return self.GITEA_REPO.strip()
|
|
|
|
@property
|
|
def use_project_repositories(self) -> bool:
|
|
"""Whether the service should create one repository per generated project."""
|
|
return not bool(self.gitea_repo)
|
|
|
|
@property
|
|
def n8n_webhook_url(self) -> str:
|
|
"""Get n8n webhook URL with trimmed whitespace."""
|
|
return self.N8N_WEBHOOK_URL.strip()
|
|
|
|
@property
|
|
def n8n_api_url(self) -> str:
|
|
"""Get n8n API URL with trimmed whitespace."""
|
|
return self.N8N_API_URL.strip()
|
|
|
|
@property
|
|
def n8n_api_key(self) -> str:
|
|
"""Get n8n API key with trimmed whitespace."""
|
|
return self.N8N_API_KEY.strip()
|
|
|
|
@property
|
|
def n8n_telegram_credential_name(self) -> str:
|
|
"""Get the preferred n8n Telegram credential name."""
|
|
return self.N8N_TELEGRAM_CREDENTIAL_NAME.strip() or "AI Software Factory Telegram"
|
|
|
|
@property
|
|
def telegram_bot_token(self) -> str:
|
|
"""Get Telegram bot token with trimmed whitespace."""
|
|
return self.TELEGRAM_BOT_TOKEN.strip()
|
|
|
|
@property
|
|
def telegram_chat_id(self) -> str:
|
|
"""Get Telegram chat ID with trimmed whitespace."""
|
|
return self.TELEGRAM_CHAT_ID.strip()
|
|
|
|
@property
|
|
def backend_public_url(self) -> str:
|
|
"""Get backend public URL with trimmed whitespace."""
|
|
return self.BACKEND_PUBLIC_URL.strip().rstrip("/")
|
|
|
|
@property
|
|
def projects_root(self) -> Path:
|
|
"""Get the root directory for generated project artifacts."""
|
|
if self.PROJECTS_ROOT.strip():
|
|
return Path(self.PROJECTS_ROOT).expanduser().resolve()
|
|
return Path(__file__).resolve().parent.parent / "test-project"
|
|
|
|
@property
|
|
def postgres_host(self) -> str:
|
|
"""Get PostgreSQL host."""
|
|
return self.POSTGRES_HOST.strip()
|
|
|
|
@property
|
|
def postgres_port(self) -> int:
|
|
"""Get PostgreSQL port as integer."""
|
|
return int(self.POSTGRES_PORT)
|
|
|
|
@property
|
|
def postgres_user(self) -> str:
|
|
"""Get PostgreSQL user."""
|
|
return self.POSTGRES_USER.strip()
|
|
|
|
@property
|
|
def postgres_password(self) -> str:
|
|
"""Get PostgreSQL password."""
|
|
return self.POSTGRES_PASSWORD.strip()
|
|
|
|
@property
|
|
def postgres_db(self) -> str:
|
|
"""Get PostgreSQL database name."""
|
|
return self.POSTGRES_DB.strip()
|
|
|
|
@property
|
|
def postgres_test_db(self) -> str:
|
|
"""Get test PostgreSQL database name."""
|
|
return self.POSTGRES_TEST_DB.strip()
|
|
|
|
# Create instance for module-level access
|
|
settings = Settings() |