oqclib 0.1.37__tar.gz

oqclib-0.1.37/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: oqclib
+Version: 0.1.37
+Summary: OQC Python Libraries
+License: MIT
+Author: OQC
+Author-email: oqc@hotmail.com
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: mplfinance (>=0.12.10b0,<0.13.0)
+Requires-Dist: pycryptodome (>=3.18.0,<4.0.0)
+Requires-Dist: tomli (>=2.0.1,<3.0.0)
+Description-Content-Type: text/markdown
+
+# oqclib
+
+

oqclib-0.1.37/README.md

@@ -0,0 +1,2 @@
+# oqclib
+

oqclib-0.1.37/oqclib/config.py

@@ -0,0 +1,51 @@
+import tomli
+import socket
+import os
+import base64
+from . import encrypt_util
+
+
+class Config:
+    def __init__(self, config_path: str):
+        self.data = None
+        self.key_path = os.path.expanduser('~/.ssh/id_rsa')
+        self.config_path = config_path
+        self.load_config()
+
+    def load_config(self):
+        with open(self.config_path, 'rb') as f:
+            self.data = tomli.load(f)
+
+        try:
+            vault_path = self.get_vault_path()
+            with open(vault_path, 'rb') as f:
+                self.vault = tomli.load(f)
+                for k, v in self.vault.items():
+                    encrypted_data = base64.b64decode(v.encode())
+                    decrypted_data = encrypt_util.decryt(self.key_path, encrypted_data)
+                    self.vault[k] = decrypted_data.decode('ascii').strip()
+            self.populate_password(self.data)
+        except Exception as e:
+            print(f"Error loading vault: {e}")
+
+    def populate_password(self, config_dict: dict[str, str]):
+        for k, v in config_dict.items():
+            if isinstance(v, dict):
+                self.populate_password(v)
+                continue
+            if not isinstance(v, str) or not v.startswith('map:'):
+                continue
+            vault_key = v.split(':')[1]
+            if vault_key in self.vault:
+                config_dict[k] = self.vault[vault_key]
+
+    def get_vault_path(self):
+        dirname = os.path.dirname(self.config_path)
+        return os.path.join(dirname, 'vault', socket.gethostname() + '.py')
+
+    def get_mysql_string(self, config_name: str):
+        if config_name not in self.data['mysql']:
+            return
+        config = self.data['mysql'][config_name]
+        return 'mysql+mysqldb://%s:%s@%s:%d/%s?charset=utf8' % (
+        config["user"], config["password"], config["host"], config["port"], config["db"])

oqclib-0.1.37/oqclib/encrypt_util.py

@@ -0,0 +1,32 @@
+from Crypto.PublicKey import RSA
+from Crypto.Cipher import PKCS1_v1_5
+from Crypto import Random
+
+def read_private_key(path: str):
+    with open(path, 'rb') as f:
+        data = f.read()
+    key = RSA.importKey(data)
+    return key
+
+def decode_msg_v1_5(cipherbytes, private_key):
+    """  Should consider using the more robust PKCS1 OAEP. """
+    sentinel = Random.new().read(256)      # data length is 256
+    cipher = PKCS1_v1_5.new(private_key)
+    messagereceived = cipher.decrypt(cipherbytes, sentinel)
+    return messagereceived
+
+def decryt(rsa_file: str, cipherbytes: bytes):
+    private_key = read_private_key(rsa_file)
+
+    # Decrypt the data
+    return decode_msg_v1_5(cipherbytes, private_key)
+
+if __name__ == '__main__':
+    import os
+    import base64
+    
+    encrypted_data = base64.b64decode(b"iICR6L42w6lqTNsOcZEs9fu7OmRDLSyfpW8v85u0hEkD4gObbwAM+SXO64ZCpKrzJPwoQPggmOaPybgOS4ZZtHsXeNq/CAznK+dz/fxp9FQher+yp6TBZ2BFe5B0NOj3NLDVImLBYPcXZ99IAQNrIylBkF7Ns6ZxPPBeqh3jlIZMTmoyO3PMBvPDmOyOP3zir2SG/CDU2quYKBRSNXNjo+Y2jeO/SPJqBjRWlsSW5xWz2+kqcxsXUhvQH56sQVT+MbYtvTfgQMkPS81Mk9JFJd6mlGgCKUrXKbW6wO9xfkdi92hOLSwGCQEbdaXqyQaYv62+Rb5KtM6Mw8/zoBJx7wNhkR/CWJt0jygEix57s+qKop1+KU9UZVbFdQDgyWCz7Un8v0kHEcMEF8TbgHSqajwqGumaXKQYy3bMkLAT816TeGWd4Yl1pD2SuTHoO1N76q1oLwmXhiZ9TQeDXuLOhwP0Fqc9SzbcB3ZUjUWHF/vCjF+UPbAtCBIotymNA+4Xc3YLHMJOCeRVhrorn4sG+Iu1tUjLtNqhYDgtuauzE7sB8cR0Q+qDajlTZw7iDLAkleQ8K+kDNUjaT37/AM37/m6Q2k9rT7EZMBDihkbXd3Y2u4z2yzxItArI1kPAd4HmBoc2R0JdnZnPJBr02SurGrYRwnJRrTW5UXWnmTjVBFA=")
+
+    decrypted_data = decryt(os.path.expanduser('~/.ssh/id_rsa'), encrypted_data)
+    # Print the decrypted data
+    print(decrypted_data)

