gjdatac-api 0.0.5__tar.gz → 0.0.6__tar.gz

{gjdatac_api-0.0.5 → gjdatac_api-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gjdatac_api
-Version: 0.0.5
+Version: 0.0.6
 Summary: 主动管理项目第一版(部分接口)
 Home-page: UNKNOWN
 Author: yin

{gjdatac_api-0.0.5 → gjdatac_api-0.0.6}/gjdatac_api/data_api_class.py

@@ -1,9 +1,11 @@
 # 此文件用于编写数据接口---类方式实现
 
 import datetime
-import holidays
 import asyncio
+
+import holidays
 import pandas as pd
+import rqdatac as rq
 import dolphindb as ddb
 
 from .dict_data import get_price_frequency_dict, get_price_data_type_dict, get_instruments_type_dict
@@ -60,10 +62,22 @@ class GJDataC:
         ''' get_activate_contract 接口相关属性 '''
         self.get_active_contract_data = None  # 用于存放get_activate_contract接口数据
 
+        ''' get_basic_data 接口相关属性 '''
+        self.get_basic_data_data = None  # 用于获取get_basic_data接口数据
+
+        ''' get_warehouse_stocks_future 接口相关属性 '''
+        self.get_warehouse_stocks_future_data = None  # 用于获取get_warehouse_stocks_future接口数据
+
+        ''' get_vwap 接口相关属性 '''
+        self.get_vwap_data = None  # 用于获取get_vwap接口数据
+
+        ''' get_twap 接口相关属性 '''
+        self.get_twap_data = None  # 用于获取get_twap接口数据
+
     # @staticmethod
     def connect_db(self, table_name, db_path):
-        """ 
-        此方法用于根据不同的数据表及数据库获取数据，只返回Table对象，对应的数据处理在对应的数据接口处理 
+        """
+        此方法用于根据不同的数据表及数据库获取数据，只返回Table对象，对应的数据处理在对应的数据接口处理
         :param table_name: 数据表路径
         :param db_path: 数据库路径
         :return 根据数据库和表路径获取的数据(Table对象), 会话信息(db_session)
@@ -93,8 +107,8 @@ class GJDataC:
 
     @staticmethod
     def general_validate_either_or(field_1_name, field_1_value, field_2_name, field_2_value):
-        """ 
-        此方法用于验证二选一的参数填写情况 
+        """
+        此方法用于验证二选一的参数填写情况
         :param field_1_name: 参数1名称
         :param field_1_value: 参数1值
         :param field_2_name: 参数2名称
@@ -110,7 +124,7 @@ class GJDataC:
         """
         判断字符串是否为datetime.date, datetime.datetime格式。
         :param date_str: 待判断的字符串。
-        
+
         Returns:
             True: 如果是日期格式，返回 True。
             False: 否则返回 False。
@@ -124,7 +138,7 @@ class GJDataC:
         """
         此方法用于验证日期字段是否为可以转换为datetime的类型
         :param date_data: 日期字符串
-        
+
         :return : 如果可以转换为datetime类型，返回 True, 否则返回 False。
         """
 
@@ -139,7 +153,7 @@ class GJDataC:
         """
         此方法用于验证日期字段是否为可以转换为date的类型
         :param date_data: 日期字符串
-        
+
         :return : 如果可以转换为date类型，返回 True, 否则返回 False。
         """
 
@@ -167,7 +181,7 @@ class GJDataC:
         校验参数是否为str类型
         :param param_name: 参数名称
         :param param_value: 参数值
-        
+
         :return: None （用于校验数据无需返回值）
         """
 
@@ -178,7 +192,7 @@ class GJDataC:
         """
         对asset_type进行校验
         :param asset_type: str, 合约类型
-        
+
         :return: None （用于校验数据无需返回值）
         """
         self.general_validate_params_required(asset_type, "asset_type")  # 校验必填参数
@@ -192,7 +206,7 @@ class GJDataC:
         根据用户选择的字段进行字段筛选
         :param fields: 字段列表--用户传入的需要返回的字段
         :param data: 数据
-        
+
         :return data: 根据用户填写的字段筛选后的数据
         """
 
@@ -220,9 +234,9 @@ class GJDataC:
     def _deal_fields(_field, columns_list):
         """
         判断用户选择的字段是否存在
-        
+
         :param columns_list: 数据的所有字段
-        
+
         :return: None （用于校验数据无需返回值）
         """
         if _field not in columns_list:
@@ -237,7 +251,7 @@ class GJDataC:
         :param data: pandas.DataFrame, 数据
         :param field_name: str, 过滤字段
         :param field_value: str or list, 过滤值
-        
+
         :return 根据字段过滤后的数据
         """
 
@@ -250,15 +264,15 @@ class GJDataC:
         :param data: 需要处理的数据
         :param field_name: 字段名
         :param field_value: 字段值
-        
+
         :return : 根据字段过滤后的数据
         """
         self.general_validate_field_str_or_list(field_value, field_name)
         return self.general_filter_data_by_field(data, field_name, field_value)
 
     def general_date_str_to_date(self, date_str):
-        """ 
-        将date类型的str转换成datetime.date类型 
+        """
+        将date类型的str转换成datetime.date类型
         :param date_str: str, 日期字符串
         """
         if not self.general_validate_date_str_is_date_type(date_str):
@@ -266,6 +280,12 @@ class GJDataC:
 
         return datetime.datetime.strptime(date_str, "%Y-%m-%d")
 
+    @staticmethod
+    def general_date_str_to_datetime(date_str):
+        """ 将date类型的str转换成datetime.datetime类型 """
+        if isinstance(date_str, str):
+            return datetime.datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
+
     """ get_price(获取行情数据接口) """
 
     def get_price(self, order_book_ids=None, asset_type="future", frequency=None, start_date=None, end_date=None,
@@ -318,8 +338,8 @@ class GJDataC:
         """
         对order_book_ids 类型 以及 是否必填 进行校验
         :param order_book_ids: 合约类型
-        
-        :return: None 
+
+        :return: None
         """
         self.general_validate_params_required(order_book_ids, "order_book_ids")  # 校验必填参数
         self.general_validate_field_str_or_list(order_book_ids, "order_book_ids")  # 校验参数类型
@@ -327,7 +347,7 @@ class GJDataC:
     def get_price_validate_frequency(self, frequency):
         """
         对frequency进行校验
-        
+
         :param frequency: 频率
         :return: None
         """
@@ -340,7 +360,7 @@ class GJDataC:
         """
         对 start_date 和 end_date 进行校验
         校验 start_date 和 end_date 是否同时提供，或者都不提供。
-        
+
         :param start_date: 开始日期
         :param end_date: 结束日期
         :return: None
@@ -365,7 +385,7 @@ class GJDataC:
     def _get_price_convert_start_end_date(start_date, end_date):
         """
         将 start_date 和 end_date 转换为 datetime 类型。
-        
+
         :param start_date: 开始日期，可以是 datetime.datetime 对象或字符串。
         :param end_date: 结束日期，可以是 datetime.datetime 对象或字符串。
         :return: 转换后的 start_date 和 end_date。
@@ -403,7 +423,7 @@ class GJDataC:
         """
         根据start_date和end_date筛选数据
         此处order_book_ids参数用于处理未传递start_date和end_date的情况(根据order_book_ids返回距离当前时间最近的一条数据)
-        
+
         :param start_date: 开始时间
         :param end_date: 结束时间
         :param order_book_ids: 合约代码
@@ -440,7 +460,7 @@ class GJDataC:
         """
         根据用户选择的字段返回数据
         :param fields: 字段列表 -- 用户传入的需要返回的字段
-        
+
         :return : None
 
         """
@@ -449,7 +469,7 @@ class GJDataC:
     def get_price_by_type_frequency(self, asset_type, frequency):
         """
         根据合约类型和frequency筛选数据
-        
+
         :param asset_type: 合约类型
         :param frequency: 频率
         :return: None
@@ -483,7 +503,7 @@ class GJDataC:
     def get_price_data_rename_columns(self, bar_or_tick):
         """
         将从数据库中获取的数据列名重命名
-        
+
         :param bar_or_tick: 是bar类型数据还是tick类型(不同类型字段不同)
         :return: None
         """
@@ -494,10 +514,10 @@ class GJDataC:
     def _get_price_get_data(self, order_book_ids, table_name, db_path):
         """
         用于接收数据表以及数据库，获取数据
-        : params order_book_ids: 合约代码 
-        : params table_name: 数据表路径 
+        : params order_book_ids: 合约代码
+        : params table_name: 数据表路径
         : params db_path: 数据库路径
-        
+
         : return filtered_data: 从数据库获取并根据合约代码筛选后的数据
         """
         get_price_data, db_session = self.connect_db(table_name, db_path)
@@ -508,6 +528,10 @@ class GJDataC:
         else:
             limit_data = get_price_data.where(f"instrument_id in {order_book_ids}")
 
+        print("开始处理数据\n")
+        if limit_data.rows > 1000000:
+            print(f"当前获取的数据量较大,总数据量为: {limit_data.rows}, 执行时间可能较久,建议调整参数范围,多次获取")
+
         # 分批处理
         filtered_data = self._get_price_get_data_todf(limit_data)
 
@@ -581,8 +605,8 @@ class GJDataC:
     #     return data.toDF()
 
     def get_price_data_get_data(self, order_book_ids, asset_type, frequency):
-        """ 
-        根据参数获取数据库和表名，调用接口获取数据 
+        """
+        根据参数获取数据库和表名，调用接口获取数据
 
         :param order_book_ids: 合约代码列表
         :param asset_type: 合约类型
@@ -640,7 +664,7 @@ class GJDataC:
         self.get_instruments_data_rename_columns(asset_type)
 
         # 从交易参数中填充commodity和trading_hour的值
-        # self.get_instruments_deal_commodity_trading_hour()
+        self.get_instruments_deal_commodity_trading_hour()
 
         ''' 按照文档筛选需要返回的字段 '''
         self.get_instruments_data_filter_return_fileds(asset_type)
@@ -716,7 +740,7 @@ class GJDataC:
     def _get_instruments_data_get_data(self, order_book_ids, table_name, db_path):
         """
         用于接收数据表以及数据库，获取数据
-        
+
         :param order_book_ids: 合约代码
         :param table_name: 数据表路径
         :param db_path: 数据库路径
@@ -737,9 +761,9 @@ class GJDataC:
         return filtered_data
 
     def get_instruments_data_get_data(self, asset_type=None, order_book_ids=None, commodity=None):
-        """ 
-        根据参数获取数据库和表名，调用接口获取数据 
-        
+        """
+        根据参数获取数据库和表名，调用接口获取数据
+
         :param asset_type: 合约类型
         :param order_book_ids: 合约代码
         :param commodity: 合约品种
@@ -784,7 +808,7 @@ class GJDataC:
     def get_instruments_data_rename_columns(self, asset_type):
         """
         将从数据库中获取的数据列名重命名为文档要求的名字
-        
+
         :param asset_type: 合约类型
         :return: None
         """
@@ -832,7 +856,7 @@ class GJDataC:
     def get_trading_dates_validate_date_n_start_end(self, date, n, start_date, end_date):
         """
         校验date、n和start_date、end_date有效性
-        
+
         :param date: str-- 日期
         :param n: str--根据不同值获取对应的交易日历
         :param start_date: str（datetime.date, datetime.datetime）--开始日期
@@ -876,7 +900,7 @@ class GJDataC:
         根据start_date和end_date获取交易日历
         :param start_date: str（datetime.date, datetime.datetime）--选填, 开始日期
         :param end_date: str（datetime.date, datetime.datetime）--选填, 结束日期
-        
+
         :return: 根据start_date和end_date筛选后的数据
         """
 
@@ -906,7 +930,7 @@ class GJDataC:
     def _get_trading_dates_by_start_end(time_data):
         """
         将时间str数据处理成对应的时间类型（例如：date类型的str，处理成datetime.date类型）
-        
+
         :param time_data: 时间数据
         :return: 转换后的时间数据类型
         """
@@ -926,7 +950,7 @@ class GJDataC:
         其中，如果是str类型，还要判断是否是datetime.date, datetime.datetime两种类型的字符串.
         :params _start_date: 开始日期
         :params _end_date: 结束日期
-        
+
         :return: 如果类型正确，返回 True。否则返回 False，并打印错误信息
         """
         if isinstance(_start_date, (str, datetime.date, datetime.datetime)) and \
@@ -956,11 +980,11 @@ class GJDataC:
     def get_date_get_week_month_year(data, start_date, end_date):
         """
         用于获取当前日期所在周、月、年的交易日数据
-        
+
         :param data: 交易日历数据
         :param start_date: 开始日期
         :param end_date: 结束日期
-        
+
         :return: 交易日历数据
 
         """
@@ -1025,7 +1049,7 @@ class GJDataC:
         :param commodity: str--选填（和order_book_id二选一），合约品种,如果入参为品种，则返回该品种条件下所有合约的保证金list
         :param date: datetime--必填（默认今天)，日期
         :param exchange: str--必填，交易所
-        :return:
+        :return: 期货保证金数据
         """
 
         """ 校验数据 """
@@ -1048,7 +1072,11 @@ class GJDataC:
         return self.get_margin_ratio_data[["order_book_id", "commodity", "date", "exchange"]]
 
     def get_margin_ratio_validate_exchange(self, exchange):
-        """ 校验exchange """
+        """
+        校验exchange
+        :param exchange: str--必填，交易所
+        :return: None
+        """
 
         self.general_validate_params_required(exchange, "exchange")  # 校验必填参数
 
@@ -1056,7 +1084,12 @@ class GJDataC:
             raise ValueError("exchange should be str")
 
     def get_margin_ratio_validate_order_book_id_commodity(self, order_book_id, commodity):
-        """ 校验order_book_id和commodity """
+        """
+        校验order_book_id和commodity
+        :param order_book_id: str--二选一，合约代码
+        :param commodity: str--二选一，品种
+        :return: None
+        """
 
         ''' 对order_book_ids和commodity_type进行校验 '''
         self.general_validate_either_or("order_book_id", order_book_id, "commodity", commodity)
@@ -1071,18 +1104,24 @@ class GJDataC:
                                                                             commodity)
 
     def get_margin_ratio_validate_date(self, date):
-        """ 校验date """
+        """
+        校验date
+        :param date: datetime--日期
+        :return: None
+        """
 
         if isinstance(date, (str, datetime.date, datetime.datetime)):
             if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date 不是有效的日期字符串格式")
-            return True
+                raise ValueError("date is not a valid date string format")
+            # return True
         else:
-            raise ValueError("date 类型错误，请传入 str，datetime.date 或 datetime.datetime 类型")
+            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     def get_margin_ratio_data_by_date(self, date):
         """
         根据date筛选数据
+        :param date: datetime--日期
+        :return: None
         """
 
         if isinstance(date, str):
@@ -1092,6 +1131,8 @@ class GJDataC:
     def get_margin_ratio_data_by_exchange(self, exchange):
         """
         根据exchange筛选数据
+        :param exchange: str--交易所
+        :return: None
         """
 
         self.get_margin_ratio_data = self.get_margin_ratio_data[self.get_margin_ratio_data["exchange"] == exchange]
@@ -1105,7 +1146,7 @@ class GJDataC:
         :param commodity: str--选填（和order_book_id二选一），合约品种,如果入参为品种，则返回该品种条件下所有合约的交割手续费list
         :param date: datetime--必填（默认今天)，日期
         :param exchange: str--必填，交易所
-        :return:
+        :return: 期货交割手续费
         """
 
         """ 校验数据 """
@@ -1128,7 +1169,11 @@ class GJDataC:
         return self.get_fee_data[["order_book_id", "commodity", "date", "exchange"]]
 
     def get_fee_validate_exchange(self, exchange):
-        """ 校验exchange """
+        """
+        校验exchange
+        :param exchange: str--必填，交易所
+        :return: None
+        """
         # 是否必填
         self.general_validate_params_required(exchange, "exchange")
 
@@ -1136,7 +1181,12 @@ class GJDataC:
             raise ValueError("exchange should be str")
 
     def get_fee_validate_order_book_id_commodity(self, order_book_id, commodity):
-        """ 校验order_book_id和commodity """
+        """
+        校验order_book_id和commodity
+        :param order_book_id: str--二选一，合约代码
+        :param commodity: str--二选一，品种
+        :return: None
+        """
 
         ''' 对order_book_ids和commodity_type进行校验 '''
         self.general_validate_either_or("order_book_id", order_book_id, "commodity", commodity)
@@ -1151,18 +1201,24 @@ class GJDataC:
                                                                    commodity)
 
     def get_fee_validate_date(self, date):
