kaq-quant-common 0.2.12__py3-none-any.whl

kaq_quant_common/resources/kaq_mysql_resources.py

@@ -0,0 +1,341 @@
+import os
+import threading
+import time
+import traceback
+import datetime
+
+import numpy as np
+import pandas as pd
+from natsort import natsorted
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+from kaq_quant_common.utils import hash_utils, yml_utils
+from kaq_quant_common.utils.logger_utils import get_logger
+
+mutex = threading.Lock()
+
+
+def append_id(df: pd.DataFrame):
+    """
+    统一添加id和时间戳
+    :param df:
+    :return:
+    """
+    if df is not None and not df.empty:
+        df = df.copy()
+        df["id"] = df.apply(lambda i: hash_utils.generate_hash_id(i), axis=1)
+
+        now_time = time.localtime()
+        df["ctimestampe"] = pd.Timestamp(now_time.tm_year, now_time.tm_mon, now_time.tm_mday, now_time.tm_hour, now_time.tm_min, now_time.tm_sec)
+    return df
+
+
+class KaqQuantMysqlRepository:
+    """
+    获取过往一段时间的归集成交
+    数据库创建语句：
+    mysql -uroot -pxxxxxxxxxx -e "create database if not exists db_kaq_binance character set 'utf8mb4';"
+    PS: 高并发下可能产生错误 (1205, 'Lock wait timeout exceeded; try restarting transaction. 使用`SET GLOBAL innodb_lock_wait_timeout = 3000;`调整)
+    同时设置为可以读取已经提交的数据：
+    SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;
+    SHOW VARIABLES LIKE 'autocommit';
+    -- 禁用自动提交, 便于直接一次性提交
+    -- SET autocommit = 0;
+    """
+
+    def __init__(self, host, port, user, passwd, database, charset="utf8mb4", pool_size=3):
+        self.logger = get_logger(self)
+        # 创建写入引擎数据库连接池
+        self.conn_engine = create_engine(
+            f"mysql+mysqldb://{user}:{passwd}@{host}:{port}/{database}?charset={charset}",
+            # 连接池大小
+            pool_size=pool_size,
+            # 超出连接池后，允许的最大扩展数
+            max_overflow=5,
+            # 池中没有线程最多等待的时间（秒）
+            pool_timeout=60,
+            # 多久之后，连接自动断开，-1 表示不自动断开（秒）
+            pool_recycle=650,
+             # 启用连接前检查
+            pool_pre_ping=True,
+            echo=False,  # 关闭 SQL 语句日志
+            echo_pool=False,  # 关闭连接池日志
+        )
+        # 会话工厂
+        self.session_maker = sessionmaker(bind=self.conn_engine, autoflush=False)
+        # todo 删掉
+        self.session = self.session_maker()
+
+    # 判断表是否存在
+    def table_exists(self, table_name):
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            tables = session.execute(text("SHOW TABLES")).mappings().all()
+            table_list = np.array([[v for _, v in table.items()] for table in tables]).flatten()
+            return table_name in table_list
+        except Exception as e:
+            self.logger.error(f"【mysql-table_exists】异常, {table_name} - {str(e)}")
+        finally:
+            session.close()
+
+    # 执行sql
+    def execute_sql(self, sql, need_commit=False):
+        # 从连接池获取连接
+        session = self.session_maker()
+        ret = None
+        try:
+            ret = session.execute(text(sql))
+            if need_commit:
+                session.commit()
+        except Exception as e:
+            self.logger.error(f"【mysql.execute_sql】异常, {sql} - {str(e)}")
+            ret = None
+            session.rollback()
+        finally:
+            session.close()
+        return ret
+
+     # 判断表是否存在
+    def rename_table(self, table_name):
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            time_str = time.strftime("%Y_%m_%d_%H_%M", time.localtime(time.time()))
+            sql = f"RENAME TABLE {table_name} TO {table_name}_{time_str};"
+            session.execute(text(sql))
+            return True
+        except Exception as e:
+            self.logger.error(f"【mysql-table_exists】异常, {table_name} - {str(e)}")
+            return False
+        finally:
+            session.close()
+
+    def get_table_size(self, table_name, database="db_kaq_binance"):
+        """
+        查询操作，输入查询语句
+        """
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            # 从session中获取数据
+            sql = f"""
+                SELECT ROUND(SUM(data_length + index_length) / 1024 / 1024, 2)
+                FROM information_schema.tables 
+                WHERE table_name = '{table_name}' AND table_schema = '{database}'
+            """
+            count = session.execute(text(sql)).fetchone()[0]
+            return count
+        except Exception as e:
+            self.logger.error(f"【mysql-fetch_data】异常, {sql} - {str(e)}")
+        finally:
+            session.close()
+        return 0
+
+    def get_table_list(self):
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            # 获取表名
+            tables = (
+                session.execute(
+                    text(
+                        "SELECT table_name, create_time FROM information_schema.tables WHERE table_schema = 'db_kaq_binance' ORDER BY create_time DESC"
+                    )
+                )
+                .mappings()
+                .all()
+            )
+            table_list = [table["TABLE_NAME"] for table in tables]
+            table_list = list(reversed(natsorted(table_list)))
+            return table_list
+        except Exception as e:
+            self.logger.error(f"【mysql-get_table_list】异常, - {str(e)}")
+        finally:
+            session.close()
+        return []
+
+    def fetch_data(self, query):
+        """
+        查询操作，输入查询语句
+        """
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            # 从session中获取数据
+            rows = session.execute(text(query)).mappings().all()
+            df = pd.DataFrame(rows)
+            return df
+        except Exception as e:
+            self.logger.error(f"【mysql-fetch_data】异常, {query} - {str(e)}")
+        finally:
+            session.close()
+        return pd.DataFrame()
+
+    def fetch_data_count(self, query):
+        """
+        查询操作，输入查询语句
+        """
+        # 从连接池获取连接
+        session = self.session_maker()
+        try:
+            # 从session中获取数据
+            count = session.execute(text(query)).fetchone()[0]
+            return count
+        except Exception as e:
+            self.logger.error(f"【mysql-fetch_data】异常, {query} - {str(e)}")
+        finally:
+            session.close()
+        return 0
+
+    def get_conn_engine(self):
+        """
+        create_engine: pandas写入支持的比较好
+        """
+        return self.conn_engine
+
+    def get_exits_id_list(self, df, table_name):
+        """
+        获取已经存在的id的列表
+        """
+        if df is None or df.empty:
+            return []
+        id_list_str = ", ".join(["'" + _id + "'" for _id in df["id"].values.tolist()])
+        id_df = self.fetch_data(f"select id from {table_name} where id in ({id_list_str})")
+        exits_id_list = id_df["id"].values.tolist()
+        return exits_id_list
+
+    def insert_data(self, df, table_name):
+        # 将pdFrame转为table, 并存入mysql
+        session = None
+        try:
+            mutex.acquire(True)
+            if df is None or df.empty:
+                return
+            if "id" not in df:
+                df = append_id(df)
+            # df = df[~df['id'].isin(self.get_exits_id_list(df, table_name))]
+            # pandas写法
+            # pd.io.sql.to_sql(df, table_name, self.conn_engine, if_exists='append', index=False, chunksize=100000)
+
+            # 使用 INSERT IGNORE, 如果遇见重复的主键id，则跳过
+            columns = ", ".join([_col for _col in df.columns.values])
+
+            # mysql默认一次性可以写入16mb数据，如果超过16mb，有可能阻塞，所以设置为1000条，应该没有问题
+            mysql_max_allowed_packet = 300
+            total_rows = df.shape[0]
+            # 要切分的份数
+            part_rows = total_rows // mysql_max_allowed_packet
+            if total_rows % mysql_max_allowed_packet > 0:
+                part_rows = part_rows + 1
+            for i in range(part_rows):
+                df_part = df.iloc[i * mysql_max_allowed_packet : (i + 1) * mysql_max_allowed_packet]
+
+                # 拼接插入的sql语句
+                value_list = ["(" + ", ".join(["'" + str(_r) + "'" for _r in row.values]) + ")" for index, row in df_part.iterrows()]
+                value_list_str = ", ".join(value_list)
+                query = f"INSERT IGNORE INTO {table_name} ({columns}) VALUES {value_list_str} ;"
+                # 从连接池获取session
+                if session is None:
+                    session = self.session_maker()
+                session.execute(text(query))
+            # 一并提交
+            if session is not None:
+                session.commit()
+        except Exception as e:
+            self.logger.error(f"【mysql-insert_data异常】- {str(e)} - {str(traceback.format_exc())}")
+            if session is not None:
+                session.rollback()
+        finally:
+            mutex.release()
+            if session is not None:
+                session.close()
+
+    def insert_data_duplicate(self, df, table_name, update_columns: list = None, mysql_max_allowed_packet = 300):
+        """
+        插入数据，如果遇见主键冲突，则更新指定的列
+        """
+        session = None
+        try:
+            mutex.acquire(True)
+            if df is None or df.empty:
+                return
+            if "id" not in df:
+                df = append_id(df)
+            # pandas写法
+            # pd.io.sql.to_sql(df, table_name, self.conn_engine, if_exists='append', index=False, chunksize=100000)
+
+            # 使用 INSERT ... ON DUPLICATE KEY UPDATE, 如果遇见重复的主键id，则更新指定的列
+            columns = ", ".join([_col for _col in df.columns.values])
+            update_columns_str = ", ".join([f"{col}=IFNULL(VALUES({col}), {col})" for col in update_columns])
+
+            # mysql默认一次性可以写入16mb数据，如果超过16mb，有可能阻塞，所以设置为1000条，应该没有问题
+            
+            total_rows = df.shape[0]
+            # 要切分的份数
+            part_rows = total_rows // mysql_max_allowed_packet
+            if total_rows % mysql_max_allowed_packet > 0:
+                part_rows = part_rows + 1
+            for i in range(part_rows):
+                df_part = df.iloc[i * mysql_max_allowed_packet : (i + 1) * mysql_max_allowed_packet]
+
+                # 拼接插入的sql语句
+                value_list = ["(" + ", ".join(["'" + str(_r) + "'" if str(_r) != 'NaT' and str(_r) != 'nan' else "NULL" for _r in row.values]) + ")" for index, row in df_part.iterrows()]
+                value_list_str = ", ".join(value_list)
+                query = f"INSERT INTO {table_name} ({columns}) VALUES {value_list_str} ON DUPLICATE KEY UPDATE {update_columns_str} ;"
+
+                # 从连接池获取session
+                if session is None:
+                    session = self.session_maker()
+                session.execute(text(query))
+            # 一并提交
+            if session is not None:
+                session.commit()
+        except Exception as e:
+            self.logger.error(f"【mysql-insert_data_duplicate异常】- {str(e)} - {str(traceback.format_exc())}")
+            if session is not None:
+                session.rollback()
+        finally:
+            mutex.release()
+            if session is not None:
+                session.close()
+
+
+def main(query="select * from kaq_binance_perpetual_klines_1h limit 5;"):
+    host, port, user, passwd, database, charset = yml_utils.get_mysql_info(os.getcwd())
+    KaqQuantMysqlRepository = KaqQuantMysqlRepository(host, port, user, passwd, database, charset)
+
+    print(KaqQuantMysqlRepository.table_exists("kaq_binance_perpetual_klines_1h"))
+    # print(KaqQuantMysqlRepository.fetch_data(query).head(3))
+
+
+# 测试数据库连接池
+def test_db_pool():
+    host, port, user, passwd, database, charset = yml_utils.get_mysql_info(os.getcwd())
+    KaqQuantMysqlRepository = KaqQuantMysqlRepository(host, port, user, passwd, database, charset)
+
+    # 获取一个session
+    session1 = KaqQuantMysqlRepository.session_maker()
+    session1.execute(text("SELECT 1;")).mappings().all()
+    # SHOW PROCESSLIST;  有1条连接
+
+    # 由于上面没有close,这里不会复用上面的连接
+    session2 = KaqQuantMysqlRepository.session_maker()
+    session2.execute(text("SELECT 1;")).mappings().all()
+    # SHOW PROCESSLIST;  有2条连接
+
+    # 关闭session
+    session1.close()
+    session2.close()
+
+    # 上面session关闭后，这里再创建session会复用之前创建的连接
+    session3 = KaqQuantMysqlRepository.session_maker()
+    session3.execute(text("SELECT 1;")).mappings().all()
+    # SHOW PROCESSLIST;  有2条连接
+
+    print("end")
+
+
+if __name__ == "__main__":
+    main()