oqclib-0.1.37/oqclib/exch/okv5/consts.py

@@ -0,0 +1,9 @@
+# This is translated from Rust to Python.
+
+# Constants for rate limit and API endpoints
+RATE_LIMIT_SLEEP_20_PER_2 = 100  # Milliseconds
+HOST = "https://www.okx.com"
+REST_TICKER = "/api/v5/market/ticker?instId={}"
+REST_INSTRUMENTS = "/api/v5/public/instruments?instType={}"
+REST_FUNDING_RATE = "/api/v5/public/funding-rate?instId={}"
+REST_CANDLE_STICK = "/api/v5/market/mark-price-candles?limit=100&instId={instId}&bar={bar}"

oqclib-0.1.37/oqclib/exch/okv5/utils.py

@@ -0,0 +1,58 @@
+
+
+def format_time_period(minutes:int) -> str:
+    if minutes < 60:
+        return f"{minutes}m"  # Minutes
+    elif minutes == 60:
+        return "1H"  # 1 Hour
+    elif minutes < 1440:
+        hours = minutes // 60
+        return f"{hours}H"  # Hours
+    elif minutes == 1440:
+        return "1D"  # 1 Day
+    elif minutes < 10080:
+        days = minutes // 1440
+        return f"{days}D"  # Days
+    elif minutes < 43200:
+        weeks = minutes // 10080
+        return f"{weeks}W"  # Weeks
+    else:
+        months = minutes // 43200
+        return f"{months}M"  # Months
+
+import asyncio
+import aiohttp
+import time
+from datetime import datetime
+
+async def fetch_candlesticks(client, symbol, bar_period, look_back_minutes):
+    result = []
+    now_ms = int(time.time() * 1000)
+    from_ms = now_ms - look_back_minutes * 1000 * 60
+
+    while True:
+        to_ms = from_ms + 1000 * 60 * 100
+        # url = f"{HOST}{REST_CANDLE_STICK.replace('{instId}', symbol).replace('{bar}', bar_period)}&before={to_ms}&after={from_ms}"
+        
+        print(f"Requesting {url} from {datetime.fromtimestamp(from_ms/1000)} to {datetime.fromtimestamp(to_ms/1000)}")
+        async with client.get(url) as response:
+            response_data = await response.json()
+            if response_data['code'] == '0':  # Assuming '0' indicates success
+                response_data['data'].reverse()
+                result.extend(response_data['data'])
+        
+        if to_ms >= now_ms:
+            break
+        from_ms = to_ms
+        await asyncio.sleep(RATE_LIMIT_SLEEP_20_PER_2 / 1000)  # Convert milliseconds to seconds
+
+    return result
+
+# Example usage
+async def main():
+    async with aiohttp.ClientSession() as client:
+        candles = await fetch_candlesticks(client, 'BTC-USD', '1m', 60)
+        print(candles)
+
+if __name__ == '__main__':
+    asyncio.run(main())

oqclib-0.1.37/oqclib/indicators/macd_dvgc.py

