Functions-d 1.2.5__tar.gz → 1.28__tar.gz

{functions_d-1.2.5 → functions_d-1.28}/Functions_d/Functions_d.py

@@ -148,6 +148,7 @@ class DataProcessingAndMessaging:
         self.logger.info('\n' * 10)
 
     # -------------------------- 企业微信消息发送 --------------------------
+    # 仅展示修改后的 uxin_wx 方法，其余代码不变
     def uxin_wx(self, name, message, mentioned_list=None):
         sender = WeComMsg.WeChatWorkSender(self.corpid, self.corpsecret, self.agentid)
         try:
@@ -158,6 +159,43 @@ class DataProcessingAndMessaging:
                 target_type = "群聊（Webhook）" if name.startswith("https://") else "单个用户"
                 self.logger.info(f"开始向{target_type}发送消息，目标：{name}")
 
+            # ========== 新增：Markdown消息识别与处理 ==========
+            # 识别规则：message以特定标识开头（如「MD:」），或显式传入markdown类型
+            is_markdown = False
+            md_content = ""
+            if isinstance(message, dict) and message.get("type") == "markdown":
+                # 支持字典格式传参：{"type": "markdown", "content": "markdown内容"}
+                is_markdown = True
+                md_content = message.get("content", "")
+            elif isinstance(message, str) and message.startswith("MD:"):
+                # 支持字符串前缀标识："MD:### 标题\n内容"
+                is_markdown = True
+                md_content = message[3:].strip()  # 去掉前缀"MD:"
+
+            if is_markdown:
+                # 处理Markdown消息
+                if isinstance(name, str) and name.startswith("https://"):
+                    # 群聊Webhook发送Markdown
+                    self.logger.info(f"发送群聊Markdown消息：内容={md_content}")
+                    result = sender.send_markdown_to_group(name, md_content)
+                else:
+                    # 个人/多用户发送Markdown
+                    receivers = name if isinstance(name, list) else [name]
+                    self.logger.info(f"发送个人Markdown消息：内容={md_content}，接收者：{receivers}")
+                    result = sender.send_markdown(receivers, md_content)
+
+                msg_id = result.get('msgid', '未知')
+                self.logger.info(
+                    f"Markdown消息发送结果：{'成功' if result.get('errcode') == 0 else '失败'}，错误信息：{result.get('errmsg')}，消息ID：{msg_id}")
+
+                if result.get('errcode') == 0:
+                    print(f"给 {target_type} 的Markdown消息发送成功，消息ID：{msg_id}")
+                else:
+                    print(
+                        f"给 {target_type} 的Markdown消息发送失败，错误码：{result.get('errcode')}，错误信息：{result.get('errmsg')}，消息ID：{msg_id}")
+                return
+
+            # ========== 原有逻辑（文本/文件/图片）保持不变 ==========
             if isinstance(name, str) and name.startswith("https://"):
                 if isinstance(message, str) and message.endswith(('.xlsx', '.docx', '.pdf', '.txt')) and os.path.isfile(
                         message):
@@ -1028,15 +1066,55 @@ class DataProcessingAndMessaging:
                 self._wechat_doc_log(error_msg)
                 raise Exception(error_msg)
             docid = result.get("docid")
