morphiq-sdk 0.1.0__py3-none-any.whl

morphiq_sdk/__init__.py

@@ -0,0 +1,89 @@
+"""Typed sync/async clients for the MorphIQ Labs API."""
+
+from importlib.metadata import version
+
+from .client import AsyncMorphIQ, MorphIQ
+from .errors import (
+    APIError,
+    MorphIQError,
+    RateLimitError,
+    RequestTimeout,
+    ResponseError,
+    TransportError,
+)
+from .market_data import PriceAdjustment, PriceBar, PriceHistory, PriceInterval, PriceProvider
+from .models import (
+    AnalyticsRequest,
+    AnalyticsResponse,
+    AnalyticsResult,
+    BatchAnalyticsRequest,
+    BatchAnalyticsResponse,
+    BatchFailure,
+    BatchGreeksRequest,
+    BatchGreeksResponse,
+    BatchImpliedVolatilityRequest,
+    BatchImpliedVolatilityResponse,
+    BatchPriceRequest,
+    BatchPriceResponse,
+    BatchSuccess,
+    DividendEvent,
+    Greeks,
+    GreeksRequest,
+    GreeksResponse,
+    GreeksResult,
+    ImpliedVolatilityRequest,
+    ImpliedVolatilityResponse,
+    ImpliedVolatilityResult,
+    PriceRequest,
+    PriceResponse,
+    RegimeRequest,
+    RegimeResponse,
+)
+from .workflows import AsyncBatchWorkflow, BatchWorkflow, ChunkAttempt
+
+__version__ = version("morphiq-sdk")
+
+__all__ = [
+    "AsyncBatchWorkflow",
+    "BatchWorkflow",
+    "ChunkAttempt",
+    "BatchPriceRequest",
+    "BatchPriceResponse",
+    "BatchGreeksRequest",
+    "BatchGreeksResponse",
+    "BatchImpliedVolatilityRequest",
+    "BatchImpliedVolatilityResponse",
+    "BatchAnalyticsRequest",
+    "BatchAnalyticsResponse",
+    "BatchSuccess",
+    "BatchFailure",
+    "RateLimitError",
+    "APIError",
+    "AnalyticsRequest",
+    "AnalyticsResponse",
+    "AnalyticsResult",
+    "AsyncMorphIQ",
+    "DividendEvent",
+    "Greeks",
+    "GreeksRequest",
+    "GreeksResponse",
+    "GreeksResult",
+    "ImpliedVolatilityRequest",
+    "ImpliedVolatilityResponse",
+    "ImpliedVolatilityResult",
+    "MorphIQ",
+    "MorphIQError",
+    "PriceAdjustment",
+    "PriceBar",
+    "PriceHistory",
+    "PriceInterval",
+    "PriceProvider",
+    "PriceRequest",
+    "PriceResponse",
+    "RegimeRequest",
+    "RegimeResponse",
+    "RequestTimeout",
+    "ResponseError",
+    "TransportError",
+    "__version__",
+]

morphiq_sdk/client.py