kaq_quant_common/resources/kaq_postgresql_resources.py

@@ -0,0 +1,58 @@
+import os
+from kaq_quant_common.utils import yml_utils
+import pandas as pd
+import threading
+import psycopg2
+from kaq_quant_common.utils.logger_utils import get_logger
+
+mutex = threading.Lock()
+
+class KaqQuantPostgreSqlRepository:
+    '''
+    timescaleDB的操作类
+    '''
+    def __init__(self, host, port, user, passwd, database, charset='utf8'):
+        self.logger = get_logger(self)
+        # 数据库连接参数
+        conn_params = {
+            "dbname": database,
+            "user": user,
+            "password": passwd,
+            "host": host,
+            "port": port
+        }
+        # 创建写入引擎数据库连接池
+        # 建立连接和游标
+        self.conn = psycopg2.connect(**conn_params)
+        self.cur = self.conn.cursor()
+        
+        # 关闭游标和连接
+        # self.cur.close()
+        # self.conn.close()
+
+    def fetch_data(self, query):
+        '''
+        查询操作，输入查询语句
+        '''
+        try:
+            # 执行查询
+            self.cur.execute(query)
+            rows = self.cur.fetchall()
+            field_names = [desc[0] for desc in self.cur.description]
+            df = pd.DataFrame(rows, columns=field_names)
+            return df
+        except Exception as e:
+            self.logger.error(f'【posgresql-fetch_data】异常, {query} - {str(e)}')
+        return pd.DataFrame()
+
+
+def main(query='select * from footprint_candle limit 5;'):
+        
+    # alias
+    host, port, user, passwd, database, charset  = yml_utils.get_posgresql_info(os.getcwd())
+    kaqBtcTimeScaleDbRepository = KaqQuantPostgreSqlRepository(host, port, user, passwd, database)
+    df = kaqBtcTimeScaleDbRepository.fetch_data(query)
+    print(df.head(3))
+
+if __name__ == '__main__':
+    main()

