gjdatac-api 0.2.4__tar.gz → 0.2.6__tar.gz

{gjdatac_api-0.2.4 → gjdatac_api-0.2.6}/PKG-INFO

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

{gjdatac_api-0.2.4 → gjdatac_api-0.2.6}/gjdatac_api/data_api_class.py

@@ -295,6 +295,116 @@ class GJDataC:
             bar_db_session.close()
             return 'option'
 
+    @staticmethod
+    def format_date(input_date):
+        """
+        将输入的日期转换为指定格式的字符串。
+
+        参数:
+            input_date: 输入的日期，可以是 datetime、date 或 str 类型。
+                       支持的字符串格式包括：
+                       - "YYYY-MM-DD HH:MM:SS"
+                       - "YYYY-MM-DD"
+                       - "YYYY.MM.DD HH:MM:SS"
+                       - "YYYY.MM.DD"
+
+        返回:
+            str: 转换后的日期字符串，格式为 "YYYY.MM.DD HH:MM:SS" 或 "YYYY.MM.DD"。
+        """
+        # 如果输入是 datetime 类型
+        if isinstance(input_date, datetime.datetime):
+            if input_date.hour == 0 and input_date.minute == 0 and input_date.second == 0:
+                return input_date.strftime("%Y.%m.%d")
+            else:
+                return input_date.strftime("%Y.%m.%d %H:%M:%S")
+
+        # 如果输入是 date 类型
+        elif isinstance(input_date, datetime.date):
+            return input_date.strftime("%Y.%m.%d")
+
+        # 如果输入是字符串类型
+        elif isinstance(input_date, str):
+            try:
+                # 尝试解析包含时间的格式
+                dt = datetime.datetime.strptime(input_date, "%Y-%m-%d %H:%M:%S")
+                return dt.strftime("%Y.%m.%d %H:%M:%S")
+            except ValueError:
+                try:
+                    # 尝试解析不包含时间的格式
+                    dt = datetime.datetime.strptime(input_date, "%Y-%m-%d")
+                    return dt.strftime("%Y.%m.%d")
+                except ValueError:
+                    try:
+                        # 尝试解析包含时间的点分隔格式
+                        dt = datetime.datetime.strptime(input_date, "%Y.%m.%d %H:%M:%S")
+                        return dt.strftime("%Y.%m.%d %H:%M:%S")
+                    except ValueError:
+                        try:
+                            # 尝试解析不包含时间的点分隔格式
+                            dt = datetime.datetime.strptime(input_date, "%Y.%m.%d")
+                            return dt.strftime("%Y.%m.%d")
+                        except ValueError:
+                            raise ValueError("输入的日期格式不支持")
+
+        # 如果输入类型不支持
+        else:
+            raise TypeError("输入类型必须是 datetime、date 或 对应格式的str")
+
+    @staticmethod
+    def format_date_split_by_(input_date):
+        """
+        将输入的日期转换为指定格式的字符串。
+
+        参数:
+            input_date: 输入的日期，可以是 datetime、date 或 str 类型。
+                       支持的字符串格式包括：
+                       - "YYYY-MM-DD HH:MM:SS"
+                       - "YYYY-MM-DD"
+                       - "YYYY.MM.DD HH:MM:SS"
+                       - "YYYY.MM.DD"
+
+        返回:
+            str: 转换后的日期字符串，格式为 "YYYY.MM.DD HH:MM:SS" 或 "YYYY.MM.DD"。
+        """
+        # 如果输入是 datetime 类型
+        if isinstance(input_date, datetime.datetime):
+            if input_date.hour == 0 and input_date.minute == 0 and input_date.second == 0:
+                return input_date.strftime("%Y-%m-%d")
+            else:
+                return input_date.strftime("%Y-%m-%d %H:%M:%S")
+
+        # 如果输入是 date 类型
+        elif isinstance(input_date, datetime.date):
+            return input_date.strftime("%Y-%m-%d")
+
+        # 如果输入是字符串类型
+        elif isinstance(input_date, str):
+            try:
+                # 尝试解析包含时间的格式
+                dt = datetime.datetime.strptime(input_date, "%Y-%m-%d %H:%M:%S")
+                return dt.strftime("%Y-%m-%d %H:%M:%S")
+            except ValueError:
+                try:
+                    # 尝试解析不包含时间的格式
+                    dt = datetime.datetime.strptime(input_date, "%Y-%m-%d")
+                    return dt.strftime("%Y-%m-%d")
+                except ValueError:
+                    try:
+                        # 尝试解析包含时间的点分隔格式
+                        dt = datetime.datetime.strptime(input_date, "%Y.%m.%d %H:%M:%S")
+                        return dt.strftime("%Y-%m-%d %H:%M:%S")
+                    except ValueError:
+                        try:
+                            # 尝试解析不包含时间的点分隔格式
+                            dt = datetime.datetime.strptime(input_date, "%Y.%m.%d")
+                            return dt.strftime("%Y-%m-%d")
+                        except ValueError:
+                            raise ValueError("输入的日期格式不支持")
+
+        # 如果输入类型不支持
+        else:
+            raise TypeError("输入类型必须是 datetime、date 或 对应格式的str")
+
     """ get_price(获取行情数据接口) """
 
     def get_price(self, order_book_ids=None, asset_type="future", frequency=None, start_date=None, end_date=None,
@@ -411,18 +521,20 @@ class GJDataC:
         if (start_date and not end_date) or (not start_date and end_date):
             raise ValueError("start_date and end_date should be both provided or not provided at all")
         if start_date and end_date:
+            self.format_date(start_date)
+            self.format_date(end_date)
             # 如果提供了，则进行进一步校验
-            is_start_datetime = self._is_convertible_datetime(start_date)
-            is_end_datetime = self._is_convertible_datetime(end_date)
-            if not is_end_datetime or not is_start_datetime:
-                raise ValueError(
-                    "start_date and end_date should be datetime.datetime objects or "
-                    "convertible to datetime.datetime objects")
-
-            # 如果传入的数据类型符合要求，进行转换
-            start_date, end_date = self._get_price_convert_start_end_date(start_date, end_date)
-            if start_date > end_date:
-                raise ValueError("start_date should be earlier than end_date")
+            # is_start_datetime = self._is_convertible_datetime(start_date)
+            # is_end_datetime = self._is_convertible_datetime(end_date)
+            # if not is_end_datetime or not is_start_datetime:
+            #     raise ValueError(
+            #         "start_date and end_date should be datetime.datetime objects or "
+            #         "convertible to datetime.datetime objects")
+            #
+            # # 如果传入的数据类型符合要求，进行转换
+            # start_date, end_date = self._get_price_convert_start_end_date(start_date, end_date)
+            # if start_date > end_date:
+            #     raise ValueError("start_date should be earlier than end_date")
 
     @staticmethod
     def _get_price_convert_start_end_date(start_date, end_date):
@@ -618,8 +730,10 @@ class GJDataC:
             limit_data = get_price_data.where(f"instrument_id in {order_book_ids}")
 
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        format_start_date = self.get_price_format_date(start_date)
-        format_end_date = self.get_price_format_date(end_date)
+        # format_start_date = self.get_price_format_date(start_date)
+        # format_end_date = self.get_price_format_date(end_date)
+        format_start_date = self.format_date(start_date)
+        format_end_date = self.format_date(end_date)
 
         # 根据日期对数据再次进行筛选，最大程度减轻数据库压力
         limit_data = limit_data.where(f"trade_time >= {format_start_date} and trade_time <= {format_end_date}")
@@ -1041,6 +1155,7 @@ class GJDataC:
             raise ValueError("date parameter error, type should be str or datetime.date")
 
         if isinstance(date, str):
+            date = self.format_date_split_by_(date)
             date = datetime.datetime.strptime(date, "%Y-%m-%d").date()
 
         return self.get_dates_in_n(date, n)
@@ -1069,6 +1184,8 @@ class GJDataC:
                 start_date = self._get_trading_dates_by_start_end(start_date)
             if isinstance(end_date, str):
                 end_date = self._get_trading_dates_by_start_end(end_date)
+
+
             # 筛选 trading_day_str 列在 start_date 和 end_date 之间的数据
             # filtered_df = trading_params_data.loc[
             #     (trading_params_data['trading_day_str'] >= start_date) & (
@@ -1304,7 +1421,8 @@ class GJDataC:
 
         # 根据 date 筛选数据
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        dolphin_date = self.get_margin_ratio_date_to_dolphin_time(date)
+        # dolphin_date = self.get_margin_ratio_date_to_dolphin_time(date)
+        dolphin_date = self.format_date(date)
         date_data = data.where(f"trading_day = {dolphin_date}")
 
         # 根据 exchange 筛选数据
@@ -1369,11 +1487,13 @@ class GJDataC:
         :return: None
         """
 
-        if isinstance(date, (str, datetime.date, datetime.datetime)):
-            if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date is not a valid date string format")
-        else:
-            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
+        self.format_date(date)
+
+        # if isinstance(date, (str, datetime.date, datetime.datetime)):
+        #     if isinstance(date, str) and not self.general_validate_date(date):
+        #         raise ValueError("date is not a valid date string format")
+        # else:
+        #     raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     """ get_fee 期货交割手续费 """
 
@@ -1470,7 +1590,8 @@ class GJDataC:
 
         # 根据 date 筛选数据
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        dolphin_date = self.get_fee_datetime_to_dolphin_time(date)
+        # dolphin_date = self.get_fee_datetime_to_dolphin_time(date)
+        dolphin_date = self.format_date(date)
 
         date_data = get_fee_data.where(f"trading_day = {dolphin_date}")
 
@@ -1502,12 +1623,14 @@ class GJDataC:
         # 校验参数是否必填
         self.general_validate_params_required(date, "date")
 
-        # 校验参数类型格式
-        if isinstance(date, (str, datetime.date, datetime.datetime)):
-            if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date is not a valid date string format")
-        else:
-            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
+        self.format_date(date)
+
+        # # 校验参数类型格式
+        # if isinstance(date, (str, datetime.date, datetime.datetime)):
+        #     if isinstance(date, str) and not self.general_validate_date(date):
+        #         raise ValueError("date is not a valid date string format")
+        # else:
+        #     raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     @staticmethod
     def get_fee_handle_data(data):
@@ -1590,7 +1713,8 @@ class GJDataC:
 
         # 根据 date 筛选数据
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        dolphin_date = self.get_limit_position_date_to_dolphin_time(date)
+        # dolphin_date = self.get_limit_position_date_to_dolphin_time(date)
+        dolphin_date = self.format_date(date)
         date_data = data.where(f"trading_day = {dolphin_date}")
 
         # 根据 order_book_id 和 commodity 获取数据
@@ -1627,11 +1751,13 @@ class GJDataC:
         :return: None
         """
 
-        if isinstance(date, (str, datetime.date, datetime.datetime)):
-            if isinstance(date, str) and not self.general_validate_date(date):
-                raise ValueError("date is not a valid date string format")
-        else:
-            raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
+        self.format_date(date)
+
+        # if isinstance(date, (str, datetime.date, datetime.datetime)):
+        #     if isinstance(date, str) and not self.general_validate_date(date):
+        #         raise ValueError("date is not a valid date string format")
+        # else:
+        #     raise ValueError("date type error, please pass in str, datetime.date or datetime.datetime type")
 
     @staticmethod
     def get_limit_position_handle_data(data):
@@ -1808,8 +1934,12 @@ 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_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}")
 
         if compute_type:
