vantage-python 0.3.0__tar.gz → 0.3.2__tar.gz

{vantage_python-0.3.0 → vantage_python-0.3.2}/.github/workflows/pypi-publish.yml

@@ -17,6 +17,8 @@ jobs:
             TAG_NOT_PRESENT: ${{ steps.get-tag.outputs.TAG_NOT_PRESENT }}
         steps:
             - uses: actions/checkout@v4
+              with:
+                  fetch-depth: 0
             - name: Get the tag from Python and check if it's present
               id: get-tag
               run: |

{vantage_python-0.3.0 → vantage_python-0.3.2}/.github/workflows/test.yml

@@ -14,7 +14,6 @@ jobs:
               with:
                   python-version: ${{ matrix.python-version }}
             - run: pip install -e ".[dev]"
-            - run: python autogen.py
             - run: pytest tests/test_e2e.py
               env:
                   VANTAGE_API_TOKEN: ${{ secrets.VANTAGE_API_TOKEN }}
@@ -32,7 +31,6 @@ jobs:
               with:
                   python-version: ${{ matrix.python-version }}
             - run: pip install -e ".[dev]"
-            - run: python autogen.py
             - run: python -c "from vantage import Client, AsyncClient"
 
     compare-to-api:

{vantage_python-0.3.0 → vantage_python-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vantage-python
-Version: 0.3.0
+Version: 0.3.2
 Summary: Python SDK for the Vantage API
 Project-URL: Homepage, https://github.com/vantage-sh/vantage-python
 Project-URL: Repository, https://github.com/vantage-sh/vantage-python

{vantage_python-0.3.0 → vantage_python-0.3.2}/autogen.py

@@ -20,6 +20,17 @@ from typing import Any
 OPENAPI_URL = "https://api.vantage.sh/v2/oas_v3.json"
 OUTPUT_DIR = Path(__file__).parent / "src" / "vantage"
 
+# Maps a substring found in a response description to the internal client method
+# that should handle it, and the Python return type to emit.
+# Checked against each HTTP status code's description during endpoint parsing.
+RESPONSE_HANDLERS: list[tuple[str, str, str]] = [
+    (
+        "will be available at the location specified in the Location header",
+        "_request_for_location",
+        "str",
+    ),
+]
+
 
 @dataclass
 class Parameter:
@@ -48,6 +59,8 @@ class Endpoint:
     request_body_type: str | None = None
     response_type: str | None = None
     is_multipart: bool = False
+    response_handler: str | None = None  # internal client method to call, if not the default
+    response_handler_return_type: str | None = None
 
 
 @dataclass
@@ -292,13 +305,27 @@ def parse_endpoints(schema: dict[str, Any]) -> list[Endpoint]:
 
             response_type = extract_response_type(spec.get("responses", {}), schemas)
 
+            description = spec.get("description")
+
+            response_handler = None
+            response_handler_return_type = None
+            for resp_desc in spec.get("responses", {}).values():
+                text = resp_desc.get("description", "")
+                for phrase, handler, return_type in RESPONSE_HANDLERS:
+                    if phrase in text:
+                        response_handler = handler
+                        response_handler_return_type = return_type
+                        break
+                if response_handler:
+                    break
+
             endpoints.append(
                 Endpoint(
                     path=path,
                     method=method.upper(),
                     operation_id=operation_id,
                     summary=spec.get("summary"),
-                    description=spec.get("description"),
+                    description=description,
                     deprecated=spec.get("deprecated", False),
                     parameters=parameters,
                     request_body_required=request_body.get("required", False)
@@ -307,6 +334,8 @@ def parse_endpoints(schema: dict[str, Any]) -> list[Endpoint]:
                     request_body_type=body_type,
                     response_type=response_type,
                     is_multipart=is_multipart,
+                    response_handler=response_handler,
+                    response_handler_return_type=response_handler_return_type,
                 )
             )
 
@@ -373,6 +402,70 @@ def generate_method_name(endpoint: Endpoint, resource_name: str) -> str:
     return to_snake_case(op_id)
 
 
+def _extract_inner_type(type_hint: str, generic_prefix: str) -> str | None:
+    """Extract inner type from simple generic forms like Prefix[Inner]."""
+    if not type_hint.startswith(generic_prefix) or not type_hint.endswith("]"):
+        return None
+    return type_hint[len(generic_prefix):-1].strip()
+
+
+def _extract_dict_value_type(type_hint: str) -> str | None:
+    """Extract value type from Dict[str, ValueType]."""
+    if not type_hint.startswith("Dict[") or not type_hint.endswith("]"):
+        return None
+    inner = type_hint[len("Dict["):-1].strip()
+    key_and_value = inner.split(",", 1)
+    if len(key_and_value) != 2:
+        return None
+    key_type = key_and_value[0].strip()
+    value_type = key_and_value[1].strip()
+    if key_type not in {"str", "Optional[str]"}:
+        return None
+    return value_type
+
+
+def _is_model_type(type_hint: str) -> bool:
+    """Return True for generated Pydantic model type names."""
+    return bool(re.match(r"^[A-Z][A-Za-z0-9_]*$", type_hint))
+
+
+def _append_response_mapping(lines: list[str], return_type: str, data_var: str) -> None:
+    """Append generated code that coerces dict payloads into typed models."""
+    type_hint = return_type.strip()
+
+    optional_inner = _extract_inner_type(type_hint, "Optional[")
+    if optional_inner:
+        type_hint = optional_inner
+
+    list_inner = _extract_inner_type(type_hint, "List[")
+    if list_inner and _is_model_type(list_inner):
+        lines.extend(
+            [
+                f"        if isinstance({data_var}, list):",
+                f"            return [{list_inner}.model_validate(item) if isinstance(item, dict) else item for item in {data_var}]",
+            ]
+        )
+        return
+
+    dict_inner = _extract_dict_value_type(type_hint)
+    if dict_inner and _is_model_type(dict_inner):
+        lines.extend(
+            [
+                f"        if isinstance({data_var}, dict):",
+                f"            return {{k: {dict_inner}.model_validate(v) if isinstance(v, dict) else v for k, v in {data_var}.items()}}",
+            ]
+        )
+        return
+
+    if _is_model_type(type_hint):
+        lines.extend(
+            [
+                f"        if isinstance({data_var}, dict):",
+                f"            return {type_hint}.model_validate({data_var})",
+            ]
+        )
+
+
 def generate_pydantic_models(schema: dict[str, Any]) -> str:
     """Generate Pydantic models from OpenAPI schemas."""
     schemas = schema.get("components", {}).get("schemas", {})
@@ -459,6 +552,18 @@ def generate_pydantic_models(schema: dict[str, Any]) -> str:
     return "\n".join(lines)
 
 
+def _collect_handler_routes(resources: dict[str, Resource]) -> dict[str, list[tuple[str, str]]]:
+    """Scan all endpoints and group (method, path) pairs by their response_handler."""
+    handler_routes: dict[str, list[tuple[str, str]]] = {}
+    for resource in resources.values():
+        for endpoint in resource.endpoints:
+            if endpoint.response_handler:
+                handler_routes.setdefault(endpoint.response_handler, []).append(
+                    (endpoint.method, endpoint.path)
+                )
+    return handler_routes
+
+
 def generate_sync_client(resources: dict[str, Resource]) -> str:
     """Generate synchronous client code."""
     lines = [
@@ -554,6 +659,19 @@ def generate_sync_client(resources: dict[str, Resource]) -> str:
             "                body=response.text,",
             "            )",
             "",
+        ]
+    )
+
+    # Inject generated routing: one if-block per handler, checking (method, path)
+    handler_routes = _collect_handler_routes(resources)
+    for handler, routes in sorted(handler_routes.items()):
+        route_set = "{" + ", ".join(f'("{m}", "{p}")' for m, p in sorted(routes)) + "}"
+        lines.append(f"        if (method, path) in {route_set}:")
+        lines.append(f"            return self.{handler}(response)")
+        lines.append("")
+
+    lines.extend(
+        [
             "        try:",
             "            data = response.json()",
             "        except Exception:",
@@ -561,6 +679,10 @@ def generate_sync_client(resources: dict[str, Resource]) -> str:
             "",
             "        return data",
             "",
+            "    def _request_for_location(self, response: Any) -> str:",
+            '        """Extract the Location header from a response."""',
+            '        return response.headers["Location"]',
+            "",
             "",
         ]
     )
