gjdatac-api 0.3.9__tar.gz → 0.4.0__tar.gz

{gjdatac_api-0.3.9 → gjdatac_api-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gjdatac_api
-Version: 0.3.9
+Version: 0.4.0
 Summary: 数据接口打包
 Author: fml
 Author-email: 13306510996@163.com

{gjdatac_api-0.3.9 → gjdatac_api-0.4.0}/gjdatac_api/__init__.py

@@ -1,3 +1,4 @@
 from .data_api_class import GJDataC
 
 __all__ = ['GJDataC']
+

{gjdatac_api-0.3.9 → gjdatac_api-0.4.0}/gjdatac_api/data_api_class.py

@@ -1078,7 +1078,7 @@ class GJDataC:
                                                        option_contract_db_table_name,
                                                        option_contract_db_path)
             data["type"] = "option"
-            data["exercise_type"] = data["option_type"]
+            data["exercise_type"] = data["option_type"] if "option_type" in data.columns else ""
         else:
             raise Exception("asset_type is not valid")
         data["commodity"] = ""
@@ -1132,8 +1132,11 @@ class GJDataC:
         try:
             unique_ids = data['order_book_id'].unique().tolist()
 
+            if len(unique_ids) == 0:
+                return data
+
             # 根据合约类型选择基础信息表
-            if 'type' in data.columns and data['type'].iloc[0] == 'option':
+            if 'type' in data.columns and len(data) > 0 and data['type'].iloc[0] == 'option':
                 table_name = option_contract_db_table_name
             else:
                 table_name = future_contract_db_table_name
@@ -1393,7 +1396,11 @@ class GJDataC:
 
         """
 
-        # 获取开始日期和结束日期
+        # 获取开始日期和结束日期（先确保是字符串格式）
+        if not isinstance(start_date, str):
+            start_date = str(int(start_date)) if not pd.isna(start_date) else ""
+        if not isinstance(end_date, str):
+            end_date = str(int(end_date)) if not pd.isna(end_date) else ""
         start_date = datetime.datetime.strptime(start_date, "%Y%m%d").date()
         end_date = datetime.datetime.strptime(end_date, "%Y%m%d").date()
 
@@ -1417,32 +1424,25 @@ class GJDataC:
 
         cn_holidays = holidays.CN()  # 创建中国节假日对象
 
+        # 提取当前日期的匹配行，避免重复筛选
+        matched_row = trading_params_data.loc[trading_params_data["trading_day_str"] == _date]
+        if matched_row.empty:
+            raise ValueError(f"Date {_date} not found in trading_params_data")
+
         time_period_mapping_dict = {
             "0": _date in cn_holidays,
-            "1": trading_params_data.loc[trading_params_data["trading_day_str"] == _date]["next_trading_day"].iloc[0],
-            "2": trading_params_data.loc[trading_params_data["trading_day_str"] == _date]["pre_trading_day"].iloc[0],
+            "1": matched_row["next_trading_day"].iloc[0],
+            "2": matched_row["pre_trading_day"].iloc[0],
             "3": self.get_date_get_week_month_year(trading_params_data,
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "first_trading_day_week"].iloc[0],
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "last_trading_day_week"].iloc[0]),
+                                                   matched_row["first_trading_day_week"].iloc[0],
+                                                   matched_row["last_trading_day_week"].iloc[0]),
             "4": self.get_date_get_week_month_year(trading_params_data,
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "first_trading_day_month"].iloc[0],
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "last_trading_day_month"].iloc[0]),
+                                                   matched_row["first_trading_day_month"].iloc[0],
+                                                   matched_row["last_trading_day_month"].iloc[0]),
             "5": self.get_date_get_week_month_year(trading_params_data,
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "first_trading_day_year"].iloc[0],
-                                                   trading_params_data.loc[
-                                                       trading_params_data["trading_day_str"] == _date][
-                                                       "last_trading_day_year"].iloc[0]),
-            "6": trading_params_data.loc[trading_params_data["trading_day_str"] == _date]["night_day"].iloc[0],
+                                                   matched_row["first_trading_day_year"].iloc[0],
+                                                   matched_row["last_trading_day_year"].iloc[0]),
+            "6": matched_row["night_day"].iloc[0],
         }
 
         if _n not in time_period_mapping_dict:
@@ -1889,24 +1889,116 @@ class GJDataC:
 
         return new_df
 
-    """ get_active_contract 主力/次主力合约 """
+    """ get_main_price 主力/次主力合约 """
 
-    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):
+    def get_main(self, commodity=None, start_date=None, end_date=None,
+                 compute_type=None, source=None, fields=None):
         """
