programgarden 1.37.7__tar.gz → 1.37.8__tar.gz

{programgarden-1.37.7 → programgarden-1.37.8}/PKG-INFO

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

{programgarden-1.37.7 → programgarden-1.37.8}/programgarden/context.py

@@ -2865,6 +2865,19 @@ class ExecutionContext:
             logger.warning(f"Failed to update order fill price: {e}")
             return False
 
+    async def _annotate_workflow_fill_currency(self, *, currency: str, **fill_kwargs: Any) -> bool:
+        """Preserve post-refresh currency without replaying the AS1 execution."""
+        tracker = self._workflow_position_tracker
+        if tracker is None:
+            return False
+        fill_kwargs["fill_time"] = fill_kwargs.get("fill_time") or UNKNOWN_FILL_TIME
+        try:
+            return await tracker.annotate_fill_currency(currency=currency, **fill_kwargs)
+        except ValueError:
+            # Unusable/conflicting identity must never cause another fill write.
+            logger.warning("Cannot attach currency evidence to the retained execution")
+            return False
+
     async def record_workflow_fill(
         self,
         order_no: str,
@@ -2879,6 +2892,7 @@ class ExecutionContext:
         *,
         execution_id: Optional[str | int] = None,
         account_avg_price: Optional[float] = None,
+        currency: Optional[str] = None,
     ) -> str:
         """Record fill event for FIFO position tracking.
         
@@ -2904,6 +2918,7 @@ class ExecutionContext:
             execution_id: Optional broker execution number, preserved for durable replay detection.
             account_avg_price: Optional account average purchase price for this
                 symbol at fill time; only a workflow sell's residual tail uses it.
+            currency: Explicit broker unit at fill time; no product default.
 
         Returns:
             분류 결과: "workflow" | "manual" | "unknown_api" | "pending"
@@ -2976,6 +2991,8 @@ class ExecutionContext:
                 # 재시도에도 유지한다 — identity 축이 아니고, 매도 잔량 추정의
                 # 유일한 근거다.
                 base_kwargs["account_avg_price"] = account_avg_price
+            if currency is not None:
+                base_kwargs["currency"] = currency
 
             try:
                 result = await self._workflow_position_tracker.record_fill(

{programgarden-1.37.7 → programgarden-1.37.8}/programgarden/database/fill_reconciler.py

@@ -227,6 +227,7 @@ async def reconcile_workflow_fills(
                     # 빈 값이면 트래커가 '우리 주문과 일치하는가' 로만 분류한다.
                     commda_code="",
                     account_avg_price=avg_price,
+                    currency=hit.get("currency"),
                 )
             except Exception as exc:
                 report.errors.append(f"record_fill_failed[{order_no}]: {exc}")

{programgarden-1.37.7 → programgarden-1.37.8}/programgarden/database/workflow_position_tracker.py

@@ -183,6 +183,9 @@ class PendingFill:
     # read from the broker snapshot before it refreshes. Used only to estimate a
     # workflow sell's residual tail (see _process_sell_fifo); None → no estimate.
     account_avg_price: Optional[float] = None
+    # An explicit broker unit, never inferred from the product or exchange.
+    currency: Optional[str] = None
+    currency_conflict: bool = False
 
 
 class ExecutionIdentityError(ValueError):
@@ -535,6 +538,12 @@ class WorkflowPositionTracker:
             for column in ("execution_id", "normalized_order_no", "execution_payload"):
                 if column not in columns:
                     cursor.execute(f"ALTER TABLE trade_history ADD COLUMN {column} TEXT")
+            if "currency" not in columns:
+                cursor.execute("ALTER TABLE trade_history ADD COLUMN currency TEXT")
+            if "currency_conflict" not in columns:
+                cursor.execute(
+                    "ALTER TABLE trade_history ADD COLUMN currency_conflict INTEGER NOT NULL DEFAULT 0"
+                )
             # Additive columns for the account-average-price sell estimate. A
             # workflow sell that empties the strategy's own lots and still has a
             # tail records that tail here (the residual quantity, the account
@@ -722,6 +731,7 @@ class WorkflowPositionTracker:
         *,
         execution_id: Optional[str | int] = None,
         account_avg_price: Optional[float] = None,
+        currency: Optional[str] = None,
     ) -> str:
         """
         체결 기록 및 FIFO 처리
