openfund-core 0.0.4__py3-none-any.whl → 1.0.5__py3-none-any.whl

core/smc/SMCStruct.py

@@ -0,0 +1,296 @@
+import logging
+import operator
+from core.utils.OPTools import OPTools
+from core.smc.SMCBase import SMCBase
+
+class SMCStruct(SMCBase):
+    BULLISH_TREND = 'Bullish'
+    BEARISH_TREND = 'Bearish'
+    STRUCT_COL = "struct"
+    STRUCT_HIGH_COL = "struct_high"
+    STRUCT_LOW_COL = "struct_low"
+    STRUCT_MID_COL = "struct_mid"
+    STRUCT_HIGH_INDEX_COL = "struct_high_index"
+    STRUCT_LOW_INDEX_COL = "struct_low_index"
+    STRUCT_DIRECTION_COL = "struct_direction"
+    HIGH_START_COL = "high_start"
+    LOW_START_COL = "low_start"
+
+    def __init__(self):  
+        super().__init__()
+        self.logger = logging.getLogger(__name__)
+      
+   
+    def build_struct(self, data, is_struct_body_break=True):
+        """处理价格结构,识别高低点突破和结构方向
+        
+        Args:
+            df: 数据框
+            window: 寻找结构极值的窗口大小
+            is_struct_body_break: 是否使用收盘价判断突破
+            
+        Returns:
+            处理后的数据框,包含结构相关列
+        """
+        # 复制数据并去掉最后一条记录，因为最后一条记录不是完成状态的K线
+        df = data.copy().iloc[:-1]
+        check_columns = [self.HIGH_COL, self.LOW_COL, self.CLOSE_COL]
+        self.check_columns(df, check_columns)
+        
+        # 初始化结构相关列
+        # 定义结构相关的列名
+        struct_columns = [self.STRUCT_COL, self.STRUCT_HIGH_COL, self.STRUCT_LOW_COL, 
+                         self.STRUCT_HIGH_INDEX_COL, self.STRUCT_LOW_INDEX_COL, self.STRUCT_DIRECTION_COL]
+        
+        # 初始化结构相关列的默认值
+        default_values = {
+            self.STRUCT_COL: None,  # 结构类型列初始化为None
+            self.STRUCT_HIGH_COL: self.toDecimal('0.0'),  # 结构高点价格初始化为0
+            self.STRUCT_LOW_COL: self.toDecimal('0.0'),  # 结构低点价格初始化为0
+            self.STRUCT_HIGH_INDEX_COL: 0,  # 结构高点索引初始化为0 
+            self.STRUCT_LOW_INDEX_COL: 0,  # 结构低点索引初始化为0
+            self.STRUCT_DIRECTION_COL: None  # 结构方向初始化为0
+        }
+        
+        # 为每个结构列赋默认值
+        for col in struct_columns:
+            df[col] = default_values[col]
+            
+        # 初始化结构变量
+        structure = {
+            self.HIGH_COL: df[self.HIGH_COL].iloc[0],
+            self.LOW_COL: df[self.LOW_COL].iloc[0],
+            self.HIGH_START_COL: -1,
+            self.LOW_START_COL: -1,
+            'direction': 0
+        }
+
+        # 确定突破判断列
+        break_price_col = self.CLOSE_COL if is_struct_body_break else self.HIGH_COL
+        break_price_col_low = self.CLOSE_COL if is_struct_body_break else self.LOW_COL
+
+        for i in range(1, len(df)):
+            curr_prices = {
+                self.HIGH_COL: df[break_price_col].iloc[i],
+                self.LOW_COL: df[break_price_col_low].iloc[i]
+            }
+            
+            # 获取前3根K线价格
+            prev_prices = {
+                self.HIGH_COL: df[break_price_col].iloc[i-3:i].values,
+                self.LOW_COL: df[break_price_col_low].iloc[i-3:i].values
+            }
+
+            # 判断结构突破
+            is_high_broken = self._check_structure_break(
+                curr_price=curr_prices[self.HIGH_COL],
+                struct_price=structure[self.HIGH_COL],
+                prev_prices=prev_prices[self.HIGH_COL],
+                struct_start=structure[self.HIGH_START_COL],
+                i=i,
+                direction=structure['direction'],
+                target_direction=1
+            )
+            
+            is_low_broken = self._check_structure_break(
+                curr_price=curr_prices[self.LOW_COL],
+                struct_price=structure[self.LOW_COL],
+                prev_prices=prev_prices[self.LOW_COL],
+                struct_start=structure[self.LOW_START_COL],
+                i=i,
+                direction=structure['direction'],
+                target_direction=2,
+                mode=self.LOW_COL
+            )
+
+            if is_low_broken:
+                # 处理低点突破
+                structure = self._handle_structure_break(
+                    df, i, structure,
+                    break_type=self.LOW_COL,
+                    struct_type='BOS' if structure['direction'] == 1 else 'CHOCH'
+                )
+                
+            elif is_high_broken:
+                # 处理高点突破
+                structure = self._handle_structure_break(
+                    df, i, structure,
+                    break_type=self.HIGH_COL, 
+                    struct_type='BOS' if structure['direction'] == 2 else 'CHOCH'
+                )
+                
+            else:
+                # 更新当前结构
+                structure = self._update_current_structure(
+                    df, i, structure,
+                    is_struct_body_break=is_struct_body_break
+                )
+            
+            # 更新数据框结构列
+            self._update_structure_columns(df, i, structure)
+
+        return df
+
+    def _get_structure_extreme_bar(self, df, bar_index,  struct_index, mode='high'):
+        """
+        获取结构最高点或最低点
+        :param df: DataFrame数据
+        :param bar_index: 当前K线索引
+        :param lookback: 回溯周期
+        :param mode: self.HIGH_COL寻找最高点,self.LOW_COL寻找最低点
+        :return: 结构极值点的索引
+        """
+        df = df.copy()
+        # window_start = max(0, bar_index - lookback + 1)
+        window_start = max(0, struct_index)
+        
+        window = df.iloc[window_start : bar_index + 1]
+        
+        # 获取窗口内的极值点索引
+        if mode == self.HIGH_COL:
+            extremeBar = window[self.HIGH_COL].argmax() 
+            price_col = self.HIGH_COL
+            comp_func = lambda x, y: x > y
+        else:
+            extremeBar = window[self.LOW_COL].argmin() 
+            price_col = self.LOW_COL
+            comp_func = lambda x, y: x < y
+
+        # 初始化记录点
+        pivot = 0
+        # 从后向前遍历寻找结构极值点
+        # for i in range(lookback - 1, -1, -1):
+        for idx in range(bar_index - 1, struct_index - 1, -1):
+            # 计算当前位置的索引
+            # idx = bar_index - i
+            if idx - 2 < 0 or idx + 1 >= len(df):
+                continue
+                
+            price_prev = df[price_col].iloc[idx - 1]
+            price_prev2 = df[price_col].iloc[idx - 2]
+            price_curr = df[price_col].iloc[idx]
+            
+            # 记录满足条件的点位
+            if (comp_func(price_prev, price_prev2) and
+                not comp_func(price_curr, price_prev) \
+                # and idx - 1 >= extremeBar
+                ):
+                if pivot == 0:
+                    pivot = idx - 1
+                    continue
+                else:                   
+                    # 比较当前点位与之前记录的极值点的价格,因为在区间内有多个极致点，需要比较
+                    if comp_func(df[price_col].iloc[idx-1], df[price_col].iloc[pivot]):
+                        pivot = idx - 1
+        if pivot != 0:
+            extremeBar = pivot 
+                
+        return extremeBar
+
+    def _check_structure_break(self, curr_price, struct_price, prev_prices, struct_start, i, direction, target_direction, mode='high'):
+        """检查结构是否突破"""
+        comp = operator.gt if mode == self.HIGH_COL else operator.lt
+        reverse_comp = operator.le if mode == self.HIGH_COL else operator.ge
+        
+        basic_break = (
+            comp(curr_price, struct_price) and
+            all(reverse_comp(p, struct_price) for p in prev_prices) and
+            all(i-j > struct_start for j in range(1,4))
+        )
+        
+        direction_break = direction == target_direction and comp(curr_price, struct_price)
+        
+        return basic_break or direction_break
+
+    def _handle_structure_break(self, df, i, structure, break_type, struct_type):
+        """处理结构突破"""
+        is_high_break = break_type == self.HIGH_COL
+        
+        struct_start = structure[self.HIGH_START_COL] if is_high_break else structure[self.LOW_START_COL]
+        
+        # 获取新的极值点
+        extreme_idx = self._get_structure_extreme_bar(
+            df, i, struct_start,  
+            mode=self.LOW_COL if is_high_break else self.HIGH_COL
+        )
+        
+        # 更新结构信息
+        new_structure = structure.copy()
+        new_structure['direction'] = 2 if is_high_break else 1
+        
+        if is_high_break:
+            new_structure.update({
+                self.LOW_COL: self.toDecimal(df[self.LOW_COL].iloc[extreme_idx]),
+                self.HIGH_COL: self.toDecimal(df[self.HIGH_COL].iloc[i]),
+                self.LOW_START_COL: extreme_idx,
+                self.HIGH_START_COL: i
+            })
+        else:
+            new_structure.update({
+                self.HIGH_COL: self.toDecimal(df[self.HIGH_COL].iloc[extreme_idx]),
+                self.LOW_COL: self.toDecimal(df[self.LOW_COL].iloc[i]),
+                self.HIGH_START_COL: extreme_idx,
+                self.LOW_START_COL: i
+            })
+            
+        # 更新DataFrame结构信息
+        # df.at[i, self.STRUCT_DIRECTION_COL] = new_structure['direction'] 
+        df.at[i, self.STRUCT_DIRECTION_COL] = self.BULLISH_TREND if is_high_break else self.BEARISH_TREND
+        df.at[i, self.STRUCT_COL] = f"{self.BULLISH_TREND if is_high_break else self.BEARISH_TREND}_{struct_type}"
+        
+        return new_structure
+
+    def _update_current_structure(self, df, i, structure, is_struct_body_break):
+        """更新当前结构"""
+        new_structure = structure.copy()
+        
+        # 检查是否需要更新高点
+        if (structure['direction'] in (2,0)) and df.at[i,self.HIGH_COL] > structure[self.HIGH_COL]:
+            if not (is_struct_body_break and all(i-j > structure[self.HIGH_START_COL] for j in range(1,4))):
+                new_structure[self.HIGH_COL] = df.at[i,self.HIGH_COL]
+                new_structure[self.HIGH_START_COL] = i
+                
+        # 检查是否需要更新低点
+        elif (structure['direction'] in (1,0)) and df.at[i,self.LOW_COL] < structure[self.LOW_COL]:
+            if not (is_struct_body_break and all(i-j > structure[self.LOW_START_COL] for j in range(1,4))):
+                new_structure[self.LOW_COL] = df.at[i,self.LOW_COL]
+                new_structure[self.LOW_START_COL] = i
+                
+        return new_structure
+
+    def _update_structure_columns(self, df, i, structure):
+        """更新数据框中的结构列"""
+        df.at[i, self.STRUCT_HIGH_COL] = self.toDecimal(structure[self.HIGH_COL])
+        df.at[i, self.STRUCT_LOW_COL] = self.toDecimal(structure[self.LOW_COL] )
+        df.at[i, self.STRUCT_HIGH_INDEX_COL] = structure[self.HIGH_START_COL]
+        df.at[i, self.STRUCT_LOW_INDEX_COL] = structure[self.LOW_START_COL]
+
+    def get_last_struct(self, df):
+        """
+        获取最新的结构
+        """
+        check_columns = [self.STRUCT_COL]
+        if not self.check_columns(df, check_columns):
+            data = self.build_struct(df=df)
+        else:
+            data = df.copy()
+       
+        # 筛选有效结构且在prd范围内的数据
+        last_struct = None
+        mask = data[self.STRUCT_COL].notna()
+        valid_structs = data[ mask ]
+        if not valid_structs.empty:
+            # 获取最近的结构
+            last_struct = valid_structs.iloc[-1]
+            return {
+                self.STRUCT_COL: last_struct[self.STRUCT_COL],
+                self.STRUCT_HIGH_COL: last_struct[self.STRUCT_HIGH_COL],
+                self.STRUCT_LOW_COL: last_struct[self.STRUCT_LOW_COL], 
+                self.STRUCT_MID_COL: (last_struct[self.STRUCT_HIGH_COL] + last_struct[self.STRUCT_LOW_COL]) / 2,
+                self.STRUCT_HIGH_INDEX_COL: last_struct[self.STRUCT_HIGH_INDEX_COL],
+                self.STRUCT_LOW_INDEX_COL: last_struct[self.STRUCT_LOW_INDEX_COL],
+                self.STRUCT_DIRECTION_COL: last_struct[self.STRUCT_DIRECTION_COL]
+            }
+
+        return last_struct
+

