pytbox 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

pytbox/alert/alert_handler.py

@@ -4,7 +4,6 @@
 import uuid
 from typing import Literal
 from ..database.mongo import Mongo
-from ..base import MongoClient
 from ..feishu.client import Client as FeishuClient
 from ..dida365 import Dida365
 from ..utils.timeutils import TimeUtils
@@ -14,7 +13,7 @@ class AlertHandler:
     
     def __init__(self, 
                  config: dict=None,
-                 mongo_client: Mongo=MongoClient(collection='alert'),
+                 mongo_client: Mongo=None,
                  feishu_client: FeishuClient=None,
                  dida_client: Dida365=None
             ):
@@ -70,7 +69,8 @@ class AlertHandler:
                 f'**事件内容**: {event_content}',
                 f'**告警实例**: {entity_name}',
                 f'**建议**: {suggestion}',
-                f'**故障排查**: {troubleshot}'
+                f'**故障排查**: {troubleshot}',
+                f'**历史告警**: {self.mongo.recent_alerts(event_content=event_content)}'
             ]
             
             if event_type == "resolved":

pytbox/base.py

@@ -1,15 +1,19 @@
 #!/usr/bin/env python3
 
-
+import os
 from pytbox.database.mongo import Mongo
 from pytbox.utils.load_config import load_config_by_file
 from pytbox.database.victoriametrics import VictoriaMetrics
 from pytbox.feishu.client import Client as FeishuClient
 from pytbox.dida365 import Dida365