-        获取主力/次主力合约信息接口
-        :param commodity: str or str list--必填，品种
-        :param start_date: date--必填，默认当天
-        :param end_date: date--必填，默认当天
-        :param frequency: str--必填
-        :param compute_type: str--必填，active指主力；next_active次主力
+        获取主力合约(qc_gtja_future_maincontract)
+        :param commodity: str or str list--必填，品种代码，如 'CU'
+        :param start_date: date--选填，开始时间
+        :param end_date: date--选填，结束时间
+        :param compute_type: str--必填，'main'=主力 / 'sub_main'=次主力
+        :param source: str--选填，返回source字段里的值，默认 gtja
+        :param fields: str or str list--选填，返回字段筛选，默认全部
+
+        :return: DataFrame with columns: trading_day, exchange_id, commodity, order_book_id, compute_type, source, fields(float)
+        """
+        """ 校验参数 """
+        self.general_validate_params_required(commodity, "commodity")
+        self.general_validate_params_required(compute_type, "compute_type")
+        self.general_validate_field_str_or_list(commodity, "commodity")
+
+        if start_date and end_date:
+            if not self.validate_dates(start_date, end_date):
+                return None
+        elif not start_date and not end_date:
+            start_date = datetime.date.today()
+            end_date = datetime.date.today()
+
+        # 校验 compute_type 值
+        valid_compute_types = {"main": "MAIN", "sub_main": "SUB_MAIN"}
+        if compute_type not in valid_compute_types:
+            raise ValueError(f"compute_type must be one of {list(valid_compute_types.keys())}, got '{compute_type}'")
+        rank_value = valid_compute_types[compute_type]
+
+        # 默认 source
+        source = source or "gtja"
+
+        """ 查询主表 qc_gtja_future_maincontract """
+        table_name, db_path = main_contract_db_table_name, main_contract_db_path
+        data, db_session = self.connect_db(table_name, db_path)
+
+        # 按品种筛选 (unify_product_id)
+        code_data = data.where(f"unify_product_id in {commodity}") if isinstance(commodity, list) else \
+            data.where(f"unify_product_id = '{commodity}'")
+
+        # 按日期筛选
+        start_dolphin_date = self.format_date(start_date)
+        end_dolphin_date = self.format_date(end_date)
+        date_data = code_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
+
+        # 按 compute_type 筛选
+        result_data = date_data.where(f"compute_type = '{rank_value}'")
+
+        result = result_data.toDF()
+        db_session.close()
+
+        """ 筛选字段并重命名（按截图出参）"""
+        # 截图出参字段：trading_day, exchange_id, commodity(=unify_product_id),
+        #   order_book_id(=instrument_id), compute_type, source, fields(=open/收盘等数值列)
+        rename_map = {
+            "unify_product_id": "commodity",
+            "instrument_id": "order_book_id",
+        }
+
+        # 确定返回列：固定字段 + 数值(fields)列
+        fixed_cols = ["trading_day", "exchange_id", "unify_product_id", "instrument_id", "compute_type", "source"]
+        numeric_cols = ["open", "high", "low", "close", "volume", "amount", "oi",
+                        "post_adj_factor_of_prev_close_spread", "post_adj_factor_of_open_spread",
+                        "post_adj_factor_of_prev_close_ratio", "post_adj_factor_of_open_ratio_ratio"]
+
+        available_numeric = [c for c in numeric_cols if c in result.columns]
+        all_return_cols = [c for c in fixed_cols if c in result.columns] + available_numeric
+
+        if fields:
+            # 用户指定字段：处理别名映射
+            field_list = [fields] if isinstance(fields, str) else list(fields)
+            resolved_fields = []
+            for f in field_list:
+                if f in rename_map.values():
+                    # 反向查找原始列名
+                    orig = [k for k, v in rename_map.items() if v == f][0]
+                    resolved_fields.append(orig)
+                else:
+                    resolved_fields.append(f)
+            result = result[resolved_fields]
+        else:
+            result = result[all_return_cols]
+
+        # 重命名
+        for orig, new in rename_map.items():
+            if orig in result.columns:
+                result.rename(columns={orig: new}, inplace=True)
+
+        return result
+
+    def get_main_price(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 commodity: str or str list--必填，品种代码
+        :param start_date: date--必填，开始日期，默认当天
+        :param end_date: date--必填，结束日期，默认当天
+        :param frequency: str--必填，频率，支持 1d / 1min / tick_l1 / tick_l2
+        :param compute_type: str--必填，主力类型：main - 主力，sub_main - 次主力
         :param fields: str or str list--选填，返回字段，默认全部
-        :param adjust_type: str--选填，复权方式：不复权 - none，后复权 - post
+        :param adjust_type: str--选填，复权方式：none - 不复权，post - 后复权
         :param adjust_method: str--选填，复权方法
-        :param source: str--选填，数据源，默认研究所, 3个来源可选：1-数据中台, 2-米筐, 3-研究所(表中无研究所的source)
+        :param source: str--选填，数据源（暂未使用）
 
-        :return: 主力/次主力合约
+        :return: 主力/次主力合约行情数据（DataFrame）
         """
 
         """ 校验参数 """
