ccflow-http 0.1.0__tar.gz → 0.2.0__tar.gz

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/.gitignore

@@ -13,6 +13,10 @@ __pycache__/
 *.exp
 *.lib
 
+# vcpkg
+vcpkg/
+vcpkg_installed/
+
 # Rust
 target
 target-capi
@@ -142,13 +146,14 @@ ccflow_http/labextension
 
 # Emscripten SDK (locally installed)
 emsdk
+.pyodide_build/
 
 # Mac
 .DS_Store
 
 # Hydra
-outputs/
-multirun/
+/outputs/
+/multirun/
 
 # AI
 ROADMAP.md

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ccflow-http
-Version: 0.1.0
+Version: 0.2.0
 Summary: ccflow models for HTTP
 Project-URL: Repository, https://github.com/1kbgz/ccflow-http
 Project-URL: Homepage, https://github.com/1kbgz/ccflow-http
@@ -10,17 +10,16 @@ License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: ccflow-etl>=0.1.0
 Requires-Dist: ccflow>=0.8.5
-Requires-Dist: httpx
+Requires-Dist: httpx2
 Requires-Dist: jinja2
 Provides-Extra: develop
 Requires-Dist: build; extra == 'develop'
@@ -56,7 +55,7 @@ It should not contain provider-specific endpoint catalogs. Domain packages can c
 
 ## Current Status
 
-- Implemented: `HTTPConfig`, `HTTPAuth`, `HTTPContext`, `HTTPRequestContext`, `HTTPRequest`, `HTTPRetryPolicy`, `HTTPResponseResult`, compatibility `HTTPResult`, `HTTPModel`, templated path/query/header rendering, request explanation through `build_request`, no-auth/bearer/API-key/basic auth helpers, JSON/text/bytes/CSV/gzip response parsing, HTTP status retry classification over `ccflow` retry semantics, retry event summaries on HTTP results, `ccflow-etl` `ExecutionPolicy` request spacing, `next_url`/cursor/page/offset pagination, rate-limit header capture, and mocked `httpx` transport tests.
+- Implemented: `HTTPConfig`, `HTTPAuth`, `HTTPContext`, `HTTPRequestContext`, `HTTPRequest`, `HTTPRetryPolicy`, `HTTPResponseResult`, compatibility `HTTPResult`, `HTTPModel`, templated path/query/header rendering, request explanation through `build_request`, no-auth/bearer/API-key/basic auth helpers, JSON/text/bytes/CSV/gzip response parsing, HTTP status retry classification over `ccflow` retry semantics, accepted error statuses returned as results instead of exceptions, retry event summaries on HTTP results, `ccflow-etl` `ExecutionPolicy` request spacing, `next_url`/cursor/page/offset pagination, rate-limit header capture, redaction of secret query values from `httpx2` request logs, result URLs, and status errors, and mocked `httpx2` transport tests.
 - Partial: the shared execution policy is currently consumed inside `HTTPModel` for sequential request spacing; broader evaluator-level concurrency coordination still belongs in evaluator integrations.
 - Missing: broader integration examples and provider-specific subclasses/configs in downstream packages.
 
@@ -68,7 +67,7 @@ It should not contain provider-specific endpoint catalogs. Domain packages can c
 
 ## Test Convention
 
-Default tests should use mocked `httpx` transports or local fixtures. They should not require live network calls or provider credentials.
+Default tests should use mocked `httpx2` transports or local fixtures. They should not require live network calls or provider credentials.
 
 > [!NOTE]
 > This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/README.md

@@ -15,7 +15,7 @@ It should not contain provider-specific endpoint catalogs. Domain packages can c
 
 ## Current Status
 
-- Implemented: `HTTPConfig`, `HTTPAuth`, `HTTPContext`, `HTTPRequestContext`, `HTTPRequest`, `HTTPRetryPolicy`, `HTTPResponseResult`, compatibility `HTTPResult`, `HTTPModel`, templated path/query/header rendering, request explanation through `build_request`, no-auth/bearer/API-key/basic auth helpers, JSON/text/bytes/CSV/gzip response parsing, HTTP status retry classification over `ccflow` retry semantics, retry event summaries on HTTP results, `ccflow-etl` `ExecutionPolicy` request spacing, `next_url`/cursor/page/offset pagination, rate-limit header capture, and mocked `httpx` transport tests.
+- Implemented: `HTTPConfig`, `HTTPAuth`, `HTTPContext`, `HTTPRequestContext`, `HTTPRequest`, `HTTPRetryPolicy`, `HTTPResponseResult`, compatibility `HTTPResult`, `HTTPModel`, templated path/query/header rendering, request explanation through `build_request`, no-auth/bearer/API-key/basic auth helpers, JSON/text/bytes/CSV/gzip response parsing, HTTP status retry classification over `ccflow` retry semantics, accepted error statuses returned as results instead of exceptions, retry event summaries on HTTP results, `ccflow-etl` `ExecutionPolicy` request spacing, `next_url`/cursor/page/offset pagination, rate-limit header capture, redaction of secret query values from `httpx2` request logs, result URLs, and status errors, and mocked `httpx2` transport tests.
 - Partial: the shared execution policy is currently consumed inside `HTTPModel` for sequential request spacing; broader evaluator-level concurrency coordination still belongs in evaluator integrations.
 - Missing: broader integration examples and provider-specific subclasses/configs in downstream packages.
 
@@ -27,7 +27,7 @@ It should not contain provider-specific endpoint catalogs. Domain packages can c
 
 ## Test Convention
 