-            self._wechat_doc_log(f"智能表格：{sheet_name} 创建成功，docid={docid}")
-            print(f"智能表格：{sheet_name} 创建成功，docid={docid}")
-            return {"智能表格": sheet_name, "docid": docid, "url": result.get("url")}
+            # ========== 新增：添加创建时间 ==========
+            # 获取当前时间（北京时间，格式：YYYY-MM-DD HH:MM:SS）
+            create_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+            # ========== 核心新增：创建成功后自动查询子sheet ==========
+            self._wechat_doc_log(f"开始查询新创建表格[{docid}]的子表信息")
+            # 然后修改wx_create_table中调用wx_get_sheets的代码，传入send_notice=False：
+            sheet_list = self.wx_get_sheets(docid, send_notice=False)
+
+            # ========== 构造包含子sheet的完整消息内容 ==========
+            # 基础信息
+            msg_content = f"✅ 智能表格创建成功\n表格名称：{sheet_name}\n创建时间：{create_time}\ndocid：{docid}\n\n子表信息："
+            # 子sheet信息
+            if sheet_list:
+                for idx, sheet in enumerate(sheet_list, 1):
+                    sheet_visibility = '可见' if sheet['is_visible'] else '不可见'
+                    msg_content += f"\n{idx}. ID: {sheet['sheet_id']} | 标题: {sheet['title']} | 类型: {sheet['type']} | 可见性: {sheet_visibility}"
+            else:
+                msg_content += "\n暂无子表信息"
+
+            self._wechat_doc_log(
+                f"智能表格：{sheet_name} 创建成功，docid={docid}，创建时间={create_time}，子表数量：{len(sheet_list)}")
+            print(f"智能表格：{sheet_name} 创建成功，docid={docid}，创建时间={create_time}")
+            print(f"该表格的子表信息：")
+            if sheet_list:
+                for idx, sheet in enumerate(sheet_list, 1):
+                    sheet_visibility = '可见' if sheet['is_visible'] else '不可见'
+                    print(
+                        f"  {idx}. ID: {sheet['sheet_id']} | 标题: {sheet['title']} | 类型: {sheet['type']} | 可见性: {sheet_visibility}")
+            else:
+                print("  暂无子表信息")
+
+            # 调用uxin_wx发送包含子sheet的完整消息
+            self.uxin_wx('dongyang', msg_content)
+
+            return {
+                "智能表格": sheet_name,
+                "docid": docid,
+                "url": result.get("url"),
+                "创建时间": create_time,
+                "子表列表": sheet_list  # 返回值新增子sheet列表
+            }
         except Exception as e:
             self._wechat_doc_log(f"创建异常: {str(e)}")
             raise
 
     # -------------------------- 企微文档：查询子表 --------------------------
-    def wx_get_sheets(self, docid):
+    # 修改wx_get_sheets方法的定义，新增send_notice参数
+    def wx_get_sheets(self, docid, send_notice=True):
         self._wechat_doc_log(f"查询文档[{docid}]的子表信息")
         self._wechat_doc_refresh_token_if_needed()
 
@@ -1052,10 +1130,30 @@ class DataProcessingAndMessaging:
         if result.get("errcode") != 0:
             error_msg = f"查询子表失败: {result.get('errmsg')}"
             self._wechat_doc_log(error_msg)
+            # 失败时仍发送通知
+            fail_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            fail_content = f"⚠️ 企微文档子表查询失败\n查询时间：{fail_time}\n文档ID：{docid}\n错误信息：{result.get('errmsg')}"
+            self.uxin_wx('dongyang', fail_content)
             raise Exception(error_msg)
 
         sheet_list = result.get("sheet_list", [])
+        query_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         self._wechat_doc_log(f"查询文档[{docid}]子表完成，共找到{len(sheet_list)}个子表")
+
+        # 构造通知内容
+        msg_content = f"✅ 企微文档子表查询完成\n查询时间：{query_time}\n文档ID：{docid}\n子表总数：{len(sheet_list)}\n\n子表详细信息："
+        if sheet_list:
+            for idx, sheet in enumerate(sheet_list, 1):
+                sheet_visibility = '可见' if sheet['is_visible'] else '不可见'
+                msg_content += f"\n{idx}. ID: {sheet['sheet_id']} | 标题: {sheet['title']} | 类型: {sheet['type']} | 可见性: {sheet_visibility}"
+        else:
+            msg_content += "\n暂无子表信息"
+
+        # 仅当send_notice为True时发送通知
+        if send_notice:
+            self.uxin_wx('dongyang', msg_content)
+
+        # 原有日志和打印逻辑
         for sheet in sheet_list:
             sheet_info = (f"子表信息 - ID: {sheet['sheet_id']}, 标题: {sheet['title']}, "
                           f"类型: {sheet['type']}, 可见性: {'可见' if sheet['is_visible'] else '不可见'}")
@@ -1098,6 +1196,40 @@ class DataProcessingAndMessaging:
             print(f"[企业微信文档] {msg}")
             return pd.DataFrame()
 