@@ -1914,38 +2006,34 @@ class GJDataC:
             if not self.validate_dates(start_date, end_date):
                 return None
 
-        self.get_active_contract_validate_params(commodity, start_date, end_date, frequency, compute_type, adjust_type,
-                                                 adjust_method)
+        self.get_main_price_validate_params(commodity, start_date, end_date, frequency, compute_type, adjust_type,
+                                            adjust_method)
 
         """ 获取、筛选数据 """
         if frequency in ['1min', '1d', '1min_gtja']:
-            data, db_session = self.get_active_contract_get_data(commodity, start_date, end_date, frequency,
+            data, db_session = self.get_main_price_get_data(commodity, start_date, end_date, frequency,
+                                                            compute_type,
+                                                            source)
+        else:
+            data, db_session = self.get_main_price_get_data_tick(commodity, start_date, end_date, frequency,
                                                                  compute_type,
                                                                  source)
-        elif frequency == 'main_contract':
-            data, db_session = self.get_active_contract_get_data_tick(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)
+            data = self.get_main_price_tick_data(data, frequency, start_date, end_date)
         db_session.close()
 
         """ 处理字段名 """
-        data = self.get_active_contract_rename(data, adjust_method, frequency)
+        data = self.get_main_price_rename(data, adjust_method, frequency)
 
         """ 根据是否复权计算价格数据 """
-        data = self.get_active_contract_adjust_price(data, adjust_type, adjust_method, frequency)
+        data = self.get_main_price_adjust_price(data, adjust_type, adjust_method, frequency)
 
         """ 处理返回字段 """
-        data = self.get_active_contract_process_return_fields(data, fields)
+        data = self.get_main_price_process_return_fields(data, fields)
 
         return data
 
-    def get_active_contract_validate_params(self, code, start_date, end_date, frequency, asset_type, adjust_type,
-                                            adjust_method):
+    def get_main_price_validate_params(self, code, start_date, end_date, frequency, asset_type, adjust_type,
+                                       adjust_method):
         """
         校验参数
         Args:
@@ -1961,19 +2049,21 @@ class GJDataC:
         """
 
         # 校验必填参数
-        self.get_active_contract_validate_required_params(code, start_date, end_date, frequency, asset_type)
+        self.get_main_price_validate_required_params(code, start_date, end_date, frequency, asset_type)
 
         # 校验日期参数类型
-        self.get_active_contract_validate_date_type(start_date, end_date)
+        self.get_main_price_validate_date_type(start_date, end_date)
 
         # 校验code类型
-        self.get_active_contract_validate_code(code)
+        self.get_main_price_validate_code(code)
 
-        # 校验 adjust_type, adjust_method
-        self.general_validate_param_is_str("adjust_type", adjust_type)
-        self.general_validate_param_is_str("adjust_method", adjust_method)
+        # 校验 adjust_type, adjust_method（仅当非 None 时校验）
+        if adjust_type is not None:
+            self.general_validate_param_is_str("adjust_type", adjust_type)
+        if adjust_method is not None:
+            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):
+    def get_main_price_validate_required_params(self, code, start_date, end_date, frequency, asset_type):
         """
         校验参数是否必填
         :param code: str or str list--必填，品种
@@ -1994,7 +2084,7 @@ class GJDataC:
         for key, value in params_dict.items():
             self.general_validate_params_required(value, key)  # 校验必填参数
 
-    def get_active_contract_validate_code(self, code):
+    def get_main_price_validate_code(self, code):
         """
         校验code 类型
         :param code: str or str list--必填，品种
