mailsocket 0.3.0__tar.gz → 0.3.1__tar.gz

{mailsocket-0.3.0 → mailsocket-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mailsocket
-Version: 0.3.0
+Version: 0.3.1
 Summary: Official Python client for the mailsocket REST API — one line to wait for an OTP.
 Author: mailsocket
 License-Expression: MIT
@@ -162,6 +162,12 @@ invalid id never reaches the network.
 
 ## Changelog
 
+- **0.3.1** — the `wait*` helpers no longer miss a message that lands between
+  two long-poll calls. When you pass no `since`, the first call still omits it
+  (the server uses the request start), and every following call sends the
+  cutoff the server reported in the `Mailsocket-Wait-Since` response header of
+  the previous call. With an older server that sends no such header, behaviour
+  is unchanged. An explicit `since` is used as before on every call.
 - **0.3.0** — new `Client.send_test_code(inbox_id)` (`POST /inboxes/{id}/test-code`):
   puts one sample OTP email into your own inbox without going through the
   mail server, and returns `{"message_id", "sent_at"}`. README samples now

{mailsocket-0.3.0 → mailsocket-0.3.1}/README.md

@@ -135,6 +135,12 @@ invalid id never reaches the network.
 
 ## Changelog
 
+- **0.3.1** — the `wait*` helpers no longer miss a message that lands between
+  two long-poll calls. When you pass no `since`, the first call still omits it
+  (the server uses the request start), and every following call sends the
+  cutoff the server reported in the `Mailsocket-Wait-Since` response header of
+  the previous call. With an older server that sends no such header, behaviour
+  is unchanged. An explicit `since` is used as before on every call.
 - **0.3.0** — new `Client.send_test_code(inbox_id)` (`POST /inboxes/{id}/test-code`):
   puts one sample OTP email into your own inbox without going through the
   mail server, and returns `{"message_id", "sent_at"}`. README samples now

{mailsocket-0.3.0 → mailsocket-0.3.1}/mailsocket/__init__.py

@@ -3,7 +3,7 @@
 from .client import Client, Page, WaitResult
 from .errors import AuthError, MailsocketError, NotFound, RateLimited, WaitTimeout
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 __all__ = [
     "Client",

{mailsocket-0.3.0 → mailsocket-0.3.1}/mailsocket/client.py

@@ -18,6 +18,8 @@ DEFAULT_BASE_URL = "https://dash.mailsocket.app/api/v1"
 WAIT_TIMEOUT_MAX = 25  # seconds — the server clamps the per-call wait to [1, 25]
 WAIT_SOCKET_BUFFER = 10  # seconds of client-side slack above the server block
 DEFAULT_RETRY_AFTER = 1.0  # seconds, when a 429 carries no Retry-After header
+# Response header with the cutoff a wait call actually used (server >= 2026-10).
+WAIT_SINCE_HEADER = "mailsocket-wait-since"
 
 __all__ = ["Client", "Page", "WaitResult"]
 
@@ -289,6 +291,12 @@ class Client:
         since,
     ) -> WaitResult:
         deadline = _monotonic() + float(timeout)
+        # No caller ``since``: the first call omits it (server default = the
+        # request start), and every later call sends back the cutoff the
+        # previous response reported, so a message that lands between two
+        # calls is still matched. An older server sends no header; then each
+        # call keeps omitting ``since`` exactly as before.
+        cursor = since
         while True:
             remaining = deadline - _monotonic()
             if remaining <= 0:
@@ -297,8 +305,8 @@ class Client:
                 )
             server_timeout = max(1.0, min(float(WAIT_TIMEOUT_MAX), remaining))
             params = {"timeout": server_timeout, "require": require}
-            if since is not None:
-                params["since"] = since
+            if cursor is not None:
+                params["since"] = cursor
             if min_confidence is not None:
                 params["min_confidence"] = min_confidence
 
@@ -312,6 +320,7 @@ class Client:
             if status == 200:
                 return WaitResult(payload["data"])
             if status == 204:
+                cursor = self._next_cursor(since, cursor, headers)
                 continue
             if status == 429:
                 if not self._retry_wait_on_429:
@@ -326,6 +335,15 @@ class Client:
                 continue
             self._raise_for_status(status, headers, payload)
 
+    @staticmethod
+    def _next_cursor(since, cursor, headers: dict):
+        """The ``since`` for the next wait call: the caller's own value when
+        given, else the server-reported cutoff of this call, else unchanged
+        (an older server sends no header)."""
+        if since is not None:
+            return cursor
+        return headers.get(WAIT_SINCE_HEADER) or cursor
+
     def _request(self, method: str, path: str, *, params: dict | None = None, json_body=None):
         status, headers, body = self._request_http(method, path, params=params, json_body=json_body)
         payload = self._parse_json(body)
@@ -339,7 +357,7 @@ class Client:
             url += "?" + urllib.parse.urlencode(params, doseq=True)
         headers = {
             "Accept": "application/json",
-            "User-Agent": "mailsocket-python/0.3.0",
+            "User-Agent": "mailsocket-python/0.3.1",
         }
         headers.update(self._extra_headers)
         # Set last so nothing in extra_headers can ever replace it.

{mailsocket-0.3.0 → mailsocket-0.3.1}/mailsocket.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mailsocket
-Version: 0.3.0
+Version: 0.3.1
 Summary: Official Python client for the mailsocket REST API — one line to wait for an OTP.
 Author: mailsocket
 License-Expression: MIT
