python-sendparcel-inpost 0.2.0__tar.gz → 0.3.0__tar.gz

python_sendparcel_inpost-0.3.0/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/),
+and this project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.3.0] - 2026-07-04
+
+### Fixed
+
+- Transport factory now returns a shared, cached `ShipXClient` per
+  configuration instead of building (and leaking) a fresh
+  `httpx.AsyncClient` on every operation. Connections are reused and
+  the circuit breaker, rate limiter, and metrics keep their state
+  across operations.
+- HTTP 429 responses are retried (also for non-idempotent operations —
+  a rate-limited request was never processed), honoring the
+  `Retry-After` header when present.
+- Retry log messages now name the operation being retried.
+- Removed an unreachable `httpx.HTTPStatusError` retry branch.
+- Replaced deprecated `asyncio.get_event_loop().time()` with
+  `time.monotonic()`; rate limiter now uses anyio primitives (works
+  under trio).
+
+### Added
+
+- `sendparcel_inpost.aclose_transports()` — closes and evicts all
+  shared ShipX clients; call on application shutdown.
+- Resilience settings exposed in `config_schema`: `rate_limit`,
+  `burst`, `max_retries`, `retry_base_delay`, `circuit_threshold`,
+  `circuit_cooldown`.
+
+### Changed
+
+- Requires `python-sendparcel>=0.3.0` (unified `BaseProvider`,
+  `CallbackContext`, transport injection).
+
+## [0.2.0] - 2025-06-05
+
+### Changed
+
+- Adapted to the python-sendparcel 0.2.x provider API:
+  `CallbackContext`-based callbacks and transport injection via
+  `transport_factory`.
+- Removed dead enums (`ShipXService`, `ShipXParcelTemplate`).
+
+## [0.1.0] - 2026-02-16
+
+### Added
+
+- InPost ShipX provider for python-sendparcel
+- `InPostLockerProvider` for Paczkomat locker deliveries
+- `InPostCourierProvider` for door-to-door courier deliveries
+- `ShipXClient` standalone async HTTP client for the ShipX API
+- ShipX exception hierarchy (`ShipXAPIError`, `ShipXAuthenticationError`, `ShipXValidationError`)
+- ShipX-specific enums (`ShipXService`, `ShipXParcelTemplate`)
+- ShipX-specific TypedDicts (`ShipXAddress`, `ShipXPeer`, `ShipXParcel`, `ShipXShipmentPayload`)
+- Status mapping from 24 ShipX statuses to 8 sendparcel statuses
+- Webhook verification by InPost source IP range (`91.216.25.0/24`)
+- Address conversion with legacy name-splitting fallback
+- Entry-point registration for auto-discovery
+- Full test suite (93 tests)