@@ -2003,7 +2093,7 @@ class GJDataC:
         self.general_validate_field_str_or_list(code, "code")
 
     @staticmethod
-    def get_active_contract_get_table(frequency):
+    def get_main_price_get_table(frequency):
         """
         获取表信息
         :param frequency: 频率
@@ -2017,7 +2107,7 @@ class GJDataC:
         }.get(frequency, (None, None))
 
     @staticmethod
-    def get_active_contract_get_table_tick(frequency):
+    def get_main_price_get_table_tick(frequency):
         """
         获取表信息
         :param frequency: 频率
@@ -2029,7 +2119,7 @@ class GJDataC:
             '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):
+    def get_main_price_get_data(self, code, start_date, end_date, frequency, compute_type, source):
         """
         获取数据
         :param code: str or str list--必填，品种
@@ -2043,7 +2133,7 @@ class GJDataC:
         """
 
         # 根据频率获取对应的表
-        table_name, db_path = self.get_active_contract_get_table(frequency)
+        table_name, db_path = self.get_main_price_get_table(frequency)
 
         # 先从数据库获取数据
         data, db_session = self.connect_db(table_name, db_path)
@@ -2054,8 +2144,8 @@ class GJDataC:
 
         # 根据日期筛选数据
         # 将日期转换成 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)
+        # start_dolphin_date = self.get_main_price_datetime_to_dolphin_time(start_date)
+        # end_dolphin_date = self.get_main_price_datetime_to_dolphin_time(end_date)
 
         start_dolphin_date = self.format_date(start_date)
         end_dolphin_date = self.format_date(end_date)
@@ -2063,16 +2153,16 @@ class GJDataC:
         date_data = code_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
 
         if compute_type:
-            # 根据表中的 rank 字段筛选主力/次主力合约，rank == 1是主力合约， 2 是次主力合约
+            # 根据 compute_type 字段筛选主力/次主力合约，MAIN 是主力合约，SUB_MAIN 是次主力合约
             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):
+    def get_main_price_get_data_tick(self, code, start_date, end_date, frequency, compute_type, source):
         """
-        获取tick数据
+        从 qc_gtja_future_maincontract 获取主力合约列表（用于后续联查tick表）
         :param code: str or str list--必填，品种
         :param start_date: str--必填，开始日期
         :param end_date: str--必填，结束日期
@@ -2080,7 +2170,7 @@ class GJDataC:
         :param frequency: str--必填
         :param source: str--选填，数据来源
 
-        :return: 主力/次主力合约数据
+        :return: 主力/次主力合约列表
         """
 
         table_name, db_path = main_contract_db_table_name, main_contract_db_path