+        # 新增：解析公式列的核心函数
+        def _parse_formula_field(field_value):
+            """
+            解析公式列数据，提取公式计算后的数值结果
+            公式列典型格式：{"type":"FormulaFieldProperty","value": 100, "expression": "A1+B1"}
+            """
+            if not field_value:
+                return ""
+
+            # 处理公式列的嵌套字典格式
+            if isinstance(field_value, dict) and field_value.get("type") == "FormulaFieldProperty":
+                formula_value = field_value.get("value")
+                # 如果公式计算结果是数字，直接返回；否则返回空字符串
+                if isinstance(formula_value, (int, float)):
+                    self._wechat_doc_log(f"解析公式列值：{field_value} → 提取数值{formula_value}")
+                    return formula_value
+                else:
+                    self._wechat_doc_log(f"公式列无有效数值：{field_value}")
+                    return ""
+
+            # 兼容列表嵌套公式字典的情况
+            elif isinstance(field_value, list) and len(field_value) > 0:
+                formula_values = []
+                for item in field_value:
+                    if isinstance(item, dict) and item.get("type") == "FormulaFieldProperty":
+                        val = item.get("value")
+                        if isinstance(val, (int, float)):
+                            formula_values.append(val)
+                return formula_values[0] if formula_values else ""
+
+            # 非公式格式直接返回原值
+            else:
+                return field_value
+
         # 时间转换工具
         def _unified_time_convert(value):
             if value is None or str(value).strip() in ["", "None", "nan"]:
@@ -1149,6 +1281,118 @@ class DataProcessingAndMessaging:
             else:
                 return raw_text
 
+        # 判断是否为包含user_id的有效人员字段格式
+        def _is_valid_person_format(field_value):
+            """
+            判断字段值是否为包含user_id的有效人员格式（字典/列表嵌套字典且有user_id）
+            """
+            # 空值直接返回False
+            if not field_value:
+                return False
+
+            # 列表类型：检查是否有元素包含user_id字段
+            if isinstance(field_value, list):
+                for item in field_value:
+                    if isinstance(item, dict) and item.get("user_id") is not None:
+                        return True
+                return False
+
+            # 字典类型：检查是否有user_id字段
+            elif isinstance(field_value, dict):
+                return field_value.get("user_id") is not None
+
+            # 其他类型返回False
+            else:
+                return False
+
+        # 解析人员列数据的函数
+        def _parse_person_field(field_value):
+            """
+            解析人员列数据，提取所有人员名称/user_id，用逗号分隔
+            """
+            if not field_value:
+                return ""
+
+            # 如果是列表，遍历所有元素
+            if isinstance(field_value, list):
+                person_names = []
+                for item in field_value:
+                    if isinstance(item, dict):
+                        # 优先获取名称相关字段，没有则用user_id
+                        name = item.get("name") or item.get("user_id") or item.get("text") or item.get("title")
+                        if name:
+                            person_names.append(str(name))
+                        else:
+                            # 如果没有名称字段，拼接有用的信息
+                            person_info = []
+                            if item.get("user_id"):
+                                person_info.append(item["user_id"])
+                            if item.get("id_type"):
+                                person_info.append(f"类型{item['id_type']}")
+                            if person_info:
+                                person_names.append("-".join(person_info))
+                            else:
+                                person_names.append(str(item))
+                    else:
+                        person_names.append(str(item))
+                # 去重并拼接
+                unique_names = list(set(person_names))  # 去重
+                return ", ".join(unique_names)
+
+            # 如果是字典
+            elif isinstance(field_value, dict):
+                name = field_value.get("name") or field_value.get("user_id") or field_value.get(
+                    "text") or field_value.get("title")
+                if name:
+                    return str(name)
+                else:
+                    # 返回格式化的字典信息
+                    return f"{field_value.get('user_id', '')}"
+
+            # 其他类型直接转字符串
+            else:
+                return str(field_value)
+
+        # 判断字符串是否为纯数字（支持整数/小数）
+        def _is_pure_number(s):
+            """
+            判断字符串是否为纯数字（包含整数、小数、负数）
+            """
+            if not s or str(s).strip() in ["", "None", "nan"]:
+                return True  # 空值不影响列的数字判断
+            try:
+                float(str(s).strip())
+                return True
+            except (ValueError, TypeError):
+                return False
+
+        # 转换列为数值格式
+        def _convert_numeric_columns(df):
+            """
+            遍历DataFrame列，将全为数字的列转换为数值格式（int/float自动适配）
+            """
+            numeric_columns = []
+            for col in df.columns:
+                # 跳过时间/人员相关列（避免误转换）
+                if any(kw in str(col) for kw in
+                       ["日期", "时间", "记录ID", "创建", "更新", "编辑者", "人员", "负责人", "经办人", "对接人",
+                        "联系人", "使用人", "成交人", "交付人", "品牌专家", "姓名", "销售", "维护人", "操作人",
+                        "转移人", "执行人", "人", "编辑"]):
+                    continue
+
+                # 检查列中所有非空值是否为纯数字
+                all_numeric = df[col].apply(lambda x: _is_pure_number(x)).all()
+                if all_numeric:
+                    # 先转换为float，再判断是否能转int（保留小数的自动适配）
+                    df[col] = pd.to_numeric(df[col], errors="coerce")
+                    # 若所有值都是整数，转int类型；否则保留float
+                    if (df[col].dropna() % 1 == 0).all():
+                        df[col] = df[col].astype('Int64')  # Int64支持空值
+                    numeric_columns.append(col)
+                    self._wechat_doc_log(f"列[{col}]全为数字，已转换为{df[col].dtype}格式")
+
+            return df, numeric_columns
+
         # 处理记录
         rows = []
         custom_fields = set()