kaq_quant_common/resources/kaq_quant_hive_resources.py

@@ -0,0 +1,107 @@
+from pyhive import hive
+import pandas as pd
+
+class KaqQuantHiveClient:
+    def __init__(self, host="localhost", port=10000, username="hive", password=None, auth="NONE", database="default"):
+        """
+        初始化 Hive 连接
+        """
+        self.conn = hive.Connection(
+            host=host,
+            port=port,
+            username=username,
+            password=password,
+            auth=auth,
+            database=database
+        )
+        self.cursor = self.conn.cursor()
+
+    def query(self, sql):
+        """
+        执行查询并返回结果（list of tuples）
+        """
+        self.cursor.execute(sql)
+        return self.cursor.fetchall()
+
+    def query_df(self, sql):
+        """
+        执行查询并返回 pandas.DataFrame
+        """
+        return pd.read_sql(sql, self.conn)
+
+    def insert_many(self, table, columns, values_list, partition=None):
+        """
+        批量插入数据
+        :param table: Hive 表名
+        :param columns: 插入的字段列表，如 ["id", "name", "department"]
+        :param values_list: 数据列表，如 [(1, "Alice", "HR"), (2, "Bob", "IT")]
+        :param partition: 可选分区，如 {"dt": "2025-09-21"}
+        """
+        cols = ",".join(columns)
+        values_str = ",".join(
+            ["(" + ",".join([f"'{str(v)}'" if isinstance(v, str) else str(v) for v in row]) + ")" 
+             for row in values_list]
+        )
+
+        if partition:
+            part_clause = " PARTITION (" + ",".join([f"{k}='{v}'" for k, v in partition.items()]) + ")"
+        else:
+            part_clause = ""
+
+        sql = f"INSERT INTO {table}{part_clause} ({cols}) VALUES {values_str}"
+        print("执行SQL:", sql)
+        self.cursor.execute(sql)
+
+    def close(self):
+        """
+        关闭连接
+        """
+        self.cursor.close()
+        self.conn.close()
+
+if __name__ == "__main__":
+    '''
+    CREATE TABLE employees (
+        id INT,
+        name STRING,
+        position STRING,
+        hire_date String
+    )
+    COMMENT 'Table for employee details'
+    PARTITIONED BY (department STRING);
+
+    INSERT INTO employees (id, name, position, hire_date, department) VALUES (6, 'Alice', 'Manager', '2020-05-12', 'HR');
+
+    -- 插入第二条数据
+    INSERT INTO employees (id, name, position, hire_date, department) VALUES (2, 'Bob', 'Software Engineer', '2018-11-05', 'Engineering');
+
+    -- 插入第三条数据
+    INSERT INTO employees (id, name, position, hire_date, department) VALUES (3, 'Charlie', 'Sales Representative', '2019-08-15', 'Sales');
+
+    -- 插入第四条数据
+    INSERT INTO employees (id, name, position, hire_date, department) VALUES (4, 'David', 'Data Analyst', '2021-01-22', 'Engineering');
+
+    -- 插入第五条数据
+    INSERT INTO employees (id, name, position, hire_date, department) VALUES (5, 'Eva', 'Marketing Specialist', '2020-02-17', 'Marketing');
+    '''
+    hive_client = KaqQuantHiveClient(
+        host="127.0.0.1",
+        port=10000,
+        username="hive"
+    )
+
+    # 查询数据
+    result = hive_client.query_df("SELECT * FROM employees")
+    print(result)
+
+    # 插入数据
+    hive_client.insert_many(
+        table="employees",
+        columns=["id", "name", "position", "hire_date", "department"],
+        values_list=[
+            (101, "Alice", "Manager", "2025-09-21", "HR"),
+            (102, "Bob", "Engineer", "2025-09-21", "IT")
+        ],
+    )
+
+    hive_client.close()

