local-openai2anthropic 0.3.6__tar.gz → 0.3.7__tar.gz

{local_openai2anthropic-0.3.6 → local_openai2anthropic-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: local-openai2anthropic
-Version: 0.3.6
+Version: 0.3.7
 Summary: A lightweight proxy server that converts Anthropic Messages API to OpenAI API
 Project-URL: Homepage, https://github.com/dongfangzan/local-openai2anthropic
 Project-URL: Repository, https://github.com/dongfangzan/local-openai2anthropic
@@ -24,7 +24,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: openai>=1.30.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.0.0
-Requires-Dist: tomli>=2.0.0; python_version < '3.11'
+Requires-Dist: tomli-w>=1.0.0
 Requires-Dist: uvicorn[standard]>=0.23.0
 Provides-Extra: dev
 Requires-Dist: black>=23.0.0; extra == 'dev'

{local_openai2anthropic-0.3.6 → local_openai2anthropic-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "local-openai2anthropic"
-version = "0.3.6"
+version = "0.3.7"
 description = "A lightweight proxy server that converts Anthropic Messages API to OpenAI API"
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -29,7 +29,7 @@ dependencies = [
     "pydantic-settings>=2.0.0",
     "anthropic>=0.30.0",
     "openai>=1.30.0",
-    "tomli>=2.0.0; python_version<'3.11'",
+    "tomli-w>=1.0.0",
 ]
 
 [project.optional-dependencies]

{local_openai2anthropic-0.3.6 → local_openai2anthropic-0.3.7}/src/local_openai2anthropic/__init__.py

@@ -3,7 +3,7 @@
 local-openai2anthropic: A proxy server that converts Anthropic Messages API to OpenAI API.
 """
 
-__version__ = "0.3.6"
+__version__ = "0.3.7"
 
 from local_openai2anthropic.protocol import (
     AnthropicError,

local_openai2anthropic-0.3.7/src/local_openai2anthropic/config.py

@@ -0,0 +1,328 @@
+# SPDX-License-Identifier: Apache-2.0
+"""
+Configuration settings for the proxy server.
+"""
+
+import sys
+from functools import lru_cache
+from pathlib import Path
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+def get_config_dir() -> Path:
+    """Get platform-specific config directory.
+
+    Returns:
+        Path to the config directory (~/.oa2a)
+    """
+    return Path.home() / ".oa2a"
+
+
+def get_config_file() -> Path:
+    """Get config file path.
+
+    Returns:
+        Path to the config file (~/.oa2a/config.toml)
+    """
+    return get_config_dir() / "config.toml"
+
+
+def create_default_config() -> bool:
+    """Create default config file if not exists.
+
+    Returns:
+        True if a new config file was created, False if it already exists
+    """
+    config_file = get_config_file()
+    if config_file.exists():
+        return False
+
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Set restrictive permissions (0o600) for the config directory on Unix-like systems
+    if sys.platform != "win32":
+        config_dir.chmod(0o700)
+
+    default_config = """# OA2A Configuration File
+# Place this file at ~/.oa2a/config.toml
+
+# OpenAI API Configuration
+openai_api_key = ""
+openai_base_url = "https://api.openai.com/v1"
+openai_org_id = ""
+openai_project_id = ""
+
+# Server Configuration
+host = "0.0.0.0"
+port = 8080
+request_timeout = 300.0
+
+# API Key for authenticating requests to this server (optional)
+api_key = ""
+
+# CORS settings
+cors_origins = ["*"]
+cors_credentials = true
+cors_methods = ["*"]
+cors_headers = ["*"]
+
+# Logging
+log_level = "INFO"
+log_dir = ""  # Empty uses platform-specific default
+
+# Tavily Web Search Configuration
+tavily_api_key = ""
+tavily_timeout = 30.0
+tavily_max_results = 5
+websearch_max_uses = 5
+"""
+    config_file.write_text(default_config, encoding="utf-8")
+
+    # Set restrictive permissions (0o600) for the config file on Unix-like systems
+    if sys.platform != "win32":
+        config_file.chmod(0o600)
+
+    return True
+
+
+def interactive_setup() -> dict:
+    """Interactive configuration setup wizard.
+
+    Guides user through setting up essential configuration values.
+
+    Returns:
+        Dictionary containing user-provided configuration
+    """
+    print("=" * 60)
+    print("  Welcome to local-openai2anthropic Setup Wizard")
+    print("=" * 60)
+    print()
+    print("This wizard will help you create the initial configuration.")
+    print(f"Config file will be saved to: {get_config_file()}")
+    print()
+
+    config = {}
+
+    # OpenAI API Key (required)
+    print("[1/3] OpenAI API Configuration")
+    print("-" * 40)
+    while True:
+        api_key = input("Enter your OpenAI API Key (required): ").strip()
+        if api_key:
+            config["openai_api_key"] = api_key
+            break
+        print("API Key is required. Please enter a valid key.")
+
+    # Base URL (optional, with default)
+    default_url = "https://api.openai.com/v1"
+    base_url = input(f"Enter OpenAI Base URL [{default_url}]: ").strip()
+    config["openai_base_url"] = base_url if base_url else default_url
+
+    print()
+    print("[2/3] Server Configuration")
+    print("-" * 40)
+
+    # Host (with default)
+    default_host = "0.0.0.0"
+    host = input(f"Enter server host [{default_host}]: ").strip()
+    config["host"] = host if host else default_host
+
+    # Port (with default)
+    default_port = "8080"
+    port_input = input(f"Enter server port [{default_port}]: ").strip()
+    try:
+        config["port"] = int(port_input) if port_input else int(default_port)
+    except ValueError:
+        print(f"Invalid port number, using default: {default_port}")
+        config["port"] = int(default_port)
+
+    # API Key for server authentication (optional)
+    print()
+    print("[3/3] Server API Authentication (Optional)")
+    print("-" * 40)
+    print("Set an API key to authenticate requests to this server.")
+    print(
+        "Leave empty to allow unauthenticated access (not recommended for production)."
+    )
+    server_api_key = input("Enter server API key (optional): ").strip()
+    if server_api_key:
+        config["api_key"] = server_api_key
+
+    print()
+    print("=" * 60)
+    print("  Configuration Summary")
+    print("=" * 60)
+    print(f"OpenAI Base URL: {config.get('openai_base_url', default_url)}")
+    print(
+        f"Server: {config.get('host', default_host)}:{config.get('port', default_port)}"
+    )
+    print(f"OpenAI API Key: {config.get('openai_api_key', '')[:8]}... (configured)")
+    if config.get("api_key"):
+        print(f"Server Auth: {config['api_key'][:8]}... (configured)")
+    print()
+
+    return config
+
+
+def create_config_from_dict(config: dict) -> None:
+    """Create config file from dictionary.
+
+    Args:
+        config: Dictionary containing configuration values
+    """
+    import tomli_w
+
+    config_file = get_config_file()
+    config_dir = get_config_dir()
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    # Set restrictive permissions for the config directory on Unix-like systems
+    if sys.platform != "win32":
+        config_dir.chmod(0o700)
+
+    # Build config dict with proper structure
+    toml_config: dict = {
+        "openai_api_key": config.get("openai_api_key", ""),
+        "openai_base_url": config.get("openai_base_url", "https://api.openai.com/v1"),
+        "host": config.get("host", "0.0.0.0"),
+        "port": config.get("port", 8080),
+        "request_timeout": config.get("request_timeout", 300.0),
+        "cors_origins": ["*"],
+        "cors_credentials": True,
+        "cors_methods": ["*"],
+        "cors_headers": ["*"],
+        "log_level": "INFO",
+        "log_dir": "",
+        "tavily_timeout": 30.0,
+        "tavily_max_results": 5,
+        "websearch_max_uses": 5,
+    }
+
+    # Add optional values only if present
+    if config.get("api_key"):
+        toml_config["api_key"] = config["api_key"]
+
+    if config.get("tavily_api_key"):
+        toml_config["tavily_api_key"] = config["tavily_api_key"]
+
+    # Write using proper TOML serialization (prevents injection attacks)
+    with open(config_file, "wb") as f:
+        tomli_w.dump(toml_config, f)
+
+    # Set restrictive permissions for the config file on Unix-like systems
+    if sys.platform != "win32":
+        config_file.chmod(0o600)
+
+
+def load_config_from_file() -> dict:
+    """Load configuration from TOML file.
+
+    Returns:
+        Dictionary containing configuration values, empty dict if file doesn't exist
+    """
+    if sys.version_info >= (3, 11):
+        import tomllib
+    else:
+        import tomli as tomllib
+
+    config_file = get_config_file()
+    if not config_file.exists():
+        return {}
+    with open(config_file, "rb") as f:
+        return tomllib.load(f)
+
+
+class Settings(BaseModel):
+    """Application settings loaded from config file."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    # OpenAI API Configuration
+    openai_api_key: Optional[str] = None
+    openai_base_url: str = "https://api.openai.com/v1"
+    openai_org_id: Optional[str] = None
+    openai_project_id: Optional[str] = None
+
+    # Server Configuration
+    host: str = "0.0.0.0"
+    port: int = 8080
+    request_timeout: float = 300.0  # 5 minutes
+
+    # API Key for authenticating requests to this server (optional)
+    api_key: Optional[str] = None
+
+    # CORS settings
+    cors_origins: list[str] = ["*"]
+    cors_credentials: bool = True
+    cors_methods: list[str] = ["*"]
+    cors_headers: list[str] = ["*"]
+
+    # Logging
+    log_level: str = "INFO"
+    log_dir: str = ""  # Empty means use platform-specific default
+
+    # Tavily Web Search Configuration
+    tavily_api_key: Optional[str] = None
+    tavily_timeout: float = 30.0
+    tavily_max_results: int = 5
+    websearch_max_uses: int = 5  # Default max_uses per request
+
+    @property
+    def openai_auth_headers(self) -> dict[str, str]:
+        """Get OpenAI authentication headers."""
+        headers = {
+            "Authorization": f"Bearer {self.openai_api_key}",
+        }
+        if self.openai_org_id:
+            headers["OpenAI-Organization"] = self.openai_org_id
+        if self.openai_project_id:
+            headers["OpenAI-Project"] = self.openai_project_id
+        return headers
+
+    @classmethod
+    def from_toml(cls) -> "Settings":
+        """Load settings from TOML config file.
+
+        Returns:
+            Settings instance populated from config file
+        """
+        config_data = load_config_from_file()
+        return cls(**config_data)
+
+
+def is_interactive() -> bool:
+    """Check if running in an interactive terminal.
+
+    Returns:
+        True if stdin is a TTY (interactive), False otherwise
+    """
+    return sys.stdin.isatty()
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """Get cached settings instance.
+
+    Creates config file interactively if it doesn't exist and running in a TTY.
+    Falls back to creating a default config file in non-interactive environments.
+
+    Returns:
+        Settings instance loaded from config file
+    """
+    config_file = get_config_file()
+    if not config_file.exists():
+        if is_interactive():
+            # Interactive setup wizard
+            config = interactive_setup()
+            create_config_from_dict(config)
+            print(f"\nConfiguration saved to: {config_file}")
+            print("You can edit this file later to change settings.\n")
+        else:
+            # Non-interactive environment: create default config
+            create_default_config()
+            print(f"Created default config file: {config_file}")
+            print("Please edit it to add your API keys and settings.")
+    return Settings.from_toml()

{local_openai2anthropic-0.3.6 → local_openai2anthropic-0.3.7}/src/local_openai2anthropic/main.py

@@ -101,7 +101,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     app = FastAPI(
         title="local-openai2anthropic",
         description="A proxy server that converts Anthropic Messages API to OpenAI API",
-        version="0.3.6",
+        version="0.3.7",
         docs_url="/docs",
         redoc_url="/redoc",
     )
@@ -253,7 +253,7 @@ Examples:
     parser.add_argument(
         "--version",
         action="version",
-        version="%(prog)s 0.3.6",
+        version="%(prog)s 0.3.7",
     )
 
     # Create subparsers for commands

{local_openai2anthropic-0.3.6 → local_openai2anthropic-0.3.7}/tests/test_config.py

@@ -8,10 +8,13 @@ import pytest
 
 from local_openai2anthropic.config import (
     Settings,
+    create_config_from_dict,
     create_default_config,
     get_config_dir,
     get_config_file,
     get_settings,
+    interactive_setup,
+    is_interactive,
     load_config_from_file,
 )
 
@@ -360,5 +363,287 @@ class TestGetSettings:
         assert "Please edit it to add your API keys and settings" in captured.out
 
 
+class TestIsInteractive:
+    """Tests for is_interactive function."""
+
+    def test_is_interactive_returns_bool(self):
+        """Test that is_interactive returns a boolean."""
+        result = is_interactive()
+        assert isinstance(result, bool)
+
+
+class TestCreateConfigFromDict:
+    """Tests for create_config_from_dict function."""
+
+    def test_create_config_from_dict_basic(self, tmp_path, monkeypatch):
+        """Test creating config file from dictionary with basic values."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        config = {
+            "openai_api_key": "test-api-key",
+            "openai_base_url": "https://api.openai.com/v1",
+            "host": "0.0.0.0",
+            "port": 8080,
+        }
+
+        create_config_from_dict(config)
+
+        config_file = get_config_file()
+        assert config_file.exists()
+
+        content = config_file.read_text()
+        assert 'openai_api_key = "test-api-key"' in content
+        assert 'openai_base_url = "https://api.openai.com/v1"' in content
+        assert 'host = "0.0.0.0"' in content
+        assert "port = 8080" in content
+
+    def test_create_config_from_dict_with_optional_values(self, tmp_path, monkeypatch):
+        """Test creating config with optional values."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        config = {
+            "openai_api_key": "test-api-key",
+            "api_key": "server-api-key",
+        }
+
+        create_config_from_dict(config)
+
+        config_file = get_config_file()
+        content = config_file.read_text()
+
+        assert 'api_key = "server-api-key"' in content
+
+    def test_create_config_from_dict_without_optional_values(
+        self, tmp_path, monkeypatch
+    ):
+        """Test creating config without optional values omits them."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        config = {
+            "openai_api_key": "test-api-key",
+        }
+
+        create_config_from_dict(config)
+
+        config_file = get_config_file()
+        content = config_file.read_text()
+
+        # Parse TOML to verify structure
+        import tomllib
+
+        with open(config_file, "rb") as f:
+            parsed = tomllib.load(f)
+
+        # Optional api_key should not be present when not provided
+        assert "api_key" not in parsed
+        # But openai_api_key should be present
+        assert parsed["openai_api_key"] == "test-api-key"
+
+    def test_create_config_from_dict_custom_host_port(self, tmp_path, monkeypatch):
+        """Test creating config with custom host and port."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        config = {
+            "openai_api_key": "test-key",
+            "host": "127.0.0.1",
+            "port": 9000,
+        }
+
+        create_config_from_dict(config)
+
+        config_file = get_config_file()
+        content = config_file.read_text()
+
+        assert 'host = "127.0.0.1"' in content
+        assert "port = 9000" in content
+
+    def test_create_config_from_dict_creates_directory(self, tmp_path, monkeypatch):
+        """Test that create_config_from_dict creates the config directory."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        config_dir = tmp_path / ".oa2a"
+        assert not config_dir.exists()
+
+        create_config_from_dict({"openai_api_key": "test"})
+
+        assert config_dir.exists()
+        assert config_dir.is_dir()
+
+    def test_create_config_file_permissions(self, tmp_path, monkeypatch):
+        """Test that created config file has correct permissions."""
+        import sys
+
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+
+        create_config_from_dict({"openai_api_key": "test"})
+
+        if sys.platform != "win32":
+            import stat
+
+            config_file = get_config_file()
+            config_dir = get_config_dir()
+
+            file_perms = stat.S_IMODE(config_file.stat().st_mode)
+            dir_perms = stat.S_IMODE(config_dir.stat().st_mode)
+
+            assert file_perms == 0o600
+            assert dir_perms == 0o700
+
+
+class TestInteractiveSetup:
+    """Tests for interactive_setup function."""
+
+    def test_interactive_setup_all_values(self, monkeypatch):
+        """Test interactive setup with all values provided."""
+        # Mock get_config_file to return a fixed path
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_file",
+            lambda: Path("/tmp/.oa2a/config.toml"),
+        )
+
+        # Mock input for all inputs
+        inputs = iter(
+            [
+                "openai-api-key",  # api_key (required)
+                "https://custom.api.com",  # base_url
+                "127.0.0.1",  # host
+                "9000",  # port
+                "server-api-key",  # server api_key
+            ]
+        )
+        monkeypatch.setattr("builtins.input", lambda prompt: next(inputs))
+
+        config = interactive_setup()
+
+        assert config["openai_api_key"] == "openai-api-key"
+        assert config["openai_base_url"] == "https://custom.api.com"
+        assert config["host"] == "127.0.0.1"
+        assert config["port"] == 9000
+        assert config["api_key"] == "server-api-key"
+
+    def test_interactive_setup_defaults(self, monkeypatch):
+        """Test interactive setup with default values."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_file",
+            lambda: Path("/tmp/.oa2a/config.toml"),
+        )
+
+        # Mock input - api key + all empty to accept defaults
+        inputs = iter(["openai-api-key", "", "", "", ""])
+        monkeypatch.setattr("builtins.input", lambda prompt: next(inputs))
+
+        config = interactive_setup()
+
+        assert config["openai_api_key"] == "openai-api-key"
+        assert config["openai_base_url"] == "https://api.openai.com/v1"
+        assert config["host"] == "0.0.0.0"
+        assert config["port"] == 8080
+        assert "api_key" not in config
+
+    def test_interactive_setup_invalid_port(self, monkeypatch):
+        """Test interactive setup with invalid port falls back to default."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_file",
+            lambda: Path("/tmp/.oa2a/config.toml"),
+        )
+
+        # Mock input with invalid port
+        inputs = iter(["openai-api-key", "", "", "invalid", ""])
+        monkeypatch.setattr("builtins.input", lambda prompt: next(inputs))
+
+        config = interactive_setup()
+
+        assert config["port"] == 8080  # Should fall back to default
+
+    def test_interactive_setup_requires_api_key(self, monkeypatch):
+        """Test that interactive setup requires API key."""
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_file",
+            lambda: Path("/tmp/.oa2a/config.toml"),
+        )
+
+        # Mock input - first empty (rejected), then valid
+        inputs = iter(["", "openai-api-key", "", "", "", ""])
+        monkeypatch.setattr("builtins.input", lambda prompt: next(inputs))
+
+        config = interactive_setup()
+
+        assert config["openai_api_key"] == "openai-api-key"
+
+
+class TestGetSettingsInteractive:
+    """Tests for get_settings with interactive mode."""
+
+    def test_get_settings_non_interactive_creates_default(
+        self, tmp_path, monkeypatch, capsys
+    ):
+        """Test get_settings in non-interactive mode creates default config."""
+        # Clear cache
+        get_settings.cache_clear()
+
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.is_interactive", lambda: False
+        )
+
+        settings = get_settings()
+
+        # Should create default config
+        assert get_config_file().exists()
+        assert isinstance(settings, Settings)
+
+        # Check notification
+        captured = capsys.readouterr()
+        assert "Created default config file" in captured.out
+
+    def test_get_settings_interactive_mode(self, tmp_path, monkeypatch, capsys):
+        """Test get_settings in interactive mode runs setup wizard."""
+        # Clear cache
+        get_settings.cache_clear()
+
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.get_config_dir", lambda: tmp_path / ".oa2a"
+        )
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.is_interactive", lambda: True
+        )
+
+        # Mock interactive_setup
+        mock_config = {
+            "openai_api_key": "test-key",
+            "host": "127.0.0.1",
+            "port": 9000,
+        }
+        monkeypatch.setattr(
+            "local_openai2anthropic.config.interactive_setup", lambda: mock_config
+        )
+
+        settings = get_settings()
+
+        # Should create config with interactive values
+        assert get_config_file().exists()
+        assert settings.openai_api_key == "test-key"
+        assert settings.host == "127.0.0.1"
+        assert settings.port == 9000
+
+        # Check notification
+        captured = capsys.readouterr()
+        assert "Configuration saved to" in captured.out
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])