@@ -1844,8 +1974,11 @@ 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_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 是次主力合约
@@ -1875,8 +2008,10 @@ 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_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 = 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()}")
@@ -1912,13 +2047,18 @@ class GJDataC:
         :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 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("start_date type error， please enter datetime.date type")
-        else:
-            raise ValueError("start_date or end_date type error, please enter datetime.date type")
+        # 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 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("start_date type error， please enter datetime.date type")
+        # else:
+        #     raise ValueError("start_date or end_date type error, please enter datetime.date type")
+
+
+
+        self.format_date(start_date)
+        self.format_date(end_date)
 
         # 校验begin_date 是否为datetime.datetime类型或者为可以转换为该类型的字符串
         # if isinstance(begin_date, (str, datetime.datetime)):
@@ -2135,17 +2275,21 @@ class GJDataC:
         :param end_date: 结束日期
         :return: None
         """
-        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, (
-                str, datetime.date, datetime.datetime, pd.Timestamp)):
-            if isinstance(start_date, str) and not self.general_validate_date(start_date):
-                raise ValueError(error_msg)
-            if isinstance(end_date, str) and not self.general_validate_date(end_date):
-                raise ValueError(error_msg)
-        else:
-            raise ValueError(error_msg)
+        self.format_date(start_date)
+        self.format_date(end_date)
+
+        # 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, (
+        #         str, datetime.date, datetime.datetime, pd.Timestamp)):
+        #     if isinstance(start_date, str) and not self.general_validate_date(start_date):
+        #         raise ValueError(error_msg)
+        #     if isinstance(end_date, str) and not self.general_validate_date(end_date):
+        #         raise ValueError(error_msg)
+        # else:
+        #     raise ValueError(error_msg)
 
     def get_basic_data_get_data(self, order_book_id, asset_type, start_date, end_date):
         """