-Default tests should use mocked `httpx` transports or local fixtures. They should not require live network calls or provider credentials.
+Default tests should use mocked `httpx2` transports or local fixtures. They should not require live network calls or provider credentials.
 
 > [!NOTE]
 > This library was generated using [copier](https://copier.readthedocs.io/en/stable/) from the [Base Python Project Template repository](https://github.com/python-project-templates/base).

ccflow_http-0.2.0/ccflow_http/__init__.py

@@ -0,0 +1,3 @@
+from .base import *
+
+__version__ = "0.2.0"

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/ccflow_http/base.py

@@ -1,12 +1,15 @@
 from base64 import b64encode
 from csv import DictReader
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
 from gzip import decompress
 from io import StringIO
+from logging import Filter, LogRecord, getLogger
 from time import monotonic, sleep
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
-from urllib.parse import parse_qsl, urlsplit, urlunsplit
+from typing import Any, Literal
+from urllib.parse import parse_qsl, unquote_plus, urlsplit, urlunsplit
 
-import httpx
+import httpx2
 from ccflow import BaseModel, CallableModel, ContextBase, Flow, GenericResult, PyObjectPath
 from ccflow.utils.retry import RetryPolicy
 from ccflow_etl import ExecutionPolicy
@@ -14,16 +17,17 @@ from jinja2 import Environment
 from pydantic import Field
 
 __all__ = (
-    "HTTPConfig",
     "HTTPAuth",
+    "HTTPConfig",
     "HTTPContext",
-    "HTTPRequestContext",
+    "HTTPModel",
     "HTTPRequest",
-    "HTTPRetryPolicy",
+    "HTTPRequestContext",
     "HTTPResponseResult",
     "HTTPResult",
-    "HTTPModel",
+    "HTTPRetryPolicy",
     "redact_mapping",
+    "redact_url",
     "safe_request_dump",
 )
 
@@ -38,27 +42,27 @@ class HTTPConfig(BaseModel):
     base_url: str = ""
     timeout: float = 30.0
     follow_redirects: bool = True
-    headers: Dict[str, str] = Field(default_factory=dict)
-    transport: Optional[Any] = None
+    headers: dict[str, str] = Field(default_factory=dict)
+    transport: Any | None = None
 
 
 class HTTPAuth(BaseModel):
     strategy: HTTPAuthStrategy = "none"
-    token: Optional[str] = None
-    name: Optional[str] = None
-    value: Optional[str] = None
-    username: Optional[str] = None
-    password: Optional[str] = None
+    token: str | None = None
+    name: str | None = None
+    value: str | None = None
+    username: str | None = None
+    password: str | None = None
     scheme: str = "Bearer"
 
 
 class HTTPContext(ContextBase):
-    path: Optional[str] = None
-    query: Dict[str, Any] = Field(default_factory=dict)
-    headers: Dict[str, str] = Field(default_factory=dict)
-    template_values: Dict[str, Any] = Field(default_factory=dict)
-    json_body: Optional[Any] = None
-    content: Optional[Union[bytes, str]] = None
+    path: str | None = None
+    query: dict[str, Any] = Field(default_factory=dict)
+    headers: dict[str, str] = Field(default_factory=dict)
+    template_values: dict[str, Any] = Field(default_factory=dict)
+    json_body: Any | None = None
+    content: bytes | str | None = None
 
 
 class HTTPRequestContext(HTTPContext): ...
@@ -67,24 +71,45 @@ class HTTPRequestContext(HTTPContext): ...
 class HTTPRequest(BaseModel):
     method: HTTPMethod
     url: str
-    params: Dict[str, Any] = Field(default_factory=dict)
-    headers: Dict[str, str] = Field(default_factory=dict)
-    json_data: Optional[Any] = None
-    content: Optional[Union[bytes, str]] = None
+    params: dict[str, Any] = Field(default_factory=dict)
+    headers: dict[str, str] = Field(default_factory=dict)
+    json_data: Any | None = None
+    content: bytes | str | None = None
+
+
+def _is_sensitive_key(key: str) -> bool:
+    normalized_key = key.lower().replace("_", "").replace("-", "")
+    return normalized_key in {"apikey", "authorization", "password"} or "token" in normalized_key or "secret" in normalized_key
+
+
+def redact_mapping(values: dict[str, Any]) -> dict[str, Any]:
+    return {key: "***" if _is_sensitive_key(key) else value for key, value in values.items()}
+
+
+def redact_url(url: str) -> str:
+    parts = urlsplit(url)
+    if not parts.query:
+        return url
+    pairs = []
+    for pair in parts.query.split("&"):
+        key = pair.split("=", 1)[0]
+        pairs.append(f"{key}=***" if _is_sensitive_key(unquote_plus(key)) else pair)
+    return urlunsplit(parts._replace(query="&".join(pairs)))
 
 
-def redact_mapping(values: Dict[str, Any]) -> Dict[str, Any]:
-    redacted = {}
-    for key, value in values.items():
-        normalized_key = key.lower().replace("_", "").replace("-", "")
-        if normalized_key in {"apikey", "authorization", "password"} or "token" in normalized_key or "secret" in normalized_key:
-            redacted[key] = "***"
-        else:
-            redacted[key] = value
-    return redacted
+class _RedactURLFilter(Filter):
+    """Redact secret query values from URLs that httpx2 logs for each request."""
 
+    def filter(self, record: LogRecord) -> bool:
+        if isinstance(record.args, tuple):
+            record.args = tuple(redact_url(str(arg)) if isinstance(arg, httpx2.URL) else arg for arg in record.args)
+        return True
 
-def safe_request_dump(request: HTTPRequest) -> Dict[str, Any]:
+
+getLogger("httpx2").addFilter(_RedactURLFilter())
+
+
+def safe_request_dump(request: HTTPRequest) -> dict[str, Any]:
     request_data = request.model_dump(exclude={"type_"})
     request_data["params"] = redact_mapping(request_data.get("params", {}))
     request_data["headers"] = redact_mapping(request_data.get("headers", {}))
@@ -95,33 +120,52 @@ class HTTPRetryEvent(BaseModel):
     attempt: int
     outcome: HTTPRetryOutcome
     delay_seconds: float = 0.0
-    status_code: Optional[int] = None
-    exception_type: Optional[str] = None
-    category: Optional[str] = None
-    message: Optional[str] = None
+    status_code: int | None = None
+    exception_type: str | None = None
+    category: str | None = None
+    message: str | None = None
 
 
 class HTTPRetryPolicy(RetryPolicy):
-    retry_status_codes: List[int] = Field(default_factory=lambda: [429, 500, 502, 503, 504])
-    retry_exceptions: List[PyObjectPath] = Field(
-        default_factory=lambda: [PyObjectPath.validate(httpx.TimeoutException), PyObjectPath.validate(httpx.ConnectError)]
-    )
-    timeout_exception_types: List[str] = Field(
+    retry_status_codes: list[int] = Field(default_factory=lambda: [429, 500, 502, 503, 504])
+    retry_exceptions: list[PyObjectPath] = Field(default_factory=lambda: [PyObjectPath.validate(httpx2.TransportError)])
+    timeout_exception_types: list[str] = Field(
         default_factory=lambda: ["TimeoutError", "TimeoutException", "ConnectTimeout", "ReadTimeout", "WriteTimeout", "PoolTimeout"]
     )
+    retry_after_max: float | None = Field(
+        default=300.0,
+        ge=0.0,
+        description="Cap (in seconds) on honoring a server-provided Retry-After header. None honors it unbounded.",
+    )
 
-    def should_retry_status(self, status_code: Optional[int], attempt: int) -> bool:
+    def should_retry_status(self, status_code: int | None, attempt: int) -> bool:
         return status_code in self.retry_status_codes and attempt < self.max_attempts
 
+    def retry_after_seconds(self, headers: dict[str, str]) -> float | None:
+        value = next((v for k, v in headers.items() if k.lower() == "retry-after"), None)
+        if value is None:
+            return None
+        try:
+            delay_seconds = float(value)
+        except ValueError:
+            try:
+                delay_seconds = (parsedate_to_datetime(value) - datetime.now(UTC)).total_seconds()
+            except (TypeError, ValueError):
+                return None
+        delay_seconds = max(delay_seconds, 0.0)
+        if self.retry_after_max is not None:
+            delay_seconds = min(delay_seconds, self.retry_after_max)
+        return delay_seconds
+
     def should_retry_exception(self, exception: BaseException, attempt: int) -> bool:
         return self._should_retry(exception) and attempt < self.max_attempts
 
-    def delay_seconds(self, attempt: int, jitter_value: Optional[float] = None) -> float:
+    def delay_seconds(self, attempt: int, jitter_value: float | None = None) -> float:
         if attempt < 1:
             raise ValueError("attempt must be greater than or equal to 1")
         return self._compute_delay(attempt, jitter_value=jitter_value)
 
-    def retry_delay_seconds(self, attempt: int, total_wait_seconds: float) -> Optional[float]:
+    def retry_delay_seconds(self, attempt: int, total_wait_seconds: float) -> float | None:
         delay_seconds = self.delay_seconds(attempt)
         if self.max_delay is not None and total_wait_seconds + delay_seconds > self.max_delay:
             return None
@@ -136,7 +180,7 @@ class HTTPRetryPolicy(RetryPolicy):
             return "connection"
         return "exception"
 
-    def status_category(self, status_code: Optional[int]) -> str:
+    def status_category(self, status_code: int | None) -> str:
         if status_code == 429:
             return "rate_limit"
         if status_code == 408:
@@ -148,48 +192,52 @@ class HTTPRetryPolicy(RetryPolicy):
 
 class HTTPResponseResult(GenericResult[Any]):
     status_code: int
-    headers: Dict[str, str] = Field(default_factory=dict)
+    headers: dict[str, str] = Field(default_factory=dict)
     url: str = ""
     attempts: int = 1
     pages: int = 1
-    rate_limit: Dict[str, str] = Field(default_factory=dict)
-    retry_events: List[Dict[str, Any]] = Field(default_factory=list)
-    retry_summary: Dict[str, int] = Field(default_factory=dict)
+    rate_limit: dict[str, str] = Field(default_factory=dict)
+    retry_events: list[dict[str, Any]] = Field(default_factory=list)
+    retry_summary: dict[str, int] = Field(default_factory=dict)
 
 
 class HTTPResult(HTTPResponseResult): ...
 
 
 class HTTPModel(CallableModel):
-    config: Optional[HTTPConfig] = None
+    config: HTTPConfig | None = None
     auth: HTTPAuth = Field(default_factory=HTTPAuth)
     method: HTTPMethod = "GET"
     base_url: str = ""
     path: str = ""
-    query: Dict[str, Any] = Field(default_factory=dict)
-    headers: Dict[str, str] = Field(default_factory=dict)
+    query: dict[str, Any] = Field(default_factory=dict)
+    headers: dict[str, str] = Field(default_factory=dict)
     timeout: float = 30.0
     follow_redirects: bool = True
     response_format: ResponseFormat = "json"
-    json_body: Optional[Any] = None
-    content: Optional[Union[bytes, str]] = None
+    json_body: Any | None = None
+    content: bytes | str | None = None
     max_attempts: int = 1
-    retry_status_codes: List[int] = Field(default_factory=lambda: [429, 500, 502, 503, 504])
-    retry_policy: Optional[HTTPRetryPolicy] = None
-    execution_policy: Optional[ExecutionPolicy] = None
+    retry_status_codes: list[int] = Field(default_factory=lambda: [429, 500, 502, 503, 504])
+    retry_policy: HTTPRetryPolicy | None = None
+    accepted_status_codes: list[int] = Field(
+        default_factory=list,
+        description="Error status codes returned as results with value None instead of raising, such as 404 for lookups that may miss.",
+    )
+    execution_policy: ExecutionPolicy | None = None
     paginate: bool = False
     max_pages: int = 100
     pagination_mode: HTTPPaginationMode = "next_url"
     next_url_field: str = "next_url"
     next_cursor_field: str = "next_cursor"
     cursor_param: str = "cursor"
-    cursor_start: Optional[str] = None
+    cursor_start: str | None = None
     page_param: str = "page"
     page_start: int = 1
     offset_param: str = "offset"
     offset_start: int = 0
     limit_param: str = "limit"
-    limit: Optional[int] = None
+    limit: int | None = None
     results_field: str = "results"
 
     @property
@@ -200,25 +248,25 @@ class HTTPModel(CallableModel):
     def result_type(self):
         return HTTPResult
 
-    def _template_data(self, context: HTTPContext) -> Dict[str, Any]:
+    def _template_data(self, context: HTTPContext) -> dict[str, Any]:
         data = context.model_dump(exclude_none=True)
         data.update(context.template_values)
         return data
 
-    def _render(self, value: Any, data: Dict[str, Any]) -> Any:
+    def _render(self, value: Any, data: dict[str, Any]) -> Any:
         if isinstance(value, str):
             return Environment().from_string(value).render(**data)
         return value
 
-    def _render_mapping(self, values: Dict[str, Any], data: Dict[str, Any]) -> Dict[str, Any]:
+    def _render_mapping(self, values: dict[str, Any], data: dict[str, Any]) -> dict[str, Any]:
         return {key: self._render(value, data) for key, value in values.items() if value is not None}
 
-    def _render_required_auth_value(self, value: Optional[str], field_name: str, data: Dict[str, Any]) -> str:
+    def _render_required_auth_value(self, value: str | None, field_name: str, data: dict[str, Any]) -> str:
         if value is None:
             raise ValueError(f"HTTP auth strategy {self.auth.strategy!r} requires {field_name}.")
         return str(self._render(value, data))
 
-    def _apply_auth(self, headers: Dict[str, str], query: Dict[str, Any], data: Dict[str, Any]) -> None:
+    def _apply_auth(self, headers: dict[str, str], query: dict[str, Any], data: dict[str, Any]) -> None:
         match self.auth.strategy:
             case "none":
                 return
@@ -236,7 +284,7 @@ class HTTPModel(CallableModel):
             case "basic":
                 username = self._render_required_auth_value(self.auth.username, "username", data)
                 password = self._render_required_auth_value(self.auth.password, "password", data)
-                encoded = b64encode(f"{username}:{password}".encode("utf-8")).decode("ascii")
+                encoded = b64encode(f"{username}:{password}".encode()).decode("ascii")
                 headers["Authorization"] = f"Basic {encoded}"
             case _:
                 raise ValueError(f"Unsupported HTTP auth strategy: {self.auth.strategy}")
@@ -254,7 +302,7 @@ class HTTPModel(CallableModel):
             return self.config.follow_redirects
         return self.follow_redirects
 
-    def _client_kwargs(self) -> Dict[str, Any]:
+    def _client_kwargs(self) -> dict[str, Any]:
         kwargs = {
             "base_url": self._base_url(),
             "timeout": self._timeout(),
@@ -264,7 +312,7 @@ class HTTPModel(CallableModel):
             kwargs["transport"] = self.config.transport
         return kwargs
 
-    def build_request(self, context: Optional[HTTPContext] = None) -> HTTPRequest:
+    def build_request(self, context: HTTPContext | None = None) -> HTTPRequest:
         context = context or HTTPRequestContext()
         data = self._template_data(context)
 
@@ -286,7 +334,7 @@ class HTTPModel(CallableModel):
             content=context.content if context.content is not None else self.content,
         )
 
-    def _response_value(self, response: httpx.Response) -> Any:
+    def _response_value(self, response: httpx2.Response) -> Any:
         match self.response_format:
             case "json":
                 return response.json()
@@ -304,7 +352,7 @@ class HTTPModel(CallableModel):
     def _safe_url(self, request: HTTPRequest) -> str:
         return request.url.split("?", 1)[0]
 
-    def _rate_limit_headers(self, headers: Dict[str, str]) -> Dict[str, str]:
+    def _rate_limit_headers(self, headers: dict[str, str]) -> dict[str, str]:
         rate_limit = {}
         for key, value in headers.items():
             normalized_key = key.lower()
@@ -322,7 +370,7 @@ class HTTPModel(CallableModel):
     def _now(self) -> float:
         return monotonic()
 
-    def _throttle(self, previous_started_at: Optional[float]) -> float:
+    def _throttle(self, previous_started_at: float | None) -> float:
         now = self._now()
         if self.execution_policy is None:
             return now
@@ -331,10 +379,10 @@ class HTTPModel(CallableModel):
             self._sleep(delay_seconds)
         return now + delay_seconds
 
-    def _retry_event(self, **values: Any) -> Dict[str, Any]:
+    def _retry_event(self, **values: Any) -> dict[str, Any]:
         return HTTPRetryEvent(**values).model_dump(exclude={"type_"}, exclude_none=True)
 
-    def _retry_summary(self, events: List[Dict[str, Any]], attempts: int, succeeded: bool) -> Dict[str, int]:
+    def _retry_summary(self, events: list[dict[str, Any]], attempts: int, succeeded: bool) -> dict[str, int]:
         return {
             "attempts": attempts,
             "retried": sum(1 for event in events if event["outcome"] == "retry"),
@@ -351,10 +399,10 @@ class HTTPModel(CallableModel):
         return current
 
     def _request_once(
-        self, client: httpx.Client, request: HTTPRequest, previous_started_at: Optional[float]
-    ) -> Tuple[httpx.Response, int, List[Dict[str, Any]], float]:
+        self, client: httpx2.Client, request: HTTPRequest, previous_started_at: float | None
+    ) -> tuple[httpx2.Response, int, list[dict[str, Any]], float]:
         attempts = 0
-        events: List[Dict[str, Any]] = []
+        events: list[dict[str, Any]] = []
         retry_policy = self._retry_policy()
         total_retry_wait_seconds = 0.0
         while True:
@@ -369,13 +417,18 @@ class HTTPModel(CallableModel):
                     json=request.json_data,
                     content=request.content,
                 )
+                if response.status_code in self.accepted_status_codes:
+                    return response, attempts, events, previous_started_at
                 response.raise_for_status()
                 return response, attempts, events, previous_started_at
-            except httpx.HTTPStatusError as exc:
+            except httpx2.HTTPStatusError as exc:
                 status_code = exc.response.status_code if exc.response is not None else None
                 if retry_policy.should_retry_status(status_code, attempts):
                     delay_seconds = retry_policy.retry_delay_seconds(attempts, total_wait_seconds=total_retry_wait_seconds)
                     if delay_seconds is not None:
+                        retry_after = retry_policy.retry_after_seconds(dict(exc.response.headers or {})) if exc.response is not None else None
+                        if retry_after is not None:
+                            delay_seconds = max(delay_seconds, retry_after)
                         events.append(
                             self._retry_event(
                                 attempt=attempts,
@@ -399,8 +452,9 @@ class HTTPModel(CallableModel):
                     )
                 )
                 status_label = status_code if status_code is not None else "unknown"
-                raise RuntimeError(f"HTTP {request.method} {self._safe_url(request)} failed with status {status_label}") from exc
-            except (httpx.TimeoutException, httpx.ConnectError) as exc:
+                # httpx2 status errors embed the full request URL, including secret query values.
+                raise RuntimeError(f"HTTP {request.method} {self._safe_url(request)} failed with status {status_label}") from None
+            except httpx2.TransportError as exc:
                 if retry_policy.should_retry_exception(exc, attempts):
                     delay_seconds = retry_policy.retry_delay_seconds(attempts, total_wait_seconds=total_retry_wait_seconds)
                     if delay_seconds is not None:
@@ -427,10 +481,10 @@ class HTTPModel(CallableModel):
                     )
                 )
                 raise RuntimeError(f"HTTP {request.method} {self._safe_url(request)} failed with {type(exc).__name__}") from exc
