Merge remote-tracking branch 'origin/main' into openapi-update-27777677089

# Conflicts:
#	CHANGELOG.md

Author: zfarrell

.github/workflows/check-release.yml

@@ -27,9 +27,9 @@ jobs:
 
       # Build + install + import the wheel here rather than in the regen workflow.
       # This job runs on any PR touching pyproject.toml/CHANGELOG.md — which every
-      # regen PR does (version bump + seeded changelog) — so a packaging or import
-      # regression surfaces as red CI on the PR instead of silently aborting the
-      # regen before it can open one. (Step name kept stable to preserve the
+      # regen PR does (it seeds a [Unreleased] changelog entry) — so a packaging or
+      # import regression surfaces as red CI on the PR instead of silently aborting
+      # the regen before it can open one. (Step name kept stable to preserve the
       # required-check / branch-protection wiring.)
       - name: Build, install, and import the wheel
         run: |

.github/workflows/regenerate.yml

@@ -67,75 +67,64 @@ jobs:
             esac
           done
 
-      # pyproject.toml is hand-maintained (see .openapi-generator-ignore), so the
-      # generator no longer stamps the version. Bump the patch version directly,
-      # rewriting the same `^version = "X"` line scripts/release.sh treats as the
-      # source of truth.
-      - name: Bump package patch version in pyproject.toml
-        id: pkg
-        run: |
-          version=$(python3 - <<'PY'
-          import re, pathlib
-          path = pathlib.Path("pyproject.toml")
-          text = path.read_text()
-          m = re.search(r'(?m)^version = "(\d+)\.(\d+)\.(\d+)"', text)
-          if not m:
-              raise SystemExit("could not find a semver version in pyproject.toml")
-          new = f"{int(m[1])}.{int(m[2])}.{int(m[3]) + 1}"
-          text, n = re.subn(r'(?m)^version = "[^"]+"', f'version = "{new}"', text, count=1)
-          if n != 1:
-              raise SystemExit("failed to rewrite version in pyproject.toml")
-          path.write_text(text)
-          print(new)
-          PY
-          )
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-
-      # check-release.yml gates merges on a `## [x.y.z]` CHANGELOG section
-      # matching the bumped version, so without a seeded entry every regen PR
-      # fails that check. Insert a stub (the spec-change title under ### Changed)
-      # just above the most recent released section; the PR author refines the
-      # wording before merge. Idempotent: skips if a section for this version
-      # already exists.
-      - name: Seed changelog entry
+      # The version bump is intentionally NOT done here. A regen is just a set of
+      # changes; which release they ship in (and the bump kind) is decided later
+      # by scripts/release.sh prepare. Seed the regen notes under [Unreleased] so
+      # they accumulate there until a release rolls them into a version. This
+      # avoids minting a dated version section per regen that may never publish.
+      - name: Seed changelog entry under [Unreleased]
         env:
-          VERSION: ${{ steps.pkg.outputs.version }}
           TITLE: ${{ inputs.title }}
         run: |
-          export CHANGELOG_DATE=$(date -u +%Y-%m-%d)
           python3 - <<'PY'
           import os, pathlib, re
-          version = os.environ["VERSION"]
-          date = os.environ["CHANGELOG_DATE"]
           title = (os.environ.get("TITLE") or "").strip() \
               or "Regenerate the client from the updated Hotdata OpenAPI spec"
+          bullet = f"- {title}"
           path = pathlib.Path("CHANGELOG.md")
           text = path.read_text()
-          if re.search(rf"^## \[{re.escape(version)}\]", text, re.M):
-              print(f"CHANGELOG already has a [{version}] section; leaving it untouched.")
-              raise SystemExit(0)
-          unreleased = re.search(r"^## \[Unreleased\]", text, re.M)
-          if not unreleased:
+
+          heading = re.search(r"^## \[Unreleased\][^\n]*\n", text, re.M)
+          if not heading:
               raise SystemExit("CHANGELOG.md has no '## [Unreleased]' section to anchor the new entry")