@@ -2176,12 +2320,15 @@ class GJDataC:
         库存表的 data_date 字段为 STRING 类型，筛选日期时，需要提供和表中格式一致的数据，才能筛选，例如：2024-12-01
         '''
         # 将日期转换为 DolphinDB 的时间格式
-        start_dolphin_date = self._get_basic_data_date_to_dolphin_time(start_date, asset_type)
-        end_dolphin_date = self._get_basic_data_date_to_dolphin_time(end_date, asset_type)
+        # start_dolphin_date = self._get_basic_data_date_to_dolphin_time(start_date, asset_type)
+        # end_dolphin_date = self._get_basic_data_date_to_dolphin_time(end_date, asset_type)
+        start_dolphin_date = self.format_date(start_date)
+        end_dolphin_date = self.format_date(end_date)
+
 
         # 此处还需要判断的原因是，因为对 dolphindb 中不同的日期数据类型查询数据的语法不同
         asset_type_data = product_data.where(
-            f"data_date>='{start_dolphin_date}' and data_date<='{end_dolphin_date}'") if asset_type == '库存' \
+            f"data_date>={start_dolphin_date} and data_date<={end_dolphin_date}") if asset_type == '库存' \
             else product_data.where(f"date>={start_dolphin_date} and date<={end_dolphin_date}")
 
         return asset_type_data.toDF(), db_session
@@ -2243,10 +2390,10 @@ class GJDataC:
                                    }, inplace=True)
         # 处理库存
         else:
-            new_df.rename(columns={'product_id': 'order_book_id', '	data_date': 'date', 'inventory_value': 'value'},
+            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', 'data_date', 'value']]
+        return new_df[['order_book_id', 'asset_type', 'date', 'value']]
 
     """ get_warehouse_stocks_future 仓单数据 """
 
@@ -2265,7 +2412,11 @@ class GJDataC:
         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_validate_type_str(commodity)
+
+        # 校验start_date, end_date
+        start_date = self.format_date_split_by_(start_date)
+        end_date = self.format_date_split_by_(end_date)
 
         """ 获取数据 """
         # 从数据库中获取数据
@@ -2296,7 +2447,7 @@ class GJDataC:
         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):
+    def get_warehouse_stocks_future_validate_type_str(self, commodity):
         """
         校验参数类型是否为str
         :param commodity: str--必填，期货合约品种
@@ -2307,8 +2458,8 @@ class GJDataC:
 
         params_dict = {
             "commodity": commodity,
-            "start_date": start_date,
-            "end_date": end_date
+            # "start_date": start_date,
+            # "end_date": end_date
         }
 
         for key, value in params_dict.items():
@@ -2354,6 +2505,8 @@ class GJDataC:
         :return: 过滤后的数据
         """
 
+
+
         start_date = self._get_warehouse_stocks_future_date_conversion(start_date)
         end_date = self._get_warehouse_stocks_future_date_conversion(end_date)
 
@@ -2495,8 +2648,10 @@ class GJDataC:
         :return: None
         """
 
-        self._get_vwap_validate_date_type(start_date, "start_date")
-        self._get_vwap_validate_date_type(end_date, "end_date")
+        # self._get_vwap_validate_date_type(start_date, "start_date")
+        # self._get_vwap_validate_date_type(end_date, "end_date")
+        self.format_date(start_date)
+        self.format_date(end_date)
 
     def _get_vwap_validate_date_type(self, date_str, date_str_name):
         """
@@ -2587,8 +2742,10 @@ class GJDataC:
             limit_data = get_vwap_data.where(f"instrument_id in {order_book_ids}")
 
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        format_start_date = self.get_vwap_format_date(start_date)
-        format_end_date = self.get_vwap_format_date(end_date)
+        # format_start_date = self.get_vwap_format_date(start_date)
+        # format_end_date = self.get_vwap_format_date(end_date)
+        format_start_date = self.format_date(start_date)
+        format_end_date = self.format_date(end_date)
 
         # 根据日期对数据再次进行筛选，最大程度减轻数据库压力
         limit_data = limit_data.where(f"trade_time >= {format_start_date} and trade_time <= {format_end_date}").where(
@@ -2736,8 +2893,11 @@ class GJDataC:
         :return: None
         """
 
-        self._get_twap_validate_date_type(start_date, "start_date")
-        self._get_twap_validate_date_type(end_date, "end_date")
+        self.format_date(start_date)
+        self.format_date(end_date)
+
+        # 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):
         """
@@ -2801,8 +2961,11 @@ class GJDataC:
             limit_data = get_vwap_data.where(f"instrument_id in {order_book_ids}")
 
         # 将日期转换成 DolphinDB 识别的日期格式，用于筛选数据
-        format_start_date = self.get_twap_format_date(start_date)
-        format_end_date = self.get_twap_format_date(end_date)
+        # format_start_date = self.get_twap_format_date(start_date)
+        # format_end_date = self.get_twap_format_date(end_date)
+
+        format_start_date = self.format_date(start_date)
+        format_end_date = self.format_date(end_date)
 
         # 根据日期对数据再次进行筛选，最大程度减轻数据库压力
         limit_data = limit_data.where(f"trade_time >= {format_start_date} and trade_time <= {format_end_date}").where(
@@ -2950,11 +3113,10 @@ class GJDataC:
             self._get_history_bar_validate_params(datetime_str, instrument_id, bar_count, frequency, fields)
 
             # 转换日期格式
-            # query_time = self._get_history_bar_parse_datetime(datetime_str)
+            query_time = self._get_history_bar_parse_datetime(datetime_str)
 
-            # 1d ['v2505'] 2025.01.21 1
             # 执行查询并筛选数据
-            result, bar_db_session = self._get_history_bar_execute_query(frequency, instrument_id, datetime_str,
+            result, bar_db_session = self._get_history_bar_execute_query(frequency, instrument_id, query_time,
                                                                          bar_count)
             # 此处在所有的查询筛选都在数据库层面进行完后，再关闭连接
             # 如果将dolphindb的Table对象转换成DataFrame时，如果数据量较大，那么需要耗费的时间较长，所以尽可能将所有的筛选在数据库层面完成
@@ -2963,7 +3125,6 @@ class GJDataC:
             # 处理结果
             return self._get_history_bar_process_result(result, instrument_id, fields, bar_count)
         else:
-            print("22222")
             return self.get_history_bar(instrument_id, start_date, end_date, frequency, fields)
 
     def _get_history_bar_validate_params(self, datetime_str, instrument_id, bar_count,
@@ -3022,8 +3183,8 @@ class GJDataC:
         else:
             return False
 
-    @staticmethod
-    def _get_history_bar_parse_datetime(datetime_str):
+    # @staticmethod
+    def _get_history_bar_parse_datetime(self, datetime_str):
         """
         解析日期时间字符串
         Args:
@@ -3035,11 +3196,14 @@ class GJDataC:
 
         """
 
-        try:
-            return datetime.datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S') if isinstance(datetime_str, str) \
-                else datetime_str
-        except ValueError:
-            raise ValueError("Invalid datetime format, should be 'YYYY-MM-DD HH:MM:SS'")
+        return self.format_date(datetime_str)
+
+        # try:
+        #     return datetime.datetime.strptime(datetime_str, '%Y-%m-%d %H:%M:%S') if isinstance(datetime_str, str) \
+        #         else datetime_str
+        # except ValueError:
+        #     raise ValueError("Invalid datetime format, should be 'YYYY-MM-DD HH:MM:SS'")
+
 
     def _get_history_bar_execute_query(self, frequency, instrument_id, datetime_str, bar_count):
         """
@@ -3055,7 +3219,6 @@ class GJDataC:
 
         # 获取表信息
         table_info = self._get_history_bar_get_table_info(frequency, instrument_id)
-        print(table_info)
 
         # 获取数据
         table_data, bar_db_session = self.connect_db(table_info[0], table_info[1])
@@ -3094,7 +3257,8 @@ class GJDataC:
         else:
             raise Exception("frequency is not valid or frequency is not valid for this frequency")
 
-    def _get_history_bar_filter_data(self, table_data, instrument_id, datetime_str, bar_count):
+    @staticmethod
+    def _get_history_bar_filter_data(table_data, instrument_id, datetime_str, bar_count):
         """
         筛选数据
         Args:
@@ -3112,22 +3276,17 @@ class GJDataC:
         # dolphin_date = self._get_history_bar_datetime_to_dolphin_time(datetime_str)
         dolphin_date = datetime_str
 
-        # 使用 DolphinDB 的 where 子句筛选数据(这里因为实际需求的原因需要对每个instrument_id进行筛选，所以需要使用 contextby)
-        # 根据bar_count 分别对不同的instrument_id 进行筛选
-        # 此处的逻辑是，筛选出每个instrument_id距离给定日期最近的前bar_count条数据
-
         if isinstance(instrument_id, str):
-            if bar_count != 0:
-                query_data = (table_data.where(f"instrument_id='{instrument_id}'").where(f"trading_day <= {dolphin_date}")
-                              .contextby("instrument_id").sort("trading_day", ascending=True).limit(-bar_count))
-            else:
-                query_data = table_data.where(f"instrument_id='{instrument_id}'").where(f"trading_day = {dolphin_date}")
+            query_data = (table_data.where(f"instrument_id='{instrument_id}'")
+                          .where(f"trading_day <= {dolphin_date}")
+                          .sort("trading_day", ascending=False)
+                          .limit(bar_count))
+
         else:
-            if bar_count != 0:
-                query_data = (table_data.where(f"instrument_id in {instrument_id}").where(f"trading_day <= {dolphin_date}")
-                              .contextby("instrument_id").sort("trading_day", ascending=True).limit(-bar_count))
-            else:
-                query_data = table_data.where(f"instrument_id in {instrument_id}").where(f"trading_day = {dolphin_date}")
+            query_data = (table_data.where(f"instrument_id in {instrument_id}")
+                          .where(f"trading_day <= {dolphin_date}")
+                          .sort("trading_day", ascending=False)
+                          .limit(bar_count))
 
         # 根据日期对数据再次进行筛选，最大程度减轻数据库压力
         query_data = query_data.where(f"trade_time <= {dolphin_date}")
@@ -3291,8 +3450,13 @@ class GJDataC:
         # 获取数据
         table_data, bars_db_session = self.connect_db(table_info[0], table_info[1])
 
+        # 转换日期格式
+        conv_start_date =  self.format_date(start_date)
+        conv_end_date =  self.format_date(end_date)
+
+
         # 筛选数据
-        query_data = self._get_history_bars_filter_data(table_data, instrument_id, start_date, end_date)
+        query_data = self._get_history_bars_filter_data(table_data, instrument_id, conv_start_date, conv_end_date)
 
         return query_data.toDF(), bars_db_session
 
@@ -3644,7 +3808,8 @@ class GJDataC:
         :return: 查询到的交易日或时间点列表
         """
         # 将 trade_time 转换为 datetime 对象
-        trade_time = datetime.datetime.strptime(trade_time, '%Y.%m.%d %H:%M:%S')
+        trade_time = self.format_date(trade_time)
+
 
         # 获取交易日历数据
         trading_dates = self.get_trading_dates_data()
@@ -3755,6 +3920,8 @@ class GJDataC:
         """
 
         data, db_session = self.connect_db(trading_dates_db_table_name, trading_dates_db_path)
+        date = self.format_date(date)
+
 
         # 根据条件筛选数据
         # 筛选 trade_flag 列等于 T 的数据（是交易日的数据）
@@ -3765,13 +3932,13 @@ class GJDataC:
 
     """ 节假日判断 """
 
-    @staticmethod
-    def is_holiday(date):
+    def is_holiday(self, date):
         """
         判断给定日期是否为节假日
         :param date: 给定的日期
         :return: True 或 False
         """
+        date = self.format_date(date)
 
         # 将输入日期字符串转换为 datetime 对象
         date = datetime.datetime.strptime(date, '%Y.%m.%d').date()
@@ -3780,13 +3947,13 @@ class GJDataC:
 
     """ 周末判断 """
 
-    @staticmethod
-    def is_weekend(date):
+    def is_weekend(self, date):
         """
         判断给定日期是否为周末
         :param date: 给定日期
         :return: True 或 False
         """
+        date = self.format_date(date)
 
         # 将输入日期字符串转换为 datetime 对象
         date = datetime.datetime.strptime(date, '%Y.%m.%d')

{gjdatac_api-0.2.4 → gjdatac_api-0.2.6}/gjdatac_api.egg-info/PKG-INFO

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

{gjdatac_api-0.2.4 → gjdatac_api-0.2.6}/setup.py

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