gjdatac-api 0.1.6__tar.gz → 0.1.7__tar.gz

{gjdatac_api-0.1.6 → gjdatac_api-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gjdatac_api
-Version: 0.1.6
+Version: 0.1.7
 Summary: 数据接口打包
 Author: yin
 Author-email: 2018209921@qq.com

{gjdatac_api-0.1.6 → gjdatac_api-0.1.7}/gjdatac_api/data_api_class.py

@@ -10,12 +10,15 @@ import chinese_calendar as calendar
 import pandas as pd
 import dolphindb as ddb
 
-from .dict_data import (get_price_frequency_dict, get_price_data_type_dict, get_instruments_type_dict,
+from utils.dict_data import (get_price_frequency_dict, get_price_data_type_dict, get_instruments_type_dict,
                              future_delivery_fee_return_fields, future_delivery_fee_return_fields_rename,
                              future_margin_ratio_return_fields, future_margin_ratio_return_fields_rename,
-                             future_limit_position_return_fields, future_limit_position_return_fields_rename)
-from .dolphindb_info import *
-from .instrument_class import Instrument
+                             future_limit_position_return_fields, future_limit_position_return_fields_rename,
+                             main_contract_return_fields, main_contract_return_fields_rename,
+                             tick_main_contract_return_fields, tick_main_contract_return_fields_rename
+                             )
+from utils.dolphindb_info import *
+from utils.instrument_class import Instrument
 
 
 class GJDataC:
@@ -38,6 +41,10 @@ class GJDataC:
         self.user_id = user_id
         self.password = password
 
+        # 创建向量，包含所有可用节点的地址和端口
+        self.sites = dolphindb_service
+
+
     def connect_db(self, table_name, db_path):
         """
         此方法用于根据不同的数据表及数据库获取数据，只返回Table对象，对应的数据处理在对应的数据接口处理
@@ -48,7 +55,12 @@ class GJDataC:
 
         # 连接数据库
         db_session = ddb.session()
-        success = db_session.connect(self.host, self.port, self.user_id, self.password)
+        # 原始方式
+        # success = db_session.connect(self.host, self.port, self.user_id, self.password)
+
+        # 创建连接；开启高可用，并指定sites为所有可用节点的ip:port
+        success = db_session.connect(self.host, self.port, self.user_id, self.password, highAvailability=True,
+                  highAvailabilitySites=self.sites)
         if not success:
             raise Exception("please check your database connection information")
 
@@ -1641,47 +1653,69 @@ class GJDataC:
 
     """ get_active_contract 主力/次主力合约 """
 
-    def get_active_contract(self, code=None, start_date=datetime.date.today(),
-                            end_date=datetime.date.today(), asset_type=None,
-                            fields=None, source=None):
+    def get_active_contract(self, commodity=None, start_date=datetime.date.today(),
+                            end_date=datetime.date.today(), frequency=None, compute_type=None,
+                            fields=None, adjust_type=None, adjust_method=None, source=None):
         """
         获取主力/次主力合约信息接口
-        :param code: str or str list--必填，品种
+        :param commodity: str or str list--必填，品种
         :param start_date: date--必填，默认当天
         :param end_date: date--必填，默认当天
-        :param asset_type: str--必填，active指主力；next_active次主力
+        :param frequency: str--必填
+        :param compute_type: str--必填，active指主力；next_active次主力
         :param fields: str or str list--选填，返回字段，默认全部
+        :param adjust_type: str--选填，复权方式：不复权 - none，后复权 - post
+        :param adjust_method: str--选填，复权方法
         :param source: str--选填，数据源，默认研究所, 3个来源可选：1-数据中台, 2-米筐, 3-研究所(表中无研究所的source)
 
         :return: 主力/次主力合约
         """
 
         """ 校验参数 """
-        self.get_active_contract_validate_params(code, start_date, end_date, asset_type)
+        self.get_active_contract_validate_params(commodity, start_date, end_date, frequency, compute_type, adjust_type,
+                                                 adjust_method)
 
         """ 获取、筛选数据 """
-        data, db_session = self.get_active_contract_get_data(code, start_date, end_date, asset_type, source)
+        if frequency in ['1min', '1d', '1min_gtja']:
+            data, db_session = self.get_active_contract_get_data(commodity, start_date, end_date, frequency,
+                                                                 compute_type,
+                                                                 source)
+        else:
+            data, db_session = self.get_active_contract_get_data_tick(commodity, start_date, end_date, frequency,
+                                                                      compute_type,
+                                                                      source)
+            data = self.get_active_contract_tick_data(data, frequency, start_date, end_date)
         db_session.close()
 
-        """ 处理返回结果 """
-        data = self.get_active_contract_process_result(data, fields)
+        """ 处理字段名 """
+        data = self.get_active_contract_rename(data, adjust_method, frequency)
+
+        """ 根据是否复权计算价格数据 """
+        data = self.get_active_contract_adjust_price(data, adjust_type, adjust_method, frequency)
+
+        """ 处理返回字段 """
+        data = self.get_active_contract_process_return_fields(data, fields)
 
         return data
 
-    def get_active_contract_validate_params(self, code, start_date, end_date, asset_type):
+    def get_active_contract_validate_params(self, code, start_date, end_date, frequency, asset_type, adjust_type,
+                                            adjust_method):
         """
         校验参数
         Args:
             code: str or str list--选填，合约代码，默认全部
             start_date: str--选填，开始日期，默认全部
             end_date: str--选填，结束日期，默认全部
+            frequency: str--必填
             asset_type: str--选填，合约类型，默认全部
+            adjust_type: str--选填，复权类型
+            adjust_method: str--选填，复权方法
         Raises:
             ValueError: 参数错误
         """
 
         # 校验必填参数
-        self.get_active_contract_validate_required_params(code, start_date, end_date, asset_type)
+        self.get_active_contract_validate_required_params(code, start_date, end_date, frequency, asset_type)
 
         # 校验日期参数类型
         self.get_active_contract_validate_date_type(start_date, end_date)
@@ -1689,12 +1723,17 @@ class GJDataC:
         # 校验code类型
         self.get_active_contract_validate_code(code)
 
-    def get_active_contract_validate_required_params(self, code, start_date, end_date, asset_type):
+        # 校验 adjust_type, adjust_method
+        self.general_validate_param_is_str("adjust_type", adjust_type)
+        self.general_validate_param_is_str("adjust_method", adjust_method)
+
+    def get_active_contract_validate_required_params(self, code, start_date, end_date, frequency, asset_type):
         """
         校验参数是否必填
         :param code: str or str list--必填，品种
         :param start_date: date--必填，默认当天
         :param end_date: date--必填，默认当天
+        :param frequency: str--必填
         :param asset_type: str--必填，active指主力；next_active次主力
         :return: None
         """
@@ -1703,7 +1742,8 @@ class GJDataC:
             "code": code,
             "start_date": start_date,
             "end_date": end_date,
-            "asset_type": asset_type
+            "asset_type": asset_type,
+            "frequency": frequency
         }
         for key, value in params_dict.items():
             self.general_validate_params_required(value, key)  # 校验必填参数
@@ -1716,20 +1756,86 @@ class GJDataC:
         """
         self.general_validate_field_str_or_list(code, "code")
 
-    def get_active_contract_get_data(self, code, start_date, end_date, asset_type, source):
+    @staticmethod
+    def get_active_contract_get_table(frequency):
+        """
+        获取表信息
+        :param frequency: 频率
+        :return: 表信息
+        """
+
+        return {
+            '1d': (qc_future_maincontract_dayk, dayk_future_maincontract_db),
+            '1min': (qc_future_maincontract_minutek, minutek_future_maincontract_db),
+            '1min_gtja': (qc_future_maincontract_minutek, minutek_future_maincontract_db)
+        }.get(frequency, (None, None))
+
+    @staticmethod
+    def get_active_contract_get_table_tick(frequency):
+        """
+        获取表信息
+        :param frequency: 频率
+        :return: 表信息
+        """
+
+        return {
+            'tick_l1': (tick_main_contract_db_table_name, tick_main_contract_db_path),
+            'tick_l2': (tick_main_contract_db_table_name, tick_main_contract_db_path),
+        }.get(frequency, (None, None))
+
+    def get_active_contract_get_data(self, code, start_date, end_date, frequency, compute_type, source):
         """
         获取数据
         :param code: str or str list--必填，品种
         :param start_date: str--必填，开始日期
         :param end_date: str--必填，结束日期
-        :param asset_type: str--必填，资产类型
+        :param compute_type: str--必填，资产类型
+        :param frequency: str--必填
         :param source: str--选填，数据来源
 
         :return: 主力/次主力合约数据
         """
 
+        # 根据频率获取对应的表
+        table_name, db_path = self.get_active_contract_get_table(frequency)
+
         # 先从数据库获取数据
+        data, db_session = self.connect_db(table_name, db_path)
+
+        # 根据code筛选数据
+        code_data = data.where(f"product_id in {code}") if isinstance(code, list) else \
+            data.where(f"product_id = '{code}'")
+
+        # 根据日期筛选数据
+        # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
+        start_dolphin_date = self.get_active_contract_datetime_to_dolphin_time(start_date)
+        end_dolphin_date = self.get_active_contract_datetime_to_dolphin_time(end_date)
+        date_data = code_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
+
+        if compute_type:
+            # 根据表中的 rank 字段筛选主力/次主力合约，rank == 1是主力合约， 2 是次主力合约
+            rank = 'MAIN' if compute_type == "main" else 'SUB_MAIN'
+            rank_data = date_data.where(f"compute_type = '{rank}'")
+
+            return rank_data.toDF(), db_session
+        return date_data.toDF(), db_session
+
+    def get_active_contract_get_data_tick(self, code, start_date, end_date, frequency, compute_type, source):
+        """
+        获取tick数据
+        :param code: str or str list--必填，品种
+        :param start_date: str--必填，开始日期
+        :param end_date: str--必填，结束日期
+        :param compute_type: str--必填，资产类型
+        :param frequency: str--必填
+        :param source: str--选填，数据来源
+
+        :return: 主力/次主力合约数据
+        """
+
         table_name, db_path = main_contract_db_table_name, main_contract_db_path
+
+        # 先从数据库获取数据
         data, db_session = self.connect_db(table_name, db_path)
 
         # 根据code筛选数据
@@ -1742,24 +1848,43 @@ class GJDataC:
         end_dolphin_date = self.get_active_contract_datetime_to_dolphin_time(end_date)
         date_data = code_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
 
-        # 根据 asset_type 筛选数据 (现无次主力合约信息，不清楚数据结构和字段信息，后续需要根据实际数据进行调整)
         # 根据表中的 rank 字段筛选主力/次主力合约，rank == 1是主力合约， 2 是次主力合约
-        rank = 1 if asset_type == "active" else 2
-        rank_data = date_data.where(f"rank = {rank}")
-
-        # 根据 source 筛选数据，如果有，就筛选，反之直接返回 date_data
-        if source:
-            source_dict = {
-                "1": "dc",
-                "2": "mick",
-                # "3": "研究所"  # 表中没有研究所的数据来源
-            }
+        if compute_type:
+            rank = 'MAIN' if compute_type == "main" else 'SUB_MAIN'
+            rank_data = date_data.where(f"compute_type = '{rank}'")
+            return rank_data.toDF(), db_session
 
-            source_data = rank_data.where(f"source = '{source_dict[str(source)]}'")
+        return date_data.toDF(), db_session
 
-            return source_data.toDF(), db_session
+    def get_active_contract_tick_data(self, data, frequency, start_date, end_date):
+        """
+        根据主力合约表查询tick表
+        :param data: 数据
+        :param frequency: 频率
+        :param start_date: 开始日期
+        :param end_date: 结束日期
+        :return: 查询后的数据
+        """
 
-        return rank_data.toDF(), db_session
+        table_name, db_path = self.get_active_contract_get_table_tick(frequency)
+        # 先从数据库获取数据
+        tick_data, db_session = self.connect_db(table_name, db_path)
+
+        # 使用 strftime 方法将 Timestamp 转换为所需格式
+        formatted_dates = [ts.strftime('%Y.%m.%d') for ts in data['trading_day'].tolist()]
+
+        # 根据日期筛选数据
+        # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
+        start_dolphin_date = self.get_active_contract_datetime_to_dolphin_time(start_date)
+        end_dolphin_date = self.get_active_contract_datetime_to_dolphin_time(end_date)
+        date_data = tick_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
+
+        instrument_data = date_data.where(f"instrument_id in {data['instrument_id'].tolist()}")
+
+        fina_data = instrument_data.toDF()
+        db_session.close()
+
+        return fina_data
 
     @staticmethod
     def get_active_contract_datetime_to_dolphin_time(datetime_str):
@@ -1769,9 +1894,15 @@ class GJDataC:
                     格式化后的日期字符串，例如 '2018.01.04 09:01:00'。
                 """
         if isinstance(datetime_str, str):
-            date_obj = datetime.datetime.strptime(datetime_str, '%Y-%m-%d')
-            return date_obj.strftime('%Y.%m.%d %H:%M:%S')
-        return datetime_str.strftime('%Y.%m.%d %H:%M:%S')
+            try:
+                datetime.datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S')
+                date_obj = datetime.datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S')
+                return date_obj.strftime('%Y.%m.%d %H:%M:%S')
+            except ValueError:
+                date_obj = datetime.datetime.strptime(datetime_str, '%Y-%m-%d')
+                return date_obj.strftime('%Y.%m.%d')
+        else:
+            return datetime_str.strftime('%Y.%m.%d %H:%M:%S')
 
     def get_active_contract_validate_date_type(self, start_date, end_date):
         """
@@ -1796,10 +1927,85 @@ class GJDataC:
         # else:
         #     raise ValueError("begin_date type error， please enter datetime.datetime type")
 
-    # @staticmethod
-    def get_active_contract_process_result(self, data, fields):
+    @staticmethod
+    def get_active_contract_rename(data, ex_factor, frequency):
         """
         处理返回结果
+        :param data: 数据
+        :param ex_factor: 复权因子
+        :param frequency: 频率
+        :return: 处理后的返回结果
+        """
+        new_df = data.copy()
+
+        if frequency in ['1min', '1d', '1min_gtja']:
+            return_fields = main_contract_return_fields
+            return_fields_rename = main_contract_return_fields_rename
+        else:
+            return_fields = tick_main_contract_return_fields
+            return_fields_rename = tick_main_contract_return_fields_rename
+
+        # 筛选出需求文档中指定的字段
+        new_df = new_df[return_fields]
+
+        # 将实际数据字段转换成需求文档中指定的字段
+        new_df.rename(columns=return_fields_rename, inplace=True)
+
+        if frequency in ['1min', '1d', '1min_gtja']:
+            new_df['none_close'] = new_df['close']
+            new_df['none_prev_close'] = new_df['prev_close']
+            new_df['ex_factor'] = ex_factor
+        else:
+            new_df['total_turnover'] = new_df.groupby(['order_book_ids', 'trading_day'])['turnover'].transform('sum')
+
+        return new_df
+
+    @staticmethod
+    def get_active_contract_adjust_price(data, adjust_type, adjust_method, frequency):
+        """
+        根据参数计算是否复权
+        :param data: 数据
+        :param adjust_type: 复权类型
+        :param adjust_method: 复权因子
+        :param frequency: 频率
+        :return: 计算后的数据
+        """
+
+        if not adjust_type or frequency in ['tick_l1', 'tick_l2']:
+            return data
+
+        adjust_fields = ['open', 'close', 'high', 'low', 'limit_up', 'limit_down', 'settlement', 'prev_settlement',
+                         'prev_close']
+        if adjust_type == 'post':
+            if adjust_method in ['prev_close_spread', 'open_spread']:
+                for field in adjust_fields:
+                    data[field] = data[field] + data[adjust_method]
+            else:
+                for field in adjust_fields:
+                    data[field] = data[field] * data[adjust_method]
+
+        return data
+
+    @staticmethod
+    def get_active_contract_process_return_fields(data, fields):
+        """
+        处理返回字段
+        :param data: 主力/次主力合约数据
+        :param fields: str or str list--选填，返回字段，默认全部
+        :return: 筛选后的主力/次主力合约数据
+        """
+
+        if not fields:
+            return data
+
+        if isinstance(fields, str):
+            return data[[fields]]
+        else:
+            return data[fields]
+
+    def get_active_contract_process_result(self, data, fields):
+        """
+        处理返回字段
         :param data: 主力/次主力合约数据
         :param fields: str or str list--选填，返回字段，默认全部
         :return: 筛选后的主力/次主力合约数据
@@ -1984,21 +2190,12 @@ class GJDataC:
             格式化后的日期字符串，例如 '2018.01.04 09:01:00'。
         """
 
-        # 在此需求中，因为所需的数据源表中对于日期字段的定义不一样，所以需要根据不同情况进行处理
-        if asset_type == "库存":
-            if isinstance(date, str):
-                return datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S').strftime('%Y-%m-%d %H:%M:%S') if (
-                    self.general_validate_date_str_is_datetime_type(date)) else (
-                    datetime.datetime.strptime(date, '%Y-%m-%d').strftime('%Y-%m-%d'))
-            return date.strftime('%Y-%m-%d %H:%M:%S') if (
-                self.general_validate_date_str_is_datetime_type(date)) else date.strftime('%Y-%m-%d')
-        else:
-            if isinstance(date, str):
-                return datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S').strftime('%Y.%m.%d %H:%M:%S') if (
-                    self.general_validate_date_str_is_datetime_type(date)) else (
-                    datetime.datetime.strptime(date, '%Y-%m-%d').strftime('%Y.%m.%d'))
-            return date.strftime('%Y.%m.%d %H:%M:%S') if (
-                self.general_validate_date_str_is_datetime_type(date)) else date.strftime('%Y.%m.%d')
+        if isinstance(date, str):
+            return datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S').strftime('%Y.%m.%d %H:%M:%S') if (
+                self.general_validate_date_str_is_datetime_type(date)) else (
+                datetime.datetime.strptime(date, '%Y-%m-%d').strftime('%Y.%m.%d'))
+        return date.strftime('%Y.%m.%d %H:%M:%S') if (
+            self.general_validate_date_str_is_datetime_type(date)) else date.strftime('%Y.%m.%d')
 
     @staticmethod
     def _get_basic_data_get_table_info(asset_type):