@@ -743,6 +753,8 @@ class WorkflowPositionTracker:
             account_avg_price: Optional account average purchase price for this
                 symbol at fill time. Only a workflow sell whose own lots run out
                 uses it, to estimate the residual tail. None → no estimate.
+            currency: Explicit broker currency for this fill. Missing/invalid
+                values remain unknown and never change fill identity or amounts.
             execution_id: Optional broker execution identity. Positive numeric
                 strings/integers ignore padding; opaque strings retain case.
                 None, blank, and zero mean no identity and retain legacy replay
@@ -765,6 +777,7 @@ class WorkflowPositionTracker:
             exchange=exchange, side=side, quantity=quantity, price=price,
             fill_time=fill_time, commda_code=commda_code, received_at=datetime.now(),
             execution_id=execution_id, account_avg_price=account_avg_price,
+            currency=self._currency_code(currency),
         )
         identity = self._execution_key(fill)
         notifications: list = []
@@ -879,6 +892,59 @@ class WorkflowPositionTracker:
             "commda_code": fill.commda_code,
         }
 
+    @staticmethod
+    def _currency_code(value: Any) -> Optional[str]:
+        if not isinstance(value, str):
+            return None
+        value = value.strip().upper()
+        return value if re.fullmatch(r"[A-Z]{3}", value) else None
+
+    async def annotate_fill_currency(self, *, currency: str, **fill_kwargs: Any) -> bool:
+        """Attach a contemporaneous broker unit to an exact retained execution.
+
+        Called after the existing AS1 account refresh, never to reconstruct old
+        history. No identity means no annotation. Check all canonical facts and
+        hold the ledger write lock, but do not create a fill, consume a lot, emit
+        another fill notification or alter the deduplication payload. Conflicting
+        units permanently make the unit unknown until separately investigated.
+        """
+        unit = self._currency_code(currency)
+        if unit is None or self.product != "overseas_stock":
+            return False
+        fill = PendingFill(**fill_kwargs, received_at=datetime.now(), currency=unit)
+        identity = self._execution_key(fill)
+        if identity is None:
+            return False
+        changed = False
+        async with self._buffer_lock:
+            for pending in self._pending_fills.values():
+                if self._execution_key(pending) == identity:
+                    self._assert_same_execution(pending, fill)
+                    if pending.currency_conflict or pending.currency == unit:
+                        return False
+                    pending.currency_conflict = pending.currency is not None
+                    pending.currency = None if pending.currency_conflict else unit
+                    return True
+            with sqlite3.connect(self.db_path) as conn:
+                conn.execute("BEGIN IMMEDIATE")
+                cursor = conn.cursor()
+                if self._find_execution(cursor, fill) is None:
+                    return False
+                where = """product=? AND provider=? AND trading_mode=? AND order_date=?
+                    AND normalized_order_no=? AND execution_id=?"""
+                stored, conflict = cursor.execute(
+                    f"SELECT currency, currency_conflict FROM trade_history WHERE {where}", identity
+                ).fetchone()
+                if not conflict and stored != unit:
+                    cursor.execute(
+                        f"UPDATE trade_history SET currency=?, currency_conflict=? WHERE {where}",
+                        (unit if stored is None else None, int(stored is not None), *identity),
+                    )
+                    changed = True
+            if changed:
+                self.fill_revision += 1
+        return changed
+
     def _assert_same_execution(self, previous: PendingFill, fill: PendingFill) -> None:
         if self._execution_facts(previous) != self._execution_facts(fill):
             raise ExecutionIdentityConflictError("Conflicting fill facts for an existing execution identity")