@@ -2093,15 +2183,11 @@ class GJDataC:
             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)
         start_dolphin_date = self.format_date(start_date)
         end_dolphin_date = self.format_date(end_date)
 
         date_data = code_data.where(f"trading_day >= {start_dolphin_date} and trading_day <= {end_dolphin_date}")
 
-        # 根据表中的 rank 字段筛选主力/次主力合约，rank == 1是主力合约， 2 是次主力合约
         if compute_type:
             rank = 'MAIN' if compute_type == "main" else 'SUB_MAIN'
             rank_data = date_data.where(f"compute_type = '{rank}'")
@@ -2109,7 +2195,7 @@ class GJDataC:
 
         return date_data.toDF(), db_session
 
-    def get_active_contract_tick_data(self, data, frequency, start_date, end_date):
+    def get_main_price_tick_data(self, data, frequency, start_date, end_date):
         """
         根据主力合约表查询tick表
         :param data: 数据
@@ -2119,7 +2205,7 @@ class GJDataC:
         :return: 查询后的数据
         """
 
-        table_name, db_path = self.get_active_contract_get_table_tick(frequency)
+        table_name, db_path = self.get_main_price_get_table_tick(frequency)
         # 先从数据库获取数据
         tick_data, db_session = self.connect_db(table_name, db_path)
 
@@ -2136,7 +2222,7 @@ class GJDataC:
         return fina_data
 
     @staticmethod
-    def get_active_contract_datetime_to_dolphin_time(datetime_str):
+    def get_main_price_datetime_to_dolphin_time(datetime_str):
         """将日期字符串格式化为 'YYYY.MM.DD HH:mm:ss' 格式。
                 : params datetime_str: 日期字符串，例如 '2018-01-04 09:01:00'。
                 : return ：
@@ -2153,7 +2239,7 @@ class GJDataC:
         else:
             return datetime_str.strftime('%Y.%m.%d %H:%M:%S')
 
-    def get_active_contract_validate_date_type(self, start_date, end_date):
+    def get_main_price_validate_date_type(self, start_date, end_date):
         """
         校验日期数据的类型
         :param start_date: date--必填，默认当天
@@ -2180,7 +2266,7 @@ class GJDataC:
         #     raise ValueError("begin_date type error， please enter datetime.datetime type")
 
     @staticmethod
-    def get_active_contract_rename(data, ex_factor, frequency):
+    def get_main_price_rename(data, ex_factor, frequency):
         """
         处理返回结果
         :param data: 数据
@@ -2190,9 +2276,7 @@ class GJDataC:
         """
         new_df = data.copy()
 
-        if frequency == 'main_contract':
-            return new_df
-        elif frequency in ['1min', '1d']:
+        if frequency in ['1min', '1d']:
             return_fields = main_contract_return_fields
             return_fields_rename = main_contract_return_fields_rename
         elif frequency in ['1min_gtja']:
@@ -2220,7 +2304,7 @@ class GJDataC:
         return new_df
 
     @staticmethod
-    def get_active_contract_adjust_price(data, adjust_type, adjust_method, frequency):
+    def get_main_price_adjust_price(data, adjust_type, adjust_method, frequency):
         """
         根据参数计算是否复权
         :param data: 数据
@@ -2230,7 +2314,7 @@ class GJDataC:
         :return: 计算后的数据
         """
 