kaq_quant_common/resources/kaq_redis_resources.py

@@ -0,0 +1,117 @@
+import json
+import os
+from typing import Any, List
+import pandas as pd
+import redis
+import threading
+from kaq_quant_common.utils import yml_utils
+from loguru import logger
+import traceback
+
+mutex = threading.Lock()
+
+class KaqQuantRedisRepository:
+    '''
+    定义 redis操作
+    '''
+    def __init__(self, host='localhost', port=6379, password=None, db=0):
+        '''
+        redis连接池
+        '''
+        try:
+            mutex.acquire()
+            # 创建连接池
+            pool = redis.ConnectionPool(host=host, port=port, db=db, password=password, max_connections=3, decode_responses=True, health_check_interval=30)
+
+            # 共享的 Redis 客户端
+            self.client = redis.StrictRedis(connection_pool=pool)
+        except Exception as e:
+            logger.error(f"【创建redis连接】错误异常: {str(e)} - {str(traceback.format_exc())}")
+        finally:
+            mutex.release()
+            
+    # 显式代理 Redis 常用方法
+    def set(self, name: str, value: Any, ex: int = None, px: int = None, nx: bool = False, xx: bool = False):
+        return self.client.set(name, value, ex, px, nx, xx)
+
+    def get(self, name: str) -> Any:
+        return self.client.get(name)
+
+    def delete(self, *names: str) -> int:
+        return self.client.delete(*names)
+
+    def keys(self, pattern: str) -> list:
+        return self.client.keys(pattern)
+
+    def exists(self, name: str) -> bool:
+        return self.client.exists(name)
+    
+    def lrange(self, name: str) -> pd.DataFrame:
+        result = self.client.lrange(name, 0, -1)
+        return pd.DataFrame([json.loads(item) for item in result]) if result else pd.DataFrame()
+    
+    def rpush(self, name: str, df: pd.DataFrame) -> pd.DataFrame:
+        # 每次都先删除，后添加
+        self.client.delete(name)
+        # 自定义 JSON 序列化函数
+        def timestamp_serializer(obj):
+            if isinstance(obj, pd.Timestamp):
+                return obj.isoformat()  # 或者返回 int(obj.timestamp()) 转换为时间戳
+            raise TypeError("Type not serializable")
+        if df is not None and not df.empty:
+            json_data = [json.dumps(row.to_dict(), default=timestamp_serializer) for _, row in df.iterrows()]
+            self.client.rpush(name, *json_data)
+        return 
+    
+    def get_keys_by_pattern(self, pattern: str) -> List[str]:
+        '''
+        根据模糊前缀获取 Redis 中匹配的键
+        :param pattern: 模糊匹配的模式，支持 * 通配符
+        :return: 匹配的键列表
+        '''
+        try:
+            # 获取匹配的键
+            keys = self.client.keys(pattern)
+            return keys
+        except Exception as e:
+            logger.error(f"获取匹配键时出错: {str(e)} - {str(traceback.format_exc())}")
+            return []
+
+    def get_values_by_pattern(self, pattern: str) -> pd.DataFrame:
+        '''
+        批量获取 Redis 中符合模糊前缀匹配的键对应的 JSON 数据，并构建 pandas DataFrame
+        :param pattern: 模糊匹配的模式，支持 * 通配符
+        :return: 返回构建的 pandas DataFrame
+        '''
+        try:
+            # 获取所有匹配的键
+            keys = self.get_keys_by_pattern(pattern)
+            
+            # 批量获取对应的 JSON 数据
+            json_data_list = self.client.mget(keys)
+            
+            # 将 JSON 数据转换为字典列表
+            data_list = [json.loads(data.replace("'", '"')) if data else None for data in json_data_list]
+            
+            # 去除为 None 的数据
+            data_list = [data for data in data_list if data is not None]
+
+            # 构建 pandas DataFrame
+            df = pd.DataFrame(data_list)
+            return df
+        except Exception as e:
+            logger.error(f"获取并转换 JSON 数据时出错: {str(e)} - {str(traceback.format_exc())}")
+            return pd.DataFrame()  # 返回空 DataFrame
+            
+    def __getattr__(self, name):
+        '''
+        使得对象在没有明确调用时，能够直接调用 Redis 的方法
+        '''
+        return getattr(self.client, name)
+
+if __name__ == '__main__':
+    host, port, passwd = yml_utils.get_redis_info(os.getcwd())
+    KaqQuantRedisRepository = KaqQuantRedisRepository(host=host, port=port, password=passwd)
+    # value = KaqQuantRedisRepository.get('test')
+    df = KaqQuantRedisRepository.get_values_by_pattern('kaq_binance_commision_rate_*')
+    print(df)