core/utils/OPTools.py

@@ -0,0 +1,30 @@
+import requests
+from decimal import Decimal
+
+class OPTools:
+    
+    @staticmethod
+    def toDecimal(value, precision:int=None):
+        """将数值转换为Decimal类型
+        
+        Args:
+            value: 需要转换的数值
+            precision: 精度,如果不指定则保持原始精度
+        
+        Returns:
+            Decimal: 转换后的Decimal对象 
+        """
+        if precision is None:
+            return Decimal(str(value))
+        return Decimal(f"{value:.{precision}f}")
+    
+    @staticmethod
+    def send_feishu_notification(webhook, message):
+        if webhook:
+            headers = {'Content-Type': 'application/json'}
+            data = {"msg_type": "text", "content": {"text": message}}
+            response = requests.post(webhook, headers=headers, json=data)
+            if response.status_code != 200:
+                # self.logger.debug("飞书通知发送成功")
+                raise Exception(f"飞书通知发送失败: {response.text} {webhook}")
+

openfund_core-1.0.5.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.3
+Name: openfund-core
+Version: 1.0.5
+Summary: Openfund-core.
+Requires-Python: >=3.9,<4.0
+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: apscheduler (>=3.11.0,<4.0.0)
+Requires-Dist: ccxt (>=4.4.26,<5.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pyfiglet (>=1.0.2,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Description-Content-Type: text/markdown
+
+# jiezhen
+## 读秒循环接针
+**视频说明地址** ：https://www.youtube.com/watch?v=b-LhdQomOxk
+
+**环境**：`python3.9`
+**开平仓模式** ，不支持单向持仓
+**策略原理** ：上次在火币看到一些很长的针，就想着如何把针接住，本质很简单，
+1. 用ema判断短期趋势，尽可能下面挂单接住插下来的针。
+2. 如果跑15m周期以上，建议用1h的ema判断多空，或者人工介入判断
+
+**源码配置** ：
+config_bak.json  改成config.json
+
+#### apiKey: OKX API 的公钥，用于身份验证。
+#### secret: OKX API 的私钥，用于签名请求。
+#### password: OKX 的交易密码（或 API 密码）。
+#### leverage: 默认持仓杠杆倍数
+#### feishu_webhook: 飞书通知地址
+#### monitor_interval: 循环间隔周期 / 单位秒
+
+
+## 每个交易对都可以单独设置其交易参数：
+#### long_amount_usdt: 做多交易时每笔订单分配的资金量（以 USDT 为单位）。
+#### short_amount_usdt: 做空交易时每笔订单分配的资金量（以 USDT 为单位）。
+#### value_multiplier: 用于放大交易价值的乘数，适合调整风险/回报比。
+
+zhen.py 跟 zhen_2.py 的区别是：https://x.com/huojichuanqi/status/1858991226877603902
+
+打赏地址trc20: TUunBuqQ1ZDYt9WrA3ZarndFPQgefXqZAM
+

openfund_core-1.0.5.dist-info/RECORD

@@ -0,0 +1,15 @@
+core/Exchange.py,sha256=eanGV-8ZLDFxP2tV6xumo8c68yqFTUeseJA_dHMhYb0,20785
+core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/main.py,sha256=E-VZzem7-0_J6EmOo9blLPokc5MRcgjqCbqAvbkPnWI,630
+core/smc/SMCBase.py,sha256=epRC5bWDymx7ZMIhn_bVJRjvBHItt6BCnYASO2fhSDg,4302
+core/smc/SMCFVG.py,sha256=QtqlW1oooYVA7CG5ld5X0Q5twX1XCELO118IlMUhX6M,2974
+core/smc/SMCLiquidity.py,sha256=lZt2IQk3TWaT-nA7he57dUxPdLEWW61jRZWLAzOTat0,119
+core/smc/SMCOrderBlock.py,sha256=Il5JKmVER2vT6AKZLo0mD4wRqV_Op9IBK3jB1SfgTqY,9894
+core/smc/SMCPDArray.py,sha256=Vn_nTBLaIhrBhxe_hX3Iycn0gY0tmYd_qaqNalztfmA,2841
+core/smc/SMCStruct.py,sha256=FZoh_F81YvONZObbDF7jzH8F6lDgo0-17tNQwOS3V_g,12260
+core/smc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+core/utils/OPTools.py,sha256=tJ1Jq_Caab6OWaX12xn4_g9ryf98Rm5I1zsJEEU8NIQ,1002
+openfund_core-1.0.5.dist-info/METADATA,sha256=VZWu0jgtwFtrr5fqdgk3p28GZWGwoMQeNNHwFj5QHsk,1953
+openfund_core-1.0.5.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_core-1.0.5.dist-info/entry_points.txt,sha256=g8GUw3cyKFtcG5VWs8geU5VBLqiWr59GElqERuH8zD0,48
+openfund_core-1.0.5.dist-info/RECORD,,

{openfund_core-0.0.4.dist-info → openfund_core-1.0.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

openfund_core-1.0.5.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+openfund-core=core.main:main
+

openfund/core/__init__.py

@@ -1,14 +0,0 @@
-# import time
-# from apscheduler.schedulers.blocking import BlockingScheduler
-
-
-# def taskDetail(taskName: str):
-#     currTime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
-#     print(f"{taskName}-->", "currTime:", currTime)
-
-
-# if __name__ == "__main__":
-#     apSchedule = BlockingScheduler()
-#     apSchedule.add_job(func=taskDetail, trigger="interval", seconds=5, args=["task-A"])
-
-#     apSchedule.start()

openfund/core/api_tools/__init__.py

@@ -1,16 +0,0 @@
-# from binance.spot import Spot
-
-# client = Spot()
-
-# Get server timestamp
-# print(client.time())
-# Get klines of BTCUSDT at 1m interval
-# print(client.klines("BTCUSDT", "1m"))
-# Get last 10 klines of BNBUSDT at 1h interval
-# print(client.klines("BNBUSDT", "1h", limit=10))
-
-# API key/secret are required for user data endpoints
-# client = Spot(api_key='<api_key>', api_secret='<api_secret>')
-
-# Get account and balance information
-# print(client.account())

openfund/core/api_tools/binance_futures_tools.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from openfund.core.base_tool import Tool as BaseTool
-from openfund.core.pyopenfund import Openfund
-
-
-logger = logging.getLogger(__name__)
-
-
-class BinanceUMFuturesTool(BaseTool):
-    def __init__(self, openfund: Openfund | None = None) -> None:
-        super().__init__(openfund, "binance")
-
-    def time(self):
-        return self.umclient.time()
-
-    def ping(self):
-        return self.umclient.ping()
-
-    def klines(self, symbol: str, interval: str = "1m", **kwargs):
-        return self.umclient.klines(symbol=symbol, interval=interval, **kwargs)

openfund/core/api_tools/binance_tools.py

@@ -1,26 +0,0 @@
-from __future__ import annotations
-
-import logging
-from poetry.utils.authenticator import Authenticator
-
-from typing import TYPE_CHECKING
-
-from openfund.core.base_tool import Tool as BaseTool
-from openfund.core.pyopenfund import Openfund
-
-
-logger = logging.getLogger(__name__)
-
-
-class BinanceTools(BaseTool):
-    def __init__(self, openfund: Openfund | None = None) -> None:
-        super().__init__(openfund, "binance")
-
-    def get_time(self):
-        return self.client.time()
-
-    def get_account(self):
-        return self.client.account()
-
-    def get_klines(self, symbol: str, interval: str, **kwargs):
-        return self.client.klines(symbol=symbol, interval=interval, **kwargs)