-            except httpx.HTTPError as exc:
+            except httpx2.HTTPError as exc:
                 raise RuntimeError(f"HTTP {request.method} {self._safe_url(request)} failed with {type(exc).__name__}") from exc
 
-    def _merge_page_values(self, values: List[Any]) -> Any:
+    def _merge_page_values(self, values: list[Any]) -> Any:
         if not values:
             return []
         if all(isinstance(value, dict) and isinstance(value.get(self.results_field), list) for value in values):
@@ -441,22 +495,18 @@ class HTTPModel(CallableModel):
             return merged
         return values
 
-    def _page_items(self, value: Any) -> Optional[List[Any]]:
+    def _page_items(self, value: Any) -> list[Any] | None:
         items = self._extract_field(value, self.results_field)
         return items if isinstance(items, list) else None
 
-    def _request_with_params(self, request: HTTPRequest, params: Dict[str, Any]) -> HTTPRequest:
+    def _request_with_params(self, request: HTTPRequest, params: dict[str, Any]) -> HTTPRequest:
         return request.model_copy(update={"params": {**request.params, **params}})
 
-    def _is_sensitive_query_param(self, key: str) -> bool:
-        normalized_key = key.lower().replace("_", "").replace("-", "")
-        return normalized_key in {"apikey", "authorization", "password"} or "token" in normalized_key or "secret" in normalized_key
-
     def _next_url_request(self, request: HTTPRequest, next_url: str) -> HTTPRequest:
         next_url_parts = urlsplit(next_url)
         next_url_params = dict(parse_qsl(next_url_parts.query, keep_blank_values=True))
         for key, value in request.params.items():