+from pytbox.alert.alert_handler import AlertHandler
+from pytbox.log.logger import AppLogger
+
+
+config = load_config_by_file(path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=os.environ.get('oc_vault_id'))
 
 
-def MongoClient(collection, config_path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=None):
-    config = load_config_by_file(path=config_path, oc_vault_id=oc_vault_id)
+def get_mongo(collection):
     return Mongo(
         host=config['mongo']['host'],
         port=config['mongo']['port'],
@@ -20,22 +24,25 @@ def MongoClient(collection, config_path='/workspaces/pytbox/tests/alert/config_d
         collection=collection
     )
 
-def vm_client(config_path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=None):
-    config = load_config_by_file(path=config_path, oc_vault_id=oc_vault_id)
-    return VictoriaMetrics(
-        url=config['victoriametrics']['url']
-    )
+vm = VictoriaMetrics(url=config['victoriametrics']['url'])
 
-def feishu_client(config_path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=None):
-    config = load_config_by_file(path=config_path, oc_vault_id=oc_vault_id)
-    return FeishuClient(
-        app_id=config['feishu']['app_id'],
-        app_secret=config['feishu']['app_secret']
-    )
+feishu = FeishuClient(
+    app_id=config['feishu']['app_id'],
+    app_secret=config['feishu']['app_secret']
+)
+dida = Dida365(
+    cookie=config['dida']['cookie'],
+    access_token=config['dida']['access_token']
+)
+
+alert_handler = AlertHandler(config=config, mongo_client=get_mongo('alert_test'), feishu_client=feishu, dida_client=dida)
 
-def dida_client(config_path='/workspaces/pytbox/tests/alert/config_dev.toml', oc_vault_id=None):
-    config = load_config_by_file(path=config_path, oc_vault_id=oc_vault_id)
-    return Dida365(
-        cookie=config['dida']['cookie'],
-        access_token=config['dida']['access_token']
+def get_logger(app):
+    return AppLogger(
+        app_name=app, 
+        enable_victorialog=True, 
+        victorialog_url=config['victorialog']['url'],
+        feishu=feishu,
+        dida=dida,
+        mongo=get_mongo('alert_program')
     )

pytbox/database/mongo.py

@@ -1,13 +1,14 @@
 #!/usr/bin/env python3
 
 import pymongo
-
+from ..utils.timeutils import TimeUtils
+from pytbox.utils import timeutils
 
 class Mongo:
     '''
     当前主要使用的类
     '''
-    def __init__(self, host, port, username, password, auto_source, db_name: str='automate', collection: str=None):
+    def __init__(self, host: str=None, port: int=27017, username: str=None, password: str=None, auto_source: str=None, db_name: str='automate', collection: str=None):
         self.client = self._create_client(host, port, username, password, auto_source)
         self.collection = self.client[db_name][collection]
     
@@ -56,3 +57,43 @@ class Mongo:
             query['event_name'] = event_name
         return self.collection.find(query)
 
+    def recent_alerts(self, event_content: str) -> str:
+        '''
+        获取最近 10 次告警
+
+        Args:
+            alarm_content (str): _description_
+
+        Returns:
+            str: _description_
+        '''
+
+        query = {
+            "event_content": event_content,
+            'resolved_time': {
+                '$exists': True,  # 字段必须存在
+            }
+        }
+        fields = {"_id": 0, 'event_time': 1, 'resolved_time': 1}
+        results = self.collection.find(query, fields).sort('event_time', -1)
+        
+        alarm_list = []
+        for result in results:
+            duration_minute = '持续 ' + str(int((result['resolved_time'] - result['event_time']).total_seconds() / 60)) + ' 分钟'
+            alarm_list.append('触发告警: ' + TimeUtils.convert_timeobj_to_str(timeobj=result['event_time']) + ' ' + duration_minute)
+
+        alarm_str = '\n'.join(alarm_list)
+        
+        alarm_str_display_threshold = 10
+        
+        if len(alarm_list) > alarm_str_display_threshold:
+            # 如果告警超过 10 个
+            alarm_counter = alarm_str_display_threshold
+            alarm_str = '\n'.join(alarm_list[:alarm_str_display_threshold])
+        else:
+            # 如果不超过 10 个
+            alarm_counter = len(alarm_list)
+            alarm_str = '\n'.join(alarm_list)
+            
+        return '该告警出现过' + str(len(alarm_list)) + f'次\n最近 {alarm_counter} 次告警如下: \n' + alarm_str
+    

pytbox/database/victoriametrics.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 
+from typing import Literal, Optional
 import requests
 from ..utils.response import ReturnResponse
 
@@ -38,7 +39,16 @@ class VictoriaMetrics:
                 return ReturnResponse(code=2, msg=f"[{query}] 没有查询到结果", data=r.json())
         else:
             return ReturnResponse(code=1, msg=f"[{query}] 查询失败: {r.json().get('error')}", data=r.json())
-    
+
+    def get_labels(self, metric_name: str) -> ReturnResponse:
+        url = f"{self.url}/api/v1/series?match[]={metric_name}"
+        response = requests.get(url, timeout=self.timeout)
+        results = response.json()
+        if results['status'] == 'success':
+            return ReturnResponse(code=0, msg=f"metric name: {metric_name} 获取到 {len(results['data'])} 条数据", data=results['data'])
+        else:
+            return ReturnResponse(code=1, msg=f"metric name: {metric_name} 查询失败")
+
     def check_ping_result(self, target: str, last_minute: int=10) -> ReturnResponse:
         '''
         检查ping结果
@@ -60,7 +70,7 @@ class VictoriaMetrics:
                 msg = f"已检查 {target} 最近 {last_minute} 分钟是正常的!"
             else:
                 if all(str(item[1]) == "1" for item in values):
-                    code = 2
+                    code = 1
                     msg = f"已检查 {target} 最近 {last_minute} 分钟是异常的!"
                 else:
                     code = 0
@@ -74,4 +84,30 @@ class VictoriaMetrics:
         except KeyError:
             data = r.data
         
-        return ReturnResponse(code=code, msg=msg, data=data)
+        return ReturnResponse(code=code, msg=msg, data=data)
+
+    def check_interface_rate(self,
+                             direction: Literal['in', 'out'],
+                             sysName: str, 
+                             ifName:str, 
+                             last_minutes: Optional[int] = None
+                            ) -> ReturnResponse:
+        """查询指定设备的入方向总流量速率（bps）。
+
+        使用 PromQL 对 `snmp_interface_ifHCInOctets` 进行速率计算并聚合到设备级别，
+        将结果从字节每秒转换为比特每秒（乘以 8）。
+
+        Args:
+            sysName: 设备 `sysName` 标签值。
+            last_minutes: 计算速率的时间窗口（分钟）。未提供时默认使用 5 分钟窗口。
+
+        Returns:
+            ReturnResponse: 查询结果包装。
+        """
+        if direction == 'in':
+            query = f'(rate(snmp_interface_ifHCInOctets{{sysName="{sysName}", ifName="{ifName}"}}[{last_minutes}m])) * 8 / 1000000'
+        else:
+            query = f'(rate(snmp_interface_ifHCOutOctets{{sysName="{sysName}", ifName="{ifName}"}}[{last_minutes}m])) * 8 / 1000000'
+        r = self.query(query)
+        rate = r.data[0]['value'][1]
+        return int(float(rate))

pytbox/log/logger.py

@@ -1,8 +1,14 @@
 #!/usr/bin/env python3
 
 import sys
+
 from loguru import logger
+
 from .victorialog import Victorialog
+from ..database.mongo import Mongo
+from ..feishu.client import Client as FeishuClient
+from ..utils.timeutils import TimeUtils
+from ..dida365 import Dida365
 
 
 logger.remove()
@@ -21,6 +27,9 @@ class AppLogger:
                  stream: str='automation', 
                  enable_victorialog: bool=False, 
                  victorialog_url: str=None,
+                 mongo: Mongo=None,
+                 feishu: FeishuClient=None,
+                 dida: Dida365=None,
                  enable_sls: bool=False,
                  sls_url: str=None,
                  sls_access_key_id: str=None,
@@ -40,6 +49,9 @@ class AppLogger:
         self.stream = stream
         self.victorialog = Victorialog(url=victorialog_url)
         self.enable_victorialog = enable_victorialog
+        self.mongo = mongo
+        self.feishu = feishu
+        self.dida = dida
     
     def _get_caller_info(self) -> tuple[str, int, str]:
         """
@@ -90,10 +102,48 @@ class AppLogger:
         logger.error(f"[{caller_filename}:{caller_lineno}:{caller_function}] {message}")
         if self.enable_victorialog:
             self.victorialog.send_program_log(stream=self.stream, level="ERROR", message=message, app_name=self.app_name, file_name=call_full_filename, line_number=caller_lineno, function_name=caller_function)
-        from src.library.monitor.insert_program import insert_error_message
-        # 传递清理后的消息给监控系统
-        message.replace('#', '')
-        insert_error_message(message, self.app_name, caller_filename, caller_lineno, caller_function)
+        
+        if self.feishu:
+            existing_message = self.mongo.collection.find_one({"message": message}, sort=[("time", -1)])
+            current_time = TimeUtils.get_now_time_mongo()
+
+            if not existing_message or TimeUtils.get_time_diff_hours(existing_message["time"], current_time) > 36:
+                self.mongo.collection.insert_one({
+                    "message": message,
+                    "time": current_time,
+                    "file_name": caller_filename,
+                    "line_number": caller_lineno,
+                    "function_name": caller_function
+                })
+                    
+                    
+                content_list = [
+                    f"{self.feishu.extensions.format_rich_text(text='app:', color='blue', bold=True)} {self.app_name}",
+                    f"{self.feishu.extensions.format_rich_text(text='message:', color='blue', bold=True)} {message}",
+                    f"{self.feishu.extensions.format_rich_text(text='file_name:', color='blue', bold=True)} {caller_filename}",
+                    f"{self.feishu.extensions.format_rich_text(text='line_number:', color='blue', bold=True)} {caller_lineno}",
+                    f"{self.feishu.extensions.format_rich_text(text='function_name:', color='blue', bold=True)} {caller_function}"
+                ]
+                
+                self.feishu.extensions.send_message_notify(
+                    title=f"自动化脚本告警: {self.app_name}",
+                    content="\n".join(content_list)
+                )
+                
+                dida_content_list = [
+                    f"**app**: {self.app_name}",
+                    f"**message**: {message}",
+                    f"**file_name**: {caller_filename}",
+                    f"**line_number**: {caller_lineno}",
+                    f"**function_name**: {caller_function}"
+                ]
+                
+                self.dida.task_create(
+                    project_id="65e87d2b3e73517c2cdd9d63",
+                    title=f"自动化脚本告警: {self.app_name}",
+                    content="\n".join(dida_content_list),
+                    tags=['L-程序告警', 't-问题处理']
+                )
         
     def critical(self, message: str):
         """记录严重错误级别日志"""
@@ -103,24 +153,6 @@ class AppLogger:
             self.victorialog.send_program_log(stream=self.stream, level="CRITICAL", message=message, app_name=self.app_name, file_name=call_full_filename, line_number=caller_lineno, function_name=caller_function)
 
 
-def get_logger(app_name: str, enable_) -> AppLogger:
-    """
-    获取应用日志记录器实例
-    
-    Args:
-        app_name: 应用名称
-        log_level: 日志级别
-        enable_influx: 是否启用InfluxDB记录
-    
-    Returns:
-        AppLogger: 日志记录器实例
-    """
-    return AppLogger(app_name)
-
-
 # 使用示例
 if __name__ == "__main__":
-    log = get_logger(app_name='test')
-    log.info("That's it, beautiful and simple logging!")
-    log.warning("That's it, beautiful and simple logging!")
-    log.error("That's it, beautiful and simple logging!11")
+    pass

pytbox/log/victorialog.py

@@ -3,8 +3,8 @@
 from typing import Literal
 import requests
 import time
-from .utils.response import ReturnResponse
-from .utils.timeutils import TimeUtils
+from ..utils.response import ReturnResponse
+from ..utils.timeutils import TimeUtils
 
 
 

pytbox/utils/timeutils.py

@@ -1,30 +1,15 @@
 #!/usr/bin/env python3
 
-
-import time
+import re
 import pytz
+import time
 import datetime
+from zoneinfo import ZoneInfo
 from typing import Literal
 
 
 class TimeUtils:
     
-    @staticmethod
-    def get_timestamp(now: bool=True) -> int:
-        '''
-        获取时间戳
-        
-        Args:
-            now (bool, optional): _description_. Defaults to True.
-
-        Returns:
-            _type_: _description_
-        '''
-        if now:
-            return int(time.time())
-        else:
-            return int(time.time() * 1000)
-    
     @staticmethod
     def get_time_object(now: bool=True):
         '''
@@ -50,4 +35,513 @@ class TimeUtils:
         if time_format == '%Y-%m-%d %H:%M:%S':
             return time_obj_with_offset.strftime("%Y-%m-%d %H:%M:%S")
         elif time_format == '%Y-%m-%dT%H:%M:%SZ':
-            return time_obj_with_offset.strftime("%Y-%m-%dT%H:%M:%SZ")
+            return time_obj_with_offset.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    @staticmethod
+    def get_time_diff_hours(time1, time2):
+        """
+        计算两个datetime对象之间的小时差
+        
+        Args:
+            time1: 第一个datetime对象
+            time2: 第二个datetime对象
+            
+        Returns:
+            float: 两个时间之间的小时差
+        """
+        if not time1 or not time2:
+            return 0
+        
+        # 确保两个时间都有时区信息
+        if time1.tzinfo is None:
+            time1 = time1.replace(tzinfo=pytz.timezone('Asia/Shanghai'))
+        if time2.tzinfo is None:
+            time2 = time2.replace(tzinfo=pytz.timezone('Asia/Shanghai'))
+        
+        # 计算时间差（秒）
+        time_diff_seconds = abs((time2 - time1).total_seconds())
+        
+        # 转换为小时
+        time_diff_hours = time_diff_seconds / 3600
+        
+        return time_diff_hours
+
+    @staticmethod
+    def convert_syslog_huawei_str_to_8601(timestr):
+        """
+        将华为 syslog 格式的时间字符串（如 '2025-08-02T04:34:24+08:00'）转换为 ISO8601 格式的 UTC 时间字符串。
+
+        Args:
+            timestr (str): 原始时间字符串，格式如 '2025-08-02T04:34:24+08:00'
+
+        Returns:
+            str: 转换后的 ISO8601 格式 UTC 时间字符串，如 '2025-08-01T20:34:24.000000Z'
+        """
+        if timestr is None:
+            return None
+        try:
+            # 解析带时区的时间字符串
+            dt: datetime.datetime = datetime.datetime.strptime(timestr, "%Y-%m-%dT%H:%M:%S%z")
+            # 转换为 UTC
+            dt_utc: datetime.datetime = dt.astimezone(datetime.timezone.utc)
+            # 格式化为 ISO8601 字符串（带微秒，Z 结尾）
+            iso8601_utc: str = dt_utc.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+            return iso8601_utc
+        except ValueError as e:
+            # 日志记录异常（此处仅简单打印，实际项目建议用 logging）
+            print(f"时间转换失败: {e}, 输入: {timestr}")
+            return None
+     
+    @staticmethod
+    def convert_str_to_timestamp(timestr):
+        """
+        将类似 '2025-04-16T00:08:28.000+0000' 格式的时间字符串转换为时间戳（秒级）。
+
+        Args:
+            timestr (str): 时间字符串，格式如 '2025-04-16T00:08:28.000+0000'
+
+        Returns:
+            int: 时间戳（秒级）
+        """
+        if timestr is None:
+            return None
+        # 兼容带毫秒和时区的ISO8601格式
+        # 先将+0000或+08:00等时区格式标准化为+00:00
+        timestr_fixed = re.sub(r'([+-]\d{2})(\d{2})$', r'\1:\2', timestr)
+   
+        # 处理毫秒部分（.000），如果没有毫秒也能兼容
+        try:
+            dt = datetime.datetime.fromisoformat(timestr_fixed)
+        except ValueError:
+            if len(timestr_fixed) == 8:
+                dt = datetime.datetime.strptime(timestr_fixed, "%Y%m%d")
+            else:
+                # 如果没有毫秒部分
+                dt = datetime.datetime.strptime(timestr_fixed, "%Y-%m-%dT%H:%M:%S%z")
+        # 返回秒级时间戳
+        return int(dt.timestamp()) * 1000
+    
+    @staticmethod
+    def convert_str_to_datetime_lg_backup(time_str: str):
+        """
+        将 '7/10/2025 3:52:43 PM' 这种格式的时间字符串转换为时间戳（秒级）。
+
+        Args:
+            time_str (str): 时间字符串，格式如 '7/10/2025 3:52:43 PM'
+
+        Returns:
+            int: 时间戳（秒级）
+        """
+        if time_str is None:
+            return None
+        # 先将字符串转换为 datetime 对象
+        dt = datetime.datetime.strptime(time_str, "%m/%d/%Y %I:%M:%S %p")
+        # 返回秒级时间戳
+        return int(dt.timestamp()) * 1000
+        
+    @staticmethod
+    def convert_timestamp_to_str(timestamp: int, time_format: Literal['%Y-%m-%d %H:%M:%S', '%Y-%m-%dT%H:%M:%SZ', '%Y-%m-%dT%H:%M:%S.000Z']='%Y-%m-%d %H:%M:%S', timezone_offset: int=8):
+        '''
+        _summary_
+
+        Args:
+            timestamp (_type_): _description_
+
+        Returns:
+            _type_: _description_
+        '''
+        timestamp = int(timestamp)
+        if timestamp > 10000000000:
+            timestamp = timestamp / 1000
+        # 使用datetime模块的fromtimestamp方法将时间戳转换为datetime对象
+        dt_object = datetime.datetime.fromtimestamp(timestamp, tz=ZoneInfo(f'Etc/GMT-{timezone_offset}'))
+
+        # 使用strftime方法将datetime对象格式化为字符串
+        return dt_object.strftime(time_format)
+
+    @staticmethod
+    def timestamp_to_timestr_dida(timestamp):
+        # 将时间戳转换为 UTC 时间
+        utc_time = datetime.datetime.fromtimestamp(timestamp, tz=datetime.timezone.utc)
+
+        # 将 UTC 时间转换为指定时区（+08:00）
+        target_timezone = datetime.timezone(datetime.timedelta(hours=8))
+        local_time = utc_time.astimezone(target_timezone)
+
+        # 格式化为指定字符串
+        formatted_time = local_time.strftime('%Y-%m-%dT%H:%M:%S%z')
+
+        # 添加冒号到时区部分
+        formatted_time = formatted_time[:-2] + ':' + formatted_time[-2:]
+        return formatted_time
+        
+    @staticmethod
+    def timestamp_to_datetime_obj(timestamp: int, timezone_offset: int=8):
+        return datetime.datetime.fromtimestamp(timestamp, tz=ZoneInfo(f'Etc/GMT-{timezone_offset}'))
+
+    @staticmethod
+    def datetime_obj_to_str(datetime_obj, add_timezone=False):
+        if add_timezone:
+            datetime_obj = datetime_obj.astimezone(pytz.timezone('Asia/Shanghai'))
+        return datetime_obj.strftime("%Y-%m-%d %H:%M:%S")
+
+    @staticmethod
+    def get_current_time(app: Literal['notion', 'dida365']):
+        if app == 'notion':
+            return datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+        elif app == 'dida365':
+            return datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S%z")
+
+    @staticmethod
+    def get_current_date_str(output_format: Literal['%Y%m%d', '%Y-%m-%d']='%Y%m%d') -> str:
+        # 获取当前日期和时间
+        now = datetime.datetime.now()
+
+        # 格式化为字符串
+        current_date_str = now.strftime(output_format)
+        return current_date_str
+    
+    @staticmethod
+    def get_date_n_days_from_now(n: int = 0, output_format: Literal['%Y%m%d', '%Y-%m-%d'] = '%Y%m%d') -> str:
+        """
+        获取距离当前日期 N 天后的日期字符串。
+
+        Args:
+            n (int): 天数，可以为负数（表示 N 天前），默认为 0（即今天）。
+            output_format (Literal['%Y%m%d', '%Y-%m-%d']): 日期输出格式，默认为 '%Y%m%d'。
+
+        Returns:
+            str: 格式化后的日期字符串。
+
+        示例:
+            >>> MyTime.get_date_n_days_from_now(1)
+            '20240620'
+            >>> MyTime.get_date_n_days_from_now(-1, '%Y-%m-%d')
+            '2024-06-18'
+        """
+        target_date = datetime.datetime.now() + datetime.timedelta(days=n)
+        return target_date.strftime(output_format)
+    
+    
+    @staticmethod
+    def get_yesterday_date_str() -> str:
+        # 获取昨天日期
+        yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
+        yesterday_date_str = yesterday.strftime("%Y%m%d")
+        return yesterday_date_str
+
+    @staticmethod
+    def get_last_month_date_str() -> str:
+        # 获取上个月日期
+        last_month = datetime.datetime.now() - datetime.timedelta(days=30)
+        last_month_date_str = last_month.strftime("%Y-%m")
+        return last_month_date_str
+    
+    @staticmethod
+    def get_current_time_str() -> str:
+        # 获取当前日期和时间
+        now = datetime.datetime.now()
+
+        # 格式化为字符串
+        current_date_str = now.strftime("%Y%m%d_%H%M")
+        return current_date_str
+    
+    @staticmethod
+    def get_timestamp(now: bool=True, last_minutes: int=0, unit: Literal['ms', 's']='ms') -> int:
+        '''
+        获取当前时间戳, 减去 last_minutes 分钟
+        ''' 
+        if now:
+            if unit == 'ms':
+                return int(time.time()) * 1000
+            elif unit == 's':
+                return int(time.time())
+        
+        if last_minutes == 0:
+            if unit == 'ms':
+                return int(time.time()) * 1000
+            elif unit == 's':
+                return int(time.time())
+        else:
+            if unit == 'ms':
+                return int(time.time()) * 1000 - last_minutes * 60 * 1000
+            elif unit == 's':
+                return int(time.time()) - last_minutes * 60
+            
+    @staticmethod
+    def get_timestamp_tomorrow() -> int:
+        return int(time.time()) * 1000 + 24 * 60 * 60 * 1000
+    
+    @staticmethod
+    def get_timestamp_last_day(last_days: int=0, unit: Literal['ms', 's']='ms') -> int:
+        if last_days == 0:
+            if unit == 'ms':
+                return int(time.time()) * 1000
+            elif unit == 's':
+                return int(time.time())
+        else:
+            return int(time.time()) * 1000 - last_days * 24 * 60 * 60 * 1000
+    
+    @staticmethod
+    def get_today_timestamp() -> int:
+        return int(time.time()) * 1000
+
+    @staticmethod
+    def convert_str_to_datetime(time_str: str, app: Literal['lg_alert_trigger', 'lg_alert_resolved', 'mongo']='lg_alert_trigger') -> datetime.datetime:
+        """
+        将字符串转换为datetime对象
+
+        Args:
+            time_str (str): 时间字符串
+            app (Literal['lg_alert_trigger', 'lg_alert_resolved', 'mongo'], optional): 应用类型. Defaults to 'lg_alert_trigger'.
+
+        Returns:
+            datetime.datetime: 带时区信息的datetime对象
+        """
+        if app == 'lg_alert_trigger':
+            time_obj = datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")
+        elif app == 'lg_alert_resolved':
+            time_obj = datetime.datetime.strptime(time_str, "%Y年%m月%d日 %H:%M:%S")
+        elif app == 'mongo':
+            time_obj = datetime.datetime.fromisoformat(time_str.replace('Z', '+00:00'))
+            return time_obj  # 已经包含时区信息，直接返回
+        
+        # 对于没有时区信息的时间对象，设置为Asia/Shanghai时区
+        time_with_tz = time_obj.replace(tzinfo=ZoneInfo("Asia/Shanghai"))
+        return time_with_tz
+
+    @staticmethod
+    def convert_timeobj_to_str(timeobj: str=None, timezone_offset: int=8, time_format: Literal['%Y-%m-%d %H:%M:%S', '%Y-%m-%dT%H:%M:%SZ']='%Y-%m-%d %H:%M:%S'):
+        time_obj_with_offset = timeobj + datetime.timedelta(hours=timezone_offset)
+        if time_format == '%Y-%m-%d %H:%M:%S':
+            return time_obj_with_offset.strftime("%Y-%m-%d %H:%M:%S")
+        elif time_format == '%Y-%m-%dT%H:%M:%SZ':
+            return time_obj_with_offset.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    @staticmethod
+    def convert_timestamp_to_timeobj(timestamp: int) -> datetime.datetime:
+        """
+        将时间戳转换为时间对象
+
+        Args:
+            timestamp (int): 时间戳，单位为秒或毫秒
+
+        Returns:
+            datetime.datetime: 转换后的时间对象，时区为 Asia/Shanghai
+        """
+        # 如果时间戳是毫秒，转换为秒
+        if len(str(timestamp)) > 10:
+            timestamp = timestamp / 1000
+        
+        return datetime.datetime.fromtimestamp(timestamp, tz=ZoneInfo("Asia/Shanghai"))
+
+    @staticmethod
+    def convert_timeobj_to_timestamp(timeobj: datetime.datetime) -> int:
+        """
+        将时间对象转换为时间戳
+
+        Args:
+            timeobj (datetime.datetime): 时间对象
+
+        Returns:
+            int: 时间戳，单位为秒或毫秒
+        """
+        return int(timeobj.timestamp())
+
+    @staticmethod
+    def convert_timeobj_add_timezone(timeobj: datetime.datetime, timezone_offset: int=8) -> datetime.datetime:
+        return timeobj + datetime.timedelta(hours=timezone_offset)
+
+    @staticmethod
+    def convert_mute_duration(mute_duration: str) -> datetime.datetime:
+        """将屏蔽时长字符串转换为带 Asia/Shanghai 时区的 ``datetime`` 对象。
+
+        支持两类输入：
+        - 绝对时间: 例如 ``"2025-01-02 13:45"``，按本地上海时区解释。
+        - 相对时间: 形如 ``"10m"``、``"2h"``、``"1d"`` 分别表示分钟、小时、天。
+
+        Args:
+            mute_duration: 屏蔽时长字符串。
+
+        Returns:
+            datetime.datetime: 带 ``Asia/Shanghai`` 时区信息的时间点。
+
+        Raises:
+            ValueError: 当输入字符串无法被解析时抛出。
+        """
+        shanghai_tz = ZoneInfo("Asia/Shanghai")
+        now: datetime.datetime = datetime.datetime.now(tz=shanghai_tz)
+        mute_duration = mute_duration.strip()
+
+        # 绝对时间格式（按上海时区解释）
+        try:
+            abs_dt_naive = datetime.datetime.strptime(mute_duration, "%Y-%m-%d %H:%M")
+            return abs_dt_naive.replace(tzinfo=shanghai_tz)
+        except ValueError:
+            pass
+
+        # 相对时间格式
+        pattern = r"^(\d+)([dhm])$"
+        match = re.match(pattern, mute_duration)
+        if match:
+            value_str, unit = match.groups()
+            value = int(value_str)
+            if unit == "d":
+                return now + datetime.timedelta(days=value)
+            if unit == "h":
+                return now + datetime.timedelta(hours=value)
+            if unit == "m":
+                return now + datetime.timedelta(minutes=value)
+
+        raise ValueError(f"无法解析 mute_duration: {mute_duration}")
+
+    @staticmethod
+    def convert_mute_duration_to_str(mute_duration: str) -> str:
+        '''
+        将屏蔽时长字符串转换为距离当前时间的标准描述，形如 '2d3h'。
+
+        支持两类输入：
+        - 绝对时间: 'YYYY-MM-DD HH:MM'（按 Asia/Shanghai 解释）
+        - 相对时间: '10m'、'2h'、'1d'
+
+        如果目标时间已过去，则返回 '0h'。
+
+        Args:
+            mute_duration (str): 屏蔽时长字符串。
+
+        Returns:
+            str: 与当前时间的距离描述，例如 '1d2h'、'3h'。
+        '''
+        shanghai_tz = ZoneInfo("Asia/Shanghai")
+        now: datetime.datetime = datetime.datetime.now(tz=shanghai_tz)
+
+        try:
+            target_time: datetime.datetime = TimeUtils.convert_mute_duration(mute_duration)
+        except ValueError:
+            # 兜底：直接尝试绝对时间格式
+            try:
+                abs_dt = datetime.datetime.strptime(mute_duration.strip(), "%Y-%m-%d %H:%M")
+                target_time = abs_dt.replace(tzinfo=shanghai_tz)
+            except ValueError:
+                return mute_duration
+
+        # 计算与现在的差值（仅面向未来的剩余时长）
+        delta_seconds: float = (target_time - now).total_seconds()
+        if delta_seconds <= 0:
+            return "0h"
+
+        days: int = int(delta_seconds // 86400)
+        hours: int = int((delta_seconds % 86400) // 3600)
+
+        parts: list[str] = []
+        if days > 0:
+            parts.append(f"{days}d")
+        if hours > 0:
+            parts.append(f"{hours}h")
+        if not parts:
+            # 小于 1 小时
+            parts.append("0h")
+
+        return "".join(parts)
+
+    @staticmethod
+    def is_work_time(start_hour: int=9, end_hour: int=18) -> bool:
+        '''
+        判断是否为工作时间
+
+        Args:
+            start_hour (int, optional): 开始工作时间. Defaults to 9.
+            end_hour (int, optional): 结束工作时间. Defaults to 18.
+
+        Returns:
+            bool: 如果是工作时间, 返回 True, 否则返回 False
+        '''
+        current_time = datetime.datetime.now().time()
+        start = datetime.time(start_hour, 0, 0)
+        end = datetime.time(end_hour, 0, 0)
+        
+        if start <= current_time <= end:
+            return True
+        else:
+            return False
+    
+    @staticmethod
+    def is_work_day() -> bool:
+        '''
+        判断是否为工作日
+
+        Returns:
+            bool: 如果是工作日, 返回 True, 否则返回 False
+        '''
+        from chinese_calendar import is_workday
+        date_now = datetime.datetime.date(datetime.datetime.now())
+        # print(date_now)
+        if is_workday(date_now):
+            return True
+        else:
+            return False
+        
+    @staticmethod
+    def get_week_number(offset: int=5) -> int:
+        '''
+        获取今天是哪一年的第几周
+        
+        Returns:
+            int: 返回一个元组，包含(年份, 周数)
+        '''
+        now = datetime.datetime.now()
+        # isocalendar()方法返回一个元组，包含年份、周数和周几
+        _year_unused, week, _ = now.isocalendar()
+        return week - offset
+    
+    @staticmethod
+    def get_week_day(timestamp: int=None, offset: int=0) -> int:
+        '''
+        获取今天是周几
+        
+        Returns:
+            int: 周几的数字表示，1表示周一，7表示周日
+        '''
+        if timestamp is None:
+            now = datetime.datetime.now()
+        else:
+            if timestamp > 10000000000:
+                timestamp = timestamp / 1000
+            now = datetime.datetime.fromtimestamp(timestamp)
+        # weekday()方法返回0-6的数字，0表示周一，6表示周日
+        return now.weekday() + 1 + offset
+    
+    @staticmethod
+    def get_week_of_year(customer: Literal['lululemon', 'other']='other') -> tuple[int, int]:
+        '''
+        获取今天是哪一年的第几周
+        
+        Returns:
+            tuple[int, int]: 返回一个元组，包含(年份, 周数)
+        '''
+        now = datetime.datetime.now()
+        # isocalendar()方法返回一个元组，包含年份、周数和周几
+        _year, week, _ = now.isocalendar()
+        if customer == 'lululemon':
+            week = week - 5
+        return _year, week
+
+    @staticmethod
+    def get_last_month_start_and_end_time() -> tuple[datetime.datetime, datetime.datetime]:
+        '''
+        获取上个月的开始和结束时间
+
+        Returns:
+            tuple[datetime.datetime, datetime.datetime]: 返回一个元组，包含上个月的开始和结束时间
+        '''
+        today = datetime.datetime.now()
+        # 获取当前月份的第一天
+        first_day_of_current_month = today.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        # 上个月1号的0:00分
+        start_time = first_day_of_current_month - datetime.timedelta(days=1)
+        start_time = start_time.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+        
+        # 获取上个月的最后一天
+        end_time = first_day_of_current_month - datetime.timedelta(days=1)
+        end_time = end_time.replace(hour=23, minute=59, second=59, microsecond=0)
+        return start_time.strftime("%Y-%m-%dT%H:%M:%SZ"), end_time.strftime("%Y-%m-%dT%H:%M:%SZ")

{pytbox-0.0.3.dist-info → pytbox-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytbox
-Version: 0.0.3
+Version: 0.0.5
 Summary: A collection of Python integrations and utilities (Feishu, Dida365, VictoriaMetrics, ...)
 Author-email: mingming hou <houm01@foxmail.com>
 License: MIT
@@ -8,8 +8,9 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: requests>=2.0
 Requires-Dist: pydantic>=1.10
-Requires-Dist: onepassword-sdk>=0.3.1
 Requires-Dist: onepasswordconnectsdk>=1.0.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: chinese_calendar>=1.10.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

{pytbox-0.0.3.dist-info → pytbox-0.0.5.dist-info}/RECORD

@@ -1,27 +1,26 @@
-pytbox/base.py,sha256=nk65USdvAhltFJGCMXPmr02F9sTM7gcvlYuzL4sUT1k,1621
+pytbox/base.py,sha256=_SpfeIiJE4xbQMsYghnMehcNzHP-mBfrKONX43b0OQk,1490
 pytbox/dida365.py,sha256=pUMPB9AyLZpTTbaz2LbtzdEpyjvuGf4YlRrCvM5sbJo,10545
 pytbox/onepassword_connect.py,sha256=nD3xTl1ykQ4ct_dCRRF138gXCtk-phPfKYXuOn-P7Z8,3064
 pytbox/onepassword_sa.py,sha256=08iUcYud3aEHuQcUsem9bWNxdXKgaxFbMy9yvtr-DZQ,6995
-pytbox/alert/alert_handler.py,sha256=arQkm95q2aqZomwflh_WWFwDw7aZyui-N5-FrxgRTZ8,5012
+pytbox/alert/alert_handler.py,sha256=FePPQS4LyGphSJ0QMv0_pLWaXxEqsRlcTKMfUjtsNfk,5048
 pytbox/alert/ping.py,sha256=g36X0U3U8ndZqfpVIcuoxJJ0X5gST3I_IwjTQC1roHA,779
 pytbox/alicloud/sls.py,sha256=UR4GdI86dCKAFI2xt_1DELu7q743dpd3xrYtuNpfC5A,4065
 pytbox/common/__init__.py,sha256=3JWfgCQZKZuSH5NCE7OCzKwq82pkyop9l7sH5YSNyfU,122
-pytbox/common/base.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pytbox/database/mongo.py,sha256=QyCeSoyWoJdIFXxjDmbV5t-xU7wN3x-Ig0I8pvRmBwg,1864
-pytbox/database/victoriametrics.py,sha256=qs3IQZbcKGSIObQcwUujZEyPshq2yOIVvnc4yfTkXJ0,2642
+pytbox/database/mongo.py,sha256=CSpHC7iR-M0BaVxXz5j6iXjMKPgXJX_G7MrjCj5Gm8Q,3478
+pytbox/database/victoriametrics.py,sha256=PfeshtlgZNfbiq7Fo4ibJruWYeAKryBXu8ckl8YC1jM,4389
 pytbox/feishu/client.py,sha256=kwGLseGT_iQUFmSqpuS2_77WmxtHstD64nXvktuQ3B4,5865
 pytbox/feishu/endpoints.py,sha256=z_nHGXAjlIyYdFnbAWY4hfzzHrENJvoNOqY9sA6-FLk,40009
 pytbox/feishu/errors.py,sha256=79qFAHZw7jDj3gnWAjI1-W4tB0q1_aSfdjee4xzXeuI,1179
 pytbox/feishu/helpers.py,sha256=jhSkHiUw4822QBXx2Jw8AksogZdakZ-3QqvC3lB3qEI,201
 pytbox/feishu/typing.py,sha256=3hWkJgOi-v2bt9viMxkyvNHsPgrbAa0aZOxsZYg2vdM,122
-pytbox/log/logger.py,sha256=4IHmMg14Rwekmc7AeKGDbsDZryhcD6elaJZsvpdYJ80,5659
-pytbox/log/victorialog.py,sha256=50cVPxq9PzzzkzQHhgv_785K3GeF8B2mEnChdeekZWU,4137
+pytbox/log/logger.py,sha256=N7KOM7Xl_FZI_RR8oggjV9sVph-Lrmspl-yBMJr2LLQ,7437
+pytbox/log/victorialog.py,sha256=gffEiq38adv9sC5oZeMcyKghd3SGfRuqtZOFuqHQF6E,4139
 pytbox/utils/env.py,sha256=jO_-BKbGuDU7lIL9KYkcxGCzQwTXfxD4mIYtSAjREmI,622
 pytbox/utils/load_config.py,sha256=wNCDPLH7xet5b9pUlTz6VsBejRsJZ7LP85wWMaITBYg,3042
 pytbox/utils/ping_checker.py,sha256=Nqnn8clbgv-5l0PgxcTOldg8mkMKrFn4TvPL-rYUUGg,1
 pytbox/utils/response.py,sha256=kXjlwt0WVmLRam2eu1shzX2cQ7ux4cCQryaPGYwle5g,1247
-pytbox/utils/timeutils.py,sha256=7ZI-TU2FCUV0Gyc_QUjhSreto8SVIs54e2CZgGix5pI,1628
-pytbox-0.0.3.dist-info/METADATA,sha256=WWQcYi7uThTfbjMuhEsV9vKgqInlBZWn1VJr-0llPDQ,6006
-pytbox-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pytbox-0.0.3.dist-info/top_level.txt,sha256=YADgWue-Oe128ptN3J2hS3GB0Ncc5uZaSUM3e1rwswE,7
-pytbox-0.0.3.dist-info/RECORD,,
+pytbox/utils/timeutils.py,sha256=XbK2KB-SVi7agNqoQN7i40wysrZvrGuwebViv1Cw-Ok,20226
+pytbox-0.0.5.dist-info/METADATA,sha256=cNFwHW1aNu_zPUuXq7KOBRj-6cx6oSO-UbAPbJFQOdU,6037
+pytbox-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pytbox-0.0.5.dist-info/top_level.txt,sha256=YADgWue-Oe128ptN3J2hS3GB0Ncc5uZaSUM3e1rwswE,7
+pytbox-0.0.5.dist-info/RECORD,,