@@ -0,0 +1,142 @@
+import pandas as pd
+from .model import DivergenceType
+import logging
+
+logger = logging.getLogger(__name__)
+
+FIELD = 'dif'
+CROSS_THRESHOLD = 2
+
+def detect_macd_divergence(df: pd.DataFrame, nth: int = 0) -> DivergenceType | None:
+    assert 'close' in df.columns, "Dataframe must contain 'close' column"
+    assert 'dif' in df.columns, "Dataframe must contain 'ema12' column"
+    assert 'dea' in df.columns, "Dataframe must contain 'ema26' column"
+
+    ret = is_bearish_divergence(df, nth)
+    if ret is not None:
+        logger.info(f"Bearish divergence detected {df.loc[ret[0]][['close', 'dif', 'dea']]} {df.loc[ret[1]][['close', 'dif', 'dea']]} last {df.tail(5)[['close', 'dif', 'dea']]}")
+        return DivergenceType.BEARISH
+    ret = is_bullish_divergence(df, nth)
+    if ret is not None:
+        logger.info(f"Bullish divergence detected {df.loc[ret[0]][['close', 'dif', 'dea']]} {df.loc[ret[1]][['close', 'dif', 'dea']]} last {df.tail(5)[['close', 'dif', 'dea']]}")
+        return DivergenceType.BULLISH
+    return None
+
+
+def is_golden_cross(df: pd.DataFrame, nth: int = 0) -> bool:
+    # time_ms = df.iloc[-nth - 1]['timeMs']
+    # print(f"is_golden_cross, nth  {nth}, time: {time_ms}")
+    dif_pre = df['dif'].iloc[-nth - 2]
+    dea_pre = df['dea'].iloc[-nth - 2]
+    return dif_pre < dea_pre and df['dif'].iloc[-nth - 1] > df['dea'].iloc[-nth - 1]
+
+
+# Write is_death_cross function
+def is_death_cross(df: pd.DataFrame, nth: int = 0) -> bool:
+    return df['dif'].iloc[-nth - 2] > df['dea'].iloc[-nth - 2] and df['dif'].iloc[-nth - 1] < df['dea'].iloc[-nth - 1]
+
+
+def is_bearish_divergence(df: pd.DataFrame, nth: int = 0) -> ():
+    ret = None
+    # 如果不是死叉，直接退出
+    if not is_death_cross(df, nth):
+        return None
+    step = 1
+    size = len(df)
+    start1, start2, end1, end2 = 0, 0, 0, 0
+    for i in range(nth + 1, size - 2):
+        # 找到上一个金叉
+        if step == 1 and is_golden_cross(df, nth=i):
+            start1, end1 = nth + 1, i
+            if end1 - start1 < CROSS_THRESHOLD:
+                # print(f"First golden cross at {start1} {end1}")
+                return ret
+            step = 2
+        # 找到上一个死叉
+        if step == 2 and is_death_cross(df, nth=i):
+            start2 = i + 1
+            if start2 - end1 < CROSS_THRESHOLD:
+                # print(f"First death cross at {end1} {start2}")
+                return ret
+            step = 3
+        # 再找到上一个金叉
+        if step == 3 and is_golden_cross(df, nth=i):
+            end2 = i
+            step = 4
+            break
+    if step == 4:
+        # 求两个区间的最高价
+        max1 = -1e8
+        max2 = -1e8
+        id1 = 0
+        id2 = 0
+        for i in range(start1, end1 + 1):
+            if max1 < df[FIELD].iloc[-i - 1]:
+                max1 = df[FIELD].iloc[-i - 1]
+                id1 = i
+        for i in range(start2, end2 + 1):
+            if max2 < df[FIELD].iloc[-i - 1]:
+                max2 = df[FIELD].iloc[-i - 1]
+                id2 = i
+        close1 = df['close'].iloc[-id1 - 1]
+        close2 = df['close'].iloc[-id2 - 1]
+        dif1 = df['dif'].iloc[-id1 - 1]
+        dif2 = df['dif'].iloc[-id2 - 1]
+
+        if close1 > close2 and dif1 < dif2:
+            logger.info(f"Bearish divergence close2 {close2} dif2 {dif2} close1 {close1} dif1 {dif1}")
+            ret = (df.index[-id2 - 1], df.index[-id1 - 1])
+    return ret
+
+
+def is_bullish_divergence(df: pd.DataFrame, nth: int = 0) -> ():
+    ret = None
+    # 如果不是金叉，直接退出
+    if not is_golden_cross(df, nth=nth):
+        return ret
+    step = 1
+    size = len(df)
+    start1, start2, end1, end2 = 0, 0, 0, 0
+    for i in range(nth + 1, size - 2):
+        # 找到上一个死叉
+        if step == 1 and is_death_cross(df, nth=i):
+            start1, end1 = nth + 1, i
+            if end1 - start1 < CROSS_THRESHOLD:
+                # print(f"First death cross at {start1} {end1}")
+                return ret
+            step = 2
+        # 找到上一个金叉
+        if step == 2 and is_golden_cross(df, nth=i):
+            start2 = i + 1
+            if start2 - end1 < CROSS_THRESHOLD:
+                # print(f"First Golden cross at {end1} {start2}")
+                return ret
+            step = 3
+        # 再找到上一个死叉
+        if step == 3 and is_death_cross(df, nth=i):
+            end2 = i
+            step = 4
+            break
+    if step == 4:
+        # 求两个区间的最低价
+        min1 = 1e8
+        min2 = 1e8
+        id1 = 0
+        id2 = 0
+        for i in range(start1, end1 + 1):
+            if min1 > df[FIELD].iloc[-i - 1]:
+                min1 = df[FIELD].iloc[-i - 1]
+                id1 = i
+        for i in range(start2, end2 + 1):
+            if min2 > df[FIELD].iloc[-i - 1]:
+                min2 = df[FIELD].iloc[-i - 1]
+                id2 = i
+        close1 = df['close'].iloc[-id1 - 1]
+        close2 = df['close'].iloc[-id2 - 1]
+        dif1 = df['dif'].iloc[-id1 - 1]
+        dif2 = df['dif'].iloc[-id2 - 1]
+
+        if close1 < close2 and dif1 > dif2:
+            logger.info(f"Bullish divergence close2 {close2} dif2 {dif2} close1 {close1} dif1 {dif1}")
+            ret = (df.index[-id2 - 1], df.index[-id1 - 1])
+    return ret

