Update app.py

app.py

@@ -1,27 +1,19 @@
 import gradio as gr
 import json
-import re
 from collections import defaultdict
 
-def safe_extract_year(info_str):
-    """安全提取出生年份"""
-    try:
-        if not info_str:
-            return 9999
-        match = re.search(r'(19\d{2}|20\d{2})', str(info_str))
-        return int(match.group(1)) if match else 9999
-    except:
-        return 9999
-
-def load_full_families():
-    # 存储所有人物的详细信息，用于反向查找配偶
-    people = {}
-    # 存储父子关系：father -> [children]
-    children_map = defaultdict(list)
-    # 存储婚姻关系：husband -> wife (尝试从数据中推断)
-    marriages = {}
+def load_people_and_families():
+    """
+    从 family_data.jsonl 加载数据，并自动推断谁是配偶。
+    返回: {father_name: {"spouse": spouse_name_or_None, "children": [(name, info), ...]}}
+    """
+    # 所有记录
+    records = []
+    # 统计每个人是否有子女（即是否为人父母）
+    is_parent = set()
+    # 构建父子关系
+    children_of = defaultdict(list)
 
-    # 第一步：读取所有数据，建立索引
     try:
         with open('family_data.jsonl', 'r', encoding='utf-8') as f:
             for line in f:
@@ -29,103 +21,94 @@ def load_full_families():
                 if not line:
                     continue
                 try:
-                    record = json.loads(line)
-                    name = record.get('n')
-                    if not name:
-                        continue
-                    # 保存人物详情
-                    people[name] = {
-                        'info': record.get('info', ''),
-                        'f': record.get('f'), # 父亲
-                        'm': record.get('m'), # 母亲 (如果有)
-                    }
+                    rec = json.loads(line)
+                    name = rec.get('n')
+                    father = rec.get('f')
+                    info = rec.get('info', '')
+                    if name and father and father != "无":
+                        records.append((name, father, info))
+                        # 记录父子关系
+                        children_of[father].append((name, info))
+                        # 标记此人有父亲，但更重要的是：如果 name 出现在别人 f 字段中，他就是父母
                 except:
                     continue
-    except:
-        return {"错误": {"wife": "文件读取失败", "children": []}}
+    except Exception as e:
+        return {"__ERROR__": str(e)}
 
-    # 第二步：构建父子关系 & 婚姻关系
-    # 逻辑：遍历所有有父亲(f)的人，将其加入父亲的子女列表
-    # 逻辑：通常，女性记录中会包含其丈夫的名字（假设字段为 'spouse' 或 'f' 是夫家，这里需要根据实际数据调整）
-    # 由于数据结构未知，这里采用一种常见逻辑：如果一个人的 'f' 是某个男性，且这个人是女性（名字在特定列表或通过其他方式判断），则该男性是其丈夫。
-    # 但为了简化并消除 "待考"，我们假设：**数据中存在记录，其 'n' 是母亲，且其 'f' 字段指向其丈夫（即家里的男主人）**
-    
-    # 重新遍历，构建关系
-    for name, details in people.items():
-        father_name = details['f']
-        
-        # 如果这个人有父亲，说明他是子女，加入子女列表
-        if father_name and father_name != "无":
-            children_map[father_name].append((name, details['info']))
-        
-        # 尝试推断婚姻：如果这个人是女性（简单判断：不在明显的男性列表中，或名字在特定库），且她的 'f' 指向一个男性，则该男性是她的丈夫
-        # 这是一个复杂的逻辑，这里做一个简单假设：**如果一个人的记录中，其 'f' 是 A，且 A 在数据中存在，那么 A 是她丈夫（即她是A的妻子）**
-        # 注意：这需要数据格式支持。如果数据中母亲的记录里写着 f: "丈夫名字"，则此逻辑成立。
-        if father_name and father_name in people:
-            # 假设这是妻子嫁给了 father_name
-            marriages[father_name] = name # father_name 的妻子是这个人
+    # 第二遍：找出所有“为人父母”的人
+    all_fathers = set(children_of.keys())
+    for children in children_of.values():
+        for child_name, _ in children:
+            if child_name in all_fathers:
+                is_parent.add(child_name)
 
