programgarden 0.1.0__tar.gz

programgarden-0.1.0/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.3
+Name: programgarden
+Version: 0.1.0
+Summary: 자동화매매 오픈소스의 실행, 로그, 환경 등의 핵심이되는 오픈소스
+Author: 프로그램동산
+Author-email: coding@programgarden.com
+Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: art (>=6.5,<7.0)
+Requires-Dist: croniter (>=6.0.0,<7.0.0)
+Requires-Dist: flask (>=3.1.2,<4.0.0)
+Requires-Dist: jsoneditor (>=1.6.0,<2.0.0)
+Requires-Dist: programgarden-community (>=0.1.0,<0.2.0)
+Requires-Dist: programgarden-core (>=0.1.0,<0.2.0)
+Requires-Dist: programgarden-finance (>=0.1.0,<0.2.0)
+Requires-Dist: pydantic (>=2.11.7,<3.0.0)
+Requires-Dist: pyqt5 (>=5.15.11,<6.0.0)
+Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
+Requires-Dist: qscintilla (>=2.14.1,<3.0.0)
+Description-Content-Type: text/markdown
+
+programgarden 

programgarden-0.1.0/README.md

@@ -0,0 +1 @@
+programgarden 

programgarden-0.1.0/programgarden/__init__.py

@@ -0,0 +1,135 @@
+"""
+클라이언트 기능 모듈
+
+LS OpenAPI 클라이언트가 사용하는 모듈입니다.
+"""
+
+from programgarden.system_executor import SystemExecutor
+from programgarden_core import exceptions
+from .client import Programgarden
+from .pg_listener import (
+    PGListener,
+)
+from programgarden_finance import (
+    ls,
+    LS,
+    oauth,
+    overseas_stock,
+    overseas_futureoption,
+
+    COSAQ00102,
+    COSAQ01400,
+    COSOQ00201,
+    COSOQ02701,
+    g3103,
+    g3202,
+    g3203,
+    g3204,
+    g3101,
+    g3102,
+    g3104,
+    g3106,
+    g3190,
+
+    o3101,
+    o3104,
+    o3105,
+    o3106,
+    o3107,
+    o3116,
+    o3121,
+    o3123,
+    o3125,
+    o3126,
+    o3127,
+    o3128,
+    o3136,
+    o3137,
+
+    COSAT00301,
+    COSAT00311,
+    COSMT00300,
+    COSAT00400,
+
+    CIDBQ01400,
+    CIDBQ01500,
+    CIDBQ01800,
+    CIDBQ02400,
+    CIDBQ03000,
+    CIDBQ05300,
+    CIDEQ00800,
+
+    o3103,
+    o3108,
+    o3117,
+    o3139,
+
+    CIDBT00100,
+    CIDBT00900,
+    CIDBT01000
+)
+
+__all__ = [
+    SystemExecutor,  # SystemExecutor 클래스는 시스템 실행을 담당합니다.
+    Programgarden,
+    ls,
+    LS,
+    oauth,
+    exceptions,
+
+    PGListener,
+
+    overseas_stock,
+    overseas_futureoption,
+
+    COSAQ00102,
+    COSAQ01400,
+    COSOQ00201,
+    COSOQ02701,
+    g3103,
+    g3202,
+    g3203,
+    g3204,
+    g3101,
+    g3102,
+    g3104,
+    g3106,
+    g3190,
+
+    COSAT00301,
+    COSAT00311,
+    COSMT00300,
+    COSAT00400,
+
+    o3101,
+    o3104,
+    o3105,
+    o3106,
+    o3107,
+    o3116,
+    o3121,
+    o3123,
+    o3125,
+    o3126,
+    o3127,
+    o3128,
+    o3136,
+    o3137,
+
+    CIDBQ01400,
+    CIDBQ01500,
+    CIDBQ01800,
+    CIDBQ02400,
+    CIDBQ03000,
+    CIDBQ05300,
+    CIDEQ00800,
+
+    o3103,
+    o3108,
+    o3117,
+    o3139,
+
+    CIDBT00100,
+    CIDBT00900,
+    CIDBT01000
+]

programgarden-0.1.0/programgarden/buysell_executor.py