@@ -635,7 +757,10 @@ def generate_sync_method(endpoint: Endpoint, method_name: str) -> list[str]:
 
     # Method signature
     param_str = ", ".join(["self"] + params) if params else "self"
-    return_type = endpoint.response_type or "Any"
+    if endpoint.response_handler:
+        return_type = endpoint.response_handler_return_type or "Any"
+    else:
+        return_type = endpoint.response_type or "None"
     lines.append(f"    def {method_name}({param_str}) -> {return_type}:")
 
     # Docstring
@@ -675,10 +800,21 @@ def generate_sync_method(endpoint: Endpoint, method_name: str) -> list[str]:
     else:
         lines.append("        body_data = None")
 
-    # Make request
-    lines.append(
-        f'        return self._client.request("{endpoint.method}", path, params=params, body=body_data)'
-    )
+    # Make request and coerce response payload into typed models where possible
+    if endpoint.response_handler:
+        lines.append(
+            f'        return self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+    elif endpoint.response_type is None:
+        lines.append(
+            f'        self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+    else:
+        lines.append(
+            f'        data = self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+        _append_response_mapping(lines, return_type, "data")
+        lines.append("        return data")
 
     return lines
 
@@ -778,6 +914,19 @@ def generate_async_client(resources: dict[str, Resource]) -> str:
             "                body=response.text,",
             "            )",
             "",
+        ]
+    )
+
+    # Inject generated routing: one if-block per handler, checking (method, path)
+    handler_routes = _collect_handler_routes(resources)
+    for handler, routes in sorted(handler_routes.items()):
+        route_set = "{" + ", ".join(f'("{m}", "{p}")' for m, p in sorted(routes)) + "}"
+        lines.append(f"        if (method, path) in {route_set}:")
+        lines.append(f"            return self.{handler}(response)")
+        lines.append("")
+
+    lines.extend(
+        [
             "        try:",
             "            data = response.json()",
             "        except Exception:",
@@ -785,6 +934,10 @@ def generate_async_client(resources: dict[str, Resource]) -> str:
             "",
             "        return data",
             "",
+            "    def _request_for_location(self, response: Any) -> str:",
+            '        """Extract the Location header from a response."""',
+            '        return response.headers["Location"]',
+            "",
             "",
         ]
     )
@@ -859,7 +1012,10 @@ def generate_async_method(endpoint: Endpoint, method_name: str) -> list[str]:
 
     # Method signature
     param_str = ", ".join(["self"] + params) if params else "self"
-    return_type = endpoint.response_type or "Any"
+    if endpoint.response_handler:
+        return_type = endpoint.response_handler_return_type or "Any"
+    else:
+        return_type = endpoint.response_type or "None"
     lines.append(f"    async def {method_name}({param_str}) -> {return_type}:")
 
     # Docstring
@@ -899,10 +1055,21 @@ def generate_async_method(endpoint: Endpoint, method_name: str) -> list[str]:
     else:
         lines.append("        body_data = None")
 
-    # Make request
-    lines.append(
-        f'        return await self._client.request("{endpoint.method}", path, params=params, body=body_data)'
-    )
+    # Make request and coerce response payload into typed models where possible
+    if endpoint.response_handler:
+        lines.append(
+            f'        return await self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+    elif endpoint.response_type is None:
+        lines.append(
+            f'        await self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+    else:
+        lines.append(
+            f'        data = await self._client.request("{endpoint.method}", path, params=params, body=body_data)'
+        )
+        _append_response_mapping(lines, return_type, "data")
+        lines.append("        return data")
 
     return lines
 

{vantage_python-0.3.0 → vantage_python-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vantage-python"
-version = "0.3.0"
+version = "0.3.2"
 description = "Python SDK for the Vantage API"
 readme = "README.md"
 license = "MIT"