@@ -1158,7 +1402,18 @@ class DataProcessingAndMessaging:
                 break
         all_fields = ["记录ID", "创建时间", "更新时间", "最后编辑者"] + list(custom_fields)
         date_related_columns = [col for col in all_fields if any(kw in str(col) for kw in ["日期", "时间"])]
+        # 识别人员相关列（包含"人员"、"负责人"、"经办人"等关键词）
+        person_related_columns = [col for col in all_fields if
+                                  any(kw in str(col) for kw in
+                                      ["人员", "负责人", "经办人", "对接人", "联系人", "使用人", "成交人", "交付人",
+                                       "品牌专家", "姓名", "销售", "维护人", "操作人", "更新人", "转移人", "执行人",
+                                       "人"])]
+        # 识别公式相关列（可根据实际列名关键词调整）
+        formula_related_columns = [col for col in all_fields if
+                                   any(kw in str(col) for kw in ["公式", "计算", "合计", "总和", "金额", "数量", "天数"])]
         self._wechat_doc_log(f"识别到需转换的日期相关列：{date_related_columns}")
+        self._wechat_doc_log(f"识别到人员相关列：{person_related_columns}")
+        self._wechat_doc_log(f"识别到公式相关列：{formula_related_columns}")
 
         for record in all_records:
             row = {
@@ -1170,15 +1425,49 @@ class DataProcessingAndMessaging:
 
             values = record.get("values", {})
             for field_name, field_value in values.items():
-                if field_name in date_related_columns:
+                # 1. 公式列优先解析
+                if field_name in formula_related_columns:
+                    row[field_name] = _parse_formula_field(field_value)
+                # 2. 日期相关列 - 时间转换
+                elif field_name in date_related_columns:
                     row[field_name] = _unified_time_convert(field_value)
+                # 3. 人员相关列 - 先判断是否为有效格式，再解析
+                elif field_name in person_related_columns:
+                    # 核心修改：先判断是否包含user_id的有效人员格式
+                    if _is_valid_person_format(field_value):
+                        row[field_name] = _parse_person_field(field_value)
+                        self._wechat_doc_log(f"列[{field_name}]值[{field_value}]符合人员格式，已解析")
+                    else:
+                        # 非有效格式，按普通字段处理
+                        if isinstance(field_value, list) and len(field_value) > 0:
+                            if isinstance(field_value[0], dict):
+                                # 处理普通列表字典，提取所有text/title并用逗号分隔
+                                text_values = []
+                                for item in field_value:
+                                    text_val = item.get("text", item.get("title", str(item)))
+                                    text_values.append(str(text_val))
+                                row[field_name] = ", ".join(text_values)
+                            else:
+                                row[field_name] = ", ".join([str(item) for item in field_value])
+                        else:
+                            row[field_name] = str(field_value) if field_value is not None else ""
+                        self._wechat_doc_log(f"列[{field_name}]值[{field_value}]非有效人员格式，按普通字段处理")
+                # 4. 其他列 - 常规处理
                 else:
-                    if isinstance(field_value, list) and len(field_value) > 0:
+                    # 兼容普通列中嵌套公式格式的情况
+                    parsed_val = _parse_formula_field(field_value)
+                    if parsed_val != "":
+                        row[field_name] = parsed_val
+                    elif isinstance(field_value, list) and len(field_value) > 0:
                         if isinstance(field_value[0], dict):
-                            row[field_name] = field_value[0].get("text",
-                                                                 field_value[0].get("title", str(field_value[0])))
+                            # 处理普通列表字典，提取所有text/title并用逗号分隔
+                            text_values = []
+                            for item in field_value:
+                                text_val = item.get("text", item.get("title", str(item)))
+                                text_values.append(str(text_val))
+                            row[field_name] = ", ".join(text_values)
                         else:
-                            row[field_name] = str(field_value)
+                            row[field_name] = ", ".join([str(item) for item in field_value])
                     else:
                         row[field_name] = str(field_value) if field_value is not None else ""
 
@@ -1187,12 +1476,17 @@ class DataProcessingAndMessaging:
         df = pd.DataFrame(rows)
         df = df[df['更新时间'] != '0']
 
-        msg = f"成功读取{len(rows)}条记录到dataframe（{len(date_related_columns)}个日期相关列已转为北京时间）"
+        # 核心新增：转换全数字列为数值格式（包含公式列）
+        df, numeric_columns = _convert_numeric_columns(df)
+
+        # 优化日志信息，包含数值列转换结果
+        msg = (f"成功读取{len(rows)}条记录到dataframe（{len(date_related_columns)}个日期相关列已转为北京时间，"
+               f"{len(person_related_columns)}个人员相关列已检查格式并处理，{len(formula_related_columns)}个公式列已解析，"
+               f"{len(numeric_columns)}个全数字列已转为数值格式：{numeric_columns}）")
         self._wechat_doc_log(msg)
         print(f"[企业微信文档] {msg}")
 
         return df
-
     # -------------------------- 企微文档：删除表格 --------------------------
     def wx_delete_table(self, docid):
         self._wechat_doc_log(f"开始删除文档：docid={docid}")
@@ -1209,8 +1503,12 @@ class DataProcessingAndMessaging:
             self._wechat_doc_log(error_msg)
             raise Exception(error_msg)
 
-        self._wechat_doc_log(f"文档删除成功：docid={docid}")
-        print(f"文档删除成功：docid={docid}")
+        # 获取当前时间（北京时间，格式：YYYY-MM-DD HH:MM:SS）
+        create_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        msg_content = f"企微文档删除成功：docid={docid} \n 删除时间：{create_time}"
+        self._wechat_doc_log(msg_content)
+        print(msg_content)
+        self.uxin_wx('dongyang', msg_content)
         return True
 
     # -------------------------- 辅助方法：检查文件是否被占用 --------------------------

{functions_d-1.2.5 → functions_d-1.28}/Functions_d/__init__.py

@@ -1,4 +1,4 @@
-# WeComMsg/__init__.py
+# Functions_d/__init__.py
 
 # 从核心代码文件中导入需要对外暴露的类/函数
 from .Functions_d import DataProcessingAndMessaging

{functions_d-1.2.5 → functions_d-1.28}/Functions_d.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Functions_d
-Version: 1.2.5
+Version: 1.28
 Summary: 包含数据处理、Hive交互、企业微信消息发送、Excel操作等功能的工具类库
 Author: DongYang
 Author-email: 649898871@qq.com

{functions_d-1.2.5 → functions_d-1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Functions_d
-Version: 1.2.5
+Version: 1.28
 Summary: 包含数据处理、Hive交互、企业微信消息发送、Excel操作等功能的工具类库
 Author: DongYang
 Author-email: 649898871@qq.com

{functions_d-1.2.5 → functions_d-1.28}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = Functions_d
-version = 1.2.5
+version = 1.28
 author = DongYang
 author_email = 649898871@qq.com
 description = 包含数据处理、Hive交互、企业微信消息发送、Excel操作等功能的工具类库