-            if key not in next_url_params and self._is_sensitive_query_param(key):
+            if key not in next_url_params and _is_sensitive_key(key):
                 next_url_params[key] = value
         next_url_without_query = urlunsplit((next_url_parts.scheme, next_url_parts.netloc, next_url_parts.path, "", next_url_parts.fragment))
         return request.model_copy(update={"url": next_url_without_query, "params": next_url_params})
@@ -484,7 +534,7 @@ class HTTPModel(CallableModel):
             case _:
                 raise ValueError(f"Unsupported pagination mode: {self.pagination_mode}")
 
-    def _next_paginated_request(self, request: HTTPRequest, value: Any) -> Optional[HTTPRequest]:
+    def _next_paginated_request(self, request: HTTPRequest, value: Any) -> HTTPRequest | None:
         if self._page_items(value) == []:
             return None
         match self.pagination_mode:
@@ -508,7 +558,7 @@ class HTTPModel(CallableModel):
     def __call__(self, context: HTTPRequestContext) -> HTTPResult:
         request = self._initial_paginated_request(self.build_request(context))
 
-        with httpx.Client(**self._client_kwargs()) as client:
+        with httpx2.Client(**self._client_kwargs()) as client:
             values = []
             retry_events = []
             total_attempts = 0
@@ -519,6 +569,9 @@ class HTTPModel(CallableModel):
                 total_attempts += attempts
                 retry_events.extend(events)
                 pages += 1