-        """ 校验date """
+        """
+        校验date
+        :param date: datetime--日期
+        :return: None
+        """
 
         if isinstance(date, (str, datetime.date, datetime.datetime)):
             if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date 不是有效的日期字符串格式")
-            return True
+                raise ValueError("date is not a valid date string format")
+            # return True
         else:
-            raise ValueError("date 类型错误，请传入 str，datetime.date 或 datetime.datetime 类型")
+            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     def get_fee_data_by_date(self, date):
         """
         根据date筛选数据
+        :param date: datetime--日期
+        :return: None
         """
 
         if isinstance(date, str):
@@ -1172,6 +1228,8 @@ class GJDataC:
     def get_fee_data_by_exchange(self, exchange):
         """
         根据exchange筛选数据
+        :param exchange: str--交易所
+        :return: None
         """
 
         self.get_fee_data = self.get_fee_data[self.get_fee_data["exchange"] == exchange]
@@ -1184,9 +1242,10 @@ class GJDataC:
         :param order_book_ids: str or list--选填（和commodity二选一），合约代码
         :param commodity: str or list--选填（和order_book_ids二选一），合约品种
         :param date: datetime.date--选填（默认今天)，日期
-        :return:
+        :return: 期货限仓数据
 
         """
+
         """ 校验数据 """
         # 校验order_book_ids和commodity
         self.get_limit_position_validate_order_book_ids_commodity(order_book_ids, commodity)
@@ -1201,7 +1260,12 @@ class GJDataC:
         return self.get_limit_position_data
 
     def get_limit_position_validate_order_book_ids_commodity(self, order_book_ids, commodity):
-        """ 对order_book_ids和commodity_type进行校验 """
+        """
+        对order_book_ids和commodity_type进行校验
+        :param order_book_ids: str or list--选填（和commodity二选一），合约代码
+        :param commodity: str or list--选填（和order_book_ids二选一），合约品种
+        :return: None
+        """
         self.general_validate_either_or("order_book_ids", order_book_ids, "commodity", commodity)
 
         ''' 根据order_book_ids和commodity_type进行筛选 '''
@@ -1216,18 +1280,23 @@ class GJDataC:
                                                                               commodity)
 
     def get_limit_position_validate_date(self, date):
-        """ 校验date """
+        """
+        校验date
+        :param date: datetime.date--选填，日期
+        :return: None
+        """
 
         if isinstance(date, (str, datetime.date, datetime.datetime)):
             if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date 不是有效的日期字符串格式")
-            return True
+                raise ValueError("date is not a valid date string format")
+            # return True
         else:
-            raise ValueError("date 类型错误，请传入 str，datetime.date 或 datetime.datetime 类型")
+            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     def get_limit_position_data_by_date(self, date):
         """
         根据date筛选数据
