programgarden 2.7.0__tar.gz → 2.7.2__tar.gz

{programgarden-2.7.0 → programgarden-2.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 2.7.0
+Version: 2.7.2
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산

{programgarden-2.7.0 → programgarden-2.7.2}/programgarden/database/broker_snapshot.py

@@ -61,19 +61,22 @@ async def read_broker_snapshot(ls, *, execution_key, product, provider, trading_
         from programgarden_finance.ls.korea_stock.extension.valuation import collect_domestic_trading_positions
         from programgarden_finance.ls.korea_stock.extension.account_queries import collect_domestic_open_orders
 
+        # The collector returns t0424 rows (trade-basis balance, chegb=2), not
+        # CSPAQ12300 rows: the symbol is expcode and the held quantity janqty,
+        # the same fields the server startup gate reads.
         _, rows = await collect_domestic_trading_positions(ls.korea_stock().accno())
         for row in rows:
-            symbol = normalized_symbol(str(required(row, "IsuNo")), product)
+            symbol = normalized_symbol(str(required(row, "expcode")), product)
             if symbol in positions:
                 raise ReconciliationUnavailable("ambiguous_position_rows")
-            positions[symbol] = quantity(required(row, "BnsBaseBalQty"))
+            positions[symbol] = quantity(required(row, "janqty"))
         await asyncio.sleep(2)
         pending = await collect_domestic_open_orders(ls.korea_stock().accno())
         # t0425 is the documented current-day inquiry. Retain that observation
         # date for exact ledger matching; never widen it to yesterday's order.
         for row in pending:
             row["order_date"] = day
-        source = "CSPAQ12300+t0425"
+        source = "t0424+t0425"
     elif product == "overseas_stock":
         from programgarden_finance import COSOQ00201, COSAQ00102
 

{programgarden-2.7.0 → programgarden-2.7.2}/programgarden/paper_futures_business_date.py

@@ -3,14 +3,46 @@
 The published same-day blank-date contract conflicts with an observed paper
 response. This adapter uses CIDBQ01500's explicit current-date echo, never a
 machine date, and does not cache it across calls or relax unavailable evidence.
+
+When the paper server returns no business date at all (observed on weekends,
+when its overseas futures day is closed), the order inquiry uses the published
+blank-date same-day form instead, with the same response checks. This is the
+form the server startup gate already uses for that answer, so a start the
+server admits is not refused here.
 """
 from dataclasses import dataclass, field
 from datetime import datetime
 import hashlib
+import logging
 import re
 import time
 
-from programgarden.database.broker_evidence import StartupEvidenceUnavailable, checked_body
+from programgarden.database.broker_evidence import StartupEvidenceUnavailable, broker_message, checked_body
+
+logger = logging.getLogger(__name__)
+
+_RESPONSE_CODE_REASON = "CIDBQ02400: unverified_response_code="
+
+
+def broker_business_day(value):
+    """The broker's explicit YYYYMMDD business date, or "" when none was given.
+
+    A blank, missing, padded or impossible value is "no date". It is never
+    replaced by a local, previous or cached date.
+    """
+    if not isinstance(value, str) or not re.fullmatch(r"[0-9]{8}", value):
+        return ""
+    try:
+        datetime.strptime(value, "%Y%m%d")
+    except ValueError:
+        return ""
+    return value
+
+
+def blank_date_unverified(response):
+    """No business date, and the blank-date answer's code was not accepted."""
+    return (f"CIDBQ02400: blank_date_unverified rsp_cd={getattr(response, 'rsp_cd', None)} "
+            f"rsp_msg={broker_message(getattr(response, 'rsp_msg', None))}")
 
 
 def is_paper_client(ls):
@@ -42,19 +74,41 @@ class PaperFuturesScope:
 
 @dataclass(frozen=True)
 class PaperFuturesBusinessDate:
+    """One fresh CIDBQ01500 observation for the following CIDBQ02400 read.
+
+    ``day`` is the broker's explicit business date, or "" when the paper server
+    returned none; "" selects the published blank-date same-day query (both
+    dates blank). ``account`` is the positions echo; it is always present with
+    a date and may be "" only on a blank-date answer.
+    """
     day: str
     account: str = field(repr=False)
     scope: PaperFuturesScope = field(repr=False)
 
+    @property
+    def blank_date(self):
+        return not self.day
+
     async def check_orders(self, ls, response, query):
         self.scope.check(ls)
-        body = await checked_body(response, "CIDBQ02400", query, paper_trading=True)
+        try:
+            body = await checked_body(response, "CIDBQ02400", query, paper_trading=True)
+        except StartupEvidenceUnavailable as exc:
+            # Without a business date the published blank-date form is the only
+            # query left; name that case, with the broker's answer, when its
+            # response code is not accepted. Other failures keep their reasons.
+            if self.blank_date and str(exc).startswith(_RESPONSE_CODE_REASON):
+                raise StartupEvidenceUnavailable(blank_date_unverified(response)) from None
+            raise
         echo = body["CIDBQ02400OutBlock1"]
         request = next(iter(query.request_data.body.values()))
         expected = request.model_dump(exclude={"RecCnt"})
+        # A dated observation always carries its account; a blank-date one binds
+        # the account only when LS echoed it (the credential scope check below
+        # still proves both reads used the same token, key and paper mode).
         if (request.ThdayTpCode != "1" or request.QrySrtDt != self.day
                 or request.QryEndDt != self.day or not isinstance(echo, dict)
-                or echo.get("AcntNo") != self.account
+                or (self.account and echo.get("AcntNo") != self.account)
                 or any(name not in echo or echo[name] != value for name, value in expected.items())):
             raise StartupEvidenceUnavailable("CIDBQ02400: business_date_scope_mismatch")
         self.scope.check(ls)
@@ -72,15 +126,16 @@ async def from_current_positions(ls, response, query, scope):
         raise StartupEvidenceUnavailable("CIDBQ01500: current_date_query_required")
     if not isinstance(echo, dict) or any(echo.get(name) != value for name, value in expected.items() if name != "QryDt"):
         raise StartupEvidenceUnavailable("CIDBQ01500: business_date_scope_mismatch")
-    day, account = echo.get("QryDt"), echo.get("AcntNo")
-    if not isinstance(day, str) or not re.fullmatch(r"[0-9]{8}", day):
-        raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_business_date")
-    try:
-        datetime.strptime(day, "%Y%m%d")
-    except ValueError:
-        raise StartupEvidenceUnavailable("CIDBQ01500: invalid_business_date") from None
+    day, account = broker_business_day(echo.get("QryDt")), echo.get("AcntNo")
     if not isinstance(account, str) or not account.strip():
-        raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_account_echo")
+        if day:
+            raise StartupEvidenceUnavailable("CIDBQ01500: unavailable_account_echo")
+        account = ""
+    if not day:
+        # Weekend paper answers carry no business date. The server startup gate
+        # uses the blank-date order form for this answer; so does the engine.
+        logger.info("CIDBQ01500: paper server returned no business date; "
+                    "using the published blank-date CIDBQ02400 same-day form")
     scope.check(ls)
     return PaperFuturesBusinessDate(day, account, scope)
 

{programgarden-2.7.0 → programgarden-2.7.2}/pyproject.toml

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "2.7.0"
+version = "2.7.2"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"