+                accepted_error = response.status_code in self.accepted_status_codes
+                if accepted_error:
+                    break
                 value = self._response_value(response)
                 values.append(value)
 
@@ -530,10 +583,10 @@ class HTTPModel(CallableModel):
                 request = next_request
 
             return HTTPResult(
-                value=self._merge_page_values(values) if self.paginate else values[-1],
+                value=None if accepted_error else (self._merge_page_values(values) if self.paginate else values[-1]),
                 status_code=response.status_code,
                 headers=dict(response.headers or {}),
-                url=str(response.url),
+                url=redact_url(str(response.url)),
                 attempts=total_attempts,
                 pages=pages,
                 rate_limit=self._rate_limit_headers(dict(response.headers or {})),

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/ccflow_http/tests/test_all.py

@@ -1,4 +1,4 @@
-from ccflow_http import *  # noqa
+from ccflow_http import *
 
 
 def test_all():

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/ccflow_http/tests/test_model.py

@@ -2,14 +2,25 @@ from __future__ import annotations
 
 from base64 import b64decode
 from dataclasses import dataclass
+from datetime import UTC
 from gzip import compress
 from typing import Any
 
-import httpx
+import httpx2
 import pytest
 from ccflow_etl import ExecutionPolicy
 
-from ccflow_http import HTTPAuth, HTTPConfig, HTTPModel, HTTPRequest, HTTPRequestContext, HTTPResponseResult, HTTPRetryPolicy, safe_request_dump
+from ccflow_http import (
+    HTTPAuth,
+    HTTPConfig,
+    HTTPModel,
+    HTTPRequest,
+    HTTPRequestContext,
+    HTTPResponseResult,
+    HTTPRetryPolicy,
+    redact_url,
+    safe_request_dump,
+)
 
 
 @dataclass
@@ -51,7 +62,7 @@ def test_http_model_renders_request_and_returns_json(monkeypatch):
             calls.append({"client": self.kwargs, "request": kwargs})
             return FakeResponse(value={"status": "OK", "results": [{"ticker": "AAA"}]}, headers={"x-limit-remaining": "9"})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     model = HTTPModel(
         base_url="https://api.example.test",
@@ -132,11 +143,11 @@ def test_http_model_error_message_omits_secret_query_values(monkeypatch):
             return False
 
         def request(self, **kwargs):
-            request = httpx.Request("GET", "https://api.example.test/v1/tickers/AAA?apiKey=secret")
-            response = httpx.Response(429, request=request)
-            raise httpx.HTTPStatusError("rate limited with apiKey=secret", request=request, response=response)
+            request = httpx2.Request("GET", "https://api.example.test/v1/tickers/AAA?apiKey=secret")
+            response = httpx2.Response(429, request=request)
+            raise httpx2.HTTPStatusError("rate limited with apiKey=secret", request=request, response=response)
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     model = HTTPModel(base_url="https://api.example.test", path="/v1/tickers/{{ ticker }}", query={"apiKey": "{{ api_key }}"})
 
@@ -145,6 +156,34 @@ def test_http_model_error_message_omits_secret_query_values(monkeypatch):
 
     assert "secret" not in str(error.value)
     assert "apiKey" not in str(error.value)
+    assert error.value.__cause__ is None
+    assert error.value.__suppress_context__
+
+
+def test_redact_url_masks_secret_query_values():
+    assert (
+        redact_url("https://api.example.test/v1/tickers?date=2024-01-03&apiKey=abc&page_token=def&limit=10")
+        == "https://api.example.test/v1/tickers?date=2024-01-03&apiKey=***&page_token=***&limit=10"
+    )
+    assert redact_url("https://api.example.test/v1/tickers") == "https://api.example.test/v1/tickers"
+    assert redact_url("/v1/tickers?cursor=2") == "/v1/tickers?cursor=2"
+
+
+def test_http_model_redacts_secret_query_values_from_request_log_and_result(caplog):
+    transport = httpx2.MockTransport(lambda request: httpx2.Response(200, json={"status": "OK"}))
+    model = HTTPModel(
+        config=HTTPConfig(base_url="https://api.example.test", transport=transport),
+        path="/v1/tickers",
+        query={"date": "2024-01-03"},
+        auth=HTTPAuth(strategy="api_key_query", name="apiKey", value="query-key"),
+    )
+
+    with caplog.at_level("INFO", logger="httpx2"):
+        result = model(HTTPRequestContext())
+
+    assert "HTTP Request: GET https://api.example.test/v1/tickers?date=2024-01-03&apiKey=***" in caplog.text
+    assert "query-key" not in caplog.text
+    assert result.url == "https://api.example.test/v1/tickers?date=2024-01-03&apiKey=***"
 
 
 def test_http_model_retries_retryable_status_and_captures_rate_limit(monkeypatch):
@@ -163,12 +202,12 @@ def test_http_model_retries_retryable_status_and_captures_rate_limit(monkeypatch
         def request(self, **kwargs):
             calls.append(kwargs)
             if len(calls) == 1:
-                request = httpx.Request("GET", "https://api.example.test/v1/tickers")
-                response = httpx.Response(429, request=request, headers={"retry-after": "1"})
-                raise httpx.HTTPStatusError("rate limited", request=request, response=response)
+                request = httpx2.Request("GET", "https://api.example.test/v1/tickers")
+                response = httpx2.Response(429, request=request, headers={"retry-after": "1"})
+                raise httpx2.HTTPStatusError("rate limited", request=request, response=response)
             return FakeResponse(value={"status": "OK"}, headers={"x-ratelimit-remaining": "8"})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     result = HTTPModel(base_url="https://api.example.test", path="/v1/tickers", max_attempts=2)(HTTPRequestContext())
 
@@ -194,12 +233,12 @@ def test_http_model_consumes_shared_retry_policy(monkeypatch):
         def request(self, **kwargs):
             calls.append(kwargs)
             if len(calls) == 1:
-                request = httpx.Request("GET", "https://api.example.test/v1/tickers")
-                response = httpx.Response(503, request=request)
-                raise httpx.HTTPStatusError("unavailable", request=request, response=response)
+                request = httpx2.Request("GET", "https://api.example.test/v1/tickers")
+                response = httpx2.Response(503, request=request)
+                raise httpx2.HTTPStatusError("unavailable", request=request, response=response)
             return FakeResponse(value={"status": "OK"})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     model = HTTPModel(base_url="https://api.example.test", path="/v1/tickers", retry_policy=HTTPRetryPolicy(max_attempts=2, retry_status_codes=[503]))
 
@@ -222,12 +261,12 @@ def test_http_model_consumes_shared_retry_delay_and_execution_policy(monkeypatch
         def request(self, **kwargs):
             calls.append(kwargs)
             if len(calls) == 1:
-                request = httpx.Request("GET", "https://api.example.test/v1/tickers")
-                response = httpx.Response(429, request=request)
-                raise httpx.HTTPStatusError("rate limited", request=request, response=response)
+                request = httpx2.Request("GET", "https://api.example.test/v1/tickers")
+                response = httpx2.Response(429, request=request)
+                raise httpx2.HTTPStatusError("rate limited", request=request, response=response)
             return FakeResponse(value={"status": "OK"})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     model = HTTPModel(
         base_url="https://api.example.test",
@@ -273,10 +312,10 @@ def test_http_model_retries_timeout_exception(monkeypatch):
         def request(self, **kwargs):
             calls.append(kwargs)
             if len(calls) == 1:
-                raise httpx.TimeoutException("timed out")
+                raise httpx2.TimeoutException("timed out")
             return FakeResponse(value={"status": "OK"})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     result = HTTPModel(base_url="https://api.example.test", path="/v1/tickers", max_attempts=2)(HTTPRequestContext())
 
@@ -300,11 +339,11 @@ def test_http_model_retries_5xx_until_attempts_are_exhausted(monkeypatch):
 
         def request(self, **kwargs):
             calls.append(kwargs)
-            request = httpx.Request("GET", "https://api.example.test/v1/tickers?apiKey=secret")
-            response = httpx.Response(500, request=request)
-            raise httpx.HTTPStatusError("server error with apiKey=secret", request=request, response=response)
+            request = httpx2.Request("GET", "https://api.example.test/v1/tickers?apiKey=secret")
+            response = httpx2.Response(500, request=request)
+            raise httpx2.HTTPStatusError("server error with apiKey=secret", request=request, response=response)
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     model = HTTPModel(base_url="https://api.example.test", path="/v1/tickers", query={"apiKey": "secret"}, max_attempts=2)
 
@@ -335,7 +374,7 @@ def test_http_model_paginates_massive_style_next_url(monkeypatch):
                 return FakeResponse(value={"results": [{"ticker": "AAA"}], "next_url": "/v3/reference/tickers?cursor=2"})
             return FakeResponse(value={"results": [{"ticker": "BBB"}]})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     result = HTTPModel(base_url="https://api.example.test", path="/v3/reference/tickers", paginate=True)(HTTPRequestContext())
 
@@ -364,7 +403,7 @@ def test_http_model_preserves_query_auth_for_next_url_pagination(monkeypatch):
                 return FakeResponse(value={"results": [{"ticker": "AAA"}], "next_url": "/v3/reference/tickers?cursor=2"})
             return FakeResponse(value={"results": [{"ticker": "BBB"}]})
 
-    monkeypatch.setattr("ccflow_http.base.httpx.Client", FakeClient)
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", FakeClient)
 
     HTTPModel(
         base_url="https://api.example.test",
@@ -377,17 +416,17 @@ def test_http_model_preserves_query_auth_for_next_url_pagination(monkeypatch):
     assert calls[1]["params"] == {"cursor": "2", "apiKey": "secret"}
 
 
-def test_http_model_sends_next_url_query_and_preserved_auth_with_httpx_transport():
+def test_http_model_sends_next_url_query_and_preserved_auth_with_httpx2_transport():
     seen_urls = []
 
-    def handler(request: httpx.Request) -> httpx.Response:
+    def handler(request: httpx2.Request) -> httpx2.Response:
         seen_urls.append(str(request.url))
         if len(seen_urls) == 1:
-            return httpx.Response(200, json={"results": [{"ticker": "AAA"}], "next_url": "/v3/reference/tickers?cursor=2"})
-        return httpx.Response(200, json={"results": [{"ticker": "BBB"}]})
+            return httpx2.Response(200, json={"results": [{"ticker": "AAA"}], "next_url": "/v3/reference/tickers?cursor=2"})
+        return httpx2.Response(200, json={"results": [{"ticker": "BBB"}]})
 
     model = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(handler)),
         path="/v3/reference/tickers",
         query={"apiKey": "secret"},
         paginate=True,
@@ -405,11 +444,11 @@ def test_http_model_sends_next_url_query_and_preserved_auth_with_httpx_transport
 def test_http_model_applies_config_and_all_auth_strategies_with_mock_transport():
     seen_requests = []
 
-    def handler(request: httpx.Request) -> httpx.Response:
+    def handler(request: httpx2.Request) -> httpx2.Response:
         seen_requests.append(request)
-        return httpx.Response(200, json={"status": "OK"}, headers={"x-ratelimit-remaining": "7"})
+        return httpx2.Response(200, json={"status": "OK"}, headers={"x-ratelimit-remaining": "7"})
 
-    transport = httpx.MockTransport(handler)
+    transport = httpx2.MockTransport(handler)
     config = HTTPConfig(base_url="https://api.example.test", timeout=4.0, headers={"Accept": "application/json"}, transport=transport)
 
     bearer = HTTPModel(config=config, path="/v1/{{ resource }}", auth=HTTPAuth(strategy="bearer", token="{{ token }}"))
@@ -438,21 +477,54 @@ def test_http_model_applies_config_and_all_auth_strategies_with_mock_transport()
     assert "authorization" not in seen_requests[4].headers
 
 
+def test_http_model_returns_accepted_error_status_without_raising():
+    transport = httpx2.MockTransport(lambda request: httpx2.Response(404, json={"status": "NOT_FOUND"}))
+    config = HTTPConfig(base_url="https://api.example.test", transport=transport)
+
+    result = HTTPModel(config=config, path="/v1/tickers/ZZZZ", accepted_status_codes=[404])(HTTPRequestContext())
+
+    assert result.status_code == 404
+    assert result.value is None
+    assert result.retry_summary == {"attempts": 1, "retried": 0, "failed": 0, "succeeded": 1}
+    with pytest.raises(RuntimeError, match="failed with status 404"):
+        HTTPModel(config=config, path="/v1/tickers/ZZZZ")(HTTPRequestContext())
+
+
+def test_http_model_stops_pagination_on_accepted_error_status():
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        if "cursor" in request.url.params:
+            return httpx2.Response(404)
+        return httpx2.Response(200, json={"results": [{"ticker": "AAA"}], "next_url": "/v1/tickers?cursor=2"})
+
+    model = HTTPModel(
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(handler)),
+        path="/v1/tickers",
+        paginate=True,
+        accepted_status_codes=[404],
+    )
+
+    result = model(HTTPRequestContext())
+
+    assert result.status_code == 404
+    assert result.value is None
+    assert result.pages == 2
+
+
 def test_http_model_parses_csv_and_gzip_responses_with_mock_transport():
-    def csv_handler(request: httpx.Request) -> httpx.Response:
-        return httpx.Response(200, text="ticker,volume\nAAA,10\nBBB,20\n")
+    def csv_handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, text="ticker,volume\nAAA,10\nBBB,20\n")
 
     csv_result = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(csv_handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(csv_handler)),
         path="/csv",
         response_format="csv",
     )(HTTPRequestContext())
 
-    def gzip_handler(request: httpx.Request) -> httpx.Response:
-        return httpx.Response(200, content=compress(b'{"status":"OK"}'))
+    def gzip_handler(request: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, content=compress(b'{"status":"OK"}'))
 
     gzip_result = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(gzip_handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(gzip_handler)),
         path="/gzip",
         response_format="gzip",
     )(HTTPRequestContext())
@@ -464,14 +536,14 @@ def test_http_model_parses_csv_and_gzip_responses_with_mock_transport():
 def test_http_model_supports_cursor_page_and_offset_pagination_with_mock_transport():
     cursor_requests = []
 
-    def cursor_handler(request: httpx.Request) -> httpx.Response:
+    def cursor_handler(request: httpx2.Request) -> httpx2.Response:
         cursor_requests.append(dict(request.url.params))
         if "cursor" not in request.url.params:
-            return httpx.Response(200, json={"results": [{"id": 1}], "next_cursor": "abc"})
-        return httpx.Response(200, json={"results": [{"id": 2}]})
+            return httpx2.Response(200, json={"results": [{"id": 1}], "next_cursor": "abc"})
+        return httpx2.Response(200, json={"results": [{"id": 2}]})
 
     cursor_result = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(cursor_handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(cursor_handler)),
         path="/items",
         paginate=True,
         pagination_mode="cursor",
@@ -481,14 +553,14 @@ def test_http_model_supports_cursor_page_and_offset_pagination_with_mock_transpo
 
     page_requests = []
 
-    def page_handler(request: httpx.Request) -> httpx.Response:
+    def page_handler(request: httpx2.Request) -> httpx2.Response:
         page_requests.append(dict(request.url.params))
         page = int(request.url.params["page"])
         payload = {1: [{"id": 1}], 2: [{"id": 2}]}.get(page, [])
-        return httpx.Response(200, json={"results": payload})
+        return httpx2.Response(200, json={"results": payload})
 
     page_result = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(page_handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(page_handler)),
         path="/items",
         paginate=True,
         pagination_mode="page",
@@ -499,14 +571,14 @@ def test_http_model_supports_cursor_page_and_offset_pagination_with_mock_transpo
 
     offset_requests = []
 
-    def offset_handler(request: httpx.Request) -> httpx.Response:
+    def offset_handler(request: httpx2.Request) -> httpx2.Response:
         offset_requests.append(dict(request.url.params))
         offset = int(request.url.params["offset"])
         payload = {0: [{"id": 1}], 2: [{"id": 2}]}.get(offset, [])
-        return httpx.Response(200, json={"results": payload})
+        return httpx2.Response(200, json={"results": payload})
 
     offset_result = HTTPModel(
-        config=HTTPConfig(base_url="https://api.example.test", transport=httpx.MockTransport(offset_handler)),
+        config=HTTPConfig(base_url="https://api.example.test", transport=httpx2.MockTransport(offset_handler)),
         path="/items",
         paginate=True,
         pagination_mode="offset",
@@ -522,3 +594,137 @@ def test_http_model_supports_cursor_page_and_offset_pagination_with_mock_transpo
     assert page_result.value["results"] == [{"id": 1}, {"id": 2}]
     assert offset_requests == [{"offset": "0", "limit": "2"}, {"offset": "2", "limit": "2"}, {"offset": "4", "limit": "2"}]
     assert offset_result.value["results"] == [{"id": 1}, {"id": 2}]
+
+
+def _retrying_client(calls, response_factory):
+    class FakeClient:
+        def __init__(self, **kwargs):
+            pass
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, traceback):
+            return False
+
+        def request(self, **kwargs):
+            calls.append(kwargs)
+            if len(calls) == 1:
+                response_factory()
+            return FakeResponse(value={"status": "OK"})
+
+    return FakeClient
+
+
+def _raise_status(status_code, headers=None):
+    request = httpx2.Request("GET", "https://api.example.test/v1/tickers")
+    response = httpx2.Response(status_code, request=request, headers=headers or {})
+    raise httpx2.HTTPStatusError("error", request=request, response=response)
+
+
+@pytest.mark.parametrize(("exception_type", "category"), [(httpx2.ConnectError, "connection"), (httpx2.RemoteProtocolError, "exception")])
+def test_http_model_retries_transport_error(monkeypatch, exception_type, category):
+    calls = []
+
+    def fail_once():
+        raise exception_type("transport failed")
+
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, fail_once))
+
+    result = HTTPModel(base_url="https://api.example.test", path="/v1/tickers", max_attempts=2)(HTTPRequestContext())
+
+    assert len(calls) == 2
+    assert result.attempts == 2
+    assert result.retry_events[0]["category"] == category
+
+
+def test_http_model_honors_retry_after_seconds_over_backoff(monkeypatch):
+    calls = []
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, lambda: _raise_status(429, {"retry-after": "45"})))
+
+    model = HTTPModel(
+        base_url="https://api.example.test",
+        path="/v1/tickers",
+        retry_policy=HTTPRetryPolicy(max_attempts=2, wait_initial=1.0),
+    )
+    sleeps = []
+    monkeypatch.setattr(model, "_sleep", sleeps.append)
+
+    result = model(HTTPRequestContext())
+
+    assert len(calls) == 2
+    assert sleeps == [45.0]
+    assert result.retry_events[0]["delay_seconds"] == 45.0
+
+
+def test_http_model_uses_backoff_when_it_exceeds_retry_after(monkeypatch):
+    calls = []
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, lambda: _raise_status(429, {"retry-after": "1"})))
+
+    model = HTTPModel(
+        base_url="https://api.example.test",
+        path="/v1/tickers",
+        retry_policy=HTTPRetryPolicy(max_attempts=2, wait_initial=5.0),
+    )
+    sleeps = []
+    monkeypatch.setattr(model, "_sleep", sleeps.append)
+
+    model(HTTPRequestContext())
+
+    assert sleeps == [5.0]
+
+
+def test_http_model_caps_retry_after_at_retry_after_max(monkeypatch):
+    calls = []
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, lambda: _raise_status(429, {"retry-after": "9999"})))
+
+    model = HTTPModel(
+        base_url="https://api.example.test",
+        path="/v1/tickers",
+        retry_policy=HTTPRetryPolicy(max_attempts=2, wait_initial=1.0, retry_after_max=300.0),
+    )
+    sleeps = []
+    monkeypatch.setattr(model, "_sleep", sleeps.append)
+
+    model(HTTPRequestContext())
+
+    assert sleeps == [300.0]
+
+
+def test_http_model_honors_retry_after_http_date(monkeypatch):
+    from datetime import datetime, timedelta
+    from email.utils import format_datetime
+
+    calls = []
+    retry_at = format_datetime(datetime.now(UTC) + timedelta(seconds=60))
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, lambda: _raise_status(429, {"retry-after": retry_at})))
+
+    model = HTTPModel(
+        base_url="https://api.example.test",
+        path="/v1/tickers",
+        retry_policy=HTTPRetryPolicy(max_attempts=2, wait_initial=1.0),
+    )
+    sleeps = []
+    monkeypatch.setattr(model, "_sleep", sleeps.append)
+
+    model(HTTPRequestContext())
+
+    assert len(sleeps) == 1
+    assert 50.0 <= sleeps[0] <= 60.0
+
+
+def test_http_model_ignores_invalid_retry_after(monkeypatch):
+    calls = []
+    monkeypatch.setattr("ccflow_http.base.httpx2.Client", _retrying_client(calls, lambda: _raise_status(429, {"retry-after": "soon"})))
+
+    model = HTTPModel(
+        base_url="https://api.example.test",
+        path="/v1/tickers",
+        retry_policy=HTTPRetryPolicy(max_attempts=2, wait_initial=1.0),
+    )
+    sleeps = []
+    monkeypatch.setattr(model, "_sleep", sleeps.append)
+
+    model(HTTPRequestContext())
+
+    assert sleeps == [1.0]

{ccflow_http-0.1.0 → ccflow_http-0.2.0}/pyproject.toml

@@ -12,8 +12,8 @@ authors = [
 description = "ccflow models for HTTP"
 readme = "README.md"
 license = { text = "Apache-2.0" }
-version = "0.1.0"
-requires-python = ">=3.10"
+version = "0.2.0"
+requires-python = ">=3.11"
 keywords = []
 
 classifiers = [
@@ -22,7 +22,6 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -32,7 +31,7 @@ classifiers = [
 dependencies = [
     "ccflow>=0.8.5",
     "ccflow-etl>=0.1.0",
-    "httpx",
+    "httpx2",
     "jinja2",
 ]
 
@@ -61,7 +60,7 @@ Repository = "https://github.com/1kbgz/ccflow-http"
 Homepage = "https://github.com/1kbgz/ccflow-http"
 
 [tool.bumpversion]
-current_version = "0.1.0"
+current_version = "0.2.0"
 commit = true
 tag = true
 commit_args = "-s"

ccflow_http-0.1.0/ccflow_http/__init__.py

@@ -1,3 +0,0 @@
-from .base import *
-
-__version__ = "0.1.0"