@@ -2044,7 +2241,7 @@ class GJDataC:
             new_df.rename(columns={'product_id': 'order_book_id', '	data_date': 'date', 'inventory_value': 'value'},
                           inplace=True)
 
-        return new_df[['order_book_id', 'asset_type', 'date', 'value']]
+        return new_df[['order_book_id', 'asset_type', 'data_date', 'value']]
 
     """ get_warehouse_stocks_future 仓单数据 """
 
@@ -2710,7 +2907,7 @@ class GJDataC:
         except KeyboardInterrupt:
             print("Subscription stopped by user.")
             # 关闭连接和资源释放逻辑
-            s.unsubscribe(subscribe_ip, subscribe_port, "QcMinKlineTable")
+            s.unsubscribe(subscribe_ip, subscribe_port, subscribe_min_db_table_name)
         except Exception as e:
             raise e
 
@@ -3567,4 +3764,4 @@ class GJDataC:
         date = datetime.datetime.strptime(date, '%Y.%m.%d')
 
         # 判断是否是周末（周六或周日）
-        return date.weekday() >= 5  # weekday() 返回 5（周六）或 6（周日）
+        return date.weekday() >= 5  # weekday() 返回 5（周六）或 6（周日）

{gjdatac_api-0.1.6 → gjdatac_api-0.1.7}/gjdatac_api/dolphindb_info.py

@@ -130,3 +130,7 @@ inventory_db_table_name = "qc_product_inventory"  # 表名
 
 # 订阅实时分钟k
 subscribe_min_db_table_name = "QcMinKlineTable"  # 表名
+
+
+''' 仿真 '''
+dolphindb_service = ["10.74.56.101:8902", "10.74.56.102:8902", "10.74.56.103:8902"]

{gjdatac_api-0.1.6 → gjdatac_api-0.1.7}/gjdatac_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gjdatac-api
-Version: 0.1.6
+Version: 0.1.7
 Summary: 数据接口打包
 Author: yin
 Author-email: 2018209921@qq.com

{gjdatac_api-0.1.6 → gjdatac_api-0.1.7}/setup.py

@@ -5,7 +5,7 @@ with open('description_info.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='gjdatac_api',  # 你的包名
-    version='0.1.6',  # 版本号
+    version='0.1.7',  # 版本号
     description='数据接口打包',  # 包的简要描述
     long_description=long_description,  # 包的详细描述
     long_description_content_type='text/markdown',  # 描述文件的类型