Merge pull request #38 from roryeckel/fix/backend-argument-parsing

Fix backend argument parsing by adding proper enum type converter

Author: roryeckel

src/wyoming_openai/__main__.py

@@ -18,6 +18,7 @@
 )
 from .const import __version__
 from .handler import OpenAIEventHandler
+from .utilities import create_enum_parser
 
 
 def configure_logging(level):
@@ -29,10 +30,27 @@ def configure_logging(level):
 
 async def main():
     """Main entry point for the Wyoming OpenAI server."""
-    env_stt_backend = os.getenv("STT_BACKEND")
-    env_tts_backend = os.getenv("TTS_BACKEND")
     parser = argparse.ArgumentParser()
 
+    # Create reusable enum parser for backend arguments
+    backend_parser = create_enum_parser(OpenAIBackend)
+
+    stt_backend_env = os.getenv("STT_BACKEND")
+    stt_backend_default = None
+    if stt_backend_env:
+        try:
+            stt_backend_default = backend_parser(stt_backend_env)
+        except argparse.ArgumentTypeError as exc:
+            parser.error(str(exc))
+
+    tts_backend_env = os.getenv("TTS_BACKEND")
+    tts_backend_default = None
+    if tts_backend_env:
+        try:
+            tts_backend_default = backend_parser(tts_backend_env)
+        except argparse.ArgumentTypeError as exc:
+            parser.error(str(exc))
+
     # General configuration
     parser.add_argument(
         "--uri",
@@ -71,10 +89,10 @@ async def main():
     )
     parser.add_argument(
         "--stt-backend",
-        type=OpenAIBackend,
+        type=backend_parser,
         required=False,
         choices=list(OpenAIBackend),
-        default=OpenAIBackend[env_stt_backend] if env_stt_backend else None,
+        default=stt_backend_default,
         help="Backend for speech-to-text (OPENAI, SPEACHES, KOKORO_FASTAPI, LOCALAI, or None)"
     )
     parser.add_argument(
@@ -122,10 +140,10 @@ async def main():
     )
     parser.add_argument(
         "--tts-backend",
-        type=OpenAIBackend,
+        type=backend_parser,
         required=False,
         choices=list(OpenAIBackend),
-        default=OpenAIBackend[env_tts_backend] if env_tts_backend else None,
+        default=tts_backend_default,
         help="Backend for text-to-speech (OPENAI, SPEACHES, KOKORO_FASTAPI, LOCALAI, or None)"
     )
     parser.add_argument(

src/wyoming_openai/utilities.py

@@ -1,4 +1,54 @@
+import argparse
+from collections.abc import Callable
+from enum import Enum
 from io import BytesIO
+from typing import TypeVar
+
+E = TypeVar('E', bound=Enum)
+
+
+def create_enum_parser(enum_class: type[E], case_insensitive: bool = True) -> Callable[[str], E]:
+    """
+    Create a type-safe parser function for argparse that converts strings to enum members.
+
+    This function generates a parser that:
+    - Handles case-insensitive matching (optional)
+    - Provides clear error messages listing all valid options
+    - Raises argparse.ArgumentTypeError for invalid inputs
+
+    Args:
+        enum_class: The Enum class to parse into
+        case_insensitive: Whether to allow case-insensitive matching (default: True)
+
+    Returns:
+        A callable that takes a string and returns the corresponding enum member
+
+    Raises:
+        argparse.ArgumentTypeError: When the input string doesn't match any enum member
+
+    Example:
+        >>> from enum import Enum
+        >>> class Color(Enum):
+        ...     RED = 1
+        ...     BLUE = 2
+        >>> parser = argparse.ArgumentParser()
+        >>> parser.add_argument('--color', type=create_enum_parser(Color))
+        >>> args = parser.parse_args(['--color', 'red'])
+        >>> args.color == Color.RED
+        True
+    """
+    def parse_enum(value: str) -> E:
+        lookup_value = value.upper() if case_insensitive else value
+        try:
+            return enum_class[lookup_value]
+        except KeyError as exc:
+            valid_options = ', '.join(member.name for member in enum_class)
+            raise argparse.ArgumentTypeError(
+                f"Invalid {enum_class.__name__}: '{value}'. "
+                f"Valid options are: {valid_options}"
+            ) from exc
+
+    return parse_enum
 
 
 class NamedBytesIO(BytesIO):

tests/test_utilities.py

@@ -1,6 +1,10 @@
+import argparse
+from enum import Enum
 from io import BytesIO
 
-from wyoming_openai.utilities import NamedBytesIO
+import pytest
+
+from wyoming_openai.utilities import NamedBytesIO, create_enum_parser
 
 
 def test_named_bytes_io_name_property():
@@ -16,3 +20,58 @@ def test_named_bytes_io_inherits_bytesio():
     buf = NamedBytesIO(b"xyz", name="foo.wav")
     assert isinstance(buf, BytesIO)
     assert buf.read() == b"xyz"
+
+
+# Test enum for create_enum_parser tests
+class TestBackend(Enum):
+    OPENAI = 1
+    LOCAL = 2
+    CUSTOM = 3
+
+
+def test_create_enum_parser_valid_input():
+    """Test that create_enum_parser successfully parses valid enum values."""
+    parser = create_enum_parser(TestBackend)
+
+    assert parser("openai") == TestBackend.OPENAI
+    assert parser("OPENAI") == TestBackend.OPENAI
+    assert parser("local") == TestBackend.LOCAL
+    assert parser("custom") == TestBackend.CUSTOM
+
+
+def test_create_enum_parser_invalid_input():
+    """Test that create_enum_parser raises ArgumentTypeError for invalid values."""
+    parser = create_enum_parser(TestBackend)
+
+    with pytest.raises(argparse.ArgumentTypeError) as exc_info:
+        parser("invalid")
+
+    error_msg = str(exc_info.value)
+    assert "Invalid TestBackend" in error_msg
+    assert "invalid" in error_msg
+    assert "OPENAI, LOCAL, CUSTOM" in error_msg
+
+
+def test_create_enum_parser_case_sensitive():
+    """Test that create_enum_parser respects case_insensitive parameter."""
+    parser = create_enum_parser(TestBackend, case_insensitive=False)
+
+    # Should work with exact case
+    assert parser("OPENAI") == TestBackend.OPENAI
+
+    # Should fail with wrong case
+    with pytest.raises(argparse.ArgumentTypeError):
+        parser("openai")
+
+
+def test_create_enum_parser_with_argparse():
+    """Test that create_enum_parser works correctly with argparse."""
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--backend", type=create_enum_parser(TestBackend))
+
+    args = parser.parse_args(["--backend", "openai"])
+    assert args.backend == TestBackend.OPENAI
+
+    # Test that invalid values are caught by argparse
+    with pytest.raises(SystemExit):
+        parser.parse_args(["--backend", "invalid"])