@@ -0,0 +1,469 @@
+"""Shared JSON API behavior for synchronous and asynchronous HTTPX clients."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Sequence
+from types import TracebackType
+from typing import Any, TypeVar
+
+import httpx
+from pydantic import ValidationError
+
+from .errors import APIError, RateLimitError, RequestTimeout, ResponseError, TransportError
+from .models import (
+    AnalyticsRequest,
+    AnalyticsResponse,
+    BatchAnalyticsRequest,
+    BatchAnalyticsResponse,
+    BatchGreeksRequest,
+    BatchGreeksResponse,
+    BatchImpliedVolatilityRequest,
+    BatchImpliedVolatilityResponse,
+    BatchPriceRequest,
+    BatchPriceResponse,
+    ErrorEnvelope,
+    GreeksRequest,
+    GreeksResponse,
+    ImpliedVolatilityRequest,
+    ImpliedVolatilityResponse,
+    PriceRequest,
+    PriceResponse,
+    RegimeRequest,
+    RegimeResponse,
+    ResponseMetadata,
+    _BatchResponse,
+)
+from .workflows import AsyncBatchWorkflow, BatchWorkflow, _prepare_chunks
+
+_ResponseType = TypeVar(
+    "_ResponseType",
+    BatchPriceResponse,
+    BatchGreeksResponse,
+    BatchImpliedVolatilityResponse,
+    BatchAnalyticsResponse,
+    PriceResponse,
+    RegimeResponse,
+    GreeksResponse,
+    ImpliedVolatilityResponse,
+    AnalyticsResponse,
+)
+
+
+_BatchResponseType = TypeVar("_BatchResponseType", bound=_BatchResponse[Any])
+
+
+def _check_batch(response: _BatchResponseType, expected: int) -> _BatchResponseType:
+    # Never silently sort, drop or misassociate outcomes with submitted options.
+    if [item.index for item in response.results] != list(range(expected)):
+        raise ResponseError(
+            request_id=response.metadata.request_id,
+            body=response.raw_body,
+            headers=response.headers,
+            metadata=response.metadata,
+        )
+    return response
+
+
+def _redact_body(body: bytes, key: str) -> bytes:
+    """Handle both literal and JSON-escaped reflections without rewriting clean bodies."""
+    try:
+        payload = json.loads(body)
+    except (ValueError, UnicodeDecodeError):
+        return body.replace(key.encode(), b"[REDACTED]")
+    changed = False
+
+    def visit(value: Any) -> Any:
+        nonlocal changed
+        if isinstance(value, str):
+            if key in value:
+                changed = True
+                return value.replace(key, "[REDACTED]")
+        elif isinstance(value, list):
+            return [visit(item) for item in value]
+        elif isinstance(value, dict):
+            return {visit(name): visit(item) for name, item in value.items()}
+        return value
+
+    sanitized = visit(payload)
+    return json.dumps(sanitized).encode() if changed else body
+
+
+class _Configuration:
+    def __init__(
+        self, *, base_url: str | None, api_key: str | None, allow_unauthenticated: bool
+    ) -> None:
+        endpoint = (
+            base_url
+            if base_url is not None
+            else os.environ.get("MORPHIQ_API_BASE_URL") or "https://api.morphiqlabs.com"
+        )
+        try:
+            url = httpx.URL(endpoint)
+        except httpx.InvalidURL:
+            raise ValueError("base_url must be an absolute HTTP(S) URL.") from None
+        if (
+            url.scheme not in ("http", "https")
+            or not url.host
+            or url.userinfo
+            or url.query
+            or url.fragment
+        ):
+            raise ValueError(
+                "base_url must be an HTTP(S) URL without credentials, query or fragment."
+            )
+        self.url = str(url).rstrip("/") + "/"
+        key = api_key if api_key is not None else os.environ.get("MORPHIQ_API_KEY")
+        if key is not None and (not key or not key.isascii() or any(c.isspace() for c in key)):
+            raise ValueError("API key must be a non-empty ASCII token without whitespace.")
+        if not key and not allow_unauthenticated:
+            raise ValueError(
+                "Pass api_key or set MORPHIQ_API_KEY. Only a controlled open development "
+                "service should use allow_unauthenticated=True."
+            )
+        self._key = key
+
+    def headers(self) -> dict[str, str]:
+        result = {"Accept": "application/json", "User-Agent": "morphiq-sdk-python"}
+        if self._key:
+            result["Authorization"] = f"Bearer {self._key}"
+        return result
+
+    def decode(self, response: httpx.Response, model: type[_ResponseType]) -> _ResponseType:
+        # Retain response evidence, never the request or its Authorization header.
+        body = response.content
+        headers = dict(response.headers)
+        if self._key:
+            body = _redact_body(body, self._key)
+            headers = {
+                key: value.replace(self._key, "[REDACTED]") for key, value in headers.items()
+            }
+        request_id = headers.get("x-request-id")
+        if response.status_code != 200:
+            try:
+                envelope = ErrorEnvelope.model_validate_json(body)
+            except ValidationError:
+                envelope = None
+            error_type = RateLimitError if response.status_code == 429 else APIError
+            raise error_type(
+                status_code=response.status_code,
+                envelope=envelope,
+                request_id=request_id,
+                body=body,
+                headers=headers,
+            )
+        try:
+            result = model.model_validate_json(body)
+        except ValidationError:
+            # A malformed numerical result does not erase valid billing evidence.
+            metadata = None
+            try:
+                payload = json.loads(body)
+                if isinstance(payload, dict):
+                    metadata = ResponseMetadata.model_validate(payload.get("metadata"))
+            except (ValueError, UnicodeDecodeError):
+                pass
+            raise ResponseError(
+                request_id=request_id, body=body, headers=headers, metadata=metadata
+            ) from None
+        result._raw_body = body
+        result._headers = headers
+        return result
+
+
+class MorphIQ:
+    """Synchronous API client. No retries or redirects are performed.
+
+    The API URL defaults to https://api.morphiqlabs.com; override it with
+    ``base_url`` or MORPHIQ_API_BASE_URL. ``api_key`` falls back to MORPHIQ_API_KEY.
+    A numeric timeout applies to connect/read/write/pool waits;
+    pass ``httpx.Timeout`` to tune them separately. Use a context manager or close().
+    """
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float | httpx.Timeout = 30.0,
+        allow_unauthenticated: bool = False,
+        transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        self._config = _Configuration(
+            base_url=base_url, api_key=api_key, allow_unauthenticated=allow_unauthenticated
+        )
+        self._http = httpx.Client(
+            base_url=self._config.url,
+            headers=self._config.headers(),
+            timeout=timeout,
+            transport=transport,
+            follow_redirects=False,
+            trust_env=False,
+        )
+
+    def price(self, request: PriceRequest) -> PriceResponse:
+        """Price one option; preserve server model selection and charge evidence."""
+        return self._post("v1/price", request.to_wire(), PriceResponse)
+
+    def regime(self, request: RegimeRequest) -> RegimeResponse:
+        """Identify regime heads; preserve scores, applicability and provenance."""
+        return self._post("v1/regime", request.to_wire(), RegimeResponse)
+
+    def greeks(self, request: GreeksRequest) -> GreeksResponse:
+        """Return the option price and all ten Greeks, preserving the API's units."""
+        return self._post("v1/greeks", request.to_wire(), GreeksResponse)
+
+    def implied_volatility(self, request: ImpliedVolatilityRequest) -> ImpliedVolatilityResponse:
+        """Solve IV from an option premium; preserve residual basis and charge evidence."""
+        return self._post("v1/implied-volatility", request.to_wire(), ImpliedVolatilityResponse)
+
+    def analytics(self, request: AnalyticsRequest) -> AnalyticsResponse:
+        """Return combined analytics and one server-reported commercial charge."""
+        return self._post("v1/analytics", request.to_wire(), AnalyticsResponse)
+
+    def price_batch(self, request: BatchPriceRequest) -> BatchPriceResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = self._post("v1/price:batch", payload, BatchPriceResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    def greeks_batch(self, request: BatchGreeksRequest) -> BatchGreeksResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = self._post("v1/greeks:batch", payload, BatchGreeksResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    def implied_volatility_batch(
+        self, request: BatchImpliedVolatilityRequest
+    ) -> BatchImpliedVolatilityResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = self._post(
+            "v1/implied-volatility:batch", payload, BatchImpliedVolatilityResponse
+        )
+        return _check_batch(response, len(payload["requests"]))
+
+    def analytics_batch(self, request: BatchAnalyticsRequest) -> BatchAnalyticsResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = self._post("v1/analytics:batch", payload, BatchAnalyticsResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    def price_workflow(
+        self, requests: Sequence[PriceRequest], *, chunk_size: int
+    ) -> BatchWorkflow[BatchPriceRequest, BatchPriceResponse]:
+        """Prepare explicit sequential chunks without sending requests; call run() once."""
+        return BatchWorkflow(
+            _prepare_chunks(requests, BatchPriceRequest, chunk_size), self.price_batch
+        )
+
+    def greeks_workflow(
+        self, requests: Sequence[GreeksRequest], *, chunk_size: int
+    ) -> BatchWorkflow[BatchGreeksRequest, BatchGreeksResponse]:
+        """Prepare explicit sequential chunks without sending requests; call run() once."""
+        return BatchWorkflow(
+            _prepare_chunks(requests, BatchGreeksRequest, chunk_size), self.greeks_batch
+        )
+
+    def implied_volatility_workflow(
+        self, requests: Sequence[ImpliedVolatilityRequest], *, chunk_size: int
+    ) -> BatchWorkflow[BatchImpliedVolatilityRequest, BatchImpliedVolatilityResponse]:
+        """Prepare explicit sequential chunks without sending requests; call run() once."""
+        return BatchWorkflow(
+            _prepare_chunks(requests, BatchImpliedVolatilityRequest, chunk_size),
+            self.implied_volatility_batch,
+        )
+
+    def analytics_workflow(
+        self, requests: Sequence[AnalyticsRequest], *, chunk_size: int
+    ) -> BatchWorkflow[BatchAnalyticsRequest, BatchAnalyticsResponse]:
+        """Prepare explicit sequential chunks without sending requests; call run() once."""
+        return BatchWorkflow(
+            _prepare_chunks(requests, BatchAnalyticsRequest, chunk_size), self.analytics_batch
+        )
+
+    def _post(
+        self, path: str, payload: dict[str, Any], model: type[_ResponseType]
+    ) -> _ResponseType:
+        try:
+            response = self._http.post(path, json=payload)
+        except httpx.TimeoutException:
+            raise RequestTimeout(
+                "The request timed out; execution and CU charges may be unknown. "
+                "No retry was attempted."
+            ) from None
+        except httpx.RequestError:
+            raise TransportError(
+                "The request failed before a complete response was received. "
+                "Execution and CU charges may be unknown; no retry was attempted."
+            ) from None
+        return self._config.decode(response, model)
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> MorphIQ:
+        self._http.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+
+class AsyncMorphIQ:
+    """Async equivalent of MorphIQ; use async with and await client.price(...)."""
+
+    def __init__(
+        self,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        timeout: float | httpx.Timeout = 30.0,
+        allow_unauthenticated: bool = False,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        self._config = _Configuration(
+            base_url=base_url, api_key=api_key, allow_unauthenticated=allow_unauthenticated
+        )
+        self._http = httpx.AsyncClient(
+            base_url=self._config.url,
+            headers=self._config.headers(),
+            timeout=timeout,
+            transport=transport,
+            follow_redirects=False,
+            trust_env=False,
+        )
+
+    async def price(self, request: PriceRequest) -> PriceResponse:
+        """Price one option; preserve server model selection and charge evidence."""
+        return await self._post("v1/price", request.to_wire(), PriceResponse)
+
+    async def regime(self, request: RegimeRequest) -> RegimeResponse:
+        """Identify regime heads; preserve scores, applicability and provenance."""
+        return await self._post("v1/regime", request.to_wire(), RegimeResponse)
+
+    async def greeks(self, request: GreeksRequest) -> GreeksResponse:
+        """Return the option price and all ten Greeks, preserving the API's units."""
+        return await self._post("v1/greeks", request.to_wire(), GreeksResponse)
+
+    async def implied_volatility(
+        self, request: ImpliedVolatilityRequest
+    ) -> ImpliedVolatilityResponse:
+        """Solve IV from an option premium; preserve residual basis and charge evidence."""
+        return await self._post(
+            "v1/implied-volatility", request.to_wire(), ImpliedVolatilityResponse
+        )
+
+    async def analytics(self, request: AnalyticsRequest) -> AnalyticsResponse:
+        """Return combined analytics and one server-reported commercial charge."""
+        return await self._post("v1/analytics", request.to_wire(), AnalyticsResponse)
+
+    async def price_batch(self, request: BatchPriceRequest) -> BatchPriceResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = await self._post("v1/price:batch", payload, BatchPriceResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    async def greeks_batch(self, request: BatchGreeksRequest) -> BatchGreeksResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = await self._post("v1/greeks:batch", payload, BatchGreeksResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    async def implied_volatility_batch(
+        self, request: BatchImpliedVolatilityRequest
+    ) -> BatchImpliedVolatilityResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = await self._post(
+            "v1/implied-volatility:batch", payload, BatchImpliedVolatilityResponse
+        )
+        return _check_batch(response, len(payload["requests"]))
+
+    async def analytics_batch(self, request: BatchAnalyticsRequest) -> BatchAnalyticsResponse:
+        """Submit one batch; preserve ordered outcomes and count its charge once."""
+        payload = request.to_wire()
+        response = await self._post("v1/analytics:batch", payload, BatchAnalyticsResponse)
+        return _check_batch(response, len(payload["requests"]))
+
+    def price_workflow(
+        self, requests: Sequence[PriceRequest], *, chunk_size: int, max_concurrency: int = 1
+    ) -> AsyncBatchWorkflow[BatchPriceRequest, BatchPriceResponse]:
+        """Prepare chunks without HTTP; max_concurrency explicitly bounds async execution."""
+        return AsyncBatchWorkflow(
+            _prepare_chunks(requests, BatchPriceRequest, chunk_size),
+            self.price_batch,
+            max_concurrency=max_concurrency,
+        )
+
+    def greeks_workflow(
+        self, requests: Sequence[GreeksRequest], *, chunk_size: int, max_concurrency: int = 1
+    ) -> AsyncBatchWorkflow[BatchGreeksRequest, BatchGreeksResponse]:
+        """Prepare chunks without HTTP; max_concurrency explicitly bounds async execution."""
+        return AsyncBatchWorkflow(
+            _prepare_chunks(requests, BatchGreeksRequest, chunk_size),
+            self.greeks_batch,
+            max_concurrency=max_concurrency,
+        )
+
+    def implied_volatility_workflow(
+        self,
+        requests: Sequence[ImpliedVolatilityRequest],
+        *,
+        chunk_size: int,
+        max_concurrency: int = 1,
+    ) -> AsyncBatchWorkflow[BatchImpliedVolatilityRequest, BatchImpliedVolatilityResponse]:
+        """Prepare chunks without HTTP; max_concurrency explicitly bounds async execution."""
+        return AsyncBatchWorkflow(
+            _prepare_chunks(requests, BatchImpliedVolatilityRequest, chunk_size),
+            self.implied_volatility_batch,
+            max_concurrency=max_concurrency,
+        )
+
+    def analytics_workflow(
+        self, requests: Sequence[AnalyticsRequest], *, chunk_size: int, max_concurrency: int = 1
+    ) -> AsyncBatchWorkflow[BatchAnalyticsRequest, BatchAnalyticsResponse]:
+        """Prepare chunks without HTTP; max_concurrency explicitly bounds async execution."""
+        return AsyncBatchWorkflow(
+            _prepare_chunks(requests, BatchAnalyticsRequest, chunk_size),
+            self.analytics_batch,
+            max_concurrency=max_concurrency,
+        )
+
+    async def _post(
+        self, path: str, payload: dict[str, Any], model: type[_ResponseType]
+    ) -> _ResponseType:
+        try:
+            response = await self._http.post(path, json=payload)
+        except httpx.TimeoutException:
+            raise RequestTimeout(
+                "The request timed out; execution and CU charges may be unknown. "
+                "No retry was attempted."
+            ) from None
+        except httpx.RequestError:
+            raise TransportError(
+                "The request failed before a complete response was received. "
+                "Execution and CU charges may be unknown; no retry was attempted."
+            ) from None
+        return self._config.decode(response, model)
+
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> AsyncMorphIQ:
+        await self._http.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.aclose()

morphiq_sdk/errors.py

@@ -0,0 +1,102 @@
+"""Errors without retained HTTP requests or credential-bearing trace messages."""
+
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
+
+from .models import ErrorEnvelope, ResponseMetadata, ServiceErrorMetadata
+
+
+class MorphIQError(Exception):
+    """Base class for request/response failures from the SDK."""
+
+
+class TransportError(MorphIQError):
+    """No complete response was received. Execution and charges may be unknown."""
+
+
+class RequestTimeout(TransportError):
+    """A client timeout does not establish that the server did no work."""
+
+
+class ResponseError(MorphIQError):
+    """A successful HTTP status carried an invalid API response.
+
+    Independently valid pricing metadata remains available even when the result
+    is malformed. Missing metadata does not establish a zero charge.
+    """
+
+    def __init__(
+        self,
+        *,
+        request_id: str | None,
+        body: bytes,
+        headers: dict[str, str],
+        metadata: ResponseMetadata | None = None,
+    ) -> None:
+        self.metadata = metadata
+        self.request_id = request_id or (metadata.request_id if metadata else None)
+        self.body = body
+        self.headers = headers
+        super().__init__("The API returned an invalid API response; no retry was attempted.")
+
+
+class APIError(MorphIQError):
+    """Non-success HTTP response, including gateway and router failures.
+
+    Inspect ``code``, ``request_id``, ``metadata``, ``headers`` and ``body``.
+    The known API key is redacted if a remote server reflects it in a response.
+    Missing charge metadata is never interpreted as a zero charge.
+    """
+
+    def __init__(
+        self,
+        *,
+        status_code: int,
+        envelope: ErrorEnvelope | None,
+        request_id: str | None,
+        body: bytes,
+        headers: dict[str, str],
+    ) -> None:
+        self.status_code = status_code
+        self.code = envelope.error.code if envelope else None
+        self.message = (
+            envelope.error.message if envelope else "Non-standard API or gateway response"
+        )
+        self.field = envelope.error.field if envelope else None
+        self.metadata: ResponseMetadata | ServiceErrorMetadata | None = (
+            envelope.metadata if envelope else None
+        )
+        self.request_id = self.metadata.request_id if self.metadata else request_id
+        self.body = body
+        self.headers = headers
+        self.retry_after = headers.get("retry-after")
+        detail = f" ({self.code})" if self.code else ""
+        support = f"; request_id={self.request_id}" if self.request_id else ""
+        super().__init__(f"HTTP {status_code}{detail}: {self.message}{support}")
+
+
+class RateLimitError(APIError):
+    """HTTP 429, including gateway responses. No automatic wait, split or retry.
+
+    ``retry_after`` retains the raw server header; ``retry_delay`` interprets
+    delta-seconds or an HTTP date for callers choosing when to try again.
+    Absence or an invalid value returns None, never an invented zero delay.
+    """
+
+    def retry_delay(self, *, now: datetime | None = None) -> float | None:
+        value = self.retry_after
+        if value is None:
+            return None
+        value = value.strip()
+        try:
+            if value.isascii() and value.isdigit():
+                return float(int(value))
+            retry_at = parsedate_to_datetime(value)
+            if retry_at.tzinfo is None:
+                retry_at = retry_at.replace(tzinfo=UTC)
+            current = now if now is not None else datetime.now(UTC)
+            if current.tzinfo is None:
+                raise ValueError("now must include a timezone")
+            return max(0.0, (retry_at - current).total_seconds())
+        except (ValueError, TypeError, OverflowError):
+            return None