openfund-maker 1.0.16__py3-none-any.whl → 1.1.0__py3-none-any.whl

maker/ThreeLineOrderBot.py

@@ -49,18 +49,6 @@ class ThreeLineOrdergBot:
     def get_precision_length(self,symbol) -> int:
         tick_size = self.get_tick_size(symbol)
         return len(f"{tick_size:.10f}".rstrip('0').split('.')[1]) if '.' in f"{tick_size:.10f}" else 0
-    
-    # def decimal_to_precision(self,symbol,price) -> float:
-    #     from ccxt.base.decimal_to_precision import DECIMAL_PLACES, TICK_SIZE, NO_PADDING, TRUNCATE, ROUND, ROUND_UP, ROUND_DOWN, SIGNIFICANT_DIGITS
-    #     tick_size = self.get_tick_size(symbol)
-    #     new_px = self.exchange.decimal_to_precision(
-    #         n=float(price),
-    #         precision=tick_size,
-    #         rounding_mode=ROUND,
-    #         counting_mode=TICK_SIZE
-    #     )
-        
-    #     return new_px
 
     def get_position_mode(self):
         try:
@@ -78,7 +66,6 @@ class ThreeLineOrdergBot:
         except Exception as e:
             self.logger.error(f"无法检测持仓模式: {e}")
             return None
-
     
     def fetch_and_store_all_instruments(self,instType='SWAP'):
         try:
@@ -123,7 +110,6 @@ class ThreeLineOrdergBot:
         else:
             raise ValueError("Unexpected response structure or missing 'c' value")
 
-
     def get_mark_price(self,symbol):
         # response = market_api.get_ticker(instId)
         ticker = self.exchange.fetch_ticker(symbol)
@@ -167,29 +153,29 @@ class ThreeLineOrdergBot:
         atr = sum(trs[-period:]) / period
         return atr
     
-    def calculate_sma_pandas(self,symbol, kLines, period) -> pd.Series:
+    def calculate_sma_pandas(self,symbol, klines, period) -> pd.Series:
         """
         使用 pandas 计算 SMA
         :param KLines K线
         :param period: SMA 周期
         :return: SMA 值
         """
-        precision= self.get_precision_length(symbol)
-        df = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
-        sma = df['close'].rolling(window=period).mean().round(precision)
+       
+        df = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+        sma = df['close'].rolling(window=period).mean()
         return sma 
                
-    def calculate_ema_pandas(self,symbol, kLines, period) -> pd.Series:
+    def calculate_ema_pandas(self,symbol, klines, period) -> pd.Series:
         """
         使用 pandas 计算 EMA
         :param KLines K线
         :param period: EMA 周期
         :return: EMA 值
         """
