qrpa 1.0.25__py3-none-any.whl → 1.0.27__py3-none-any.whl

qrpa/feishu_bot_app.py

@@ -0,0 +1,268 @@
+# pip install lark-oapi -U
+import json
+import os
+import uuid
+from typing import Optional
+
+import lark_oapi as lark
+from lark_oapi.api.im.v1 import *
+
+
+class FeishuBot:
+    """飞书机器人类，封装所有机器人相关功能"""
+    
+    def __init__(self, config):
+        """
+        初始化飞书机器人
+        
+        Args:
+            config: 配置对象，包含应用ID、应用密钥和群组信息
+        """
+        self.config = config
+        self._client = None
+    
+    @property
+    def client(self):
+        """获取飞书客户端，使用懒加载模式"""
+        if self._client is None:
+            self._client = lark.Client.builder() \
+                .app_id(self.config.feishu_bot_app_id) \
+                .app_secret(self.config.feishu_bot_app_secret) \
+                .log_level(lark.LogLevel.INFO) \
+                .build()
+        return self._client
+    
+    def _get_chat_id(self, chat_alias: str) -> Optional[str]:
+        """
+        根据群组别名获取群组ID
+        
+        Args:
+            chat_alias: 群组别名
+            
+        Returns:
+            群组ID，如果别名不存在则返回None
+        """
+        return self.config.dict_feishu_group.get(chat_alias)
+    
+    def _handle_response_error(self, response, operation_name: str):
+        """
+        处理API响应错误
+        
+        Args:
+            response: API响应对象
+            operation_name: 操作名称，用于错误日志
+        """
+        if not response.success():
+            lark.logger.error(
+                f"{operation_name} failed, code: {response.code}, "
+                f"msg: {response.msg}, log_id: {response.get_log_id()}, "
+                f"resp: \n{json.dumps(json.loads(response.raw.content), indent=4, ensure_ascii=False)}"
+            )
+            return True
+        return False
+    
+    def send_text(self, content: str, chat_alias: str = 'test') -> bool:
+        """
+        发送文本消息
+        
+        Args:
+            content: 文本内容
+            chat_alias: 群组别名，默认为'test'
+            
+        Returns:
+            发送是否成功
+        """
+        chat_id = self._get_chat_id(chat_alias)
+        if not chat_id:
+            lark.logger.error(f"未找到群组别名 '{chat_alias}' 对应的群组ID")
+            return False
+        
+        message_content = {"text": content}
+        
+        # 构造请求对象
+        request: CreateMessageRequest = CreateMessageRequest.builder() \
+            .receive_id_type("chat_id") \
+            .request_body(CreateMessageRequestBody.builder()
+                          .receive_id(chat_id)
+                          .msg_type("text")
+                          .content(json.dumps(message_content))
+                          .uuid(str(uuid.uuid4()))
+                          .build()) \
+            .build()
+        
+        # 发起请求
+        response: CreateMessageResponse = self.client.im.v1.message.create(request)
+        
+        # 处理失败返回
+        if self._handle_response_error(response, "send_text"):
+            return False
+        
+        # 处理业务结果
+        lark.logger.info(lark.JSON.marshal(response.data, indent=4))
+        return True
+    
+    def send_image(self, file_path: str, chat_alias: str = 'test') -> bool:
+        """
+        发送图片消息
+        
+        Args:
+            file_path: 图片文件路径
+            chat_alias: 群组别名，默认为'test'
+            
+        Returns:
+            发送是否成功
+        """
+        # 先上传图片获取image_key
+        image_key = self.upload_image(file_path)
+        if not image_key:
+            return False
+        
+        chat_id = self._get_chat_id(chat_alias)
+        if not chat_id:
+            lark.logger.error(f"未找到群组别名 '{chat_alias}' 对应的群组ID")
+            return False
+        
+        message_content = {"image_key": image_key}
+        
+        # 构造请求对象
+        request: CreateMessageRequest = CreateMessageRequest.builder() \
+            .receive_id_type("chat_id") \
+            .request_body(CreateMessageRequestBody.builder()
+                          .receive_id(chat_id)
+                          .msg_type("image")
+                          .content(json.dumps(message_content))
+                          .uuid(str(uuid.uuid4()))
+                          .build()) \
+            .build()
+        
+        # 发起请求
+        response: CreateMessageResponse = self.client.im.v1.message.create(request)
+        
+        # 处理失败返回
+        if self._handle_response_error(response, "send_image"):
+            return False
+        
+        # 处理业务结果
+        lark.logger.info(lark.JSON.marshal(response.data, indent=4))
+        return True
+    
+    def send_excel(self, file_path: str, chat_alias: str = 'test') -> bool:
+        """
+        发送Excel文件
+        
+        Args:
+            file_path: Excel文件路径
+            chat_alias: 群组别名，默认为'test'
+            
+        Returns:
+            发送是否成功
+        """
+        # 先上传文件获取file_key
+        file_key = self.upload_excel(file_path)
+        if not file_key:
+            return False
+        
+        chat_id = self._get_chat_id(chat_alias)
+        if not chat_id:
+            lark.logger.error(f"未找到群组别名 '{chat_alias}' 对应的群组ID")
+            return False
+        
+        message_content = {"file_key": file_key}
+        
+        # 构造请求对象
+        request: CreateMessageRequest = CreateMessageRequest.builder() \
+            .receive_id_type("chat_id") \
+            .request_body(CreateMessageRequestBody.builder()
+                          .receive_id(chat_id)
+                          .msg_type("file")
+                          .content(json.dumps(message_content))
+                          .uuid(str(uuid.uuid4()))
+                          .build()) \
+            .build()
+        
+        # 发起请求
+        response: CreateMessageResponse = self.client.im.v1.message.create(request)
+        
+        # 处理失败返回
+        if self._handle_response_error(response, "send_excel"):
+            return False
+        
+        # 处理业务结果
+        lark.logger.info(lark.JSON.marshal(response.data, indent=4))
+        return True
+    
+    def upload_excel(self, file_path: str) -> Optional[str]:
+        """
+        上传Excel文件
+        
+        Args:
+            file_path: 文件路径
+            
+        Returns:
+            文件key，上传失败返回None
+        """
+        if not os.path.exists(file_path):
+            lark.logger.error(f"文件不存在: {file_path}")
+            return None
+        
+        try:
+            with open(file_path, "rb") as file:
+                file_name = os.path.basename(file_path)
+                request: CreateFileRequest = CreateFileRequest.builder() \
+                    .request_body(CreateFileRequestBody.builder()
+                                  .file_type("xls")
+                                  .file_name(file_name)
+                                  .file(file)
+                                  .build()) \
+                    .build()
+                
+                # 发起请求
+                response: CreateFileResponse = self.client.im.v1.file.create(request)
+                
+                # 处理失败返回
+                if self._handle_response_error(response, "upload_excel"):
+                    return None
+                
+                # 处理业务结果
+                lark.logger.info(lark.JSON.marshal(response.data, indent=4))
+                return response.data.file_key
+        except Exception as e:
+            lark.logger.error(f"上传Excel文件时发生错误: {e}")
+            return None
+    
+    def upload_image(self, file_path: str) -> Optional[str]:
+        """
+        上传图片文件
+        
+        Args:
+            file_path: 图片文件路径
+            
+        Returns:
+            图片key，上传失败返回None
+        """
+        if not os.path.exists(file_path):
+            lark.logger.error(f"文件不存在: {file_path}")
+            return None
+        
+        try:
+            with open(file_path, "rb") as file:
+                request: CreateImageRequest = CreateImageRequest.builder() \
+                    .request_body(CreateImageRequestBody.builder()
+                                  .image_type("message")
+                                  .image(file)
+                                  .build()) \
+                    .build()
+                
+                # 发起请求
+                response: CreateImageResponse = self.client.im.v1.image.create(request)
+                
+                # 处理失败返回
+                if self._handle_response_error(response, "upload_image"):
+                    return None
+                
+                # 处理业务结果
+                lark.logger.info(lark.JSON.marshal(response.data, indent=4))
+                return response.data.image_key
+        except Exception as e:
+            lark.logger.error(f"上传图片文件时发生错误: {e}")
+            return None