oqclib-0.1.37/oqclib/indicators/macd_ref.py

@@ -0,0 +1,167 @@
+import pandas as pd
+import talib as tl
+
+class Divergence:
+    def __init__(self, quote: pd.DataFrame, fastperiod: int, slowperiod: int, signalperiod: int, name):
+        close = quote['close']
+        date = quote.index
+        self.dif, self.dea, self.macd = tl.MACDEXT(close, fastperiod=fastperiod, fastmatype=1, slowperiod=slowperiod,
+                                                   slowmatype=1, signalperiod=signalperiod, signalmatype=1)
+        self.dif = pd.Series(self.dif).sort_index(ascending=False).dropna().reset_index(drop=True)
+        self.dea = pd.Series(self.dea).sort_index(ascending=False).dropna().reset_index(drop=True)
+        self.macd = pd.Series(self.macd).sort_index(ascending=False).dropna().reset_index(drop=True) * 2
+        self.sz = len(self.dif)
+        self.close = pd.Series(close).sort_index(ascending=False).reset_index(drop=True).head(self.sz)
+        self.date = pd.Series(date).sort_index(ascending=False).reset_index(drop=True).head(self.sz)
+        self.name = name
+
+    def get_crosses(self):
+        values = []
+        for i in range(self.sz - 2, 0, -1):
+            if self.is_gold_cross(i):
+                values.append("('%s',1,'%s')" % (self.get_date_by_index(i), self.name))
+            elif self.is_death_cross(i):
+                values.append("('%s',0,'%s')" % (self.get_date_by_index(i), self.name))
+
+        sql = 'insert ignore into `AMV` values %s' % (', '.join(values))
+        return sql
+
+    def get_divergence(self):
+        values = []
+        last_dir = -1
+        for i in range(self.sz - 2, 0, -1):
+            if last_dir != 0 and self.is_gold_cross(i):
+                last_dir = 0
+                values.append("('%s',1,'%s')" % (self.get_date_by_index(i), self.name + "-bearish-divergence"))
+            elif self.is_bearish_divergence(i):
+                last_dir = 1
+                values.append("('%s',0,'%s')" % (self.get_date_by_index(i), self.name + "-bearish-divergence"))
+
+        sql = 'insert ignore into `AMV` values %s' % (', '.join(values))
+        return sql
+
+    def get_date_by_index(self, N=0):
+        return self.date[N]
+
+    # 判断往前第N个时段是否为金叉，N取值范围为(0, self.sz)，缺省N=0
+    def is_gold_cross(self, N=0):
+        return (self.dif[N + 1] < self.dea[N + 1] and self.dif[N] > self.dea[N])
+
+    # 判断往前第N个时段是否为死叉，N取值范围为(0, self.sz)，缺省N=0
+    def is_death_cross(self, N=0):
+        return (self.dif[N + 1] > self.dea[N + 1] and self.dif[N] < self.dea[N])
+
+    # 判断往前第N个时段是否为0轴上，N取值范围为(0, self.sz)，缺省N=0
+    def is_high_value(self, N=0):
+        return (self.dif[N] > 0 and self.dea[N] > 0)
+
+    # 判断往前第N个时段是否为0轴下，N取值范围为(0, self.sz)，缺省N=0
+    def is_low_value(self, N=0):
+        return (self.dif[N] < 0 and self.dea[N] < 0)
+
+    # 判断往前第N个时段是否是低位二次金叉，缺省N=0
+    def is_second_low_gold_cross(self, N=0):
+        # 判断当前是否发生金叉，并且位置在0轴之下
+        if not self.is_gold_cross(N=N) or not self.is_low_value(N=N):
+            return False
+        flag = False
+        for i in range(N + 1, self.sz - 1):
+            if not self.is_low_value(N=i):
+                break
+            if self.is_gold_cross(N=i):
+                flag = True
+                break
+        return flag
+
+    # 判断往前第N个时段是否是高位二次死叉，缺省N=0
+    def is_second_high_death_cross(self, N=0):
+        # 判断当前是否发生死叉，并且位置在0轴之上
+        if not self.is_death_cross(N=N) or not self.is_high_value(N=N):
+            return False
+        flag = False
+        for i in range(N + 1, self.sz - 1):
+            if not self.is_high_value(N=i):
+                break
+            if self.is_death_cross(N=i):
+                flag = True
+                break
+        return flag
+
+    # 判断往前第N个时段是否是快慢线底背离(价格与DIF的背离)，缺省N=0
+    # price创新低，但dif没有创新低
+    def is_bullish_divergence(self, N=0):
+        ret = None
+        # 如果不是金叉，直接退出
+        if not self.is_gold_cross(N=N):
+            return ret
+        step = 1
+        for i in range(N + 1, self.sz - 1):
+            # 找到上一个死叉
+            if step == 1 and self.is_death_cross(N=i):
+                start1, end1 = N + 1, i
+                step = 2
+            # 找到上一个金叉
+            if step == 2 and self.is_gold_cross(N=i):
+                start2 = i + 1
+                step = 3
+            # 再找到上一个死叉
+            if step == 3 and self.is_death_cross(N=i):
+                end2 = i
+                step = 4
+                break
+        if step == 4:
+            # 求两个区间的最低价
+            min1 = 1e8
+            min2 = 1e8
+            for i in range(start1, end1 + 1):
+                if min1 > self.close[i]:
+                    min1 = self.close[i]
+                    id1 = i
+            for i in range(start2, end2 + 1):
+                if min2 > self.close[i]:
+                    min2 = self.close[i]
+                    id2 = i
+            if self.close[id1] < self.close[id2] and self.dif[id1] > self.dif[id2]:
+                ret = (self.date[id2], self.date[id1])
+        return ret
+
+    # 判断往前第N个时段是否是快慢线顶背离(价格与DIF的背离)，缺省N=0
+    def is_bearish_divergence(self, N=0):
+        ret = None
+        # 如果不是死叉，直接退出
+        if not self.is_death_cross(N=N):
+            return ret
+        step = 1
+        for i in range(N + 1, self.sz - 1):
+            # 找到上一个金叉
+            if step == 1 and self.is_gold_cross(N=i):
+                start1, end1 = N + 1, i
+                step = 2
+            # 找到上一个死叉
+            if step == 2 and self.is_death_cross(N=i):
+                start2 = i + 1
+                step = 3
+            # 再找到上一个金叉
+            if step == 3 and self.is_gold_cross(N=i):
+                end2 = i
+                step = 4
+                break
+        if step == 4:
+            # 求两个区间的最高价
+            max1 = -1e8
+            max2 = -1e8
+            id1 = 0
+            id2 = 0
+            for i in range(start1, end1 + 1):
+                if max1 < self.close[i]:
+                    max1 = self.close[i]
+                    id1 = i
+            for i in range(start2, end2 + 1):
+                if max2 < self.close[i]:
+                    max2 = self.close[i]
+                    id2 = i
+            if self.close[id1] > self.close[id2] and self.dif[id1] < self.dif[id2]:
+                ret = (self.date[id2], self.date[id1])
+        return ret
+
+