-          # Insert before the first released section after [Unreleased] (falling
-          # back to end of file) so any pending entries under [Unreleased] stay
-          # attributed to it rather than being absorbed by the new version.
-          nxt = re.search(r"^## \[", text[unreleased.end():], re.M)
-          insert_at = unreleased.end() + nxt.start() if nxt else len(text)
-          entry = f"## [{version}] - {date}\n\n### Changed\n\n- {title}\n\n"
-          text = text[:insert_at] + entry + text[insert_at:]
-          path.write_text(text)
-          print(f"Inserted CHANGELOG [{version}] section.")
+
+          # Scope edits to the [Unreleased] body (up to the next '## [' or EOF).
+          start = heading.end()
+          nxt = re.search(r"^## \[", text[start:], re.M)
+          end = start + nxt.start() if nxt else len(text)
+          body = text[start:end]
+
+          if any(line.strip() == bullet for line in body.splitlines()):
+              print("CHANGELOG [Unreleased] already lists this entry; leaving it untouched.")
+              raise SystemExit(0)
+
+          changed = re.search(r"^### Changed[ \t]*\n", body, re.M)
+          if changed:
+              # Prepend the bullet to the existing ### Changed list.
+              i = changed.end()
+              while i < len(body) and body[i] == "\n":
+                  i += 1
+              body = body[:i] + bullet + "\n" + body[i:]
+          else:
+              # No ### Changed yet: open one right under the heading.
+              body = "\n### Changed\n\n" + bullet + "\n\n" + body.lstrip("\n")
+
+          path.write_text(text[:start] + body + text[end:])
+          print("Added regen entry under CHANGELOG [Unreleased].")
           PY
 
+      # No packageVersion: pyproject.toml is hand-maintained and the generator
+      # doesn't stamp it, while __version__ and the SDK version string both read
+      # from installed package metadata — so the generator's packageVersion never
+      # reaches committed output.
       - name: Generate client
         run: |
           npx @openapitools/openapi-generator-cli generate \
             -i openapi.yaml \
             -g python \
             -o . \
             -t .openapi-generator-templates \
-            --additional-properties=packageName=hotdata,projectName=hotdata,packageVersion=${{ steps.pkg.outputs.version }},gitUserId=hotdata-dev,gitRepoId=sdk-python \
+            --additional-properties=packageName=hotdata,projectName=hotdata,gitUserId=hotdata-dev,gitRepoId=sdk-python \
             --skip-validate-spec
 
       # pyproject.toml/requirements*.txt are hand-maintained, so the generator no
@@ -300,8 +289,9 @@ jobs:
       # on. The PR is the artifact we want, and breakage surfaces on it as red CI:
       # integration-tests.yml installs the package (`pip install -e .`) and runs
       # pytest, and check-release.yml builds + installs + imports the wheel on
-      # every PR that bumps pyproject.toml/CHANGELOG.md (which every regen PR
-      # does). Auto-merge is gated on those checks, so a broken regen can't merge.
+      # every PR touching pyproject.toml/CHANGELOG.md (a regen seeds a [Unreleased]
+      # changelog entry, so it always touches CHANGELOG.md). Auto-merge is gated on
+      # those checks, so a broken regen can't merge.
 
       - name: Check integration test scenario parity
         env:

.openapi-generator-ignore

@@ -7,10 +7,12 @@ setup.py
 # at the package root (outside hotdata/api and hotdata/models) so the generator
 # never emits or overwrites them, but they are listed here as the source of
 # truth for "hand-maintained, don't touch": _auth.py (JWT exchange), arrow.py
-# (Arrow IPC result fetch), query.py (429 retry + truncation auto-follow, #688).
+# (Arrow IPC result fetch), query.py (429 retry + truncation auto-follow, #688),
+# _retry.py (pre-response connection-reset retry on all methods, #118).
 hotdata/_auth.py
 hotdata/arrow.py
 hotdata/query.py