kaq_quant_common/utils/dagster_job_check_utils.py

@@ -0,0 +1,29 @@
+   
+from dagster import DagsterRunStatus, RunsFilter
+
+
+def dagster_job_check(context, job_name, jobs_number=1):
+     # 检查是否有正在运行的相同job
+    instance = context.instance
+    runs = instance.get_runs(filters=RunsFilter(job_name=job_name, statuses=[DagsterRunStatus.STARTED, DagsterRunStatus.QUEUED]))
+    # 过滤出当前job且状态是STARTED的运行
+    active_runs = [run for run in runs if run.job_name == job_name and run.status == DagsterRunStatus.STARTED]
+    if len(active_runs) > jobs_number:
+        # 有正在运行的实例，跳过此次执行
+        context.log.info(f'【正在运行:{job_name}.当前任务列表】{str(active_runs)}')
+        return False
+    context.log.info(f'【当前任务名称】{str(job_name)}')
+    return True
+
+def dagster_sensor_check(context, job_name, jobs_number=1):
+     # 检查是否有正在运行的相同job
+    instance = context.instance
+    runs = instance.get_runs(filters=RunsFilter(job_name=job_name, statuses=[DagsterRunStatus.STARTED, DagsterRunStatus.STARTING, DagsterRunStatus.QUEUED]))
+    # 过滤出当前job且状态是STARTED的运行
+    active_runs = [run for run in runs if run.job_name == job_name]
+    if len(active_runs) > jobs_number:
+        # 有正在运行的实例，跳过此次执行
+        context.log.info(f'【正在运行:{job_name}.当前任务列表】{str(active_runs)}')
+        return False
+    context.log.info(f'【当前任务名称】{str(job_name)}')
+    return True

kaq_quant_common/utils/dagster_utils.py

@@ -0,0 +1,19 @@
+from dagster import DagsterRunStatus, RunsFilter, RunStatusSensorContext
+
+
+# 检测dagster任务是否运行
+def check_dagster_job_running(context: RunStatusSensorContext, job_name: str):
+    # 查询最近的运行状态
+    runs = context.instance.get_runs(filters=RunsFilter(job_name=job_name), limit=1)
+
+    # STARTING , STARTED 都是运行中
+    if runs and runs[0].status in [
+        DagsterRunStatus.QUEUED,
+        DagsterRunStatus.NOT_STARTED,
+        DagsterRunStatus.MANAGED,
+        DagsterRunStatus.STARTING,
+        DagsterRunStatus.STARTED,
+    ]:
+        # context.log.info(f"Job {job_name} is already running")
+        return False
+    return True