-    # 第三步：整理最终结果
-    result = {}
-    # 获取所有可能的父亲（有子女的，或者有妻子的）
-    all_possible_fathers = set(children_map.keys()) | set(marriages.keys())
-    
-    for father in sorted(all_possible_fathers):
-        # 获取配偶（母亲），如果没有找到，则暂时标记为“请补充”或尝试其他逻辑
-        mother = marriages.get(father, "数据中未找到配偶记录，请检查数据")
-        
-        # 获取子女并去重、排序
-        children_list = children_map.get(father, [])
-        # 去重
-        unique_children = list(set(children_list))
-        # 按年份排序
-        unique_children.sort(key=lambda x: safe_extract_year(x[1]))
-        
-        result[father] = {
-            "wife": mother,
+    # 构建最终家庭结构
+    families = {}
+    processed_fathers = set()
+
+    # 所有出现过的男性家长（作为父亲出现过的人）
+    for father in all_fathers:
+        children_list = children_of[father]
+        real_children = []
+        spouse_candidate = None
+
+        for name, info in children_list:
+            # 如果这个人自己也是父母，那他大概率不是子女，而是配偶（儿媳/女婿）或同辈
+            # 但在夫权家谱中，通常是妻子被记在丈夫名下
+            if name in is_parent:
+                # 暂定为配偶（取第一个符合条件的）
+                if spouse_candidate is None:
+                    spouse_candidate = name
+                # 即使有多个，也只取一个作为配偶，其余可能需人工审核
+            else:
+                real_children.append((name, info))
+
+        # 去重子女
+        unique_children = list(set(real_children))
+        # 简单按名字排序（因无年份无法精确排）
+        unique_children.sort(key=lambda x: x[0])
+
+        families[father] = {
+            "spouse": spouse_candidate or "（请补充配偶）",
             "children": unique_children
         }
+        processed_fathers.add(father)
 
-    return result
+    return families
 
-def show_all_families():
-    families = load_full_families()
+def format_family_table():
+    families = load_people_and_families()
     
-    # 如果返回的是错误信息
-    if "错误" in families:
-        return families["错误"]
-        
-    output_lines = ["# 冯氏家族关系网家网成员表\n"]
+    if "__ERROR__" in families:
+        return f"❌ 数据加载失败：{families['__ERROR__']}"
+    
+    lines = ["# 冯氏家族关系网家网成员表\n"]
     
     for father in sorted(families.keys()):
-        family_data = families[father]
-        mother = family_data["wife"]
-        children = family_data["children"]
-        
-        output_lines.append(f"### {father} 家庭")
-        output_lines.append(f"*   **父亲**：{father}")
-        output_lines.append(f"*   **母亲**：{mother}")
-        output_lines.append("*   **子女**：")
+        data = families[father]
+        spouse = data["spouse"]
+        children = data["children"]
         
+        lines.append(f"### {father} 家庭")
+        lines.append(f"- **父亲**：{father}")
+        lines.append(f"- **母亲**：{spouse}")
+        lines.append("- **子女**：")
         if children:
             for name, info in children:
-                year = safe_extract_year(info)
-                year_str = f"({year})" if year != 9999 else ""
-                output_lines.append(f"    *   {name} {year_str} - {info}")
+                lines.append(f"  - {name} — {info}")
         else:
-            output_lines.append("    *   (暂无子女记录)")
-            
-        output_lines.append("") # 空行分隔
-
-    return "\n".join(output_lines)
+            lines.append("  - （暂无子女记录）")
+        lines.append("")  # 空行分隔
+    
+    return "\n".join(lines)
 
-# 构建 Gradio 应用
+# Gradio 应用
 demo = gr.Interface(
-    fn=show_all_families,
+    fn=format_family_table,
     inputs=None,
-    outputs=gr.Markdown(label="家族成员表"), # 使用 Markdown 更美观
+    outputs=gr.Markdown(label="家族成员表"),
     title="冯氏家族关系网家网成员表",
-    description="点击 **Generate** 查看所有家庭成员（自动关联母亲名字）"
+    description="点击 **Generate** 自动生成全体家庭成员（自动识别配偶与子女）"
 )
 
 if __name__ == "__main__":