oqclib-0.1.37/oqclib/indicators/model.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class DivergenceType(Enum):
+    BULLISH = 1,
+    BEARISH = 2

oqclib-0.1.37/oqclib/robot/dingtalk.py

@@ -0,0 +1,61 @@
+import time
+import hmac
+import hashlib
+import base64
+import json
+from urllib.parse import quote_plus
+from oqclib.utils.http_util import send_post_request_with_retries
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class DingTalkRobot:
+    def __init__(self, keys_dict):
+        self.keys_dict = keys_dict
+        self.request_url = 'https://oapi.dingtalk.com/robot/send'
+
+    def generate_sign(self, timestamp, secret: str):
+        secret_enc = secret.encode('utf-8')
+        string_to_sign = '{}\n{}'.format(timestamp, secret)
+        string_to_sign_enc = string_to_sign.encode('utf-8')
+        hmac_code = hmac.new(secret_enc, string_to_sign_enc, digestmod=hashlib.sha256).digest()
+        sign = quote_plus(base64.b64encode(hmac_code))
+        return sign
+
+    def get_request_url(self, robot):
+        timestamp = str(round(time.time() * 1000))
+        key = self.keys_dict[robot]
+
+        sign = self.generate_sign(timestamp, key['secret'])
+
+        url = self.request_url + '?access_token=' + key['token'] + '&timestamp=' + timestamp + '&sign=' + sign
+        return url
+
+    def send_msg(self, robot: str, message: str):
+        url = self.get_request_url(robot)
+
+        headers = {'Content-Type': 'application/json; charset=utf-8'}
+        data = {
+            "msgtype": "text",
+            "text": {
+                "content": message
+            }
+        }
+        logger.info(f"Sending message to DingTalk Robot: {robot}, message: {message}")
+
+        response = send_post_request_with_retries(url, headers=headers, data=json.dumps(data))
+        return response.json()
+
+    def send_card(self, robot: str, card: dict):
+        url = self.get_request_url(robot)
+
+        headers = {'Content-Type': 'application/json; charset=utf-8'}
+        data = {
+            "msgtype": "markdown",
+            "markdown": card
+        }
+        logger.info(f"Sending message to DingTalk Robot: {robot}, message: {card}")
+
+        response = send_post_request_with_retries(url, headers=headers, data=json.dumps(data))
+        return response.json()

