programgarden-community 0.1.1__tar.gz

programgarden_community-0.1.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: programgarden-community
+Version: 0.1.1
+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: croniter (>=6.0.0,<7.0.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: python-dotenv (>=1.1.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+외부 플러그인 모음

programgarden_community-0.1.1/README.md

@@ -0,0 +1 @@
+외부 플러그인 모음

programgarden_community-0.1.1/programgarden_community/__init__.py

@@ -0,0 +1,126 @@
+"""Programgarden community package root.
+
+This module implements a LangChain-style lazy import surface: names listed in
+``_MODULE_MAP`` are imported from their submodules on first access via
+``__getattr__``. Use ``getCommunityTool(name)`` to dynamically retrieve a class
+by its id string.
+"""
+
+from importlib import metadata
+import warnings
+from typing import Any, List, Optional
+
+try:
+    __version__ = metadata.version(__package__)
+except metadata.PackageNotFoundError:
+    __version__ = ""
+del metadata
+
+__all__ = [
+    "SMAGoldenDeadCross",
+    "StockSplitFunds",
+    "getCommunityTool",
+]
+
+
+def _warn_on_import(name: str, replacement: Optional[str] = None) -> None:
+    """Emit a warning when a name is imported from the package root.
+
+    This mirrors LangChain's behaviour: importing many symbols from the root
+    is convenient but we suggest importing from the actual submodule.
+    """
+    if replacement:
+        warnings.warn(
+            f"Importing {name} from programgarden_community root is discouraged; "
+            f"prefer {replacement}",
+            stacklevel=3,
+        )
+
+
+def __getattr__(name: str) -> Any:
+    """LangChain-style explicit lazy import surface.
+
+    Each supported top-level name is handled with an explicit branch that
+    imports the real implementation from its submodule on first access.
+    """
+    if name == "SMAGoldenDeadCross":
+        from programgarden_community.overseas_stock.strategy_conditions.sma_golden_dead import (
+            SMAGoldenDeadCross,
+        )
+
+        _warn_on_import(
+            name,
+            replacement=(
+                "programgarden_community.overseas_stock.strategy_conditions.sma_golden_dead.SMAGoldenDeadCross"
+            ),
+        )
+
+        globals()[name] = SMAGoldenDeadCross
+        return SMAGoldenDeadCross
+
+    if name == "StockSplitFunds":
+        from programgarden_community.overseas_stock.new_buy_conditions.stock_split_funds import (
+            StockSplitFunds,
+        )
+
+        _warn_on_import(
+            name,
+            replacement=(
+                "programgarden_community.overseas_stock.new_buy_conditions.stock_split_funds.StockSplitFunds"
+            ),
+        )
+
+        globals()[name] = StockSplitFunds
+        return StockSplitFunds
+
+    if name == "TrailingStopManager":
+        from programgarden_community.overseas_stock.new_sell_conditions.trailing_stop import (
+            TrailingStopManager,
+        )
+
+        _warn_on_import(
+            name,
+            replacement=(
+                "programgarden_community.overseas_stock.new_sell_conditions.trailing_stop.TrailingStopManager"
+            ),
+        )
+
+        globals()[name] = TrailingStopManager
+        return TrailingStopManager
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> List[str]:
+    shown: List[str] = list(globals().keys())
+    shown.extend(["SMAGoldenDeadCross", "StockSplitFunds"])
+    return sorted(shown)
+
+
+def getCommunityCondition(class_name: str) -> Any:
+    """Dynamically import and return a class by its registered id.
+
+    This mirrors the explicit-branch behaviour above and avoids importing the
+    entire package root.
+    """
+    if class_name == "SMAGoldenDeadCross":
+        from programgarden_community.overseas_stock.strategy_conditions.sma_golden_dead import (
+            SMAGoldenDeadCross,
+        )
+
+        return SMAGoldenDeadCross
+
+    if class_name == "StockSplitFunds":
+        from programgarden_community.overseas_stock.new_buy_conditions.stock_split_funds import (
+            StockSplitFunds,
+        )
+
+        return StockSplitFunds
+
+    if class_name == "TrailingStopManager":
+        from programgarden_community.overseas_stock.new_sell_conditions.trailing_stop import (
+            TrailingStopManager,
+        )
+
+        return TrailingStopManager
+
+    raise ValueError(f"{class_name} is not a valid community tool.")

programgarden_community-0.1.1/programgarden_community/overseas_stock/new_buy_conditions/stock_split_funds/__init__.py

@@ -0,0 +1,102 @@
+"""
+균등하게 분할매수하기 위한 자금배분
+"""
+from typing import List, Optional
+from programgarden_core import (
+    BaseBuyOverseasStock,
+    BaseBuyOverseasStockResponseType,
+)
+from programgarden_finance import LS, g3101
+
+
+class StockSplitFunds(BaseBuyOverseasStock):
+
+    id: str = "StockSplitFunds"
+    description: str = "주식 분할 자금"
+    securities: List[str] = ["ls-sec.co.kr"]
+
+    def __init__(
+        self,
+        appkey: Optional[str] = None,
+        appsecretkey: Optional[str] = None,
+        percent_balance: float = 10.0,
+        max_symbols: float = 5,
+    ):
+        """
+        주식 분할 자금 초기화
+
+        Args:
+            appkey (Optional[str]): LS증권 앱키
+            appsecretkey (Optional[str]): LS증권 앱시크릿키
+            percent_balance (float): 현재 예수금의 몇 %를 사용할지
+            max_symbols (float): 최대 몇 종목까지 매수할지
+        """
+        super().__init__()
+
+        self.appkey = appkey
+        self.appsecretkey = appsecretkey
+        self.percent_balance = percent_balance
+        self.max_symbols = max_symbols
+
+    async def execute(self) -> List[BaseBuyOverseasStockResponseType]:
+
+        ls = LS.get_instance()
+        if not ls.is_logged_in():
+            await ls.async_login(
+                appkey=self.appkey,
+                appsecretkey=self.appsecretkey
+            )
+
+        fcurr_dps = self.fcurr_dps * self.percent_balance
+
+        # 종목당 최대 매수 금액
+        per_max_amt = round(fcurr_dps / self.max_symbols, 2)
+
+        orders: List[BaseBuyOverseasStockResponseType] = []
+        for symbol in self.available_symbols:
+            if len(orders) >= self.max_symbols:
+                break
+
+            exchcd = symbol.get("exchcd")
+            symbol = symbol.get("symbol")
+
+            cur = await ls.overseas_stock().market().g3101(
+                body=g3101.G3101InBlock(
+                    keysymbol=exchcd+symbol,
+                    exchcd=exchcd,
+                    symbol=symbol
+                )
+            ).req_async()
+
+            # 계산된 금액으로 살 수 있는 최대 수량(정수)
+            price = round(float(cur.block.price), 1)
+            if price <= 0:
+                buy_qty = 0
+            else:
+                buy_qty = int(per_max_amt // price)
+            if buy_qty < 1:
+                continue
+
+            # 주문 생성
+            order: BaseBuyOverseasStockResponseType = {
+                "success": True,
+                "ord_ptn_code": "02",
+                "ord_mkt_code": exchcd,
+                "isu_no": symbol,
+                "ord_qty": buy_qty,
+                "ovrs_ord_prc": price,
+                "ordprc_ptn_code": "00",
+                "brk_tp_code": "01"
+            }
+
+            orders.append(order)
+
+        return orders
+
+    async def on_real_order_receive(self, order_type, response):
+        print(f"매수 Community 주문 데이터 수신: {order_type}")
+
+
+__all__ = [
+    "StockSplitFunds"
+]

programgarden_community-0.1.1/programgarden_community/overseas_stock/new_sell_conditions/loss_cut/__init__.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import List
+from programgarden_core import (
+    BaseSellOverseasStock, BaseSellOverseasStockResponseType
+)
+
+
+class BasicLossCutManager(BaseSellOverseasStock):
+
+    id: str = "BasicLossCutManager"
+    description: str = "기본 손절매 매니저"
+    securities: List[str] = ["ls-sec.co.kr"]
+
+    def __init__(
+        self,
+        losscut: float = -5,
+    ):
+        """
+        기본 손절매 매니저 초기화
+
+        Args:
+            losscut (float): 손절매 비율
+        """
+        super().__init__()
+
+        self.losscut = losscut
+
+    async def execute(self) -> List[BaseSellOverseasStockResponseType]:
+
+        results: List[BaseSellOverseasStockResponseType] = []
+        for held in self.held_symbols:
+            shtn_isu_no = held.get("ShtnIsuNo")
+            fcurr_mkt_code = held.get("FcurrMktCode")
+            keysymbol = fcurr_mkt_code + shtn_isu_no
+
+            rnl_rat = float(held.get("RnlRat", 0))
+
+            if rnl_rat <= self.losscut:
+                print(f"손절매 조건 충족: {keysymbol} 손익률={rnl_rat:.2f}% <= {self.losscut}%")
+
+                result: BaseSellOverseasStockResponseType = {
+                    "success": True,
+                    "ord_ptn_code": "01",
+                    "ord_mkt_code": fcurr_mkt_code,
+                    "shtn_isu_no": shtn_isu_no,
+                    "ord_qty": held.get("AstkSellAbleQty", 0),
+                    "ovrs_ord_prc": 0.0,
+                    "ordprc_ptn_code": "03",
+                    "crcy_code": "USD",
+                    "pnl_rat": rnl_rat,
+                    "pchs_amt": held.get("PchsAmt", 0.0),
+                }
+                results.append(result)
+
+        return results

programgarden_community-0.1.1/programgarden_community/overseas_stock/strategy_conditions/sma_golden_dead/__init__.py

@@ -0,0 +1,256 @@
+"""
+Moving average golden/dead cross detection conditions
+
+1) Observed a dead->golden where golden_price > dead_price (candidate)
+2) The golden occurred within the most recent 2 data points
+3) The latest alignment is golden (still maintained)
+"""
+from dataclasses import dataclass
+from typing import List, Literal, Optional, TypedDict
+from programgarden_core import (
+    BaseConditionResponseType,
+    BaseCondition,
+)
+from programgarden_finance import LS, g3204
+
+
+class ChartDay(TypedDict):
+    """
+    차트 일별 데이터 타입
+    """
+    date: str  # 날짜
+    price: float  # 종가
+
+
+@dataclass
+class SMASignal:
+    """
+    SMA 신호 데이터 클래스
+    """
+    cross: Literal["golden", "dead", "none"]
+    price: float
+    volume: float
+    date: str
+
+
+class SMAGoldenDeadCross(BaseCondition):
+    """
+    SMA 해외 주식 클래스
+    """
+
+    id: str = "SMAGoldenDeadCross"
+    description: str = """
+Moving average golden/dead cross detection conditions
+
+1) Observed a dead->golden where golden_price > dead_price (candidate)
+2) The golden occurred within the most recent 2 data points
+3) The latest alignment is golden (still maintained)
+"""
+
+    def __init__(
+        self,
+        start_date: Optional[str],
+        end_date: Optional[str],
+        long_period: int,
+        short_period: int,
+        time_category: Literal["months", "weeks", "days"] = "days",
+        days_prices: Optional[list[ChartDay]] = None,
+        use_ls: bool = True,
+        alignment: Literal["golden", "dead"] = "golden",
+        appkey: Optional[str] = None,
+        appsecretkey: Optional[str] = None,
+    ):
+        """
+        SMA 해외 주식 클래스 초기화
+
+        Args:
+            symbol (str): 종목 코드, ex) "82TSLA"
+            exchcd (str): LS증권에서 사용하는 거래소 코드, ex) "82"
+            start_date (Optional[str]): 시작 날짜, ex) 20230101
+            end_date (Optional[str]): 종료 날짜, ex) 20231231
+            long_period: int: 롱 포지션 기간
+            short_period: int: 숏 포지션 기간
+            time_category (Literal["months", "weeks", "days", "minutes"]): 카테고리
+            days_prices (Optional[list[ChartDay]]): 기간 동안의 종가 리스트
+            use_ls (bool): LS증권 데이터를 사용할지 여부
+            alignment (Literal["golden", "dead"]): 정렬 방식
+            appkey (Optional[str]): LS증권 앱키
+            appsecretkey (Optional[str]): LS증권 앱시크릿키
+        """
+        super().__init__()
+
+        if not use_ls and not days_prices:
+            raise ValueError("LS증권 데이터를 사용하지 않는 경우 days_prices가 필요합니다.")
+
+        if use_ls and (not appkey or not appsecretkey):
+            raise ValueError("LS증권 데이터를 사용하려면 appkey와 appsecretkey가 필요합니다.")
+
+        self.start_date = start_date
+        self.end_date = end_date
+
+        # store provided SMA periods and helper list used by calculator
+        self.long_period = long_period
+        self.short_period = short_period
+        # list of SMA periods used throughout the calculator (short -> long)
+        self.sma_periods = [self.short_period, self.long_period]
+
+        # transition detection state:
+        # last observed dead cross price (None if not seen yet)
+        self._last_dead_price = None
+        # whether a valid dead->golden transition (golden price > dead price) was observed
+        self._transition_detected = False
+
+        self.time_category = time_category
+        self.days_prices = days_prices if days_prices is not None else []
+        self.use_ls = use_ls
+        self.alignment = alignment
+        self.appkey = appkey
+        self.appsecretkey = appsecretkey
+
+    async def execute(self) -> BaseConditionResponseType:
+        """
+        SMA 해외 주식 전략을 실행합니다.
+        이 메서드는 비동기적으로 실행됩니다.
+        """
+
+        self.ls = LS.get_instance()
+        if not self.ls.token_manager.is_token_available():
+            await self.ls.async_login()
+        exchcd = self.symbol.get("exchcd")
+        symbol = self.symbol.get("symbol")
+
+        gubun = "2"
+        if self.time_category == "days":
+            gubun = "2"
+        elif self.time_category == "weeks":
+            gubun = "3"
+        elif self.time_category == "months":
+            gubun = "4"
+
+        m_g3204 = self.ls.overseas_stock().chart().g3204(
+            g3204.G3204InBlock(
+                sdate=self.start_date,
+                edate=self.end_date,
+                keysymbol=exchcd + symbol,
+                exchcd=exchcd,
+                symbol=symbol,
+                gubun=gubun,
+                qrycnt=500,
+            )
+        )
+
+        occurs_result = await m_g3204.occurs_req_async()
+        all_blocks: List[g3204.blocks.G3204OutBlock1] = []
+        for response in occurs_result:
+            all_blocks.extend(response.block1)
+        all_blocks.sort(key=lambda x: x.date)
+
+        self.all_signal = self._calculator(all_blocks)
+
+        return {
+            "condition_id": self.id,
+            # "success": getattr(self, "_transition_detected", False),
+            "success": True,
+            "exchange": self.symbol.get("exchcd", None),
+            "symbol": self.symbol.get("symbol", None),
+            "data": self.all_signal
+        }
+
+    def _calculator(
+        self,
+        blocks: List[g3204.blocks.G3204OutBlock1],
+    ) -> List[SMASignal]:
+        """
+        응답을 처리하는 메소드
+
+        Args:
+            response (g3204.blocks.G3204Response): 응답 객체
+            status (RequestStatus): 요청 상태
+        """
+
+        signals = []
+
+        # For simplicity we only handle a single short vs long SMA pair
+        short_period = int(self.short_period)
+        long_period = int(self.long_period)
+        max_period = max(self.sma_periods)
+
+        # tracking variables to support the new requirement:
+        # - golden must have occurred within the last 2 data points
+        # - golden alignment must still be maintained at the end
+        last_dead_price = None
+        golden_index = None
+        golden_price = None
+        transition_candidate = False
+        last_alignment_golden = False
+
+        for idx, block in enumerate(blocks):
+            # SMA 계산을 위한 데이터 수집
+            if not hasattr(self, 'price_history'):
+                self.price_history = []
+
+            self.price_history.append(block.close)
+
+            cross_type = "none"
+
+            # 현재 SMA 계산 (데이터가 충분할 때)
+            if len(self.price_history) >= max_period:
+                current_short = sum(self.price_history[-short_period:]) / short_period
+                current_long = sum(self.price_history[-long_period:]) / long_period
+
+                # update last alignment state (used after loop)
+                last_alignment_golden = current_short > current_long
+
+                # 이전 시점 SMA가 존재할 때만 크로스 판정
+                if len(self.price_history) > max_period:
+                    prev_short = sum(self.price_history[-short_period-1:-1]) / short_period
+                    prev_long = sum(self.price_history[-long_period-1:-1]) / long_period
+
+                    # 정렬 상태: strict 비교 (현재 단기 > 장기 => 골든 정렬)
+                    all_golden_aligned = current_short > current_long
+                    all_dead_aligned = current_short < current_long
+
+                    # 최근 크로스 발생 여부
+                    recent_golden_cross = (prev_short <= prev_long and current_short > current_long)
+                    recent_dead_cross = (prev_short >= prev_long and current_short < current_long)
+
+                    if all_golden_aligned and recent_golden_cross:
+                        cross_type = "golden"
+                    elif all_dead_aligned and recent_dead_cross:
+                        cross_type = "dead"
+
+                    sma_signal = SMASignal(
+                        cross=cross_type,
+                        price=block.close,
+                        volume=block.volume,
+                        date=block.date,
+                    )
+
+                    # transition tracking: record dead/golden with their indices and prices
+                    if cross_type == "dead":
+                        last_dead_price = block.close
+                        # keep compatibility with instance attribute
+                        self._last_dead_price = last_dead_price
+                    elif cross_type == "golden":
+                        golden_index = idx
+                        golden_price = block.close
+                        # golden must be strictly higher than last dead price to be candidate
+                        if last_dead_price is not None and golden_price > last_dead_price:
+                            transition_candidate = True
+
+                    signals.append(sma_signal)
+
+        # Final evaluation: mark transition detected only when
+        # 1) we observed a dead->golden where golden_price > dead_price (candidate)
+        # 2) the golden occurred within the most recent 2 data points
+        # 3) the latest alignment is golden (still maintained)
+        self._transition_detected = False
+        if transition_candidate and golden_index is not None:
+            # number of data points since the golden event
+            if len(blocks) - golden_index <= 2 and last_alignment_golden:
+                self._transition_detected = True
+
+        # persist last dead price for external visibility
+        self._last_dead_price = last_dead_price
+
+        return signals

programgarden_community-0.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+authors = [
+    {"name" = "프로그램동산","email" = "coding@programgarden.com"}
+]
+homepage = "https://programgarden.com"
+requires-python = ">=3.9"
+name = "programgarden-community"
+version = "0.1.1"
+description = "증권 분석에 필요한 외부 전략 모아둔 플러그인"
+readme = "README.md"
+
+[tool.poetry]
+packages = [
+    { include = "programgarden_community" }
+]
+
+[tool.poetry.dependencies]
+pydantic = ">=2.11.7,<3.0.0"
+programgarden-finance = "^0.1.0"
+programgarden-core = "^0.1.0"
+croniter = "^6.0.0"
+python-dotenv = "^1.1.1"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"