-        if not adjust_type or frequency in ['tick_l1', 'tick_l2', '1min_gtja', 'main_contract']:
+        if not adjust_type or frequency in ['tick_l1', 'tick_l2', '1min_gtja']:
             return data
 
         adjust_fields = ['open', 'close', 'high', 'low', 'limit_up', 'limit_down', 'settlement', 'prev_settlement',
@@ -2246,7 +2330,7 @@ class GJDataC:
         return data
 
     @staticmethod
-    def get_active_contract_process_return_fields(data, fields):
+    def get_main_price_process_return_fields(data, fields):
         """
         处理返回字段
         :param data: 主力/次主力合约数据
@@ -2262,52 +2346,6 @@ class GJDataC:
         else:
             return data[fields]
 
-    def get_active_contract_process_result(self, data, fields):
-        """
-        处理返回字段
-        :param data: 主力/次主力合约数据
-        :param fields: str or str list--选填，返回字段，默认全部
-        :return: 筛选后的主力/次主力合约数据
-        """
-
-        new_df = data.copy()
-
-        # 整合需求文档中所需的字段
-        # 价格相关字段通过 "dfs://dayk"."qc_future_dayk" 获取，通过unique_instrument_id 关联查找
-        # 前收盘价(qc_future_dayk也无)
-        future_day_data, future_session = self.connect_db(history_option_day_db_table_name,
-                                                          history_option_day_db_path)
-
-        # 获取筛选后的主力/次主力合约数据的交易时间和合约代码，用于去qc_future_dayk表中查询其他的缺失字段
-        unique_instrument_id_list = new_df["unique_instrument_id"].tolist()
-        future_filter_df = future_day_data.where(f"unique_instrument_id in {unique_instrument_id_list}").toDF()
-        future_session.close()
-
-        future_filter_df_unique = future_filter_df.drop_duplicates(
-            subset=['trading_day', 'unique_instrument_id'],
-            keep='first'  # 或者 'last'，取决于你要保留哪一个
-        )
-
-        merged_df = new_df.merge(
-            future_filter_df_unique[['trading_day', 'unique_instrument_id',
-                                     'pre_settlement_price', 'open_price',
-                                     'highest_price', 'lowest_price', 'close_price',
-                                     'settlement_price', 'volume', 'turnover', 'open_interest']],
-            on=['trading_day', 'unique_instrument_id'],
-            how='left'  # 使用 left join 保留 new_df 的所有行
-        )
-
-        # 统一字段（将数据表中的字段重命名成需求文档要求的字段）
-        merged_df.rename(columns={'instrument_id': 'order_book_id', 'product_id': 'code',
-                                  'exchange_id': 'exchange', 'trading_day': 'date'}, inplace=True)
-        merged_df["active_type"] = merged_df["rank"].map({1: "active", 2: "next_active"})
-
-        if fields:
-            # 根据fields返回用户需要的字段
-            merged_df = merged_df[fields] if isinstance(fields, str) else merged_df[[field for field in fields]]
-
-        return merged_df
-
     """ get_basic_data 库存/基差/现货价格-数据（日频） """
 
     def get_basic_data(self, order_book_id, asset_type, start_date, end_date):

{gjdatac_api-0.3.9 → gjdatac_api-0.4.0}/gjdatac_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gjdatac_api
-Version: 0.3.9
+Version: 0.4.0
 Summary: 数据接口打包
 Author: fml
 Author-email: 13306510996@163.com

{gjdatac_api-0.3.9 → gjdatac_api-0.4.0}/setup.py

@@ -5,12 +5,12 @@ with open('description_info.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='gjdatac_api',  # 你的包名
-    version='0.3.9',  # 版本号
+    version='0.4.0',  # 版本号
     description='数据接口打包',  # 包的简要描述
     long_description=long_description,  # 包的详细描述
     long_description_content_type='text/markdown',  # 描述文件的类型
     include_package_data=True,  # 包含包数据
-    package_data={'gjdatac_api': ['*.py', 'dict_data.py', 'dolphindb_info.py', 'instrument_class.py','data_api_class.py']},  # 指定数据文件
+    package_data={'gjdatac_api': ['*.py', 'dict_data.py', 'dolphindb_info.py', 'instrument_class.py']},  # 指定数据文件
     author='fml',  # 作者姓名
     author_email='13306510996@163.com',  # 作者邮箱
     packages=find_packages(),  # 自动查找包目录