qrpa/fun_excel.py

@@ -1860,6 +1860,117 @@ def format_to_text_v2(sheet, columns=None):
             log(f'设置[{col_name}] 文本格式')
         sheet.range(f'{col_name}:{col_name}').number_format = '@'
 
+def format_to_text_v2_safe(sheet, columns=None, data_rows=None):
+    """
+    更安全的文本格式化函数，避免COM异常
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 数据行数，用于限制格式化范围
+    """
+    if columns is None or len(columns) == 0:
+        return
+    
+    # 确保columns是列表
+    if not isinstance(columns, list):
+        columns = [columns]
+    
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+            
+            log(f'安全设置[{col_name}] 文本格式')
+            
+            # 如果指定了数据行数，只格式化有数据的范围
+            if data_rows and data_rows > 0:
+                # 格式化从第1行到数据行数的范围
+                range_str = f'{col_name}1:{col_name}{data_rows}'
+                sheet.range(range_str).number_format = '@'
+            else:
+                # 检查列是否有数据，如果没有则跳过
+                try:
+                    # 先检查第一个单元格是否存在
+                    test_range = sheet.range(f'{col_name}1')
+                    if test_range.value is not None or sheet.used_range.last_cell.column >= column_name_to_index(col_name) + 1:
+                        sheet.range(f'{col_name}:{col_name}').number_format = '@'
+                    else:
+                        log(f'列 {col_name} 没有数据，跳过格式化')
+                except:
+                    log(f'列 {col_name} 格式化失败，跳过')
+                    
+        except Exception as e:
+            log(f'设置列 {col_name} 文本格式失败: {e}，继续处理其他列')
+
+def pre_format_columns_safe(sheet, columns, data_rows):
+    """
+    预格式化函数：在写入数据前安全地设置列格式
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 预期数据行数
+    """
+    if not columns or not isinstance(columns, list):
+        return
+    
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+            
+            log(f'预格式化列 [{col_name}] 为文本格式')
+            
+            # 方法1：先创建最小范围，避免整列操作
+            try:
+                # 创建足够大的范围来覆盖预期数据
+                range_str = f'{col_name}1:{col_name}{max(data_rows, 1000)}'
+                sheet.range(range_str).number_format = '@'
+                log(f'预格式化成功: {range_str}')
+            except Exception as e1:
+                log(f'预格式化方法1失败: {e1}')
+                
+                # 方法2：逐行设置格式，更安全但稍慢
+                try:
+                    for row in range(1, data_rows + 1):
+                        cell = sheet.range(f'{col_name}{row}')
+                        cell.number_format = '@'
+                    log(f'逐行预格式化成功: {col_name}')
+                except Exception as e2:
+                    log(f'逐行预格式化也失败: {e2}')
+                    
+        except Exception as e:
+            log(f'预格式化列 {col_name} 失败: {e}，继续处理其他列')
+
+def post_format_columns_safe(sheet, columns, data_rows):
+    """
+    后格式化函数：在写入数据后确认列格式
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 实际数据行数
+    """
+    if not columns or not isinstance(columns, list):
+        return
+    
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+            
+            log(f'后格式化列 [{col_name}] 为文本格式')
+            
+            # 只对实际有数据的行进行格式化
+            if data_rows > 0:
+                range_str = f'{col_name}1:{col_name}{data_rows}'
+                sheet.range(range_str).number_format = '@'
+                log(f'后格式化成功: {range_str}')
+                
+        except Exception as e:
+            log(f'后格式化列 {col_name} 失败: {e}，继续处理其他列')
+
 def format_to_text(sheet, columns=None):
     if columns is None:
         return
