programgarden 1.37.7__tar.gz → 1.37.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: programgarden
-Version: 1.37.7
+Version: 1.37.9
 Summary: ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진
 License-Expression: AGPL-3.0-or-later
 Author: 프로그램동산
@@ -16,8 +16,8 @@ Requires-Dist: croniter (>=6.0.0,<7.0.0)
 Requires-Dist: litellm (>=1.40.0)
 Requires-Dist: lxml (>=6.0.2,<7.0.0)
 Requires-Dist: programgarden-community (>=1.15.3,<2.0.0)
-Requires-Dist: programgarden-core (>=1.28.1,<2.0.0)
-Requires-Dist: programgarden-finance (>=1.9.7,<2.0.0)
+Requires-Dist: programgarden-core (>=1.28.2,<2.0.0)
+Requires-Dist: programgarden-finance (>=1.9.8,<2.0.0)
 Requires-Dist: psutil (>=6.0.0,<7.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.11,<3.0.0)
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)

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

@@ -1968,6 +1968,7 @@ class ExecutionContext:
         current_prices: Dict[str, float],
         account_positions: Optional[Dict[str, Any]],
         currency: Optional[str] = "USD",
+        account_valuation: Optional[Dict[str, Any]] = None,
     ) -> None:
         """Notify all listeners about workflow P&L update (확장 버전).
         
@@ -2015,6 +2016,12 @@ class ExecutionContext:
             product=product,
             start_date=None,  # 전체 기간
         )
+        from .valuation import workflow_valuation_snapshot
+
+        workflow_valuation = workflow_valuation_snapshot(
+            base_workflow_result,
+            account_positions if account_positions is not None else ({} if account_valuation else None),
+            now, product)
         
         # 2. 계좌 전체 수익률 계산
         account_result = self._calculate_account_pnl(
@@ -2098,6 +2105,8 @@ class ExecutionContext:
                     "anomaly_count": base_workflow_result.get("anomaly_count", 0),
                     "currency": currency,
                     "personal_metrics": personal_metrics,
+                    "account_valuation": account_valuation,
+                    "workflow_valuation": workflow_valuation,
                     
                     # 신규 필드: 워크플로우 상품별
                     "workflow_overseas_stock_pnl_rate": base_workflow_result.get("workflow_overseas_stock_pnl_rate"),
@@ -2865,6 +2874,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 +2901,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 +2927,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 +3000,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.9}/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.9}/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.9}/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)
@@ -5582,6 +5610,8 @@ class BrokerNodeExecutor(NodeExecutorBase):
                         "current_price": float(pos_item.current_price) if hasattr(pos_item, 'current_price') else 0,
                         "pnl_rate": float(pos_item.pnl_rate) if hasattr(pos_item, 'pnl_rate') else 0,
                         "product": product,  # 상품 유형 (overseas_stock)
+                        "currency": pos_item.currency_code.strip().upper()
+                            if "currency_code" in pos_item.model_fields_set else None,
                     }
 
             self._start_background_task(context,
@@ -5592,6 +5622,7 @@ class BrokerNodeExecutor(NodeExecutorBase):
                     current_prices=current_prices,
                     account_positions=account_positions if account_positions else None,
                     currency=pnl_info.currency if hasattr(pnl_info, 'currency') else "USD",
+                    account_valuation=tracker.get_valuation_snapshot(),
                 ),
                 notification=True,
             )
@@ -17005,9 +17036,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 +17056,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.9/programgarden/valuation.py

@@ -0,0 +1,51 @@
+"""Currency-scoped open workflow valuation, independent of realized trades."""
+
+from dataclasses import asdict, is_dataclass
+from decimal import Decimal, InvalidOperation
+import re
+
+
+def workflow_valuation_snapshot(result, account_positions, observed_at, product):
+    if product != "overseas_stock" or not isinstance(account_positions, dict):
+        return None
+    positions = result.get("workflow_positions")
+    if not isinstance(positions, list):
+        return None
+    if positions and result.get("workflow_pnl_rate") is None:
+        return None
+    groups = {}
+    seen = set()
+    for item in positions:
+        row = asdict(item) if is_dataclass(item) else item
+        if not isinstance(row, dict):
+            return None
+        symbol = row.get("symbol")
+        account = account_positions.get(symbol)
+        if not isinstance(account, dict) or symbol in seen:
+            return None
+        seen.add(symbol)
+        currency = account.get("currency")
+        if not isinstance(currency, str) or not re.fullmatch(r"[A-Z]{3}", currency):
+            return None
+        values = {}
+        for key in ("quantity", "avg_price", "current_price", "pnl_amount"):
+            value = row.get(key)
+            if value is None or isinstance(value, bool):
+                return None
+            try:
+                values[key] = Decimal(str(value))
+            except InvalidOperation:
+                return None
+            if not values[key].is_finite() or (key != "pnl_amount" and values[key] <= 0):
+                return None
+        # Valuation is an estimate from the workflow's own retained cost basis.
+        pnl = values["pnl_amount"]
+        if abs(pnl - (values["current_price"] - values["avg_price"]) * values["quantity"]) > Decimal("0.0001"):
+            return None
+        group = groups.setdefault(currency, {"earned": Decimal(0), "lost": Decimal(0), "net": Decimal(0)})
+        group["earned"] += max(pnl, Decimal(0))
+        group["lost"] += max(-pnl, Decimal(0))
+        group["net"] = group["earned"] - group["lost"]
+    return {"version": 1, "product": product, "basis": "workflow_open_positions_gross",
+            "observed_at": observed_at.isoformat(),
+            "groups": [{"currency": currency, **group} for currency, group in sorted(groups.items())]}

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

@@ -5,7 +5,7 @@ authors = [
 homepage = "https://programgarden.com"
 requires-python = ">=3.12"
 name = "programgarden"
-version = "1.37.7"
+version = "1.37.9"
 license = "AGPL-3.0-or-later"
 description = "ProgramGarden - 노드 기반 자동매매 DSL 실행 엔진"
 readme = "README.md"
@@ -36,8 +36,8 @@ litellm = ">=1.40.0"
 # 로 통째 실패한다(1.35.1 의 조용한 TypeError 보다 강한 모듈 로드 실패).
 # (1.26.0 이후로도 context.py 는 WorkflowPnLEvent(**event_data) 에 personal_metrics
 #  를 무조건 실으므로 그 하한 근거도 이 상한에 포함된다.)
-programgarden-core = "^1.28.1"
-programgarden-finance = "^1.9.7"
+programgarden-core = "^1.28.2"
+programgarden-finance = "^1.9.8"
 programgarden-community = "^1.15.3"
 
 [tool.poetry.group.dev.dependencies]