@@ -162,6 +162,12 @@ invalid id never reaches the network.
 
 ## Changelog
 
+- **0.3.1** — the `wait*` helpers no longer miss a message that lands between
+  two long-poll calls. When you pass no `since`, the first call still omits it
+  (the server uses the request start), and every following call sends the
+  cutoff the server reported in the `Mailsocket-Wait-Since` response header of
+  the previous call. With an older server that sends no such header, behaviour
+  is unchanged. An explicit `since` is used as before on every call.
 - **0.3.0** — new `Client.send_test_code(inbox_id)` (`POST /inboxes/{id}/test-code`):
   puts one sample OTP email into your own inbox without going through the
   mail server, and returns `{"message_id", "sent_at"}`. README samples now

{mailsocket-0.3.0 → mailsocket-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mailsocket"
-version = "0.3.0"
+version = "0.3.1"
 description = "Official Python client for the mailsocket REST API — one line to wait for an OTP."
 readme = "README.md"
 requires-python = ">=3.9"

{mailsocket-0.3.0 → mailsocket-0.3.1}/tests/test_client.py

@@ -193,6 +193,63 @@ def test_wait_keeps_polling_through_204s_then_returns(monkeypatch):
         assert "require=otp" in url
 
 
+def _since_of(url):
+    query = urllib.parse.parse_qs(urllib.parse.urlsplit(url).query)
+    return query.get("since", [None])[0]
+
+
+CURSOR_1 = "2026-10-12T03:04:05.123456Z"
+CURSOR_2 = "2026-10-12T03:04:30.654321Z"
+EPOCH = "1970-01-01T00:00:00.000000Z"
+H = "Mailsocket-Wait-Since"
+
+
+@pytest.mark.parametrize(
+    "method, kwargs, headers, expected",
+    [
+        # 0.3.1 gap fix: no caller since -> call 1 omits it, call N sends the
+        # header of call N-1, so a message landing between calls is matched.
+        ("wait_for_otp", {}, [{H: CURSOR_1}, {H: CURSOR_1}, {}], [None, CURSOR_1, CURSOR_1]),
+        ("wait_for_link", {}, [{H: CURSOR_1}, {}], [None, CURSOR_1]),
+        ("wait", {}, [{H: CURSOR_1}, {}], [None, CURSOR_1]),
+        ("wait_for_otp", {}, [{H: CURSOR_1}, {H: CURSOR_2}, {}], [None, CURSOR_1, CURSOR_2]),
+        ("wait_for_otp", {}, [{H.upper(): CURSOR_1}, {}], [None, CURSOR_1]),
+        # Old server (no header) or an empty header: unchanged 0.3.0 behaviour.
+        ("wait_for_otp", {}, [{}, {}, {}], [None, None, None]),
+        ("wait_for_otp", {}, [{H: ""}, {}], [None, None]),
+        # An explicit since is never replaced by the header.
+        ("wait_for_otp", {"since": "msg_anchor"}, [{H: CURSOR_1}, {H: CURSOR_1}, {}], ["msg_anchor"] * 3),
+        ("wait_for_otp", {"since": 0}, [{H: EPOCH}, {}], ["0", "0"]),
+    ],
+)
+def test_wait_loop_cursor(monkeypatch, method, kwargs, headers, expected):
+    final = LINK_MESSAGE if method == "wait_for_link" else OTP_MESSAGE
+    responses = [(204, h, None) for h in headers[:-1]] + [(200, headers[-1], {"data": final})]
+    client, transport = make_client(responses)
+    _monkeypatch_transport(monkeypatch, client, transport)
+
+    getattr(client, method)("inbox_abc", timeout=60, **kwargs)
+
+    assert [_since_of(url) for _, url in transport.calls] == expected
+
+
+def test_wait_loop_keeps_cursor_across_a_429_retry_and_not_between_waits(monkeypatch):
+    responses = [
+        (204, {H: CURSOR_1}, None),
+        (429, {"Retry-After": "0"}, {"error": {"code": "wait_capacity", "message": "busy"}}),
+        (200, {}, {"data": OTP_MESSAGE}),
+        (200, {}, {"data": OTP_MESSAGE}),
+    ]
+    client, transport = make_client(responses)
+    _monkeypatch_transport(monkeypatch, client, transport)
+    monkeypatch.setattr(mailsocket.client, "_sleep", lambda s: None)
+
+    client.wait_for_otp("inbox_abc", timeout=60)
+    client.wait_for_otp("inbox_abc", timeout=60)  # a new wait starts fresh
+
+    assert [_since_of(url) for _, url in transport.calls] == [None, CURSOR_1, CURSOR_1, None]
+
+
 def test_wait_respects_overall_timeout_raises_wait_timeout(monkeypatch):
     # A 204 means "the server blocked for `timeout` seconds and found nothing".
     # Model that with a controllable clock: each 204 advances time by the
@@ -582,7 +639,7 @@ def test_metadata_consistency_across_files():
     from pathlib import Path
 
     root = Path(__file__).resolve().parents[1]
-    expected = "0.3.0"
+    expected = "0.3.1"
 
     pyproject = tomllib.loads((root / "pyproject.toml").read_text())
     assert pyproject["project"]["version"] == expected