oqclib-0.1.37/oqclib/robot/lark.py

@@ -0,0 +1,67 @@
+import json
+import logging
+from oqclib.utils.http_util import send_post_request_with_retries
+
+logger = logging.getLogger(__name__)
+
+class LarkMsg():
+    def __init__(self, keys_dict):
+        self.keys_dict = keys_dict
+        self.request_url = 'https://open.larksuite.com/open-apis/bot/v2/hook/'
+
+    def show_lark(self):
+        '''
+        show available lark config
+        :return: lark keys avaliable in config
+        '''
+        print(self.keys_dict.keys())
+
+    def send_msg(self, robot, msg): 
+        '''
+        send lark message
+        :param msg: message to send
+        :return:
+        '''
+        key = self.keys_dict[robot]
+
+        mentioned_list = ['@all']
+
+        textJSON = [[{'tag': 'text', 'text': msg}]]
+
+        headers = {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+
+        textMsg = {
+            'msg_type': 'post',
+            'content': {'post': {'en_us': {'content': textJSON}}}
+        }
+
+        se = json.dumps(textMsg)
+        #r = requests.post(self.request_url + key, data=se, headers=headers)
+        url = self.request_url + key
+        r = send_post_request_with_retries(url, se, 3, headers=headers)
+        logger.info("Sending lark resp: {}".format(r.text))
+
+
+    def send_card(self, robot, card_body: dict):
+        '''
+        send lark message card
+        :param title: lark card title
+        :param msg: message to send
+        :param robot: lark key name as defined in lark_config
+        :return:
+        '''
+        key = self.keys_dict[robot]
+        headers = {
+            'Content-Type': 'application/json; charset=utf-8'
+        }
+        textMsg = {
+            "msg_type": "interactive",
+            "card": card_body
+        }
+        se = json.dumps(textMsg)
+        #r = requests.post(self.request_url + key, data=se, headers=headers)
+        url = self.request_url + key
+        r = send_post_request_with_retries(url, se, 3, headers=headers)
+        logger.info("Sending lark resp: {}".format(r.text))

oqclib-0.1.37/oqclib/tushare_util.py

@@ -0,0 +1,4 @@
+import pandas as pd
+
+def to_tushare_date_str(date: pd.Timestamp) -> str:
+    return str(date.date()).replace("-","")

oqclib-0.1.37/oqclib/utils/common.py

@@ -0,0 +1,10 @@
+import os
+
+def has_gui():
+    # Check if DISPLAY environment variable is set (common in Unix-like systems)
+    if os.name == 'posix' and 'DISPLAY' not in os.environ:
+        return False
+    # Windows and macOS are generally running under a GUI
+    elif os.name == 'nt' or sys.platform == 'darwin':
+        return True
+    return False

oqclib-0.1.37/oqclib/utils/datetime_util.py

@@ -0,0 +1,32 @@
+from datetime import datetime, timedelta
+
+
+def seconds_to_next_interval(dt: datetime, interval_seconds: int) -> float:
+    # Calculate total minutes since midnight
+    seconds_since_midnight = (dt.hour * 60 + dt.minute) * 60 + dt.second
+
+    # Find the next multiple of the interval
+    next_interval_second = ((seconds_since_midnight // interval_seconds) + 1) * interval_seconds
+
+    # Calculate the time of the next interval
+    next_interval_time = datetime(dt.year, dt.month, dt.day, 0, 0) + timedelta(seconds=next_interval_second)
+
+    # Calculate the number of seconds until the next interval
+    seconds_to_next = (next_interval_time - dt).total_seconds()
+
+    return seconds_to_next
+
+
+def is_midnight() -> bool:
+    # Get the current local time
+    now = datetime.now()
+
+    # Get the hour component of the current time
+    hour = now.hour
+
+    return hour < 7
+
+
+if __name__ == '__main__':
+    print(seconds_to_next_interval(datetime.now(), 3600 * 12))
+    print(is_midnight())

oqclib-0.1.37/oqclib/utils/http_util.py

@@ -0,0 +1,18 @@
+import requests
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def send_post_request_with_retries(url, data, headers=None, retries=3, **kwargs):
+    for i in range(retries + 1):
+        try:
+            response = requests.post(url, data=data, headers=headers, **kwargs)
+            logger.info("POST Response: {} {}".format(response.status_code, response.content.decode("utf-8")))
+            response.raise_for_status()
+            if response.status_code // 100 == 2:
+                return response
+        except (requests.exceptions.RequestException, requests.exceptions.HTTPError) as e:
+            logger.info(f"Retry {i + 1}: {e}")
+
+    return None  # No successful response after retries

oqclib-0.1.37/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.poetry]
+name = "oqclib"
+version = "0.1.37"
+description = "OQC Python Libraries"
+authors = ["OQC <oqc@hotmail.com>"]
+readme = "README.md"
+packages = [
+    {include = "oqclib/*"},
+    {include = "oqclib/robot/*"},
+    {include = "oqclib/utils*"},
+    {include = "oqclib/indicators*"},
+    {include = "oqclib/exch*"},
+    ]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+pycryptodome = "^3.18.0"
+tomli = "^2.0.1"
+mplfinance = "^0.12.10b0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.3.1"
+
+# douban https://pypi.doubanio.com/simple/
+# netease https://mirrors.163.com/pypi/simple/
+# aliyun https://mirrors.aliyun.com/pypi/simple/
+# tsinghua https://pypi.tuna.tsinghua.edu.cn/simple/
+
+[[tool.poetry.source]]
+name = "aliyun"
+url = "https://mirrors.aliyun.com/pypi/simple/"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"