+        :param date: datetime.date--选填，日期
         """
 
         if isinstance(date, str):
@@ -1249,7 +1318,7 @@ class GJDataC:
         :param fields: str or str list--选填，返回字段，默认全部
         :param source: str--选填，数据源，默认研究所, 3个来源可选：1-数据中台, 2-米筐, 3-研究所
 
-        :return:
+        :return: 主力/次主力合约
         """
 
         """ 校验参数 """
@@ -1259,10 +1328,13 @@ class GJDataC:
         # 校验日期参数类型
         self.get_active_contract_validate_date_type(begin_date, start_date, end_date)
 
+        """ 校验code类型 """
+        self.get_active_contract_validate_code(code)
+
         """ 筛选数据 """
 
         # 根据code筛选数据
-        self.get_active_contract_validate_code(code)
+        self.get_active_contract_filter_by_code(code)
 
         # 根据日期数据筛选数据
         self.get_active_contract_filter_by_date(begin_date, start_date, end_date)
@@ -1279,7 +1351,15 @@ class GJDataC:
         return self.get_active_contract_data
 
     def get_active_contract_validate_required_params(self, code, begin_date, start_date, end_date, asset_type):
-        """ 校验参数是否必填 """
+        """
+        校验参数是否必填
+        :param code: str or str list--必填，品种
+        :param begin_date: datetime--必填，指定日期
+        :param start_date: date--必填，默认当天
+        :param end_date: date--必填，默认当天
+        :param asset_type: str--必填，active指主力；next_active次主力
+        :return: None
+        """
 
         params_dict = {
             "code": code,
@@ -1292,8 +1372,20 @@ class GJDataC:
             self.general_validate_params_required(value, key)  # 校验必填参数
 
     def get_active_contract_validate_code(self, code):
-        """ 校验code 类型 """
+        """
+        校验code 类型
+        :param code: str or str list--必填，品种
+        :return: None
+        """
         self.general_validate_field_str_or_list(code, "code")
+
+    def get_active_contract_filter_by_code(self, code):
+        """
+        根据code过滤数据
+        :param code: str or str list--必填，品种
+        :return: None
+        """
+
         self.get_active_contract_data = self.get_active_contract_data[
             self.get_active_contract_data["code"].isin(code)] if isinstance(code, list) else \
             self.get_active_contract_data[self.get_active_contract_data["code"] == code]
@@ -1301,28 +1393,36 @@ class GJDataC:
     def get_active_contract_validate_date_type(self, begin_date, start_date, end_date):
         """
         校验日期数据的类型
+        :param begin_date: datetime--必填，指定日期
+        :param start_date: date--必填，默认当天
+        :param end_date: date--必填，默认当天
+        :return: None
         """
         # 校验start_date 和 end_date 是否为datetime.date类型或者可以转换成该类型的str
         if isinstance(start_date, (str, datetime.date)) and isinstance(end_date, (str, datetime.date)):
             if isinstance(start_date, str) and not self.general_validate_date_str_is_date_type(start_date):
-                raise ValueError("start_date 类型错误，请传入 datetime.date 类型")
+                raise ValueError("start_date type error， please enter datetime.date type")
             if isinstance(end_date, str) and not self.general_validate_date_str_is_date_type(end_date):
-                raise ValueError("end_date 类型错误，请传入 datetime.date 类型")
+                raise ValueError("start_date type error， please enter datetime.date type")
         else:
-            raise ValueError("start_date 或 end_date 类型错误，请传入datetime.date 类型")
+            raise ValueError("start_date or end_date type error, please enter datetime.date type")
 
         # 校验begin_date 是否为datetime.datetime类型或者为可以转换为该类型的字符串
         if isinstance(begin_date, (str, datetime.datetime)):
             if isinstance(begin_date, str) and not self.general_validate_date_str_is_datetime_type(begin_date):
-                raise ValueError("begin_date 类型错误，请传入 datetime.datetime 类型")
+                raise ValueError("begin_date type error， please enter datetime.datetime type")
         else:
-            raise ValueError("begin_date 类型错误，请传入 datetime.datetime 类型")
+            raise ValueError("begin_date type error， please enter datetime.datetime type")
 
     def get_active_contract_filter_by_date(self, begin_date, start_date, end_date):
         """
         根据日期筛选数据
+        :param begin_date: datetime--必填，指定日期
+        :param start_date: date--必填，默认当天
+        :param end_date: date--必填，默认当天
+        :return: None
         """
-        print(begin_date)
+
         if start_date > end_date:
             raise ValueError("start_date should be earlier than end_date")
 
@@ -1337,6 +1437,8 @@ class GJDataC:
     def get_active_contract_filter_by_asset_type(self, asset_type):
         """
         根据asset_type筛选数据
+        :param asset_type: str--必填，active指主力；next_active次主力
+        :return: None
         """
 
         self.get_active_contract_data = self.general_filter_data_by_field(self.get_active_contract_data,
@@ -1346,6 +1448,8 @@ class GJDataC:
     def get_active_contract_filter_data_by_fields(self, fields):
         """
         根据fields筛选数据
+        :param fields: str or str list--选填，返回字段，默认全部
+        :return: None
         """
 
         if isinstance(fields, (str, list)):
@@ -1356,6 +1460,8 @@ class GJDataC:
     def get_active_contract_data_by_source(source):
         """
         根据数据源筛选数据
+        :param source: str--选填，数据源，默认研究所, 3个来源可选：1-数据中台, 2-米筐, 3-研究所
+        :return: None
         """
 
         if not isinstance(source, str):
@@ -1379,6 +1485,7 @@ class GJDataC:
         :param asset_type: str--必填，枚举值：库存、基差、现货
         :param start_date: str, datetime.date, datetime.datetime, pandasTimestamp--必填，开始日期
         :param end_date: str, datetime.date, datetime.datetime, pandasTimestamp--必填，结束日期
+        :return: 库存/基差/现货价格-数据（日频）
         """
 
         """ 校验参数 """
@@ -1395,7 +1502,14 @@ class GJDataC:
         # 校验start_date 和 end_date 类型
         self.get_basic_data_validate_date(start_date, end_date)
 
-        return None
+        """ 筛选数据 """
+        # 根据start_date 和 end_date 筛选数据
+        # self.get_basic_data_filter_data_by_date(start_date, end_date)
+
+        # 根据asset_type 筛选数据
+        # self.get_basic_data_filter_data_by_asset_type(asset_type)
+
+        return self.get_basic_data_data
 
     def get_basic_data_validate_required_params(self, order_book_id, asset_type, start_date, end_date):
         params_dict = {
@@ -1410,6 +1524,8 @@ class GJDataC:
     def get_basic_data_validate_order_book_id(self, order_book_id):
         """
         校验order_book_id 类型
+        :param order_book_id: str--必填，合约代码
+        :return: None
         """
 
         self.general_validate_param_is_str("order_book_id", order_book_id)
@@ -1417,6 +1533,8 @@ class GJDataC:
     def get_basic_data_validate_asset_type(self, asset_type):
         """
         校验asset_type 类型
+        :param asset_type: str--必填，枚举值：库存、基差、现货
+        :return: None
         """
 
         self.general_validate_param_is_str("asset_type", asset_type)
@@ -1424,8 +1542,11 @@ class GJDataC:
     def get_basic_data_validate_date(self, start_date, end_date):
         """
         校验start_date 和 end_date 类型
+        :param start_date: 开始日期
+        :param end_date: 结束日期
+        :return: None
         """
-        error_msg = "start_date 或 end_date 类型错误，datetime.date, datetime.datetime, pandasTimestamp类型或者可以转换成该类型的str"
+        error_msg = "start_date or end_date type error, datetime.date, datetime.datetime, pandasTimestamp type or can be converted to the type"
 
         # 校验start_date 和 end_date 是否为datetime.date, datetime.datetime, pandasTimestamp类型或者可以转换成该类型的str
         if isinstance(start_date, (str, datetime.date, datetime.datetime, pd.Timestamp)) and isinstance(end_date, (
@@ -1436,3 +1557,527 @@ class GJDataC:
                 raise ValueError(error_msg)
         else:
             raise ValueError(error_msg)
+
+    @staticmethod
+    def get_basic_data_get_data(order_book_ids, table_name, db_path):
+        """
+        获取get_basic_data数据
+        :param order_book_ids: 合约代码
+        :param table_name: 表名
+        :param db_path: 数据库路径
+        :return: 从对应数据库中获取的数据
+
+        """
+
+        # get_basic_data_data, db_session = self.connect_db(table_name, db_path)
+        get_basic_data_data = pd.DataFrame()  # 测试，用了数据库信息后需要替换成上面的代码
+
+        filtered_data = pd.DataFrame()
+        # 使用 DolphinDB 的 where 子句筛选数据
+        if isinstance(order_book_ids, str):
+            filtered_data = get_basic_data_data.where(f"instrumentid='{order_book_ids}'").toDF()
+        elif isinstance(order_book_ids, list):
+            filtered_data = get_basic_data_data.where(f"instrumentid in {order_book_ids}").toDF()
+
+        # 关闭数据库连接
+        # db_session.close()  # 用了数据库信息后，需要取消注释
+
+        return filtered_data
+
+    def get_basic_data_filter_data_by_date(self, start_date, end_date):
+        """
+        根据日期过滤get_basic_data数据
+        :param start_date: 开始日期
+        :param end_date: 结束日期
+        :return: 过滤后的数据
+        """
+
+        start_date = self._get_basic_data_filter_data_by_date_conversion(start_date)
+        end_date = self._get_basic_data_filter_data_by_date_conversion(end_date)
+
+        # 根据转换后的日期过滤数据
+        self.get_basic_data_data = self.get_basic_data_data[
+            (self.get_basic_data_data['date'] >= start_date) & (self.get_basic_data_data['date'] <= end_date)]
+
+        return self.get_basic_data_data
+
+    def _get_basic_data_filter_data_by_date_conversion(self, date_str):
+        """
+        将日期字符串转换成对应格式的日期数据
+        :param date_str: 日期字符串
+        :return: 转换后的日期数据
+        """
+
+        if isinstance(date_str, str):
+            if self.general_validate_date_str_is_datetime_type(date_str):
+                return self.general_date_str_to_datetime(date_str)
+            if self.general_validate_date_str_is_date_type(date_str):
+                return self.general_date_str_to_date(date_str).date()
+
+        return date_str
+
+    def get_basic_data_filter_data_by_asset_type(self, asset_type):
+        """
+        根据数据类型过滤数据
+        :param asset_type: 数据类型
+        :return: 过滤后的数据
+        """
+        self.get_basic_data_data = self.get_basic_data_data[self.get_basic_data_data['type'] == asset_type]
+        return self.get_basic_data_data
+
+    """ get_warehouse_stocks_future 仓单数据 """
+
+    def get_warehouse_stocks_future(self, commodity=None, start_date=None,
+                                    end_date=datetime.date.today() - datetime.timedelta(days=1)):
+        """
+        获取仓单数据
+        :param commodity: str--必填，期货合约品种
+        :param start_date: str--必填，开始日期
+        :param end_date: str--必填，结束日期 (默认为策略当天日期的前一天)
+        :return: 仓单数据
+        """
+
+        """ 校验必填参数 """
+        # 校验commodity, start_date, end_date 是否为必填参数
+        self.get_warehouse_stocks_future_validate_required_params(commodity, start_date, end_date)
+
+        # 校验commodity, start_date, end_date 是否为str类型
+        self.get_warehouse_stocks_future_validate_type_str(commodity, start_date, end_date)
+
+        """ 获取数据 """
+        # 从数据库中获取数据
+        # self.get_warehouse_stocks_future_get_data(commodity)
+
+        """ 筛选数据 """
+        # 根据日期筛选数据
+        # self.get_warehouse_stocks_future_filter_data_by_date(start_date, end_date)
+
+        return self.get_warehouse_stocks_future_data
+
+    def get_warehouse_stocks_future_validate_required_params(self, commodity, start_date, end_date):
+        """
+        校验仓单数据必填参数
+        :param commodity: str--必填，期货合约品种
+        :param start_date: str--必填，开始日期
+        :param end_date: str--必填，结束日期 (默认为策略当天日期的前一天)
+        :return: None
+        """
+
+        params_dict = {
+            "commodity": commodity,
+            "start_date": start_date,
+            "end_date": end_date
+        }
+
+        for key, value in params_dict.items():
+            self.general_validate_params_required(value, key)
+
+    def get_warehouse_stocks_future_validate_type_str(self, commodity, start_date, end_date):
+        """
+        校验参数类型是否为str
+        :param commodity: str--必填，期货合约品种
+        :param start_date: str--必填，开始日期
+        :param end_date: str--必填，结束日期 (默认为策略当天日期的前一天)
+        :return: None
+        """
+
+        params_dict = {
+            "commodity": commodity,
+            "start_date": start_date,
+            "end_date": end_date
+        }
+
+        for key, value in params_dict.items():
+            self.general_validate_param_is_str(key, value)
+
+    @staticmethod
+    def get_warehouse_stocks_future_get_data(commodity):
+        """
+        获取get_basic_data数据
+        :param commodity: 期货合约品种
+        :return: 从对应数据库中获取的数据
+
+        """
+
+        # get_warehouse_stocks_future_data, db_session = self.connect_db(table_name, db_path)
+        get_warehouse_stocks_future_data = pd.DataFrame()  # 测试，用了数据库信息后需要替换成上面的代码
+
+        filtered_data = pd.DataFrame()
+        # 使用 DolphinDB 的 where 子句筛选数据
+        if isinstance(commodity, str):
+            filtered_data = get_warehouse_stocks_future_data.where(f"instrumentid='{commodity}'").toDF()
+        elif isinstance(commodity, list):
+            filtered_data = get_warehouse_stocks_future_data.where(f"instrumentid in {commodity}").toDF()
+
+        # 关闭数据库连接
+        # db_session.close()  # 用了数据库信息后，需要取消注释
+
+        return filtered_data
+
+    def get_warehouse_stocks_future_filter_data_by_date(self, start_date, end_date):
+        """
+        根据日期过滤get_basic_data数据
+        :param start_date: 开始日期
+        :param end_date: 结束日期
+        :return: 过滤后的数据
+        """
+
+        start_date = self._get_warehouse_stocks_future_date_conversion(start_date)
+        end_date = self._get_warehouse_stocks_future_date_conversion(end_date)
+
+        # 根据转换后的日期过滤数据
+        self.get_warehouse_stocks_future_data = self.get_warehouse_stocks_future_data[
+            (self.get_warehouse_stocks_future_data['date'] >= start_date) & (
+                    self.get_warehouse_stocks_future_data['date'] <= end_date)]
+
+        return self.get_warehouse_stocks_future_data
+
+    def _get_warehouse_stocks_future_date_conversion(self, date_str):
+        """
+        将日期字符串转换成对应格式的日期数据
+        :param date_str: 日期字符串
+        :return: 转换后的日期数据
+        """
+
+        if isinstance(date_str, str):
+            if self.general_validate_date_str_is_datetime_type(date_str):
+                return self.general_date_str_to_datetime(date_str)
+            if self.general_validate_date_str_is_date_type(date_str):
+                return self.general_date_str_to_date(date_str).date()
+
+        return date_str
+
+    """ get_vwap 获取vwap成交量加权价格指标 """
+
+    def get_vwap(self, order_book_ids=None, start_date=None, end_date=None, frequency='1d'):
+        """
+        获取vwap成交量加权价格指标
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :param frequency: str--必填, 历史数据的频率
+        :return: vwap成交量加权价格指标
+        """
+
+        """ 校验必填参数 """
+        # 校验oder_book_ids, start_date, end_date, frequency 是否为必填参数
+        self.get_vwap_validate_required_params(order_book_ids, start_date, end_date, frequency)
+
+        # 校验order_book_ids是否为str OR str list
+        self.get_vwap_validate_order_book_ids(order_book_ids)
+
+        # 校验start_date, end_date是否为datetime 或 对应格式的字符串
+        self.get_vwap_validate_date_type(start_date, end_date)
+
+        # 校验frequency是否为str
+        self.get_vwap_validate_frequency(frequency)
+
+        """ 筛选数据 """
+        # 根据start_date, end_date筛选数据
+        self.get_vwap_filter_by_date(start_date, end_date)
+
+        # 根据order_book_ids, frequency, start_date, end_date筛选数据
+        self.get_vwap_get_data_by_frequency(order_book_ids, frequency, start_date, end_date)
+
+        return self.get_vwap_data
+
+    def get_vwap_validate_required_params(self, order_book_ids, start_date, end_date, frequency):
+        """
+        校验必填参数
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :param frequency: str--必填, 历史数据的频率
+        :return: None
+        """
+
+        params_dict = {
+            "order_book_ids": order_book_ids,
+            "start_date": start_date,
+            "end_date": end_date,
+            "frequency": frequency
+        }
+
+        for key, value in params_dict.items():
+            self.general_validate_params_required(value, key)
+
+    def get_vwap_validate_order_book_ids(self, order_book_ids):
+        """
+        校验order_book_ids参数类型是否为str OR str list
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :return: None
+        """
+
+        self.general_validate_field_str_or_list(order_book_ids, "order_book_ids")
+
+    def get_vwap_validate_date_type(self, start_date, end_date):
+        """
+        校验start_date和end_date参数类型是否为datetime
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :return: None
+        """
+
+        self._get_vwap_validate_date_type(start_date, "start_date")
+        self._get_vwap_validate_date_type(end_date, "end_date")
+
+    def _get_vwap_validate_date_type(self, date_str, date_str_name):
+        """
+        校验date_str参数类型是否为datetime格式的字符串
+        :param date_str: str, 日期
+        :return: None
+        """
+
+        if isinstance(date_str, str) and not self.general_validate_date_str_is_datetime_type(date_str):
+            raise ValueError(f"{date_str_name} type error, datetime.datetime type or can be converted to the type")
+        if not isinstance(date_str, str) and not isinstance(date_str, datetime.datetime):
+            raise ValueError(f"{date_str_name} type error, datetime.datetime type or can be converted to the type")
+
+    def _get_vwap_date_conversion(self, date_str):
+        """
+        将日期字符串转换成对应格式的日期数据
+        :param date_str: 日期字符串
+        :return: 转换后的日期数据
+        """
+
+        if isinstance(date_str, str):
+            if self.general_validate_date_str_is_datetime_type(date_str):
+                return self.general_date_str_to_datetime(date_str)
+            if self.general_validate_date_str_is_date_type(date_str):
+                return self.general_date_str_to_date(date_str).date()
+
+        return date_str
+
+    def get_vwap_filter_by_date(self, start_date, end_date):
+        """
+        校验start_date和end_date参数类型是否为str格式的字符串
+        :param start_date: str, 开始日期
+        :param end_date: str, 结束日期
+        :return: None
+        """
+
+        start_date = self._get_vwap_date_conversion(start_date)
+        end_date = self._get_vwap_date_conversion(end_date)
+
+        self.get_vwap_data = self.get_vwap_data[
+            (self.get_vwap_data['datetime'] >= start_date) & (self.get_vwap_data['datetime'] <= end_date)]
+
+    def get_vwap_validate_frequency(self, frequency):
+        """
+        校验frequency参数类型是否为str格式的字符串
+        :param frequency: str, 历史数据的频率
+        :return: None
+        """
+
+        self.general_validate_param_is_str("frequency", frequency)
+
+    def get_vwap_get_data_by_frequency(self, order_book_ids, frequency, start_date, end_date):
+        """
+        根据频率获取数据
+
+        :param order_book_ids: str, 合约代码
+        :param frequency: str, 历史数据的频率
+        :param start_date: str, 开始日期
+        :param end_date: str, 结束日期
+        :return: None
+        """
+
+        frequency_date_format_dict = {
+            "1m": "%Y-%m-%d %H:%M:%S",
+            "1d": "%Y-%m-%d"
+        }
+        result = rq.get_price(order_book_ids, start_date=start_date, end_date=end_date, frequency=frequency)
+
+        # result["vwap_value"] = result["total_turnover"] / result["volume"]
+        result = self.get_vwap_compute_value(result)
+
+        # 根据频率设置返回值的日期格式，1m为"%Y-%m-%d %H:%M:%S", 1d为"%Y-%m-%d"
+        result["datetime"] = pd.to_datetime(result["datetime"], format=frequency_date_format_dict[frequency])
+        self.get_vwap_data = result
+
+    @staticmethod
+    def get_vwap_compute_value(df):
+        """
+        此方法用于按照规则计算vwap_value的值
+        合成规则：
+        合成vwap数据来源：米筐分钟k数据/米筐日k数据（需要根据下述逻辑合成）
+        vwap=成交额/成交量
+        举例：2024-05-20 09:31:00的vwap行情为2024-05-20【 09:30:00， 09:31:00)bar数据中的成交额/成交量。
+        """
+
+        df["before_datetime"] = df['datetime'] - datetime.timedelta(minutes=1)
+
+        # 使用 apply 函数计算每行的 vwap_value 列
+        df['vwap_value'] = df.apply(
+            lambda row: df[(df['datetime'] >= row['before_datetime']) & (df['datetime'] <= row['datetime'])][
+                            'total_turnover'].sum() /
+                        df[(df['datetime'] >= row['before_datetime']) & (df['datetime'] <= row['datetime'])][
+                            'volume'].sum(),
+            axis=1)
+
+        return df
+
+    """ get_twap 获取twap时间加权价格 """
+
+    def get_twap(self, order_book_ids=None, start_date=None, end_date=None, frequency='1d'):
+        """
+        获取twap成交量加权价格指标
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :param frequency: str--必填, 历史数据的频率
+        :return: vwap成交量加权价格指标
+        """
+
+        """ 校验必填参数 """
+        # 校验oder_book_ids, start_date, end_date, frequency 是否为必填参数
+        self.get_twap_validate_required_params(order_book_ids, start_date, end_date, frequency)
+
+        # 校验order_book_ids是否为str OR str list
+        self.get_twap_validate_order_book_ids(order_book_ids)
+
+        # 校验start_date, end_date是否为datetime 或 对应格式的字符串
+        self.get_twap_validate_date_type(start_date, end_date)
+
+        # 校验frequency是否为str
+        self.get_twap_validate_frequency(frequency)
+
+        """ 筛选数据 """
+        # 根据start_date, end_date筛选数据
+        self.get_twap_filter_by_date(start_date, end_date)
+
+        # 根据order_book_ids, frequency, start_date, end_date筛选数据
+        self.get_twap_get_data_by_frequency(order_book_ids, frequency, start_date, end_date)
+
+        return self.get_twap_data
+
+    def get_twap_validate_required_params(self, order_book_ids, start_date, end_date, frequency):
+        """
+        校验必填参数
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :param frequency: str--必填, 历史数据的频率
+        :return: None
+        """
+
+        params_dict = {
+            "order_book_ids": order_book_ids,
+            "start_date": start_date,
+            "end_date": end_date,
+            "frequency": frequency
+        }
+
+        for key, value in params_dict.items():
+            self.general_validate_params_required(value, key)
+
+    def get_twap_validate_order_book_ids(self, order_book_ids):
+        """
+        校验order_book_ids参数类型是否为str OR str list
+        :param order_book_ids: str OR str list--必填, 合约代码
+        :return: None
+        """
+
+        self.general_validate_field_str_or_list(order_book_ids, "order_book_ids")
+
+    def get_twap_validate_date_type(self, start_date, end_date):
+        """
+        校验start_date和end_date参数类型是否为datetime
+        :param start_date: datetime--必填,  开始日期
+        :param end_date: datetime--必填, 结束日期
+        :return: None
+        """
+
+        self._get_twap_validate_date_type(start_date, "start_date")
+        self._get_twap_validate_date_type(end_date, "end_date")
+
+    def _get_twap_validate_date_type(self, date_str, date_str_name):
+        """
+        校验date_str参数类型是否为datetime格式的字符串
+        :param date_str: str, 日期
+        :return: None
+        """
+
+        if isinstance(date_str, str) and not self.general_validate_date_str_is_datetime_type(date_str):
+            raise ValueError(f"{date_str_name} type error, datetime.datetime type or can be converted to the type")
+        if not isinstance(date_str, str) and not isinstance(date_str, datetime.datetime):
+            raise ValueError(f"{date_str_name} type error, datetime.datetime type or can be converted to the type")
+
+    def _get_twap_date_conversion(self, date_str):
+        """
+        将日期字符串转换成对应格式的日期数据
+        :param date_str: 日期字符串
+        :return: 转换后的日期数据
+        """
+
+        if isinstance(date_str, str):
+            if self.general_validate_date_str_is_datetime_type(date_str):
+                return self.general_date_str_to_datetime(date_str)
+            if self.general_validate_date_str_is_date_type(date_str):
+                return self.general_date_str_to_date(date_str).date()
+
+        return date_str
+
+    def get_twap_filter_by_date(self, start_date, end_date):
+        """
+        校验start_date和end_date参数类型是否为str格式的字符串
+        :param start_date: str, 开始日期
+        :param end_date: str, 结束日期
+        :return: None
+        """
+
+        start_date = self._get_twap_date_conversion(start_date)
+        end_date = self._get_twap_date_conversion(end_date)
+
+        self.get_twap_data = self.get_twap_data[
+            (self.get_twap_data['datetime'] >= start_date) & (self.get_twap_data['datetime'] <= end_date)]
+
+    def get_twap_validate_frequency(self, frequency):
+        """
+        校验frequency参数类型是否为str格式的字符串
+        :param frequency: str, 历史数据的频率
+        :return: None
+        """
+
+        self.general_validate_param_is_str("frequency", frequency)
+
+    def get_twap_get_data_by_frequency(self, order_book_ids, frequency, start_date, end_date):
+        """
+        根据频率获取数据
+
+        :param order_book_ids: str, 合约代码
+        :param frequency: str, 历史数据的频率
+        :param start_date: str, 开始日期
+        :param end_date: str, 结束日期
+        :return: None
+        """
+
+        frequency_date_format_dict = {
+            "1m": "%Y-%m-%d %H:%M:%S",
+            "1d": "%Y-%m-%d"
+        }
+        result = rq.get_price(order_book_ids, start_date=start_date, end_date=end_date, frequency=frequency)
+
+        result = self.get_twap_compute_value(result)
+
+        # 根据频率设置返回值的日期格式，1m为"%Y-%m-%d %H:%M:%S", 1d为"%Y-%m-%d"
+        result["datetime"] = pd.to_datetime(result["datetime"], format=frequency_date_format_dict[frequency])
+        self.get_twap_data = result
+
+    @staticmethod
+    def get_twap_compute_value(df):
+        """
+        此方法用于按照规则计算twap_value的值
+        twap计算数据来源：米筐原始历史tick数据（需要根据下述逻辑合成）
+        举例；2024-05-20 09:31:00的twap行情为2024-05-20【 09:30:00， 09:31:00)时间段内所有tick数据的最新价相加之和/tick数据的个数。
+        """
+
+        df["before_datetime"] = df['datetime'] - datetime.timedelta(minutes=1)
+
+        # 使用 apply 函数计算每行的 twap_value 列
+        df['twap_value'] = df.apply(
+            lambda row: df[(df['datetime'] >= row['before_datetime']) & (df['datetime'] <= row['datetime'])][
+                'last'].mean(),
+            axis=1)
+
+        return df

{gjdatac_api-0.0.5 → gjdatac_api-0.0.6}/gjdatac_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: gjdatac-api
-Version: 0.0.5
+Version: 0.0.6
 Summary: 主动管理项目第一版(部分接口)
 Home-page: UNKNOWN
 Author: yin

{gjdatac_api-0.0.5 → gjdatac_api-0.0.6}/setup.py

@@ -5,7 +5,7 @@ with open('description_info.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='gjdatac_api',  # 你的包名
-    version='0.0.5',  # 版本号
+    version='0.0.6',  # 版本号
     description='主动管理项目第一版(部分接口)',  # 包的简要描述
     long_description=long_description,  # 包的详细描述
     long_description_content_type='text/markdown',  # 描述文件的类型