-        precision= self.get_precision_length(symbol)
-        df = pd.DataFrame(kLines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
+      
+        df = pd.DataFrame(klines, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
         # 计算EMA
-        ema = df['close'].ewm(span=period, adjust=False).mean().round(precision)
+        ema = df['close'].ewm(span=period, adjust=False).mean()
         return ema 
 
     def calculate_average_amplitude(self,klines, period=60):
@@ -202,23 +188,187 @@ class ThreeLineOrdergBot:
             amplitudes.append(amplitude)
         average_amplitude = sum(amplitudes) / len(amplitudes)
         return average_amplitude
+
+    def calculate_range_diff(self,prices:pd.Series) -> float:
+        """
+        计算价格列表中最后一个价格与第一个价格的差值。
+        Args:
+            prices: 价格列表。
+        Returns:
+            diff: 计算最高价列的最大值与最小值的差值
+。
+        """
+        if prices.empty:
+            return None
+        # 将价格列表转换为pandas Series格式
+  
+        diff = prices.max() - prices.min()
+        
+        return diff
     
-    def cancel_all_orders(self,symbol):
-        try:
-            # 获取所有未完成订单
-            params = {
-                # 'instId': instId
+    def calculate_place_order_price(self, symbol,side,base_price, amplitude_limit, offset=1) -> float:
+        """
+        计算开仓价格
+        Args:
+            symbol: 交易对
+            side: 开仓方向
+            base_price: 开盘价格
+            amplitude_limit: 振幅限制
+            offset: 偏移量
+        Returns:
+            place_order_price: 开仓价格
+        """
+        tick_size = self.get_tick_size(symbol)
+        place_order_price = None
+        # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
+      
+        if side == 'buy':
+            place_order_price = base_price * (1- amplitude_limit/100) - offset * tick_size
+        else:
+            place_order_price = base_price * (1 + amplitude_limit/100) + offset * tick_size
+        self.logger.debug(f"++++ {symbol} 下单价格: {place_order_price:.9f} 方向 {side} 基准价格{base_price} 振幅限制 {amplitude_limit} ")
+        return float(self.round_price_to_tick(place_order_price,tick_size))
+     
+    # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
+    def judge_k_line_direction(self, symbol, pair_config, ema: pd.Series, klines) -> int:
+        """
+        判断K线方向
+        Args:
+            symbol: 交易对
+            pair_config: 配置参数
+            ema: EMA数据
+        Returns:
+            int: -1:平, 0:空, 1:多
+        """
+        # 获取配置参数
+        period = int(pair_config.get('ema_range_period', 3))
+        
+        # precision= self.get_precision_length(symbol)
+
+        ema_4_diff = ema.diff().tail(period)
+ 
+        direction = None
+        if all(ema_4_diff <= 0) :
+            # 下降趋势
+            direction = 0 
+        elif all(ema_4_diff >= 0) :
+            # 上升趋势
+            direction = 1
+        else:
+            # 震荡趋势
+            direction = -1 
+        self.logger.debug(f"{symbol}: K线极差={ema_4_diff.map('{:.9f}'.format).values}  ,K线方向={direction}")
+        return direction
+    
+    def judge_ema_direction(self, symbol, pair_config, ema: pd.Series) -> int:
+        """
+        判断EMA方向
+        Args:
+            symbol: 交易对
+            pair_config: 配置参数
+            ema: EMA数据
+        Returns:
+            int: -1:平, 0:空, 1:多
+        """
+        # 获取配置参数
+        period = int(pair_config.get('ema_range_period', 3))
+        
+        precision= self.get_precision_length(symbol)
+
+        ema_4_diff = ema.round(precision).diff().tail(period)
+ 
+        direction = None
+        if all(ema_4_diff <= 0) and any(ema_4_diff < 0) :
+            # 下降趋势
+            direction = 0 
+        elif all(ema_4_diff >= 0) and any(ema_4_diff > 0) :
+            # 上升趋势
+            direction = 1
+        # 都是 (0 0 0) 或 (+ 0 -) 这两种情况认为都是震荡
+        else: 
+            # 震荡趋势
+            direction = -1 
+        self.logger.debug(f"{symbol}: EMA极差={ema_4_diff.map('{:.4f}'.format).values}  ,EMA方向={direction}")
+        return direction    
+  
+    def judge_cross_direction(self,fastklines,slowklines) :
+        # 创建DataFrame
+        df = pd.DataFrame({
+            'fast': fastklines,
+            'slow': slowklines
+        })
+        
+        # 判断金叉和死叉
+        df['golden_cross'] = (df['fast'] > df['slow']) & (df['fast'].shift(1) < df['slow'].shift(1))
+        df['death_cross'] = (df['fast'] < df['slow']) & (df['fast'].shift(1) > df['slow'].shift(1))
+        
+        # 从后往前找最近的交叉点
+        last_golden = df['golden_cross'].iloc[::-1].idxmax() if df['golden_cross'].any() else None
+        last_death = df['death_cross'].iloc[::-1].idxmax() if df['death_cross'].any() else None
+        
+        # 判断最近的交叉类型
+        if last_golden is None and last_death is None:
+            return {
+                'cross': -1,  # 无交叉
+                'index': None
             }
-            open_orders = self.exchange.fetch_open_orders(symbol=symbol,params=params)
-            
-            # 取消每个订单
-            for order in open_orders:
-                self.exchange.cancel_order(order['id'], symbol,params=params)
-                
-            self.logger.info(f"{symbol} 挂单取消成功.")
-        except Exception as e:
-            self.logger.error(f"{symbol} 取消订单失败: {str(e)}")
+        
+        # 如果金叉更近或只有金叉
+        if last_golden is not None and (last_death is None or last_golden > last_death):
+            return {
+                'cross': 1,  # 金叉
+                'index': last_golden
+            }
+        # 如果死叉更近或只有死叉
+        else:
+            return {
+                'cross': 0,  # 死叉
+                'index': last_death
+            }
+        
+    def judge_ma_apex(self,symbol,pair_config, fastklines,slowklines) -> bool:
+        period = int(pair_config.get('ema_range_period', 3))
+        precision= self.get_precision_length(symbol)
+        
+        df = pd.DataFrame({
+            'ema': fastklines,
+            'sma': slowklines
+        })
+        # 快线和慢线的差值
+        # 将ema和sma转换为tick_size精度
+        # df['diff'] = df['ema'].apply(lambda x: float(self.round_price_to_tick(x, tick_size))) - df['sma'].apply(lambda x: float(self.round_price_to_tick(x, tick_size)))
+        df['diff'] = df['ema'].round(precision)-df['sma'].round(precision)
+        df['ema_diff'] = df['ema'] - df['ema'].shift(1)
+        df['sma_diff'] = df['sma'] - df['sma'].shift(1)
+        # 计算斜率，【正】表示两线距离扩张，【负】表示两线距离收缩
+        df['slope'] = df['diff'].abs().diff().round(4)
+        
+        self.logger.debug(f"{symbol}: slopes = \n{df[['ema','ema_diff','sma','sma_diff','diff','slope']].iloc[-6:-1]}  ")
+        
+        # 两条线的距离是扩张状态还是收缩状态 true 是收缩 flase 是扩张
+        is_expanding_or_contracting = all(df['slope'].tail(period) <= 0 ) and any(df['slope'].tail(period) < 0)
 
+        return is_expanding_or_contracting 
+    
+    def judge_range_diff(self,symbol,pair_config,prices:pd.Series) -> bool:
+        """
+        计算价格列表中最后一个价格与第一个价格的差值。
+        Args:
+            prices: 价格列表。
+        Returns:
+            diff: 计算最高价列的最大值与最小值的差值
+。
+        """
+        limit = int(pair_config.get('ema_range_limit', 1))
+        period = int(pair_config.get('ema_range_period', 3))
+        tick_size = self.get_tick_size(symbol)
+        if prices.empty:
+            return None     
+  
+        diff = prices.tail(period).max() - prices.tail(period).min()   
+        self.logger.debug(f"{symbol}: 最高价列的最大值与最小值的差值 = {diff:.9f}")     
+        return abs(diff) <= tick_size * limit       
+      
     def set_leverage(self,symbol, leverage, mgnMode='isolated',posSide=None):
         try:
             # 设置杠杆
@@ -255,7 +405,6 @@ class ThreeLineOrdergBot:
             self.logger.error(f"{symbol} 检查持仓失败: {str(e)}")
             return False
 
-
     def place_order(self,symbol, price, amount_usdt, side):
 
         
@@ -312,147 +461,24 @@ class ThreeLineOrdergBot:
                 # self.logger.debug(f"{symbol} ++ Order placed rs :  {order_result}")
             except Exception as e:
                 self.logger.error(f"{symbol} Failed to place order: {e}")
-        self.logger.info(f"--------- ++ {symbol} Order placed done! --------")   
-        
-    # 定义根据均线斜率判断 K 线方向的函数： 0 空 1 多 -1 平
-    def judge_k_line_direction(self,symbol, pair_config, ema:pd.Series) -> int:
-        """
-        判断K线方向
-        Args:
-            symbol: 交易对
-            pair_config: 配置参数
-            ema: EMA数据
-        Returns:
-            int: -1:平, 0:空, 1:多
-        """
-        def check_ema_range(ema_data: pd.Series, period: int, limit: float, tick_size: float) -> bool:
-            """检查EMA是否在指定范围内震荡"""
-            ema_window = ema_data[-period:]
-            price_range = ema_window.max() - ema_window.min()
-            return abs(price_range) <= limit * tick_size
-            
-        def get_trend_direction(slope: float) -> int:
-            """根据斜率判断趋势方向"""
-            if slope > 0:
-                return 1    # 上升趋势
-            elif slope < 0:
-                return 0    # 下降趋势
-            return -1       # 震荡趋势
-            
-        # 获取配置参数
-        tick_size = self.get_tick_size(symbol)
-        ema_range_period = int(pair_config.get('ema_range_period', 3))
-        ema_range_limit = float(pair_config.get('ema_range_limit', 1))
-        
-        # 判断是否在震荡区间
-        if check_ema_range(ema, ema_range_period, ema_range_limit, tick_size):
-            direction = -1
-        else:
-            # 计算最新斜率并判断方向
-            latest_slope = ema.diff().iloc[-1]
-            direction = get_trend_direction(latest_slope)
-            
-        self.logger.debug(f"{symbol}: 极差={abs(ema[-ema_range_period:].max() - ema[-ema_range_period:].min()):.9f} "
-                         f"斜率={ema.diff().iloc[-1]:.9f}, K线方向 {direction}")
-        
-        return direction
+        self.logger.info(f"--------- ++ {symbol} Order placed done! --------")         
   
-    def judge_cross_direction(self,fastklines,slowklines) :
-        # 创建DataFrame
-        df = pd.DataFrame({
-            'fast': fastklines,
-            'slow': slowklines
-        })
-        
-        # 判断金叉和死叉
-        df['golden_cross'] = (df['fast'] > df['slow']) & (df['fast'].shift(1) < df['slow'].shift(1))
-        df['death_cross'] = (df['fast'] < df['slow']) & (df['fast'].shift(1) > df['slow'].shift(1))
-        
-        # 从后往前找最近的交叉点
-        last_golden = df['golden_cross'].iloc[::-1].idxmax() if df['golden_cross'].any() else None
-        last_death = df['death_cross'].iloc[::-1].idxmax() if df['death_cross'].any() else None
-        
-        # 判断最近的交叉类型
-        if last_golden is None and last_death is None:
-            return {
-                'cross': -1,  # 无交叉
-                'index': None
-            }
-        
-        # 如果金叉更近或只有金叉
-        if last_golden is not None and (last_death is None or last_golden > last_death):
-            return {
-                'cross': 1,  # 金叉
-                'index': last_golden
-            }
-        # 如果死叉更近或只有死叉
-        else:
-            return {
-                'cross': 0,  # 死叉
-                'index': last_death
+    def cancel_all_orders(self,symbol):
+        try:
+            # 获取所有未完成订单
+            params = {
+                # 'instId': instId
             }
+            open_orders = self.exchange.fetch_open_orders(symbol=symbol,params=params)
+            
+            # 取消每个订单
+            for order in open_orders:
+                self.exchange.cancel_order(order['id'], symbol,params=params)
+                
+            self.logger.info(f"{symbol} 挂单取消成功.")
+        except Exception as e:
+            self.logger.error(f"{symbol} 取消订单失败: {str(e)}")
         
-    def judge_ma_apex(self,symbol, fastklines,slowklines) -> bool:
-
-        df = pd.DataFrame({
-            'ema': fastklines,
-            'sma': slowklines
-        })
-        # 快线和慢线的差值
-        # 将ema和sma转换为tick_size精度
-        # df['diff'] = df['ema'].apply(lambda x: float(self.round_price_to_tick(x, tick_size))) - df['sma'].apply(lambda x: float(self.round_price_to_tick(x, tick_size)))
-        df['diff'] = df['ema']-df['sma']
-        # 计算斜率，【正】表示两线距离扩张，【负】表示两线距离收缩
-        df['slope'] = df['diff'].abs().diff().round(4)
-        df['flag'] = df['slope'] <= 0.0
-        
-        self.logger.debug(f"{symbol}: slopes = \n{df[['ema','sma','diff','slope','flag']].iloc[-6:-1]}  ")
-        # 检查最后两个斜率是否都为负
-        # 取slopes最新的第2个和第3个值进行判断
-        
-        return all(slope <= 0.0 for slope in df['slope'].iloc[-3:-1])
-        
-        
-    def calculate_range_diff(self,prices:pd.Series) -> float:
-        """
-        计算价格列表中最后一个价格与第一个价格的差值。
-        Args:
-            prices: 价格列表。
-        Returns:
-            diff: 计算最高价列的最大值与最小值的差值
-。
-        """
-        if prices.empty:
-            return None
-        # 将价格列表转换为pandas Series格式
-  
-        diff = prices.max() - prices.min()
-        
-        return diff
-    
-    def calculate_place_order_price(self, symbol,side,base_price, amplitude_limit, offset=1) -> float:
-        """
-        计算开仓价格
-        Args:
-            symbol: 交易对
-            side: 开仓方向
-            base_price: 开盘价格
-            amplitude_limit: 振幅限制
-            offset: 偏移量
-        Returns:
-            place_order_price: 开仓价格
-        """
-        tick_size = float(self.exchange.market(symbol)['precision']['price'])
-        place_order_price = None
-        # 计算止盈价格，用市场价格（取持仓期间历史最高）减去开仓价格的利润，再乘以不同阶段的止盈百分比。
-      
-        if side == 'buy':
-            place_order_price = base_price * (1- amplitude_limit/100) - offset * tick_size
-        else:
-            place_order_price = base_price * (1 + amplitude_limit/100) + offset * tick_size
-        self.logger.debug(f"++++ {symbol} 下单价格: {place_order_price:.9f} 方向 {side} 基准价格{base_price} 振幅限制 {amplitude_limit} ")
-        return float(self.round_price_to_tick(place_order_price,tick_size))
-      
     def process_pair(self,symbol,pair_config):
         # 检查是否有持仓，有持仓不进行下单
         if self.check_position(symbol=symbol) :
@@ -474,8 +500,8 @@ class ThreeLineOrdergBot:
             sma_length = pair_config.get('sma', 50)
             
             # 增加 金叉死叉 方向确认的 20250209
-            fastk = self.calculate_ema_pandas(symbol, klines, period=ema_length)
-            slowk = self.calculate_sma_pandas(symbol, klines, period=sma_length)
+            fastk = self.calculate_ema_pandas(symbol=symbol, klines=klines, period=ema_length)
+            slowk = self.calculate_sma_pandas(symbol=symbol, klines=klines, period=sma_length)
 
             cross_direction = self.judge_cross_direction(fastklines=fastk,slowklines=slowk)
             # 更新交叉状态
@@ -487,27 +513,37 @@ class ThreeLineOrdergBot:
                 
                 
             # 判断趋势：多头趋势或空头趋势
-            direction = self.judge_k_line_direction(symbol=symbol, pair_config=pair_config,ema=fastk) 
+            direction = self.judge_k_line_direction(symbol=symbol, pair_config=pair_config,ema=fastk,klines=klines) 
             if direction == 1:
                 is_bullish_trend = True     
             elif direction == 0:
                 is_bearish_trend = True
      
             # 结合金叉死叉判断是否是周期顶部和底部
-            is_apex = self.judge_ma_apex(symbol=symbol,fastklines=fastk,slowklines=slowk)
+            is_apex = self.judge_ma_apex(symbol=symbol,pair_config=pair_config, fastklines=fastk,slowklines=slowk)
+            ema_direction = self.judge_ema_direction(symbol=symbol, pair_config=pair_config,ema=fastk)
+            if_inner_range = self.judge_range_diff(symbol=symbol, pair_config=pair_config, prices=fastk)
             # 金叉死叉逻辑
             if last_cross_direction and last_cross_direction['cross'] == 1 : # 金叉
                 self.logger.debug(f"{symbol} 金叉:{last_cross_direction}，清理空单，挂多单！！")
                 is_bearish_trend = False
-                if is_apex :
-                    self.logger.debug(f"{symbol} 金叉:{last_cross_direction}，周期见顶 {is_apex}，不开单！！")
+                # 强校验下单条件
+                if is_apex or ema_direction == -1 or if_inner_range:
+                    self.logger.debug(f"{symbol} 强校验 - 死叉:{last_cross_direction}，两线收缩={is_apex} ,ema_平={ema_direction}，均线振幅={if_inner_range} ,不开单！！")
+                # 弱校验下单条件
+                # if is_apex or ema_direction == -1: 
+                #     self.logger.debug(f"{symbol} 金叉:{last_cross_direction}，两线收缩={is_apex} ,ema_平={ema_direction}，不开单！！")
                     is_bullish_trend = False
                     
             elif last_cross_direction and last_cross_direction['cross'] == 0 : # 死叉
                 self.logger.debug(f"{symbol} 死叉:{last_cross_direction}，清理多单，挂空单！！")
                 is_bullish_trend = False  
-                if is_apex :
-                    self.logger.debug(f"{symbol} 死叉:{last_cross_direction}，周期见顶 {is_apex}，不开单！！")
+                # 强校验下单条件
+                if is_apex or ema_direction == -1 or if_inner_range :
+                    self.logger.debug(f"{symbol} 强校验 - 死叉:{last_cross_direction}，两线收缩={is_apex} ,ema_平={ema_direction}，均线振幅={if_inner_range} ,不开单！！")
+                # 弱校验下单条件
+                # if is_apex or ema_direction == -1:
+                #     self.logger.debug(f"{symbol} 死叉:{last_cross_direction}，两线收缩={is_apex} ,ema_平={ema_direction}，不开单！！")
                     is_bearish_trend = False
                     
             else:
@@ -535,9 +571,7 @@ class ThreeLineOrdergBot:
             
             amplitude_limit = pair_config.get('amplitude_limit', 0.32)
             
-            self.logger.debug(f"{symbol} 当前K线的前三根K线 最高价: {max_high}, 最低价: {min_low}")
-  
-     
+            self.logger.debug(f"{symbol} 当前K线的前三根K线 最高价: {max_high}, 最低价: {min_low}")    
             
             long_amount_usdt = pair_config.get('long_amount_usdt', 5)
             short_amount_usdt = pair_config.get('short_amount_usdt', 5)     
@@ -550,6 +584,7 @@ class ThreeLineOrdergBot:
             close_price = klines[-1][4]
             self.logger.debug(f"-- {symbol} 最新K线 {klines[-1]}")
             
+            # FIXME calculate_range_diff 去掉
             if is_bullish_trend:
                 diff = self.calculate_range_diff(prices=low_prices)
                 cur_amplitude_limit =  diff / close_price * 100 
@@ -579,8 +614,6 @@ class ThreeLineOrdergBot:
             self.logger.error(error_message,exc_info=True)
             traceback.print_exc()
             self.send_feishu_notification(error_message)
-
-
             
     def monitor_klines(self):
         symbols = list(self.trading_pairs_config.keys())  # 获取所有币对的ID

{openfund_maker-1.0.16.dist-info → openfund_maker-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openfund-maker
-Version: 1.0.16
+Version: 1.1.0
 Summary: Openfund-maker.
 Requires-Python: >=3.9,<4.0
 Classifier: Programming Language :: Python :: 3

{openfund_maker-1.0.16.dist-info → openfund_maker-1.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-maker/ThreeLineOrderBot.py,sha256=e-KVx6a4cW2Afe0kNOKcA8isDObnzM_7wEmIlfw9tcI,25741
+maker/ThreeLineOrderBot.py,sha256=UBWtLMJtL6mAS4CLYThja5Z_XE7UCD4bBhik0T0Xp0s,27521
 maker/WickReversalOrderBot.py,sha256=Oc6wChdWu39lfWh3NRHM8BqvaRIYDNZiDR6PDnE9XUM,17374
 maker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 maker/config.py,sha256=YPxghO5i0vgRg9Cja8kGj9O7pgSbbtzOgf3RexqXXwY,1188
@@ -7,7 +7,7 @@ maker/main_m.py,sha256=0PzDTnuBrxfpy5WDfsIHKAzZ_7pkuvuqqeWik0vpWio,15522
 maker/okxapi.py,sha256=_9G0U_o0ZC8NxaT6PqpiLgxBm9gPobC9PsFHZE1c5w0,553
 maker/zhen.py.bak,sha256=HNkrQbJts8G9umE9chEFsc0cLQApcM9KOVNMYPpkBXM,10918
 maker/zhen_2.py,sha256=4IaHVtTCMSlrLGSTZrWpW2q-f7HZsUNRkW_-5QgWv24,10509
-openfund_maker-1.0.16.dist-info/METADATA,sha256=CkBN5XbxLll1H5OvDev47s8mYi4cS80yqIg50Q-fVJw,1966
-openfund_maker-1.0.16.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-openfund_maker-1.0.16.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
-openfund_maker-1.0.16.dist-info/RECORD,,
+openfund_maker-1.1.0.dist-info/METADATA,sha256=y6UyUbgh-IJwrJiklJxR4mBCK-SQg56J2EpDI8cIIVc,1965
+openfund_maker-1.1.0.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+openfund_maker-1.1.0.dist-info/entry_points.txt,sha256=gKMytICEKcMRFQDFkHZLnIpID7UQFoTIM_xcpiiV6Ns,50
+openfund_maker-1.1.0.dist-info/RECORD,,