anncsu-sdk 0.0.9.dev14__tar.gz → 0.0.9.dev15__tar.gz

{anncsu_sdk-0.0.9.dev14 → anncsu_sdk-0.0.9.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anncsu-sdk
-Version: 0.0.9.dev14
+Version: 0.0.9.dev15
 Summary: ANNCSU Software Development Kit for API consumption
 Author-email: Francesco Bartoli <francesco.bartoli@geobeyond.it>
 License-File: LICENSE

{anncsu_sdk-0.0.9.dev14 → anncsu_sdk-0.0.9.dev15}/scripts/post_speakeasy_generation.py

@@ -337,8 +337,43 @@ def fix_model_field_aliases(package_path: Path, dry_run: bool = False) -> list[s
     return fixed
 
 
-def process_package(package_name: str, dry_run: bool = False) -> tuple[int, int, int]:
-    """Process a single API package. Returns (deleted, modified, fixed)."""
+# Speakeasy 1.7+ emits ``is_error_status_code=lambda c: utils.match_status_codes(LIST, c)``
+# but ``BaseSDK.do_request`` accepts ``error_status_codes=LIST``. See issue #26.
+DO_REQUEST_KWARG_PATTERN = re.compile(
+    r"is_error_status_code=lambda \w+: utils\.match_status_codes\((\[[^\]]+\]), \w+\)"
+)
+
+
+def fix_do_request_kwarg(package_path: Path, dry_run: bool = False) -> list[str]:
+    """Rewrite Speakeasy 1.7+ ``is_error_status_code`` lambda to the
+    ``error_status_codes`` list form expected by ``BaseSDK.do_request``."""
+    fixed: list[str] = []
+
+    for py_file in package_path.rglob("*.py"):
+        if "__pycache__" in str(py_file):
+            continue
+
+        content = py_file.read_text()
+        new_content, count = DO_REQUEST_KWARG_PATTERN.subn(
+            r"error_status_codes=\1", content
+        )
+
+        if count > 0:
+            if not dry_run:
+                py_file.write_text(new_content)
+            rel_path = py_file.relative_to(package_path)
+            fixed.append(str(rel_path))
+            console.print(
+                f"  [green]Fixed do_request kwarg ({count}x):[/green] {rel_path}"
+            )
+
+    return fixed
+
+
+def process_package(
+    package_name: str, dry_run: bool = False
+) -> tuple[int, int, int, int]:
+    """Process a single API package. Returns (deleted, modified, fixed, do_request_fixed)."""
     package_path = SDK_ROOT / package_name
 
     if not package_path.exists():
@@ -366,7 +401,13 @@ def process_package(package_name: str, dry_run: bool = False) -> tuple[int, int,
     if not fixed:
         console.print("  [dim]No field aliases to fix[/dim]")
 
-    return len(deleted), len(modified), len(fixed)
+    # Step 4: Fix do_request kwarg (Issue #26)
+    console.print("\n[bold]4. Fixing do_request kwarg (Issue #26)...[/bold]")
+    do_request_fixed = fix_do_request_kwarg(package_path, dry_run)
+    if not do_request_fixed:
+        console.print("  [dim]No do_request kwargs to fix[/dim]")
+
+    return len(deleted), len(modified), len(fixed), len(do_request_fixed)
 
 
 @app.command()
@@ -412,26 +453,30 @@ def main(
     total_deleted = 0
     total_modified = 0
     total_fixed = 0
+    total_do_request_fixed = 0
 
     if all_packages:
         # Process all known API packages
         for pkg in ALL_PACKAGES:
-            deleted, modified, fixed = process_package(pkg, dry_run)
+            deleted, modified, fixed, do_request_fixed = process_package(pkg, dry_run)
             total_deleted += deleted
             total_modified += modified
             total_fixed += fixed
+            total_do_request_fixed += do_request_fixed
     else:
-        deleted, modified, fixed = process_package(package, dry_run)
+        deleted, modified, fixed, do_request_fixed = process_package(package, dry_run)
         total_deleted = deleted
         total_modified = modified
         total_fixed = fixed
+        total_do_request_fixed = do_request_fixed
 
     # Summary
     console.print("\n" + "=" * 50)
     console.print("[bold green]Post-generation processing complete![/bold green]")
-    console.print(f"\n  Files deleted:  {total_deleted}")
-    console.print(f"  Files modified: {total_modified}")
-    console.print(f"  Fields fixed:   {total_fixed}")
+    console.print(f"\n  Files deleted:       {total_deleted}")
+    console.print(f"  Files modified:      {total_modified}")
+    console.print(f"  Fields fixed:        {total_fixed}")
+    console.print(f"  do_request fixed:    {total_do_request_fixed}")
 
     if dry_run:
         console.print(

{anncsu_sdk-0.0.9.dev14 → anncsu_sdk-0.0.9.dev15}/src/anncsu/accessi/accessi.py

@@ -85,7 +85,7 @@ class Accessi(BaseSDK):
                 ),
             ),
             request=req,
-            is_error_status_code=lambda c: utils.match_status_codes(["4XX", "5XX"], c),
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
@@ -179,7 +179,7 @@ class Accessi(BaseSDK):
                 ),
             ),
             request=req,
-            is_error_status_code=lambda c: utils.match_status_codes(["4XX", "5XX"], c),
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 

{anncsu_sdk-0.0.9.dev14 → anncsu_sdk-0.0.9.dev15}/src/anncsu/accessi/status.py

@@ -76,7 +76,7 @@ class Status(BaseSDK):
                 ),
             ),
             request=req,