@@ -984,8 +1050,9 @@ class WorkflowPositionTracker:
                 (product, provider, order_no, order_date, symbol, exchange, side, quantity, price,
                  fill_datetime, classification, commda_code, realized_pnl, trading_mode, created_at,
                  execution_id, normalized_order_no, execution_payload,
-                 unmatched_qty, estimate_basis_price, estimate_source, estimated_pnl)
-                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                 unmatched_qty, estimate_basis_price, estimate_source, estimated_pnl,
+                 currency, currency_conflict)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
             """, (
                 self.product, self.provider,
                 fill.order_no, fill.order_date, fill.symbol, fill.exchange,
@@ -996,6 +1063,8 @@ class WorkflowPositionTracker:
                 estimate["estimate_basis_price"] if estimate else None,
                 estimate["estimate_source"] if estimate else None,
                 estimate["estimated_pnl"] if estimate else None,
+                fill.currency,
+                int(fill.currency_conflict),
             ))
 
             conn.commit()
@@ -1960,8 +2029,9 @@ class WorkflowPositionTracker:
     def personal_metrics(self) -> Dict[str, Any]:
         """Read retained workflow executions without claiming account performance.
 
-        Historical FIFO rows have no currency or fee evidence. Keep their amounts
-        per symbol/exchange and reject mixed ownership or an incomplete FIFO basis.
+        Historical FIFO rows have no currency or fee evidence. New rows can carry
+        an explicit broker unit; old units are never backfilled. Keep amounts
+        per symbol/exchange and reject contradictory units or an incomplete basis.
         Futures FIFO is not a monetary ledger. No equity/MDD basis is inferred.
 
         Version 2 adds closed-trade outcomes. One closed trade = one sell fill,
@@ -1986,8 +2056,8 @@ class WorkflowPositionTracker:
         plus the estimated tail). Any other residual is an incomplete basis.
 
         Counts aggregate across symbols because a count carries no currency.
-        Amounts do not: with `currency` unproven per row, summing gross profit
-        across symbols would invent the very unit this method refuses to claim.
+        Amounts do not: the API may sum groups only when every group carries the
+        same explicit currency. Missing evidence never inherits an account unit.
         So gross amounts stay inside each group, and the top-level profit/loss
         ratio is published only when a single group carries the whole ledger —
         the one case where "the currency is the same" needs no evidence.
@@ -2025,6 +2095,8 @@ class WorkflowPositionTracker:
 
         realized = []
         for (symbol, exchange), fills in sorted(groups.items()):
+            units = {self._currency_code(fill.get("currency")) for fill in fills}
+            unit_conflict = any(fill.get("currency_conflict") for fill in fills)
             reason = None
             amount = None
             outcome = None
@@ -2036,6 +2108,9 @@ class WorkflowPositionTracker:
                 reason = "futures_fifo_not_monetary"
             elif not symbol:
                 reason = "missing_symbol"
+            elif len(units - {None}) > 1 or unit_conflict:
+                # Contradictory units cannot establish a comparable FIFO basis.
+                reason = "incomplete_fifo_basis"
             else:
                 # The old mixed_fifo_ownership pre-check is gone: a workflow sell
                 # now consumes only workflow lots, so it can never have realized a
@@ -2137,7 +2212,10 @@ class WorkflowPositionTracker:
                 status = "available"
                 basis = "fifo"
                 estimated_quantity = 0
