krx-openapi 0.2.0__tar.gz → 0.2.1__tar.gz

{krx_openapi-0.2.0 → krx_openapi-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: krx-openapi
-Version: 0.2.0
+Version: 0.2.1
 Summary: Read the Korea Exchange (KRX) Open API: indices, stocks, ETP, bonds, derivatives, commodities, ESG.
 Project-URL: Homepage, https://github.com/seokhoonj/krx-openapi
 Project-URL: Repository, https://github.com/seokhoonj/krx-openapi

{krx_openapi-0.2.0 → krx_openapi-0.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "krx-openapi"
-version = "0.2.0"
+version = "0.2.1"
 description = "Read the Korea Exchange (KRX) Open API: indices, stocks, ETP, bonds, derivatives, commodities, ESG."
 readme = "README.md"
 requires-python = ">=3.11"

{krx_openapi-0.2.0 → krx_openapi-0.2.1}/src/krx_openapi/session.py

@@ -21,7 +21,7 @@ from typing import Any
 
 from ._config import resolve_api_key
 from ._endpoint import SAMPLE_DATE, SAMPLE_KEY, KRXEndpoint
-from .errors import KRXNetworkError, KRXRateLimitError, _error_for
+from .errors import KRXError, KRXNetworkError, KRXRateLimitError, _error_for
 from .types import Row
 
 _AUTH_HEADER = "AUTH_KEY"
@@ -99,27 +99,40 @@ class KRXSession:
         request = urllib.request.Request(
             full_url, headers={_AUTH_HEADER: api_key.strip(), "User-Agent": _USER_AGENT}
         )
+        # The key rides in the AUTH_KEY header, not the URL, so `url` is safe to name.
+        # Still, every failure is BUILT inside the except and RAISED after it
+        # (`from None`), so no transport exception is chained -- a reflecting server that
+        # echoed the request header into a response body could otherwise reach the key
+        # through, e.g., an IncompleteRead's partial body on the cause chain.
+        failure: KRXError
         try:
             with _OPENER.open(request, timeout=self.timeout) as response:
                 raw = response.read()
         except urllib.error.HTTPError as err:
             with err:  # an HTTPError is an unclosed response; release its socket
                 if err.code == _RATE_LIMIT_STATUS:
-                    raise KRXRateLimitError(
+                    failure = KRXRateLimitError(
                         "KRX daily call quota exceeded (10,000/key/day); resets at "
-                        "midnight") from err
-                hint = ""
-                if err.code == _FORBIDDEN_STATUS:
-                    hint = (" -- check the key, that the URL is https and /svc/apis "
-                            "(not /svc/sample/apis with a real key)")
-                raise KRXNetworkError(f"HTTP {err.code} from KRX for {url}{hint}") from err
+                        "midnight")
+                else:
+                    hint = ""
+                    if err.code == _FORBIDDEN_STATUS:
+                        hint = (" -- check the key, that the URL is https and /svc/apis "
+                                "(not /svc/sample/apis with a real key)")
+                    failure = KRXNetworkError(f"HTTP {err.code} from KRX for {url}{hint}")
         except urllib.error.URLError as err:
-            raise KRXNetworkError(f"request to KRX failed: {err.reason}") from err
+            # A transport reason is external text; keep only its type, then detach below.
+            failure = KRXNetworkError(
+                f"request to KRX failed for {url}: {type(err.reason).__name__}")
         except (http.client.HTTPException, OSError) as err:
             # A failure during response.read() (IncompleteRead, a socket timeout or
-            # reset) is not an HTTPError/URLError; surface it through KRXError too.
-            raise KRXNetworkError(f"KRX response read failed for {url}: {err}") from err
-        return _rows_from_body(raw, url)
+            # reset) is not an HTTPError/URLError; surface it through KRXError too. Name
+            # only the exception type -- str(err) can hold partially-read body bytes.
+            failure = KRXNetworkError(
+                f"KRX response read failed for {url}: {type(err).__name__}")
+        else:
+            return _rows_from_body(raw, url)
+        raise failure from None
 
 
 def _rows_from_body(raw: bytes, url: str) -> list[Row]:

{krx_openapi-0.2.0 → krx_openapi-0.2.1}/tests/test_session.py

@@ -199,6 +199,23 @@ def test_get_read_failure_raises_network(monkeypatch):
         KRXSession(api_key="k").fetch(ENDPOINTS["kospi_dd_trd"], basDd="20200414")
 
 
+def test_read_failure_echoing_the_key_never_leaks_it(monkeypatch):
+    # A reflecting server could echo the AUTH_KEY header into the partial body of an
+    # interrupted read; the read-phase error must not surface it or chain the raw
+    # exception (whose partial body would carry it on the cause chain).
+    key = "SECRETKEY123"
+
+    class _EchoingRead(_FakeResponse):
+        def read(self) -> bytes:
+            raise http.client.IncompleteRead(f"partial Auth_key={key}".encode())
+
+    _patch_opener(monkeypatch, lambda request, timeout=None: _EchoingRead(b""))
+    with pytest.raises(KRXNetworkError) as exc:
+        KRXSession(api_key=key).fetch(ENDPOINTS["kospi_dd_trd"], basDd="20200414")
+    assert key not in str(exc.value)
+    assert exc.value.__context__ is None and exc.value.__cause__ is None
+
+
 # --- redirects must never carry the key -------------------------------------
 
 def test_no_redirect_handler_refuses_and_never_follows():