assembly-api-client 0.1.0__py3-none-any.whl

assembly_api_client-0.1.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: assembly-api-client
+Version: 0.1.0
+Summary: A robust Python client for the Korean National Assembly Open API
+Project-URL: Homepage, https://github.com/statpan/assembly-api-client
+Project-URL: Repository, https://github.com/statpan/assembly-api-client
+Author-email: Statpan <statpan@example.com>
+License-Expression: MIT
+Keywords: api,assembly,client,korea,open-api
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: platformdirs>=3.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: tenacity>=8.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: python-semantic-release>=9.0.0; extra == 'dev'
+Requires-Dist: rich; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Assembly API Client
+# Assembly API Client (국회 오픈 API 클라이언트)
+
+대한민국 국회 오픈 API(Open API)를 위한 강력하고 유연한 비동기 Python 클라이언트입니다.
+
+## 주요 기능 (Features)
+
+- **동적 스펙 파싱 (Dynamic Spec Parsing)**: 엑셀 명세서를 자동으로 다운로드하고 파싱하여 API 엔드포인트를 동적으로 해결합니다.
+- **타입 안정성 (Type Safety)**: Pydantic 모델을 사용하여 데이터 타입을 검증하고 자동 완성 기능을 제공합니다. API의 불규칙한 데이터 타입(문자열/숫자 혼용)에도 유연하게 대응합니다.
+- **강력한 복원력 (Resilience)**: 내장된 재시도(Retry) 로직과 에러 핸들링으로 안정적인 데이터 수집이 가능합니다.
+- **자동화된 업데이트 (Automated Updates)**: 매주 자동으로 최신 API 명세를 동기화하고 코드를 재생성하는 CI/CD 파이프라인이 포함되어 있습니다.
+- **CLI 도구**: API 명세 동기화 및 검색을 위한 커맨드라인 도구를 제공합니다.
+
+## 설치 (Installation)
+
+이 프로젝트는 [uv](https://github.com/astral-sh/uv)를 사용하여 의존성을 관리하는 것을 권장합니다.
+
+```bash
+# uv 설치 (없는 경우)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# 가상환경 생성 및 패키지 설치
+uv venv
+source .venv/bin/activate
+uv pip install assembly-api-client
+```
+
+## 사용법 (Usage)
+
+### 1. API 키 설정 (API Key Configuration)
+
+API 키는 두 가지 방식으로 설정할 수 있습니다.
+
+**방법 A: 환경 변수 사용 (권장)**
+`.env` 파일을 생성하거나 환경 변수를 설정합니다.
+```bash
+export ASSEMBLY_API_KEY="YOUR_API_KEY"
+```
+
+**방법 B: 클라이언트 직접 주입**
+```python
+client = AssemblyAPIClient(api_key="YOUR_API_KEY")
+```
+
+### 2. 기본 데이터 조회
+
+```python
+import asyncio
+from assembly_client.api import AssemblyAPIClient
+from assembly_client.generated import Service
+
+async def main():
+    # 환경 변수가 설정되어 있다면 api_key 생략 가능
+    async with AssemblyAPIClient() as client:
+        
+        # 서비스 ID 또는 Enum을 사용하여 데이터 조회
+        # 예: 국회의원 발의법률안 조회
+        data = await client.get_data(Service.국회의원_발의법률안, params={"AGE": "21"})
+        
+        for item in data:
+            print(f"법안명: {item.BILL_NAME}, 발의자: {item.PROPOSER}")
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### 3. CLI 사용 (uv 기반)
+
+API 명세 동기화:
+```bash
+uv run python -m assembly_client.cli sync
+```
+
+사용 가능한 API 목록 조회:
+```bash
+uv run python -m assembly_client.cli list
+```
+
+## 유지보수 (Maintenance)
+
+### API 명세 및 Fixture 업데이트
+국회 API는 수시로 변경되거나 새로운 서비스가 추가될 수 있습니다. 
+새로운 API가 추가되면 `sync` 명령어로 명세를 업데이트하고, 테스트를 위한 Fixture도 새로 받아야 합니다.
+
+이 프로젝트는 매일 자동으로 변경사항을 확인하도록 설정되어 있습니다. 수동으로 업데이트하려면:
+
+```bash
+# 1. 명세 동기화 및 코드 재생성
+./scripts/update_client.sh
+
+# 2. (필요시) 새로운 Fixture 생성
+# 새로운 서비스가 추가되었다면 해당 서비스의 샘플 데이터를 받아 테스트에 추가해야 합니다.
+```
+
+## 개발 및 기여 (Development)
+
+### 테스트 실행
+```bash
+pytest
+```
+
+### 코드 재생성 (수동)
+```bash
+./scripts/update_client.sh
+```
+
+## 라이선스 (License)
+
+MIT License

assembly_api_client-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+assembly_client/__init__.py,sha256=3QC1owaTDkmC_gZrMAVhSSR7QuglZlX0Od0B0jrJgyA,59
+assembly_client/api.py,sha256=QD5h-AKBCJwpDPIJ0AIibSGbvRRRrdobg6kck4_ZTZk,10442
+assembly_client/cli.py,sha256=_VInR2cLVnT5uf0MFZfWgHyqIQKz1j5JgmRpIw42b9w,3264
+assembly_client/errors.py,sha256=118R1Bv3fpmZsF7aH_QKzQJYWuU9PJo14_nvDhTPWdA,1080
+assembly_client/parser.py,sha256=Gij2WN_cqnQZw2EjpvboiqhEXoWt7Dy-3cGPSxLDIu8,19163
+assembly_client/sync.py,sha256=tEPCOWiv4lf7ZX2NoxgqWbMH5-otbbAtotGqEFg-_bM,5782
+assembly_client/codegen/generator.py,sha256=ostZwMODW2L4KdPPLd4hk7Ru6UKahslb4e8taLO_LZQ,4008
+assembly_client/generated/__init__.py,sha256=-P-msuatqprRkO8qpBKK41M97SewX1ECV_DilmgU37M,29922
+assembly_client/generated/models.py,sha256=o_2rPuKPWs9NAlMlFNsOOXD95ezIZn9VmqpCfiWzls8,348376
+assembly_client/generated/services.py,sha256=3vtcTazE1xR37HsORTU2ua0Fnpm1DgPOnUvbA1OO0lc,17029
+assembly_api_client-0.1.0.dist-info/METADATA,sha256=-75SUV8vS_YOGA02cSwH9OR-8f7-moQM6v8vRo_AXoA,4897
+assembly_api_client-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+assembly_api_client-0.1.0.dist-info/entry_points.txt,sha256=_o-55CfTOZJ6s-W2rhS3sLauTiDFfIif1g2bXoCNjdQ,60
+assembly_api_client-0.1.0.dist-info/RECORD,,

assembly_api_client-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

assembly_api_client-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+assembly-client = assembly_client.cli:app

assembly_client/__init__.py

@@ -0,0 +1,5 @@
+"""
+Assembly API Client Library
+"""
+
+__version__ = "0.1.0"

assembly_client/api.py

@@ -0,0 +1,265 @@
+import logging
+import os
+from typing import Any, Union
+
+import httpx
+from pydantic import BaseModel
+from tenacity import retry, retry_if_exception, stop_after_attempt, wait_exponential
+
+from .errors import AssemblyAPIError, SpecParseError
+from .parser import APISpec, SpecParser, load_service_map, load_service_metadata
+
+# Try to import generated types, but don't fail if not generated yet
+try:
+    from .generated import MODEL_MAP, Service
+
+    HAS_GENERATED_TYPES = True
+except ImportError:
+    HAS_GENERATED_TYPES = False
+    Service = None
+    MODEL_MAP = {}
+
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+
+def _is_retryable_error(exception):
+    """Check if the exception is retryable."""
+    if isinstance(exception, (httpx.NetworkError, httpx.TimeoutException)):
+        return True
+    if isinstance(exception, httpx.HTTPStatusError):
+        return exception.response.status_code in [429, 500, 502, 503, 504]
+    return False
+
+
+class AssemblyAPIClient:
+    """Client for Korean National Assembly Open API."""
+
+    BASE_URL = "https://open.assembly.go.kr/portal/openapi"
+
+    def __init__(self, api_key: str | None = None, spec_parser: SpecParser | None = None):
+        """
+        Initialize the Assembly API Client.
+
+        Args:
+            api_key: API Key. If None, tries to read from ASSEMBLY_API_KEY env var.
+            spec_parser: Instance of SpecParser. If None, creates a default one.
+        """
+        self.api_key = api_key or os.getenv("ASSEMBLY_API_KEY")
+
+        if not self.api_key:
+            logger.warning("ASSEMBLY_API_KEY is not set. Some APIs may fail.")
+
+        self.client = httpx.AsyncClient(timeout=30.0, follow_redirects=True)
+        self.spec_parser = spec_parser or SpecParser()
+        self.parsed_specs: dict[str, APISpec] = {}
+
+        # Load service map (ID -> Name) for name resolution
+        self.service_map = load_service_map(self.spec_parser.cache_dir)
+        # Create reverse map (Name -> ID)
+        self.name_to_id = {name: sid for sid, name in self.service_map.items()}
+
+        # Load comprehensive service metadata
+        self.service_metadata = load_service_metadata(self.spec_parser.cache_dir)
+
+    def search_services(self, keyword: str) -> dict[str, str]:
+        """
+        Search for services by name or ID.
+
+        Args:
+            keyword: Search term (case-insensitive).
+
+        Returns:
+            Dictionary of {service_id: service_name}
+        """
+        results = {}
+        keyword = keyword.lower()
+        for sid, name in self.service_map.items():
+            if keyword in sid.lower() or keyword in name.lower():
+                results[sid] = name
+        return results
+
+    def _resolve_service_id(self, service_id_or_name: str) -> str:
+        """Resolve a string to a Service ID."""
+        # 1. Check if it's a known ID
+        if service_id_or_name in self.service_map:
+            return service_id_or_name
+
+        # 2. Check if it's a known Name
+        if service_id_or_name in self.name_to_id:
+            return self.name_to_id[service_id_or_name]
+
+        # 3. If it looks like an ID (alphanumeric, long), assume it's an ID
+        # (Even if not in our cache, maybe it's new?)
+        if len(service_id_or_name) > 10 and service_id_or_name.isalnum():
+            return service_id_or_name
+
+        raise AssemblyAPIError("INVALID_ID", f"Could not resolve service: {service_id_or_name}")
+
+    async def close(self):
+        """Close the underlying HTTP client."""
+        await self.client.aclose()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def get_endpoint(self, service_id: str) -> str:
+        """
+        Get the actual API endpoint for a service ID.
+
+        Args:
+            service_id: The service ID
+
+        Returns:
+            The endpoint string
+
+        Raises:
+            SpecParseError: If spec parsing fails
+        """
+        if service_id not in self.parsed_specs:
+            logger.debug(f"Resolving endpoint for {service_id}")
+
+            # We don't have the master list loaded here to check for infSeq.
+            # But SpecParser defaults to infSeq=2 which works for most.
+            # If we need robust infSeq handling, we might need to look it up from a master list.
+            # For now, we'll stick to the default behavior of the original client
+            # which tried to look it up from self.specs (which was loaded from all_apis.json).
+
+            # TODO: Consider loading all_apis.json if it exists to get hints like infSeq.
+
+            spec = await self.spec_parser.parse_spec(service_id)
+            self.parsed_specs[service_id] = spec
+
+        return self.parsed_specs[service_id].endpoint
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=2, max=10),
+        retry=retry_if_exception(_is_retryable_error),
+    )
+    async def get_data(
+        self, service_id_or_name: str | Service, params: dict[str, Any] | BaseModel = None, fmt: str = "json"
+    ) -> Union[dict[str, Any], str, BaseModel, list[BaseModel]]:
+        """
+        Fetch data from the API using dynamic endpoint resolution.
+
+        Args:
+            service_id_or_name: The API service ID, Service Name, or Service Enum member.
+            params: Query parameters.
+            fmt: Response format ('json' or 'xml').
+
+        Returns:
+            Parsed JSON dict, raw XML string, or Pydantic Model (if available).
+
+        Raises:
+            SpecParseError: If endpoint resolution fails
+            AssemblyAPIError: If API returns an error
+        """
+        # Resolve ID
+        if HAS_GENERATED_TYPES and isinstance(service_id_or_name, Service):
+            service_id = service_id_or_name.value
+        else:
+            service_id = self._resolve_service_id(service_id_or_name)
+
+        # Handle Pydantic Params
+        if isinstance(params, BaseModel):
+            # Convert to dict using aliases (to match API param names)
+            # exclude_none=True because optional params shouldn't be sent if not set
+            params = params.model_dump(by_alias=True, exclude_none=True)
+
+        # Get actual endpoint from Excel spec
+        try:
+            endpoint = await self.get_endpoint(service_id)
+        except SpecParseError as e:
+            logger.error(f"Failed to get endpoint for {service_id}: {e}")
+            raise
+
+        # Build URL with actual endpoint
+        url = f"{self.BASE_URL}/{endpoint}"
+
+        # Add format parameter using Type param (not URL path)
+        default_params = {
+            "KEY": self.api_key,
+            "Type": fmt.lower(),
+            "pIndex": 1,
+            "pSize": 100,
+        }
+        merged_params = {**default_params, **(params or {})}
+
+        try:
+            response = await self.client.get(url, params=merged_params)
+            response.raise_for_status()
+
+            if fmt.lower() == "json":
+                data = response.json()
+                self._check_api_error(data, endpoint)
+
+                # Try to convert to Pydantic model
+                if HAS_GENERATED_TYPES and service_id in MODEL_MAP:
+                    try:
+                        model_cls = MODEL_MAP[service_id]
+                        # The data structure is usually {endpoint: [{head: ...}, {row: [...]}]}
+                        # We want to parse the rows into a list of models?
+                        # Or return a wrapper model?
+                        # The generated model is for a SINGLE row item.
+                        # So we should probably return a list of models.
+                        # Extract rows
+                        # The API returns a dict with a key equal to the service ID
+                        # e.g. {"OK7XM...": [{"head": ...}, {"row": ...}]}
+                        target_key = service_id
+                        if service_id not in data:
+                            # Fallback: look for a key that has the expected structure
+                            # Expected: { "KEY": [ { "head": ... }, { "row": ... } ] }
+                            for key, val in data.items():
+                                if isinstance(val, list) and len(val) >= 2 and "row" in val[1]:
+                                    target_key = key
+                                    break
+
+                        if target_key in data:
+                            items = data[target_key][1]["row"]
+                            return [model_cls(**row) for row in items]
+                        else:
+                            # If we can't find the rows, return raw data
+                            return data
+                    except Exception as e:
+                        logger.warning(f"Failed to parse response into model {service_id}: {e}")
+                        # Fallback to raw dict
+
+                return data
+            else:
+                return response.text
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error: {e.response.status_code} - {e.response.text}")
+            raise AssemblyAPIError(str(e.response.status_code), str(e)) from e
+        except Exception as e:
+            logger.error(f"API request failed: {e}")
+            raise AssemblyAPIError("UNKNOWN", str(e)) from e
+
+    def _check_api_error(self, data: dict[str, Any], endpoint: str):
+        """Check for API specific error codes."""
+        # The response key is usually the endpoint name (e.g. "nzmimeepazxkubdpn")
+
+        if endpoint in data:
+            items = data[endpoint]
+            for item in items:
+                if "head" in item:
+                    for head_item in item["head"]:
+                        if "RESULT" in head_item:
+                            result = head_item["RESULT"]
+                            code = result.get("CODE")
+                            message = result.get("MESSAGE")
+
+                            # Check for specific error codes
+                            if code in ["INFO-200", "INFO-290", "INFO-300", "INFO-337"]:
+                                logger.info(f"API Result: {code} - {message}")
+                                if code == "INFO-200":
+                                    return  # No data is valid result
+                                raise AssemblyAPIError(code, message)
+
+                            if code != "INFO-000":
+                                raise AssemblyAPIError(code, message)

assembly_client/cli.py

@@ -0,0 +1,115 @@
+"""
+Command Line Interface for Assembly API Client.
+"""
+
+import asyncio
+import logging
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .parser import SpecParser
+from .sync import load_service_map, sync_all_services
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+logger = logging.getLogger("assembly_client")
+
+app = typer.Typer(help="Assembly API Client CLI")
+console = Console()
+
+
+def get_parser() -> SpecParser:
+    """Get a configured SpecParser."""
+    return SpecParser()
+
+
+@app.command()
+def sync(
+    api_key: str = typer.Option(..., envvar="ASSEMBLY_API_KEY", help="API Key"),
+    limit: Optional[int] = typer.Option(None, help="Limit number of services to sync"),
+    force: bool = typer.Option(False, help="Force update master list"),
+):
+    """
+    Synchronize API specifications.
+    Downloads the master list and individual service specs.
+    """
+    parser = get_parser()
+    console.print(f"[bold green]Starting sync...[/bold green] (Cache: {parser.cache_dir})")
+
+    async def run_sync():
+        stats = await sync_all_services(api_key=api_key, parser=parser, limit=limit, force_update_list=force)
+        return stats
+
+    stats = asyncio.run(run_sync())
+
+    console.print("\n[bold]Sync Complete[/bold]")
+    console.print(f"Updated: [green]{stats['updated']}[/green]")
+    console.print(f"Failed: [red]{stats['failed']}[/red]")
+
+
+@app.command("list")
+def list_apis(
+    search: Optional[str] = typer.Option(None, help="Filter by name or ID"),
+):
+    """
+    List available APIs from the cached master list.
+    """
+    parser = get_parser()
+    service_map = load_service_map(parser.cache_dir)
+
+    if not service_map:
+        console.print("[yellow]No APIs found. Run 'sync' first.[/yellow]")
+        return
+
+    table = Table(title="Available APIs")
+    table.add_column("Service ID", style="cyan")
+    table.add_column("Name", style="green")
+
+    count = 0
+    for sid, name in sorted(service_map.items()):
+        if search and (search.lower() not in sid.lower() and search.lower() not in name.lower()):
+            continue
+        table.add_row(sid, name)
+        count += 1
+
+    console.print(table)
+    console.print(f"Total: {count} APIs")
+
+
+@app.command()
+def info(service_id: str):
+    """
+    Show details for a specific API service.
+    """
+    parser = get_parser()
+
+    async def get_spec():
+        return await parser.parse_spec(service_id)
+
+    try:
+        spec = asyncio.run(get_spec())
+
+        console.print(f"[bold]Service ID:[/bold] {spec.service_id}")
+        console.print(f"[bold]Endpoint:[/bold] {spec.endpoint}")
+        console.print(f"[bold]URL:[/bold] {spec.endpoint_url}")
+
+        table = Table(title="Request Parameters")
+        table.add_column("Name", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Required", style="red")
+        table.add_column("Description")
+
+        for p in spec.request_params:
+            table.add_row(p.name, p.type, "Yes" if p.required else "No", p.description)
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]Error fetching spec for {service_id}: {e}[/red]")
+
+
+if __name__ == "__main__":
+    app()

assembly_client/codegen/generator.py

@@ -0,0 +1,120 @@
+"""
+Code generation utilities for Assembly API Client.
+"""
+import keyword
+import re
+from pathlib import Path
+
+from ..parser import APISpec, load_service_map
+
+
+def sanitize_name(name: str) -> str:
+    """Sanitize a string to be a valid Python identifier."""
+    # Remove invalid characters
+    name = re.sub(r"[^a-zA-Z0-9_]", "", name)
+    # Ensure it doesn't start with a number
+    if name[0].isdigit():
+        name = f"_{name}"
+    # Check for keywords
+    if keyword.iskeyword(name):
+        name = f"{name}_"
+    return name
+
+
+def generate_services_enum(cache_dir: Path) -> str:
+    """Generate the Service enum code."""
+    service_map = load_service_map(cache_dir)
+
+    lines = [
+        "from enum import StrEnum",
+        "",
+        "class Service(StrEnum):",
+        '    """Enumeration of all available Assembly API Services."""',
+    ]
+
+    # Sort by name for stability
+    # We need to create valid enum member names from the service names
+    # e.g. "국회의원발의법률안" -> "BILL_INFO"? No, that's hard to automate perfectly.
+    # Maybe we just use the Service ID as the value, and try to make a readable key?
+    # Or just use the ID as the key if we can't make a good name?
+    # User wants "readable".
+    # Let's try to transliterate or just use the Korean name if Python 3 supports unicode identifiers (it does!)
+    # But usually English is preferred.
+    # Since we don't have English names, maybe we can use the Korean name as the key?
+    # Python 3 allows unicode variable names.
+    # Class attributes can be unicode.
+
+    # Let's try to make English-like keys if possible, or just use the Korean name sanitized?
+    # "국회의원발의법률안" -> valid python identifier? Yes.
+
+    for service_id, name in sorted(service_map.items(), key=lambda x: x[1]):
+        # Sanitize name for Python identifier
+        # Remove spaces, special chars
+        safe_name = re.sub(r"[^a-zA-Z0-9가-힣]", "_", name)
+
+        # If it starts with digit, prefix
+        if safe_name[0].isdigit():
+            safe_name = f"_{safe_name}"
+
+        lines.append(f'    {safe_name} = "{service_id}"')
+
+    return "\n".join(lines)
+
+
+def generate_model_code(spec: APISpec) -> str:
+    """Generate Pydantic model code for a single spec."""
+    class_name = f"Model_{spec.service_id}"
+
+    lines = [
+        f"class {class_name}(BaseModel):",
+        f'    """Response model for {spec.service_id}"""',
+    ]
+
+    if not spec.response_fields:
+        lines.append("    pass")
+        return "\n".join(lines)
+
+    for field in spec.response_fields:
+        field_name = sanitize_name(field.name)
+        # Determine type (default to Union[str, int, float, None] for safety)
+        # API often returns numbers as strings or vice versa, so we must be lenient.
+        py_type = "Union[str, int, float, None]"
+
+        lines.append(
+            f'    {field_name}: {py_type} = Field(None, description="{field.description}", alias="{field.name}")'
+        )
+
+    return "\n".join(lines)
+
+
+def generate_params_model_code(spec: APISpec) -> str:
+    """Generate Pydantic model code for request parameters."""
+    class_name = f"Params_{spec.service_id}"
+
+    lines = [
+        f"class {class_name}(BaseModel):",
+        f'    """Request parameters for {spec.service_id}"""',
+    ]
+
+    if not spec.request_params:
+        lines.append("    pass")
+        return "\n".join(lines)
+
+    for param in spec.request_params:
+        field_name = sanitize_name(param.name)
+
+        # Determine type
+        # Most params are strings in this API, even numbers are often passed as strings
+        # But we can try to be smarter if needed. For now, str is safest.
+        py_type = "str"
+
+        default_val = "..." if param.required else "None"
+        if not param.required:
+            py_type += " | None"
+
+        lines.append(
+            f"    {field_name}: {py_type} = Field({default_val}, "
+            f'description="{param.description}", alias="{param.name}")'
+        )
+
+    return "\n".join(lines)