-            entry = {"symbol": symbol, "exchange": exchange, "currency": None,
+            unit = (next(iter(units)) if len(units) == 1 and None not in units
+                    and not unit_conflict
+                    and self.product != "overseas_futures" else None)
+            entry = {"symbol": symbol, "exchange": exchange, "currency": unit,
                      "amount": amount, "status": status, "reason": reason,
                      "basis": basis, "estimated_quantity": estimated_quantity}
             # A rejected group publishes no outcome: its trades are unknown, and

{programgarden-1.37.7 → programgarden-1.37.8}/programgarden/executor.py

@@ -165,6 +165,24 @@ def _whole_unit_quantity(value: Any) -> Optional[int]:
     return int(number) if number.is_integer() else None
 
 
+def _stock_position_fill_currency(position: Any, symbol: str, market_code: str) -> Optional[str]:
+    """Use only explicitly populated COSOQ00201 position fields for this symbol.
+
+    AS1 has no currency. StockPositionItem defaults to USD, so a model default
+    is insufficient evidence. No quote currency or account-wide default is used.
+    """
+    from programgarden_finance.ls.overseas_stock.extension.models import StockPositionItem
+
+    if not isinstance(position, StockPositionItem):
+        return None
+    if not {"symbol", "market_code", "currency_code"} <= position.model_fields_set:
+        return None
+    if position.symbol != symbol or not market_code or position.market_code != market_code:
+        return None
+    unit = position.currency_code.strip().upper()
+    return unit if re.fullmatch(r"[A-Z]{3}", unit) else None
+
+
 def _usable_execution_identity(order_no: Any, order_date: Any) -> bool:
     """체결 프레임의 (주문번호, 주문일자)가 원장 execution identity 키로 쓸 수 있나.
 
@@ -4881,10 +4899,12 @@ class BrokerNodeExecutor(NodeExecutorBase):
                     # 읽는다. 캐시는 아직 이번 매도가 반영되기 전이라 '매도 직전 평단'.
                     # 캐시에 없으면 None → 추정 없음(오늘처럼 unavailable).
                     account_avg_price = None
+                    currency = None
                     if tracker_info and "tracker" in tracker_info:
                         acct_tracker = tracker_info["tracker"]
                         positions = getattr(acct_tracker, "_positions", None)
                         pos = positions.get(symbol) if isinstance(positions, dict) else None
+                        currency = _stock_position_fill_currency(pos, symbol, market_code)
                         buy_price = getattr(pos, "buy_price", None) if pos is not None else None
                         if buy_price is not None:
                             try:
@@ -4892,7 +4912,7 @@ class BrokerNodeExecutor(NodeExecutorBase):
                             except (TypeError, ValueError):
                                 account_avg_price = None
 
-                    await context.record_workflow_fill(
+                    fill_kwargs = dict(
                         order_no=order_no,
                         order_date=order_date,
                         symbol=symbol,
@@ -4912,12 +4932,20 @@ class BrokerNodeExecutor(NodeExecutorBase):
                         ),
                         account_avg_price=account_avg_price,
                     )
+                    await context.record_workflow_fill(currency=currency, **fill_kwargs)
 
                     # AccountTracker refresh로 PnL 이벤트 강제 트리거
                     if tracker_info and "tracker" in tracker_info:
                         tracker = tracker_info["tracker"]
                         if hasattr(tracker, 'refresh_now'):
                             await tracker.refresh_now()
+                            positions = getattr(tracker, "_positions", None)
+                            pos = positions.get(symbol) if isinstance(positions, dict) else None
+                            refreshed_currency = _stock_position_fill_currency(pos, symbol, market_code)
+                            if refreshed_currency is not None:
+                                await context._annotate_workflow_fill_currency(
+                                    currency=refreshed_currency, **fill_kwargs
+                                )
                             logger.debug(f"📊 AccountTracker refreshed after fill")
 
                 asyncio.run_coroutine_threadsafe(record_and_refresh(), loop)
@@ -17005,9 +17033,11 @@ class NewOrderNodeExecutor(NodeExecutorBase):
                 p = float(getattr(item, "OvrsExecPrc", 0) or getattr(item, "OvrsOrdPrc", 0) or 0)
                 row = out.setdefault(order_no, {
                     "filled_qty": 0, "_amount": 0.0, "symbol": "", "fill_time": "",
+                    "_currencies": set(),
                 })
                 row["filled_qty"] += q
                 row["_amount"] += q * p
+                row["_currencies"].add(str(item.CrcyCode or "").strip().upper())
                 # 🔴 LS 는 TR 마다 같은 뜻의 필드 이름이 다르고, 이 블록에는 `ShtnIsuNo`
                 #    (단축종목번호)와 `IsuNo`(종목번호)가 **둘 다** 있다. 이 저장소의 관행은
                 #    ShtnIsuNo 우선·IsuNo 폴백이다(잔고·체결 파싱이 전부 그렇게 한다).
@@ -17023,6 +17053,9 @@ class NewOrderNodeExecutor(NodeExecutorBase):
             for row in out.values():
                 qty = row["filled_qty"]
                 row["avg_price"] = (row.pop("_amount") / qty) if qty > 0 else 0.0
+                units = row.pop("_currencies")
+                unit = next(iter(units)) if len(units) == 1 else ""
+                row["currency"] = unit if re.fullmatch(r"[A-Z]{3}", unit) else None
             return out
         except Exception as e:
             context.log("debug", f"COSAQ00102 batch fill query exception: {e}", node_id)

{programgarden-1.37.7 → programgarden-1.37.8}/pyproject.toml

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