-            is_error_status_code=lambda c: utils.match_status_codes(["4XX", "5XX"], c),
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
@@ -162,7 +162,7 @@ class Status(BaseSDK):
                 ),
             ),
             request=req,
-            is_error_status_code=lambda c: utils.match_status_codes(["4XX", "5XX"], c),
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 

anncsu_sdk-0.0.9.dev15/tests/accessi/test_do_request_signature.py

@@ -0,0 +1,91 @@
+"""Regression tests for issue #26.
+
+Speakeasy 1.7+ generates `BaseSDK.do_request(... is_error_status_code=lambda
+c: utils.match_status_codes(LIST, c), ...)` but the actual base-class
+signature accepts `error_status_codes` (a list) — not a predicate. The
+generated kwarg name is therefore wrong and every real API call explodes
+with ``TypeError: do_request() got an unexpected keyword argument
+'is_error_status_code'``.
+
+The pre-existing CLI Accessi tests mock the SDK layer entirely, so this
+bug only surfaces during a real end-to-end call. These tests close the
+gap by patching ``BaseSDK.do_request`` with a function whose signature
+mirrors the real one — any extra kwarg raises ``TypeError`` immediately,
+which is exactly the RED condition we want before the fix.
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional, Tuple
+
+import httpx
+import pytest
+
+from anncsu.accessi import AnncsuAccessi
+from anncsu.accessi.models import Security
+from anncsu.common.sdk import BaseSDK
+
+
+def _strict_do_request(
+    self,
+    hook_ctx,
+    request,
+    error_status_codes,
+    stream: bool = False,
+    retry_config: Optional[Tuple[Any, List[str]]] = None,
+) -> httpx.Response:
+    """Mirrors the real ``BaseSDK.do_request`` signature exactly.
+
+    If the generated SDK passes any kwarg that is not in this signature
+    (e.g. ``is_error_status_code``), Python raises ``TypeError`` before
+    this body runs — that is the regression we want to catch.
+    """
+    return httpx.Response(
+        200,
+        request=httpx.Request("GET", "https://example.test/"),
+        content=b'{"esito":"0","messaggio":"OK"}',
+    )
+
+
+@pytest.fixture
+def accessi_sdk():
+    return AnncsuAccessi(
+        server_url="https://example.test",
+        security=Security(),
+    )
+
+
+class TestAccessiDoRequestSignature:
+    """Issue #26: generated SDK must call ``BaseSDK.do_request`` with the
+    real signature (``error_status_codes`` list), not the Speakeasy 1.7+
+    name (``is_error_status_code`` predicate)."""
+
+    def test_show_status_calls_do_request_with_valid_kwargs(
+        self, accessi_sdk, monkeypatch
+    ):
+        monkeypatch.setattr(BaseSDK, "do_request", _strict_do_request)
+        try:
+            accessi_sdk.status.show_status()
+        except TypeError as e:
+            if "is_error_status_code" in str(e):
+                pytest.fail(f"show_status passed an invalid kwarg to do_request: {e}")
+            raise
+        except Exception:
+            # Downstream unmarshalling may fail on the stub response —
+            # we only care that do_request itself accepted the kwargs.
+            pass
+
+    def test_gestione_anncsu_pdnd_calls_do_request_with_valid_kwargs(
+        self, accessi_sdk, monkeypatch
+    ):
+        monkeypatch.setattr(BaseSDK, "do_request", _strict_do_request)
+        try:
+            accessi_sdk.anncsu.gestione_anncsu_pdnd()
+        except TypeError as e:
+            if "is_error_status_code" in str(e):
+                pytest.fail(
+                    f"gestione_anncsu_pdnd passed an invalid kwarg to do_request: {e}"
+                )
+            raise
+        except Exception:
+            pass

anncsu_sdk-0.0.9.dev15/tests/test_post_speakeasy_generation.py

@@ -0,0 +1,127 @@
+"""Tests for scripts/post_speakeasy_generation.py.
+
+Targeted coverage for transformations that fix Speakeasy 1.7+ output
+discrepancies. Currently exercises ``fix_do_request_kwarg`` (issue #26):
+the generator emits ``is_error_status_code=lambda c: utils.match_status_codes(
+LIST, c)`` but the base SDK expects ``error_status_codes=LIST``. This
+test guarantees the post-generation script rewrites the call so the fix
+survives every regeneration.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+
+import pytest
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SCRIPT_PATH = REPO_ROOT / "scripts" / "post_speakeasy_generation.py"
+
+
+@pytest.fixture(scope="module")
+def post_gen_module():
+    spec = importlib.util.spec_from_file_location(
+        "post_speakeasy_generation", SCRIPT_PATH
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["post_speakeasy_generation"] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+SPEAKEASY_17_BAD_CALL = """\
+        http_res = self.do_request(
+            hook_ctx=HookContext(
+                config=self.sdk_configuration,
+                base_url=base_url or "",
+                operation_id="example",
+                oauth2_scopes=None,
+                security_source=None,
+            ),
+            request=req,
+            is_error_status_code=lambda c: utils.match_status_codes(["4XX", "5XX"], c),
+            retry_config=retry_config,
+        )
+"""
+
+EXPECTED_FIXED_CALL = """\
+        http_res = self.do_request(
+            hook_ctx=HookContext(
+                config=self.sdk_configuration,
+                base_url=base_url or "",
+                operation_id="example",
+                oauth2_scopes=None,
+                security_source=None,
+            ),
+            request=req,
+            error_status_codes=["4XX", "5XX"],
+            retry_config=retry_config,
+        )
+"""
+
+
+class TestFixDoRequestKwarg:
+    """Issue #26: ``is_error_status_code=lambda ...`` must be rewritten
+    to ``error_status_codes=LIST`` so generated calls match the real
+    ``BaseSDK.do_request`` signature."""
+
+    def test_rewrites_4xx_5xx_pattern(self, post_gen_module, tmp_path):
+        pkg_dir = tmp_path / "fake_pkg"
+        pkg_dir.mkdir()
+        target = pkg_dir / "accessi.py"
+        target.write_text(SPEAKEASY_17_BAD_CALL)
+
+        fixed = post_gen_module.fix_do_request_kwarg(pkg_dir, dry_run=False)
+
+        assert "accessi.py" in fixed
+        assert target.read_text() == EXPECTED_FIXED_CALL
+
+    def test_rewrites_multiple_occurrences_in_same_file(
+        self, post_gen_module, tmp_path
+    ):
+        pkg_dir = tmp_path / "fake_pkg"
+        pkg_dir.mkdir()
+        target = pkg_dir / "accessi.py"
+        target.write_text(SPEAKEASY_17_BAD_CALL + "\n\n" + SPEAKEASY_17_BAD_CALL)
+
+        post_gen_module.fix_do_request_kwarg(pkg_dir, dry_run=False)
+
+        content = target.read_text()
+        assert "is_error_status_code" not in content
+        assert content.count('error_status_codes=["4XX", "5XX"]') == 2
+
+    def test_dry_run_does_not_modify_file(self, post_gen_module, tmp_path):
+        pkg_dir = tmp_path / "fake_pkg"
+        pkg_dir.mkdir()
+        target = pkg_dir / "accessi.py"
+        target.write_text(SPEAKEASY_17_BAD_CALL)
+
+        post_gen_module.fix_do_request_kwarg(pkg_dir, dry_run=True)
+
+        assert target.read_text() == SPEAKEASY_17_BAD_CALL
+
+    def test_no_match_returns_empty_list(self, post_gen_module, tmp_path):
+        pkg_dir = tmp_path / "fake_pkg"
+        pkg_dir.mkdir()
+        target = pkg_dir / "models.py"
+        target.write_text("class Foo:\n    pass\n")
+
+        fixed = post_gen_module.fix_do_request_kwarg(pkg_dir, dry_run=False)
+
+        assert fixed == []
+
+    def test_preserves_other_status_code_lists(self, post_gen_module, tmp_path):
+        """Speakeasy may emit different code lists (e.g. ["400", "5XX"]).
+        The regex must capture the full list verbatim."""
+        pkg_dir = tmp_path / "fake_pkg"
+        pkg_dir.mkdir()
+        target = pkg_dir / "endpoint.py"
+        target.write_text(
+            '            is_error_status_code=lambda c: utils.match_status_codes(["400", "5XX"], c),\n'
+        )
+
+        post_gen_module.fix_do_request_kwarg(pkg_dir, dry_run=False)
+
+        assert target.read_text() == '            error_status_codes=["400", "5XX"],\n'