+hotdata/_retry.py
 
 # Hand-written test for the patched ApiClient.close()/context-manager behavior
 # (re-applied by scripts/patch_api_client_close.py). It lives in the generated

.openapi-generator-templates/configuration.mustache

@@ -433,6 +433,13 @@ conf = {{packageName}}.Configuration(
         self.safe_chars_for_path_param = ''
         """Safe chars for path_param
         """
+        # Default to a retry policy that transparently retries pre-response
+        # connection resets (stale pooled keep-alive connections) on every
+        # method, including POST (#118). Passing an explicit `retries` (int or
+        # urllib3.Retry) overrides it entirely.
+        if retries is None:
+            from {{packageName}}._retry import default_retry
+            retries = default_retry()
         self.retries = retries
         """Retry configuration
         """

CHANGELOG.md

@@ -7,16 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-## [0.4.2] - 2026-06-18
-
 ### Changed
 
 - feat(indexes): add source_column field to index responses
 
-## [0.4.1] - 2026-06-17
+## [0.4.1] - 2026-06-19
 
 ### Changed
 
+- `Configuration` now defaults to a retry policy that transparently retries
+  pre-response connection resets (stale pooled keep-alive connections, e.g.
+  `ProtocolError('Connection aborted.', ConnectionResetError)`) on **every**
+  method, including `POST`. Such a reset happens before the request reaches the
+  server, so retrying on a fresh connection cannot double-execute. Read timeouts
+  and status retries stay idempotent-only. Pass an explicit `retries` to
+  override (#118).
 - chore: make api doc language end-user focused
 
 ## [0.4.0] - 2026-06-16

hotdata/_retry.py

@@ -0,0 +1,112 @@
+"""Transparent retry of pre-response connection resets (#118).
+
+A pooled keep-alive connection can be reused after an intermediary (load
+balancer / reverse proxy) has already dropped it for exceeding its idle
+timeout. The client is not notified, so the next request that reuses that
+socket fails immediately with::
+
+    urllib3.exceptions.ProtocolError:
+        ('Connection aborted.', ConnectionResetError(54, 'Connection reset by peer'))
+
+urllib3 classifies *every* :class:`~urllib3.exceptions.ProtocolError` as a
+*read* error (see ``Retry._is_read_error``) — it conservatively assumes the
+server may have begun processing the request. Read retries are gated by
+``allowed_methods``, which does not include ``POST``, so a ``POST`` that hits a
+dead pooled connection is re-raised to the caller instead of being retried.
+
+But a reset that happens *before any response bytes arrive* means the request
+never reached the server — the connection was already gone when urllib3 tried
+to send. That is safe to retry on **any** method, ``POST`` included, because the
+server did no work and a retry cannot double-execute.
+
+:class:`ConnectionResetRetry` reclassifies exactly that case — a
+``ProtocolError`` whose underlying cause is a connection-level ``OSError`` — as
+a *connection* error. urllib3's ``Retry.increment`` handles connection errors
+before read errors and without the ``allowed_methods`` gate, so the reset is
+retried on a fresh connection regardless of method. Read **timeouts**
+(:class:`~urllib3.exceptions.ReadTimeoutError`) and status retries are left
+untouched and stay idempotent-only, so a ``POST`` that may have reached the
+server is never blindly replayed.
+"""
+
+from __future__ import annotations
+
+from urllib3.exceptions import ProtocolError, ProxyError
+from urllib3.util.retry import Retry
+
+# Bounded attempts for the transparent connection-reset retry. Stale-pool resets
+# clear on the first fresh connection, so a small ceiling is plenty; it also
+# bounds the blast radius if a host is genuinely refusing connections.
+DEFAULT_TOTAL_RETRIES = 3
+
+# A small exponential backoff between attempts. The first retry on a fresh
+# connection almost always succeeds, so the delay stays sub-second; it exists
+# only to avoid hammering a host that is briefly flapping.
+DEFAULT_BACKOFF_FACTOR = 0.1
+
+
+def _is_pre_response_connection_reset(error: BaseException) -> bool:
+    """True for a connection reset/abort that occurred before any response.
+
+    urllib3 wraps a low-level socket failure raised while sending the request as
+    ``ProtocolError("Connection aborted.", <cause>)``, where ``<cause>`` is the
+    originating :class:`OSError` (``ConnectionResetError``,
+    ``ConnectionAbortedError``, ``BrokenPipeError``, …). Those builtin
+    connection errors all subclass :class:`ConnectionError`, so the cause's type
+    is a precise, message-independent signal that the failure was at the socket
+    layer before a response existed — distinct from a read **timeout**, which
+    urllib3 raises as a ``ReadTimeoutError`` (not a ``ProtocolError``) and which
+    we deliberately leave method-gated.
+    """
+    if isinstance(error, ProxyError):
+        error = error.original_error
+    if not isinstance(error, ProtocolError):
+        return False
+    cause = error.args[1] if len(error.args) > 1 else None
+    return isinstance(cause, ConnectionError)
+
+
+class ConnectionResetRetry(Retry):
+    """A :class:`urllib3.util.retry.Retry` that retries pre-response connection
+    resets on any HTTP method, while leaving read/status retries idempotent-only.
+
+    Behaves exactly like ``Retry`` except a connection reset/abort that happened
+    before any response bytes were received (see
+    :func:`_is_pre_response_connection_reset`) is treated as a *connection*
+    error rather than a *read* error. urllib3's ``increment`` retries connection
+    errors without consulting ``allowed_methods``, so the reset is retried on a
+    fresh connection for ``POST`` too — safe because the server did no work.
+    """
+
+    def _is_connection_error(self, err: Exception) -> bool:
+        if super()._is_connection_error(err):
+            return True
+        return _is_pre_response_connection_reset(err)
+
+
+def default_retry() -> ConnectionResetRetry:
+    """The SDK's default retry policy.
+
+    Matches urllib3's defaults (idempotent-only read/status retries, a bounded
+    total, no retry on response status codes) and adds transparent retry of
+    pre-response connection resets on every method. ``Configuration`` installs
+    this when the caller does not supply their own ``retries``.
+    """
+    return ConnectionResetRetry(
+        total=DEFAULT_TOTAL_RETRIES,
+        backoff_factor=DEFAULT_BACKOFF_FACTOR,
+        # Don't retry on response status codes by default: a status code means
+        # the request reached the server, and 429 admission-shedding already has
+        # dedicated handling in hotdata.query. Connection-reset retry is purely a
+        # transport-layer concern.
+        status=0,
+        raise_on_status=False,
+    )
+
+
+__all__ = [
+    "ConnectionResetRetry",
+    "DEFAULT_BACKOFF_FACTOR",
+    "DEFAULT_TOTAL_RETRIES",
+    "default_retry",
+]

hotdata/api_client.py

@@ -91,7 +91,7 @@ def __init__(
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/0.4.2/python'
+        self.user_agent = 'OpenAPI-Generator/0.4.1/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

hotdata/configuration.py

@@ -321,6 +321,13 @@ def __init__(
         self.safe_chars_for_path_param = ''
         """Safe chars for path_param
         """
+        # Default to a retry policy that transparently retries pre-response
+        # connection resets (stale pooled keep-alive connections) on every
+        # method, including POST (#118). Passing an explicit `retries` (int or
+        # urllib3.Retry) overrides it entirely.
+        if retries is None:
+            from hotdata._retry import default_retry
+            retries = default_retry()
         self.retries = retries
         """Retry configuration
         """

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hotdata"
-version = "0.4.2"
+version = "0.4.1"
 description = "Hotdata API"
 authors = [
   {name = "Hotdata",email = "developers@hotdata.dev"},