@@ -2469,12 +2580,25 @@ def batch_excel_operations(excel_path, operations):
                 data, format_to_text_colunm = args[0], args[1:] if len(args) > 1 else None
                 # 清空工作表
                 sheet.clear()
-                # 格式化文本列
-                if format_to_text_colunm:
-                    format_to_text_v2(sheet, format_to_text_colunm)
+                
+                # 先设置文本格式，再写入数据（确保格式生效）
+                if format_to_text_colunm and format_to_text_colunm[0]:
+                    try:
+                        # 使用安全的预格式化方式
+                        pre_format_columns_safe(sheet, format_to_text_colunm[0], len(data))
+                    except Exception as e:
+                        log(f"预格式化失败: {e}，继续执行")
+                
                 # 写入数据
                 sheet.range('A1').value = data
                 log(f"批量操作：写入数据到 {sheet_name}")
+                
+                # 写入后再次确认格式（双重保险）
+                if format_to_text_colunm and format_to_text_colunm[0]:
+                    try:
+                        post_format_columns_safe(sheet, format_to_text_colunm[0], len(data))
+                    except Exception as e:
+                        log(f"后格式化失败: {e}")
 
             elif operation_type == 'format':
                 format_func, format_args = args[0], args[1:] if len(args) > 1 else ()