@@ -0,0 +1,347 @@
+"""
+This module provides the BuyExecutor class which is responsible for
+resolving and executing external buy/sell plugin classes (conditions).
+
+The executor reads a system configuration, resolves the plugin by its
+identifier, instantiates it with configured parameters, and runs its
+"execute" method. Results (symbols to act on) are returned to the
+caller and also logged.
+
+The implementations here are intentionally small: the executor focuses
+on orchestration (resolve -> instantiate -> set context -> execute)
+and leaves trading logic to plugin classes that must subclass
+`BaseBuyOverseasStock` from `programgarden_core`.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional, TypedDict, Union
+from zoneinfo import ZoneInfo
+from programgarden_core import (
+    SystemType, SymbolInfo,
+    BaseBuyOverseasStockResponseType, BaseSellOverseasStockResponseType,
+    pg_logger, BaseBuyOverseasStock, exceptions, NewBuyTradeType, HeldSymbol,
+    NonTradedSymbol, NewSellTradeType, BaseSellOverseasStock,
+    OrderCategoryType
+)
+from programgarden_finance import LS, COSAT00301, COSOQ00201, COSAQ00102, COSOQ02701
+
+from programgarden.pg_listener import pg_listener
+from programgarden.real_order_executor import RealOrderExecutor
+from datetime import datetime
+
+if TYPE_CHECKING:
+    from .plugin_resolver import PluginResolver
+
+
+class DpsTyped(TypedDict):
+    fcurr_dps: float
+    fcurr_ord_able_amt: float
+
+
+class BuySellExecutor:
+    """Orchestrates execution of buy/sell condition plugins.
+
+    The executor requires a `PluginResolver` which maps condition
+    identifiers to concrete classes. It does not implement trading
+    strategies itself; instead it prepares and runs plugin instances
+    and returns whatever those plugins produce.
+
+    Contract (high level):
+    - Input: a `system` config (dict-like `SystemType`) and a list of
+      `SymbolInfo` items describing available symbols.
+    - Output: a list of plugin execution responses (or None on error).
+    - Error modes: missing plugin, incorrect plugin type, runtime
+      exceptions inside plugin code. Errors are logged and result in
+      a None return value from the internal executor.
+    """
+
+    def __init__(self, plugin_resolver: PluginResolver):
+        # PluginResolver instance used to look up condition classes by id
+        self.plugin_resolver = plugin_resolver
+        self.real_order_executor = RealOrderExecutor()
+
+    async def new_buy_execute(
+        self,
+        system: SystemType,
+        symbols_from_strategy: List[SymbolInfo],
+        new_buy: NewBuyTradeType,
+        order_id: str,
+    ) -> None:
+        """
+        Public entrypoint to perform buy execution for a system.
+        """
+
+        # 예수금 세팅
+        available_balance = float(new_buy.get("available_balance", 0.0))
+        dps: DpsTyped = {
+            "fcurr_dps": available_balance,
+            "fcurr_ord_able_amt": available_balance,
+        }
+        is_ls = system.get("securities", {}).get("company", None) == "ls"
+
+        if available_balance == 0.0 and is_ls:
+            # 예수금 가져오기
+            cosoq02701 = await LS.get_instance().overseas_stock().accno().cosoq02701(
+                body=COSOQ02701.COSOQ02701InBlock1(
+                    RecCnt=1,
+                    CrcyCode="USD",
+                ),
+            ).req_async()
+
+            dps["fcurr_dps"] = cosoq02701.block3[0].FcurrDps
+            dps["fcurr_ord_able_amt"] = cosoq02701.block3[0].FcurrOrdAbleAmt
+
+        # 필터링, 보유, 미체결 종목들 가져오기
+        filtered_symbols, held_symbols, non_trade_symbols = await self._block_duplicate_symbols(system, symbols_from_strategy)
+
+        # 종목 보유중이면 막기
+        if new_buy.get("block_duplicate_trade", True):
+            symbols_from_strategy[:] = filtered_symbols
+
+        if not symbols_from_strategy:
+            return
+
+        purchase_symbols, community_instance = await self.plugin_resolver.resolve_buysell_community(
+            system_id=system.get("settings", {}).get("system_id", None),
+            trade=new_buy,
+            symbols=symbols_from_strategy,
+            held_symbols=held_symbols,
+            non_trade_symbols=non_trade_symbols,
+            dps=dps,
+        )
+
+        if not purchase_symbols:
+            return
+
+        for symbol in purchase_symbols:
+            if not symbol.get("success"):
+                continue
+
+            # 주문 함수 구성
+            result = await self._build_order_function(
+                system=system,
+                trade_type="submitted_new_buy",
+                symbol=symbol
+            )
+
+            ord_no = None
+            if result is not None:
+                block2 = getattr(result, "block2", None)
+                ord_val = getattr(block2, "OrdNo", None) if block2 is not None else None
+                ord_no = str(ord_val) if ord_val is not None else None
+
+            await self.real_order_executor.send_data_community_instance(
+                ordNo=ord_no,
+                community_instance=community_instance
+            )
+
+            pg_logger.info(f"🟢 New buy order executed for order '{order_id}'")
+
+    async def _block_duplicate_symbols(
+        self,
+        system: SystemType,
+        symbols_from_strategy: List[SymbolInfo],
+    ):
+        """
+        Filter out only the stocks that are not held
+
+        Returns로는 중복 여부 필터링한 종목들과, 보유잔고 종목들과 미체결 종목들이 반환된다.
+        """
+
+        held_symbols: List[HeldSymbol] = []
+        non_trade_symbols: List[NonTradedSymbol] = []
+
+        company = system.get("securities", {}).get("company", "")
+        product = system.get("securities", {}).get("product", [])
+        if company == "ls" and product == "overseas_stock":
+            ls = LS.get_instance()
+            if not ls.is_logged_in():
+                await ls.async_login(
+                        appkey=system.get("securities", {}).get("appkey", None),
+                        appsecretkey=system.get("securities", {}).get("appsecretkey", None)
+                    )
+
+            # 보유잔고에서 확인하기
+            acc_result = await ls.overseas_stock().accno().cosoq00201(
+                    body=COSOQ00201.COSOQ00201InBlock1(
+                        # BaseDt=datetime.now(ZoneInfo("America/New_York")).strftime("%Y%m%d")
+                    )
+                ).req_async()
+
+            held_isus = set()
+            for blk in acc_result.block4:
+                shtn_isu_no = blk.ShtnIsuNo
+                if shtn_isu_no is not None:
+                    held_isus.add(str(shtn_isu_no).strip())
+
+                held_symbols.append(
+                    HeldSymbol(
+                        CrcyCode=blk.CrcyCode,
+                        ShtnIsuNo=shtn_isu_no,
+                        AstkBalQty=blk.AstkBalQty,
+                        AstkSellAbleQty=blk.AstkSellAbleQty,
+                        PnlRat=blk.PnlRat,
+                        BaseXchrat=blk.BaseXchrat,
+                        PchsAmt=blk.PchsAmt,
+                        FcurrMktCode=blk.FcurrMktCode
+                    )
+                )
+
+            # symbols_from_strategy에서
+            exchcds: set[str] = set()
+            for symbol in symbols_from_strategy:
+                exchcds.add(symbol.get("exchcd"))
+
+            for exchcd in exchcds:
+                # 미체결에서도 확인하기
+                not_acc_result = await ls.overseas_stock().accno().cosaq00102(
+                    body=COSAQ00102.COSAQ00102InBlock1(
+                        QryTpCode="1",
+                        BkseqTpCode="1",
+                        OrdMktCode=exchcd,
+                        BnsTpCode="2",
+                        SrtOrdNo="999999999",
+                        OrdDt=datetime.now(ZoneInfo("America/New_York")).strftime("%Y%m%d"),
+                        ExecYn="2",
+                        CrcyCode="USD",
+                        ThdayBnsAppYn="0",
+                        LoanBalHldYn="0"
+                    )
+                ).req_async()
+
+                if not_acc_result.block3:
+                    for blk in not_acc_result.block3:
+                        isu_no = blk.IsuNo
+                        if isu_no is not None:
+                            held_isus.add(str(isu_no).strip())
+
+                        non_trade_symbols.append(
+                            NonTradedSymbol(
+                                OrdTime=blk.OrdTime,
+                                OrdNo=blk.OrdNo,
+                                OrgOrdNo=blk.OrgOrdNo,
+                                ShtnIsuNo=blk.ShtnIsuNo,
+                                MrcAbleQty=blk.MrcAbleQty,
+                                OrdQty=blk.OrdQty,
+                                OvrsOrdPrc=blk.OvrsOrdPrc,
+                                OrdprcPtnCode=blk.OrdprcPtnCode,
+                                OrdPtnCode=blk.OrdPtnCode,
+                                MrcTpCode=blk.MrcTpCode,
+                                OrdMktCode=blk.OrdMktCode,
+                                UnercQty=blk.UnercQty,
+                                CnfQty=blk.CnfQty,
+                                CrcyCode=blk.CrcyCode,
+                                RegMktCode=blk.RegMktCode,
+                                IsuNo=blk.IsuNo,
+                                BnsTpCode=blk.BnsTpCode
+                            )
+                        )
+
+            if held_isus:
+                filtered = []
+                for m_symbol in symbols_from_strategy:
+                    m_isu_no = m_symbol.get("symbol")
+
+                    if m_isu_no is None or str(m_isu_no).strip() not in held_isus:
+                        filtered.append(m_symbol)
+                return filtered, held_symbols, non_trade_symbols
+
+            return [], held_symbols, non_trade_symbols
+
+    async def new_sell_execute(
+        self,
+        system: SystemType,
+        symbols_from_strategy: List[SymbolInfo],
+        new_sell: NewSellTradeType,
+        order_id: str,
+    ) -> Optional[Union[BaseBuyOverseasStock, BaseSellOverseasStock]]:
+        """
+        Public entrypoint to perform sell execution for a system.
+        """
+
+        filtered_symbols, held_symbols, non_trade_symbols = await self._block_duplicate_symbols(system, symbols_from_strategy)
+
+        symbols, community_instance = await self.plugin_resolver.resolve_buysell_community(
+            trade=new_sell,
+            symbols=symbols_from_strategy,
+            held_symbols=held_symbols,
+            non_trade_symbols=non_trade_symbols,
+        )
+
+        if not symbols:
+            pg_logger.warning("No symbols found for sell strategy.")
+
+            return
+
+        for symbol in symbols:
+            if not symbol.get("success"):
+                continue
+
+            result = await self._build_order_function(
+                system=system,
+                trade_type="submitted_new_sell",
+                symbol=symbol
+            )
+
+            await self.real_order_executor.send_data_community_instance(
+                ordNo=str(result.block2.OrdNo),
+                community_instance=community_instance
+            )
+
+            if result.error_msg:
+                pg_logger.error(f"Order placement failed: {result.error_msg}")
+
+                continue
+
+            pg_logger.info(f"🟢 New buy order executed for order '{order_id}'")
+
+    async def _build_order_function(
+        self,
+        system: SystemType,
+        trade_type: OrderCategoryType,
+        symbol: Union[BaseBuyOverseasStockResponseType, BaseSellOverseasStockResponseType]
+    ):
+        """
+        Function that performs the actual order placement.
+        """
+        company = system.get("securities", {}).get("company", None)
+        product = system.get("securities", {}).get("product", None)
+
+        if company is None or not product:
+            raise exceptions.NotExistCompanyException(
+                message="No securities company or product configured in system."
+            )
+
+        if company == "ls":
+
+            ls = LS.get_instance()
+
+            if product == "overseas_stock":
+                # unify buy/sell order placement
+                ord_ptn = "02" if trade_type == "submitted_new_buy" else "01"
+                result: COSAT00301.COSAT00301Response = await ls.overseas_stock().order().cosat00301(
+                    body=COSAT00301.COSAT00301InBlock1(
+                        OrdPtnCode=ord_ptn,
+                        OrgOrdNo=None,
+                        OrdMktCode=symbol.get("ord_mkt_code"),
+                        IsuNo=symbol.get("isu_no"),
+                        OrdQty=symbol.get("ord_qty"),
+                        OvrsOrdPrc=symbol.get("ovrs_ord_prc"),
+                        OrdprcPtnCode=symbol.get("ordprc_ptn_code"),
+                    )
+                ).req_async()
+
+                pg_listener.emit_real_order({
+                    "order_type": trade_type,
+                    "message": result.rsp_msg,
+                    "symbol": symbol,
+                    "response": result,
+                })
+
+                if result.error_msg:
+                    pg_logger.error(f"Order placement failed: {result.error_msg}")
+                    raise exceptions.OrderException(
+                        message=f"Order placement failed: {result.error_msg}"
+                    )
+
+                return result

programgarden-0.1.0/programgarden/client.py

@@ -0,0 +1,162 @@
+
+import asyncio
+import logging
+import threading
+from typing import Callable
+from programgarden_core import pg_log, pg_log_disable, pg_logger
+from programgarden_core.bases import SystemType
+from programgarden_finance import LS
+from programgarden_core import EnforceKoreanAliasMeta
+from programgarden_core.exceptions import LoginException
+from programgarden import SystemExecutor
+from programgarden.pg_listener import StrategyPayload, RealOrderPayload, pg_listener
+from .system_keys import exist_system_keys_error
+from art import tprint
+
+
+def my_processor(event_type: str, data: dict):
+    print("global handler:", event_type, data)
+
+
+class Programgarden(metaclass=EnforceKoreanAliasMeta):
+    """
+    Programgarden DSL Client for running trading systems.
+    """
+
+    def __init__(self):
+
+        # 내부 상태
+        self._lock = threading.RLock()
+
+        # lazy init: SystemExecutor는 실제로 필요할 때 생성한다.
+        self._executor = None
+        self._executor_lock = threading.RLock()
+
+        # 비동기 실행 태스크 핸들 (이벤트 루프 내에서 중복 실행 방지용)
+        self._task = None
+
+    @property
+    def executor(self):
+        """
+        Lazily create and return the `SystemExecutor` instance.
+
+        The executor is created on first access. Double-checked locking is
+        used to avoid creating multiple executors in concurrent access
+        scenarios.
+
+        Returns:
+            SystemExecutor: the executor instance used to run strategies.
+        """
+        if getattr(self, "_executor", None) is None:
+            with self._executor_lock:
+                if getattr(self, "_executor", None) is None:
+                    self._executor = SystemExecutor()
+        return self._executor
+
+    def run(
+        self,
+        system: SystemType
+    ):
+        """
+            Run the system - continuous execution
+            This method starts the system and, if an event loop is already running,
+            runs it as a background task. If no event loop is running, it uses
+            asyncio.run() to execute the system.
+
+            Args:
+                system (SystemType): The system data object to run.
+            """
+
+        tprint("""
+Program Garden
+    x
+LS Securities
+""", font="tarty1")
+
+        if system:
+            self._check_debug(system)
+
+        try:
+            exist_system_keys_error(system)
+            asyncio.get_running_loop()
+
+            if self._task is not None and not self._task.done():
+                pg_logger.info("A task is already running; returning the existing task.")
+                return self._task
+
+            task = asyncio.create_task(self._execute(system))
+            self._task = task
+
+            return task
+
+        except RuntimeError:
+            return asyncio.run(self._execute(system))
+
+        finally:
+            pg_logger.error("The program has terminated.")
+            pg_listener.stop()
+
+    def _check_debug(self, system: SystemType):
+        """Check debug mode setting and set the logging level"""
+
+        debug = system.get("settings", {}).get("debug", None)
+        if debug == "DEBUG":
+            pg_log(logging.DEBUG)
+        elif debug == "INFO":
+            pg_log(logging.INFO)
+        elif debug == "WARNING":
+            pg_log(logging.WARNING)
+        elif debug == "ERROR":
+            pg_log(logging.ERROR)
+        elif debug == "CRITICAL":
+            pg_log(logging.CRITICAL)
+        else:
+            pg_log_disable()
+
+    async def _execute(self, system: SystemType):
+        """
+        Execute the trading strategy.
+        """
+        try:
+            securities = system.get("securities", {})
+            company = securities.get("company", None)
+            if company == "ls":
+                ls = LS.get_instance()
+
+                if not ls.is_logged_in():
+                    login_result = await ls.async_login(
+                        appkey=securities.get("appkey"),
+                        appsecretkey=securities.get("appsecretkey")
+                    )
+                    if not login_result:
+                        raise LoginException(
+                            message="LS 증권 로그인에 실패했습니다. 로그인 정보를 확인하세요."
+                        )
+
+            await self.executor.execute_system(system)
+
+            while self.executor.running:
+                await asyncio.sleep(1)
+
+        finally:
+            self.on_strategies_message(
+                {
+                    "event": "system_stopped",
+                    "message": "시스템이 종료되었습니다."
+                }
+            )
+            await self.stop()
+            # 실행 종료 후 태스크 핸들 초기화
+            self._task = None
+
+    async def stop(self):
+        await self.executor.stop()
+        pg_logger.debug("The program has been stopped.")
+
+    def on_strategies_message(self, callback: Callable[[StrategyPayload], None]) -> None:
+        """실시간 이벤트 수신 콜백 등록"""
+        pg_listener.set_strategies_handler(callback)
+
+    def on_real_order_message(self, callback: Callable[[RealOrderPayload], None]) -> None:
+        """실시간 주문 이벤트 수신 콜백 등록"""
+        pg_listener.set_real_order_handler(callback)