{python_sendparcel_inpost-0.2.0 → python_sendparcel_inpost-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sendparcel-inpost
-Version: 0.2.0
+Version: 0.3.0
 Summary: InPost ShipX provider for python-sendparcel.
 Project-URL: Homepage, https://github.com/python-sendparcel/python-sendparcel-inpost
 Project-URL: Repository, https://github.com/python-sendparcel/python-sendparcel-inpost
@@ -22,7 +22,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: anyio>=4.0
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: python-sendparcel>=0.1.1
+Requires-Dist: python-sendparcel>=0.3.0
 Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.24.0; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0; extra == 'dev'

{python_sendparcel_inpost-0.2.0 → python_sendparcel_inpost-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-sendparcel-inpost"
-version = "0.2.0"
+version = "0.3.0"
 description = "InPost ShipX provider for python-sendparcel."
 readme = "README.md"
 license = { text = "MIT" }
@@ -18,7 +18,7 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Typing :: Typed",
 ]
-dependencies = ["python-sendparcel>=0.1.1", "httpx>=0.27.0", "anyio>=4.0"]
+dependencies = ["python-sendparcel>=0.3.0", "httpx>=0.27.0", "anyio>=4.0"]
 
 [project.optional-dependencies]
 dev = [

{python_sendparcel_inpost-0.2.0 → python_sendparcel_inpost-0.3.0}/src/sendparcel_inpost/__init__.py

@@ -1,9 +1,10 @@
 """InPost ShipX provider for python-sendparcel."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 from sendparcel_inpost.client import ShipXClient
 from sendparcel_inpost.exceptions import CircuitBreakerError
+from sendparcel_inpost.providers.base import aclose_transports
 from sendparcel_inpost.providers.courier import InPostCourierProvider
 from sendparcel_inpost.providers.locker import InPostLockerProvider
 
@@ -13,4 +14,5 @@ __all__ = [
     "InPostLockerProvider",
     "ShipXClient",
     "__version__",
+    "aclose_transports",
 ]

python_sendparcel_inpost-0.3.0/src/sendparcel_inpost/circuit_breaker.py

@@ -0,0 +1,155 @@
+"""Circuit breaker and metrics for external API resilience."""
+
+from __future__ import annotations
+
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ShipXMetrics:
+    """Collects metrics for a single ShipXClient instance.
+
+    Thread-safe. Use ``snapshot()`` to get a point-in-time view.
+    """
+
+    _lock: threading.Lock = field(default_factory=threading.Lock)
+    _request_count: int = 0
+    _error_count: int = 0
+    _circuit_trip_count: int = 0
+    _retry_count: int = 0
+    _total_latency_ms: float = 0.0
+    _max_latency_ms: float = 0.0
+    _last_error: str | None = None
+    _last_error_at: float | None = None
+    _circuit_state: str = "closed"
+
+    @property
+    def circuit_state(self) -> str:
+        with self._lock:
+            return self._circuit_state
+
+    def set_circuit_state(self, state: str) -> None:
+        with self._lock:
+            self._circuit_state = state
+
+    def record_request(
+        self,
+        latency_ms: float,
+        success: bool,
+        error: str | None = None,
+    ) -> None:
+        with self._lock:
+            self._request_count += 1
+            self._total_latency_ms += latency_ms
+            if latency_ms > self._max_latency_ms:
+                self._max_latency_ms = latency_ms
+            if not success:
+                self._error_count += 1
+                self._last_error = error
+                self._last_error_at = time.time()
+
+    def record_circuit_trip(self) -> None:
+        with self._lock:
+            self._circuit_trip_count += 1
+
+    def record_retry(self) -> None:
+        with self._lock:
+            self._retry_count += 1
+
+    def snapshot(self) -> dict[str, Any]:
+        """Return a point-in-time copy of all metrics."""
+        with self._lock:
+            avg_latency = (
+                self._total_latency_ms / self._request_count
+                if self._request_count > 0
+                else 0.0
+            )
+            return {
+                "request_count": self._request_count,
+                "error_count": self._error_count,
+                "retry_count": self._retry_count,
+                "circuit_trip_count": self._circuit_trip_count,
+                "circuit_state": self._circuit_state,
+                "avg_latency_ms": round(avg_latency, 2),
+                "max_latency_ms": round(self._max_latency_ms, 2),
+                "last_error": self._last_error,
+                "last_error_at": self._last_error_at,
+            }
+
+
+class _CircuitBreaker:
+    """Simple circuit breaker for the ShipX API.
+
+    States:
+    - CLOSED: normal operation, requests pass through
+    - OPEN: circuit tripped, requests fail fast
+    - HALF_OPEN: one probe request allowed after cooldown
+
+    Transitions:
+    - CLOSED → OPEN: after `threshold` consecutive failures
+    - OPEN → HALF_OPEN: after `cooldown` seconds
+    - HALF_OPEN → CLOSED: probe request succeeds
+    - HALF_OPEN → OPEN: probe request fails
+    """
+
+    class State:
+        CLOSED = "closed"
+        OPEN = "open"
+        HALF_OPEN = "half_open"
+
+    def __init__(
+        self,
+        threshold: int = 5,
+        cooldown: float = 30.0,
+    ) -> None:
+        self._threshold = threshold
+        self._cooldown = cooldown
+        self._state = self.State.CLOSED
+        self._failures = 0
+        self._opened_at: float | None = None
+
+    @property
+    def state(self) -> str:
+        """Current circuit state, transitioning OPEN → HALF_OPEN on cooldown."""
+        if self._state == self.State.OPEN and self._opened_at is not None:
+            elapsed = time.monotonic() - self._opened_at
+            if elapsed >= self._cooldown:
+                self._state = self.State.HALF_OPEN
+        return self._state
+
+    @property
+    def failures(self) -> int:
+        return self._failures
+
+    @property
+    def cooldown_remaining(self) -> float:
+        if self._state != self.State.OPEN or self._opened_at is None:
+            return 0.0
+        elapsed = time.monotonic() - self._opened_at
+        return max(0.0, self._cooldown - elapsed)
+
+    def allow_request(self) -> bool:
+        """Check if a request should be allowed through."""
+        current = self.state  # triggers OPEN → HALF_OPEN transition
+        return current != self.State.OPEN
+
+    def record_success(self) -> None:
+        """Record a successful request."""
+        self._failures = 0
+        self._state = self.State.CLOSED
+        self._opened_at = None
+
+    def record_failure(self) -> None:
+        """Record a failed request."""
+        self._failures += 1
+        if self.state == self.State.HALF_OPEN:
+            # Probe failed — reopen circuit
+            self._state = self.State.OPEN
+            self._opened_at = time.monotonic()
+        elif self._failures >= self._threshold:
+            # Threshold reached — open circuit
+            self._state = self.State.OPEN
+            self._opened_at = time.monotonic()