python
from docx import Document, text
from pathlib import Path, PurePosixPath
doc_main_path = Path("/mnt/data/一种基于实体链接库和知识表示进行视图数据一致性检测方法.docx")
doc_q_path = Path("/mnt/data/Q_一种基于图论和大模型的时序图一致性检测的方法.docx")
doc_main = Document(str(doc_main_path))
doc_q = Document(str(doc_q_path))
len(doc_q.paragraphs), len(doc_main.paragraphs)


(81, 65)

python
# Let's print first 30 paragraphs of Q doc with indices and text
for i,p in enumerate(doc_q.paragraphs[:30]):
    t=p.text.strip()
    if t:
        print(i, t[:200])

python
# search for markers in Q doc paragraphs
markers=[]
for i,p in enumerate(doc_q.paragraphs):
    t=p.text
    if "批注" in t or "注释" in t or "Q" in t or "?" in t or "建议" in t:
        markers.append((i,t.strip()[:200]))
markers[:20], len(markers)


([(38,
   '步骤4：将大模型的推理结果进行输出和反馈。大模型根据推理结果生成一致性检测报告或修正建议，反馈给用户，从而辅助用户修正视图中的不一致性，优化系统设计。'),
  (63,
   '大模型将推理和验证的结果进行整合，生成最终的一致性检测报告。该报告将明确指出识别到的不一致性及其可能的逻辑原因，并可能提供修正建议。验证结果最后反馈给用户，用户可以根据大模型的反馈，进一步修正视图中的不一致性，从而优化系统设计。')],
 2)

python
import zipfile, re, os, io, pandas as pd, xml.etree.ElementTree as ET
def list_docx_parts(path):
    with zipfile.ZipFile(path,'r') as z:
        return z.namelist()
parts_q = list_docx_parts(doc_q_path)
parts_main = list_docx_parts(doc_main_path)
# check for comments.xml presence
('word/comments.xml' in parts_q, 'word/comments.xml' in parts_main)


(True, False)

python
from lxml import etree
def read_xml_from_docx(path, name):
    with zipfile.ZipFile(path,'r') as z:
        data = z.read(name)
    return data
comments_xml_q = read_xml_from_docx(doc_q_path, 'word/comments.xml')
doc_xml_q = read_xml_from_docx(doc_q_path, 'word/document.xml')
# parse and extract comment texts
root = etree.fromstring(comments_xml_q)
ns = root.nsmap
# w namespace
w_ns = ns.get(None) or ns.get('w')
# comments are w:comment
comments=[]
for c in root.findall('.//{http://schemas.openxmlformats.org/wordprocessingml/2006/main}comment'):
    cid=c.get('{http://schemas.openxmlformats.org/wordprocessingml/2006/main}id')
    # get text
    texts = c.findall('.//{http://schemas.openxmlformats.org/wordprocessingml/2006/main}t')
    content=''.join([t.text or '' for t in texts])
    comments.append((cid, content[:200]))
comments[:10], len(comments)


([('0', '未明确先后顺序与逻辑关系，对步骤顺序存在不够严谨之处'),
  ('1', '和“大模型”未加具体限定，是否需要收紧术语定义以避免过度宽泛。'),
  ('2', '预处理如何体现'),
  ('3', '要解决的是时序图，还是设计视图和实现视图等多种视图，是仅限于时序图的不同抽象层级，还是泛指UML各类图'),
  ('4', '具体LLM的参数、类型'),
  ('5', '什么格式，可视化与否'),
  ('6', '如何得出显著提高的结论，有无基于某个benchmark的对比方法或baseline，缺乏数据支撑'),
  ('8', '实施例及特征可以相互组合是什么意思'),
  ('9', '是否需要说明时序图的定义'),
  ('10', '是否有些笼统，比如具体哪些可被识别的结构化格式，增加对时序图解析的描述，例如解析消息序列、识别并行/分支结构等具体步骤')],
 24)

python
# find first occurrence of commentRangeStart in doc_xml_q
doc_str = doc_xml_q.decode('utf-8')
idx = doc_str.find('commentRangeStart')
idx, doc_str[idx-200:idx+200]


(8198,
 'w:lastRenderedPageBreak/><w:t>1.</w:t></w:r><w:r w:rsidRPr="006E6E13"><w:rPr><w:rFonts w:ascii="Times New Roman" w:hAnsi="Times New Roman"/></w:rPr><w:t>一种基于图论和大模型的时序图一致性检测方法，其特征在于，所述方法</w:t></w:r><w:commentRangeStart w:id="0"/><w:r w:rsidRPr="006E6E13"><w:rPr><w:rFonts w:ascii="Times New Roman" w:hAnsi="Times New Roman"/></w:rPr><w:t>包括</w:t></w:r><w:commentRangeEnd w:id="0"/><w:r w:rsidR="009035')

python
doc_root = etree.fromstring(doc_xml_q)
W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
# locate commentRangeStart with id 0
crs = doc_root.findall(f".//{{{W}}}commentRangeStart[@{{{W}}}id='0']")
len(crs)


1

python
# get its parent paragraph text
node=crs[0]
# find ancestor paragraph
p = node.getparent()
while p is not None and p.tag != f"{{{W}}}p":
    p=p.getparent()
# collect full paragraph text
def get_par_text(p):
    return ''.join([t.text or '' for t in p.findall(f'.//{{{W}}}t')])
print(get_par_text(p)[:300])

python
for i,p in enumerate(doc_main.paragraphs):
    if "装置" in p.text and "存储介质" in p.text:
        print(i,p.text)

python
rels_q = read_xml_from_docx(doc_q_path, 'word/_rels/document.xml.rels')
print(rels_q.decode('utf-8')[:500])

python
# parse and find comments relationship
rels_root = etree.fromstring(rels_q)
pkg="http://schemas.openxmlformats.org/package/2006/relationships"
rels=[]
for rel in rels_root.findall(f"{{{pkg}}}Relationship"):
    if rel.get('Type')=="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments":
        rels.append(rel)
rels, [ (r.get('Id'), r.get('Target')) for r in rels]


([<Element {http://schemas.openxmlformats.org/package/2006/relationships}Relationship at 0x7ec88862b490>],
 [('rId11', 'comments.xml')])

python
# parse and find comments relationship
rels_root = etree.fromstring(rels_q)
pkg="http://schemas.openxmlformats.org/package/2006/relationships"
rels=[]
for rel in rels_root.findall(f"{{{pkg}}}Relationship"):
    if rel.get('Type')=="http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments":
        rels.append(rel)
rels, [ (r.get('Id'), r.get('Target')) for r in rels]


([<Element {http://schemas.openxmlformats.org/package/2006/relationships}Relationship at 0x7ec88862b490>],
 [('rId11', 'comments.xml')])



([<Element {http://schemas.openxmlformats.org/package/2006/relationships}Relationship at 0x7ec88862b490>],
 [('rId11', 'comments.xml')])

python
rels_main = read_xml_from_docx(doc_main_path, 'word/_rels/document.xml.rels')
rels_root_main = etree.fromstring(rels_main)
rels_main_ids=[rel.get('Id') for rel in rels_root_main.findall(f"{{{pkg}}}Relationship")]
rels_main_ids[:10], len(rels_main_ids), max(int(r[3:]) for r in rels_main_ids if r.startswith('rId'))


(['rId8',
  'rId13',
  'rId18',
  'rId3',
  'rId21',
  'rId7',
  'rId12',
  'rId17',
  'rId2',
  'rId16'],
 21,
 21)

python
ct_main = read_xml_from_docx(doc_main_path, '[Content_Types].xml')
ct_root = etree.fromstring(ct_main)
# find override for comments in q doc to copy
ct_q = read_xml_from_docx(doc_q_path, '[Content_Types].xml')
ct_root_q = etree.fromstring(ct_q)
ns_ct = ct_root.nsmap.get(None)
# search for Override PartName="/word/comments.xml"
def has_comments(ct_root):
    for el in ct_root.findall(f"{{{ns_ct}}}Override"):
        if el.get('PartName')=="/word/comments.xml":
            return True, el.get('ContentType')
    return False, None
has_comments(ct_root), has_comments(ct_root_q)


((False, None),
 (True,
  'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'))

python
doc_xml_main = read_xml_from_docx(doc_main_path, 'word/document.xml')
doc_root_main = etree.fromstring(doc_xml_main)
# find the paragraph containing the substring
target_sub = "本发明涉及人工智能与数据处理领域"
paras = doc_root_main.findall(f".//{{{W}}}p")
target_p=None
for p in paras:
    txt=''.join([t.text or '' for t in p.findall(f'.//{{{W}}}t')])
    if target_sub in txt:
        target_p=p
        target_txt=txt
        break
target_txt[:200] if target_p is not None else None


'本发明涉及人工智能与数据处理领域，尤其涉及一种多视图数据（Multi-view Data）一致性检测方法、装置、设备和计算机存储介质。本发明具体涉及一种结合了符号级实体对齐与向量级语义验证的双重检测机制，用于数据集成、知识图谱构建及数据治理等场景。'

python
# get xml string of paragraph with comment id 0 in Q doc
p_q = crs[0]
p = p_q
while p is not None and p.tag != f"{{{W}}}p":
    p=p.getparent()
p_xml = etree.tostring(p, encoding='unicode')
p_xml[:600]


'<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/10/chartex" xmlns:cx5="http:/'

python
# list children tags of that paragraph in q doc
children = list(p)
for c in children[:20]:
    print(c.tag.split('}')[-1], c.attrib)

python
# find commentReference in the paragraph
refs = p.findall(f".//{{{W}}}commentReference")
len(refs), refs[0].attrib


(1, {'{http://schemas.openxmlformats.org/wordprocessingml/2006/main}id': '0'})

python
# get parent run of commentReference
ref_run = refs[0]
parent = ref_run.getparent()
while parent is not None and parent.tag != f"{{{W}}}r":
    parent = parent.getparent()
etree.tostring(parent, encoding='unicode')[:300]


'<w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmln'

python
for c in list(parent):
    print(c.tag.split('}')[-1], c.attrib)

python
rPr = parent.find(f'{{{W}}}rPr')
etree.tostring(rPr, encoding='unicode')[:200]


'<w:rPr xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/offi'

python
# find rStyle inside rPr
rStyle = rPr.find(f'.//{{{W}}}rStyle')
rStyle.attrib if rStyle is not None else None


{'{http://schemas.openxmlformats.org/wordprocessingml/2006/main}val': 'a7'}

python
styles_main = read_xml_from_docx(doc_main_path, 'word/styles.xml')
styles_root = etree.fromstring(styles_main)
# find styleId containing CommentReference
styles=[]
for s in styles_root.findall(f".//{{{W}}}style"):
    sid = s.get(f"{{{W}}}styleId")
    if sid and 'Comment' in sid:
        styles.append(sid)
styles[:20]


[]

python
styles_q = read_xml_from_docx(doc_q_path, 'word/styles.xml')
styles_root_q = etree.fromstring(styles_q)
style_a7 = styles_root_q.find(f".//{{{W}}}style[@{{{W}}}styleId='a7']")
style_a7 is not None


True

python
# get its name
name = style_a7.find(f'{{{W}}}name').get(f'{{{W}}}val')
name


'annotation reference'

python
'word/commentsExtended.xml' in parts_q, 'word/commentsExtended.xml' in parts_main


(True, False)

python
[x for x in parts_q if 'comment' in x.lower()][:20]


['word/comments.xml',
 'word/commentsExtended.xml',
 'word/commentsIds.xml',
 'word/commentsExtensible.xml']

python
rels_comment_types=[]
for rel in rels_root.findall(f"{{{pkg}}}Relationship"):
    t=rel.get('Type')
    if 'comments' in t:
        rels_comment_types.append((rel.get('Id'), t, rel.get('Target')))
rels_comment_types


[('rId13',
  'http://schemas.microsoft.com/office/2016/09/relationships/commentsIds',
  'commentsIds.xml'),
 ('rId12',
  'http://schemas.microsoft.com/office/2011/relationships/commentsExtended',
  'commentsExtended.xml'),
 ('rId11',
  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments',
  'comments.xml'),
 ('rId14',
  'http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible',
  'commentsExtensible.xml')]

python
ct_q_root = ct_root_q
ctns = ct_q_root.nsmap.get(None)
overrides = [(el.get('PartName'), el.get('ContentType')) for el in ct_q_root.findall(f"{{{ctns}}}Override") if 'comments' in el.get('PartName')]
overrides


[('/word/comments.xml',
  'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'),
 ('/word/commentsExtended.xml',
  'application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml'),
 ('/word/commentsIds.xml',
  'application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml'),
 ('/word/commentsExtensible.xml',
  'application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml')]

python
for part in ['word/commentsIds.xml','word/commentsExtended.xml','word/commentsExtensible.xml']:
    xml = read_xml_from_docx(doc_q_path, part)
    print(part, xml[:200])

python
# parse and view root tags and some attributes for these files
def summarize_xml(xml_bytes):
    root=etree.fromstring(xml_bytes)
    return root.tag, root.nsmap
for part in ['word/commentsIds.xml','word/commentsExtended.xml','word/commentsExtensible.xml']:
    xml = read_xml_from_docx(doc_q_path, part)
    tag, nsmap = summarize_xml(xml)
    print(part, tag.split('}')[-1], list(nsmap.keys())[:6])

python
W14="http://schemas.microsoft.com/office/2016/09/wordml/cid"
# Actually commentsIds uses namespace w16cid maybe. Let's search in raw.
xml_ids = read_xml_from_docx(doc_q_path,'word/commentsIds.xml')
print(xml_ids.decode('utf-8')[:600])

python
# search for 'commentId' strings
s=xml_ids.decode('utf-8')
for m in re.finditer('commentId', s):
    print("pos", m.start())
    break

python
print(s[2600:2700])

python
xml_ext = read_xml_from_docx(doc_q_path,'word/commentsExtended.xml')
root_ext = etree.fromstring(xml_ext)
# find first commentEx element maybe 'w15:commentEx'?
# list child tags unique
tags=set()
for el in root_ext.iter():
    tags.add(el.tag.split('}')[-1])
sorted(list(tags))[:30], len(tags)


(['commentEx', 'commentsEx'], 2)

python
# show first 2 commentEx elements attributes
# root uses namespace 'w15' maybe; let's find element with localname commentEx
commentEx_elems=[el for el in root_ext if el.tag.split('}')[-1]=='commentEx']
len(commentEx_elems), commentEx_elems[0].attrib


(24,
 {'{http://schemas.microsoft.com/office/word/2012/wordml}paraId': '0E62C883', '{http://schemas.microsoft.com/office/word/2012/wordml}done': '0'})

python
# The commentEx has w15:paraId, w15:done, w15:durableId? Let's print attributes names
for k,v in commentEx_elems[0].attrib.items():
    print(k, v)

python
root_comments = etree.fromstring(comments_xml_q)
comment0 = root_comments.find(f".//{{{W}}}comment[@{{{W}}}id='0']")
comment0.attrib


{'{http://schemas.openxmlformats.org/wordprocessingml/2006/main}id': '0', '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}author': 'Orange Mr.', '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}date': '2025-11-18T15:30:00Z', '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}initials': 'OM'}

python
for k,v in comment0.attrib.items():
    print(k, v)

python
xml_extensible = read_xml_from_docx(doc_q_path,'word/commentsExtensible.xml')
root_extensible = etree.fromstring(xml_extensible)
tags=set(el.tag.split('}')[-1] for el in root_extensible.iter())
tags


{'commentExtensible', 'commentsExtensible'}

python
# show first commentExtensible
ce=[el for el in root_extensible if el.tag.split('}')[-1]=='commentExtensible']
len(ce), ce[0].attrib


(24,
 {'{http://schemas.microsoft.com/office/word/2018/wordml/cex}durableId': '1E3B79D1', '{http://schemas.microsoft.com/office/word/2018/wordml/cex}dateUtc': '2025-11-18T07:30:00Z'})

python
for k,v in ce[0].attrib.items():
    print(k,v)

python
import zipfile, shutil, datetime, random
from lxml import etree
out_path = Path("/mnt/data/已批注_一种基于实体链接库和知识表示进行视图数据一致性检测方法.docx")
# read main docx zip
with zipfile.ZipFile(doc_main_path, 'r') as zin:
    files = {name: zin.read(name) for name in zin.namelist()}

# Modify document.xml by inserting comment markers in target paragraph
doc_root_main = etree.fromstring(files['word/document.xml'])
# find paragraph containing target_sub
paras = doc_root_main.findall(f".//{{{W}}}p")
target_p = None
for p in paras:
    txt=''.join([t.text or '' for t in p.findall(f'.//{{{W}}}t')])
    if target_sub in txt:
        target_p = p
        break
assert target_p is not None

# Determine insertion positions: after pPr if exists else at start
children=list(target_p)
insert_pos=0
if children and children[0].tag==f"{{{W}}}pPr":
    insert_pos=1

# Create commentRangeStart element
crs = etree.Element(f"{{{W}}}commentRangeStart")
crs.set(f"{{{W}}}id","0")
cre = etree.Element(f"{{{W}}}commentRangeEnd")
cre.set(f"{{{W}}}id","0")
# commentReference run
r = etree.Element(f"{{{W}}}r")
comment_ref = etree.SubElement(r, f"{{{W}}}commentReference")
comment_ref.set(f"{{{W}}}id","0")

# Insert start at insert_pos
target_p.insert(insert_pos, crs)
# Insert end and reference at end of paragraph
target_p.append(cre)
target_p.append(r)

# Serialize back
files['word/document.xml'] = etree.tostring(doc_root_main, xml_declaration=True, encoding='UTF-8', standalone="yes")

# Create comments.xml and related parts
# Use IDs copied from Q doc (paraId/durableId)
paraId="0E62C883"
durableId="1E3B79D1"
# Date: now in UTC-ish
now_utc = datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z"
# comments.xml
comments_nsmap = {
    'w': W
}
comments_root = etree.Element(f"{{{W}}}comments", nsmap={'w':W})
# create comment element
comment_el = etree.SubElement(comments_root, f"{{{W}}}comment")
comment_el.set(f"{{{W}}}id","0")
comment_el.set(f"{{{W}}}author","研二学生")
comment_el.set(f"{{{W}}}date", now_utc)
comment_el.set(f"{{{W}}}initials","GS")
# comment paragraph
p_el = etree.SubElement(comment_el, f"{{{W}}}p")
r_el = etree.SubElement(p_el, f"{{{W}}}r")
t_el = etree.SubElement(r_el, f"{{{W}}}t")
t_el.text = "【批注】技术领域写到“装置、设备和计算机存储介质”，但权利要求目前只有“方法”条款。建议：补充装置/设备/存储介质权利要求（对应模块或处理器-存储器结构），或删减说明书中相关表述以保持一致。"
files['word/comments.xml'] = etree.tostring(comments_root, xml_declaration=True, encoding='UTF-8', standalone="yes")

# commentsIds.xml (w16cid)
w16cid = "http://schemas.microsoft.com/office/2016/09/wordml/cid"
commentsIds_root = etree.Element(f"{{{w16cid}}}commentsIds", nsmap={'w16cid':w16cid})
commentId_el = etree.SubElement(commentsIds_root, f"{{{w16cid}}}commentId")
commentId_el.set(f"{{{w16cid}}}paraId", paraId)
commentId_el.set(f"{{{w16cid}}}durableId", durableId)
files['word/commentsIds.xml'] = etree.tostring(commentsIds_root, xml_declaration=True, encoding='UTF-8', standalone="yes")

# commentsExtended.xml (w15)
w15 = "http://schemas.microsoft.com/office/word/2012/wordml"
commentsEx_root = etree.Element(f"{{{w15}}}commentsEx", nsmap={'w15':w15})
commentEx_el = etree.SubElement(commentsEx_root, f"{{{w15}}}commentEx")
commentEx_el.set(f"{{{w15}}}paraId", paraId)
commentEx_el.set(f"{{{w15}}}done","0")
files['word/commentsExtended.xml'] = etree.tostring(commentsEx_root, xml_declaration=True, encoding='UTF-8', standalone="yes")

# commentsExtensible.xml (w16cex)
w16cex="http://schemas.microsoft.com/office/word/2018/wordml/cex"
commentsExt_root = etree.Element(f"{{{w16cex}}}commentsExtensible", nsmap={'w16cex':w16cex})
commentExt_el = etree.SubElement(commentsExt_root, f"{{{w16cex}}}commentExtensible")
commentExt_el.set(f"{{{w16cex}}}durableId", durableId)
commentExt_el.set(f"{{{w16cex}}}dateUtc", now_utc.replace("Z","Z"))  # keep Z
files['word/commentsExtensible.xml'] = etree.tostring(commentsExt_root, xml_declaration=True, encoding='UTF-8', standalone="yes")

# Update relationships
rels_root_main = etree.fromstring(files['word/_rels/document.xml.rels'])
# compute next rId number
existing_ids=[rel.get('Id') for rel in rels_root_main.findall(f"{{{pkg}}}Relationship")]
max_id=max(int(r[3:]) for r in existing_ids if r.startswith('rId'))
def add_rel(rel_id, rel_type, target):
    rel=etree.SubElement(rels_root_main, f"{{{pkg}}}Relationship")
    rel.set("Id", rel_id)
    rel.set("Type", rel_type)
    rel.set("Target", target)
# add four rels
add_rel(f"rId{max_id+1}", "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", "comments.xml")
add_rel(f"rId{max_id+2}", "http://schemas.microsoft.com/office/2011/relationships/commentsExtended", "commentsExtended.xml")
add_rel(f"rId{max_id+3}", "http://schemas.microsoft.com/office/2016/09/relationships/commentsIds", "commentsIds.xml")
add_rel(f"rId{max_id+4}", "http://schemas.microsoft.com/office/2018/08/relationships/commentsExtensible", "commentsExtensible.xml")
files['word/_rels/document.xml.rels'] = etree.tostring(rels_root_main, xml_declaration=True, encoding='UTF-8', standalone="yes")

# Update content types
ct_root_main = etree.fromstring(files['[Content_Types].xml'])
ctns = ct_root_main.nsmap.get(None)
# helper to add override if not exists
def ensure_override(partname, contenttype):
    for el in ct_root_main.findall(f"{{{ctns}}}Override"):
        if el.get('PartName')==partname:
            return
    ov=etree.SubElement(ct_root_main, f"{{{ctns}}}Override")
    ov.set("PartName", partname)
    ov.set("ContentType", contenttype)
ensure_override("/word/comments.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml")
ensure_override("/word/commentsExtended.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml")
ensure_override("/word/commentsIds.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsIds+xml")
ensure_override("/word/commentsExtensible.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtensible+xml")
files['[Content_Types].xml'] = etree.tostring(ct_root_main, xml_declaration=True, encoding='UTF-8', standalone="yes")

# Write out new docx
with zipfile.ZipFile(out_path, 'w', compression=zipfile.ZIP_DEFLATED) as zout:
    for name,data in files.items():
        zout.writestr(name, data)

out_path, out_path.exists(), out_path.stat().st_size


(PosixPath('/mnt/data/已批注_一种基于实体链接库和知识表示进行视图数据一致性检测方法.docx'), True, 314578)

python
parts_out = list_docx_parts(out_path)
[x for x in parts_out if 'comment' in x.lower()] , 'word/comments.xml' in parts_out


(['word/comments.xml',
  'word/commentsIds.xml',
  'word/commentsExtended.xml',
  'word/commentsExtensible.xml'],
 True)

python
# Ensure document.xml contains commentRangeStart for id 0
doc_out = read_xml_from_docx(out_path,'word/document.xml').decode('utf-8')
'commentRangeStart' in doc_out, doc_out.count('commentRangeStart'), doc_out.count('commentReference')


(True, 1, 1)

python
from docx import Document, text
import re, os, itertools, math, json, pandas as pd
ex_path="/mnt/data/Q_一种基于图论和大模型的时序图一致性检测的方法.docx"
doc=Document(ex_path)
paras=[p.text for p in doc.paragraphs]
len(paras), paras[:30]


(81,
 ['本发明提供一种基于图论和大模型的时序图一致性检测的方法。该方法包括：首先，将时序图中的时间元素（如时间点、状态、事件）和逻辑关系（如时间依赖性、先后顺序）进行结构化转化，构建为图结构表示；其次，应用图论算法，例如深度优先遍历（DFS）和图同构检测，对所述图结构进行分析，以识别潜在的不一致性节点组合或路径；然后，将图论检测结果中的潜在错误节点或节点组合传递给大语言模型进行进一步的逻辑推理和语义验证；最后，大模型输出一致性检测结果并反馈给用户。本发明通过将图论的结构化分析与大模型的强大语义推理能力相结合，能够系统化且自动化地识别时序图中的潜在错误，显著提高验证的精度和效率。',
  '',
  '',
  '',
  '',
  '',
  '1.一种基于图论和大模型的时序图一致性检测方法，其特征在于，所述方法包括：',
  '1）时序图结构化转化：将输入的时序图中的时间元素抽象为图中的节点，并将所述时间元素之间的逻辑关系通过边进行表示，构建结构化图表示；',
  '2）图论算法应用：使用至少一种图论算法对所述结构化图表示进行遍历和检测，识别出潜在的不一致节点或节点组合；',
  '3）大模型推理验证：将图论算法识别到的所述潜在不一致节点或节点组合作为输入提示，传递给大模型，由所述大模型进行语义推理和逻辑验证；',
  '4）结果反馈：接收所述大模型的推理和验证结果，并将其作为一致性检测结果进行反馈。',
  '2.根据权利要求1所述的方法，其特征在于，所述时间元素包括时间点、状态或事件；所述逻辑关系包括时间依赖性、先后顺序或状态转换。',
  '3.根据权利要求1所述的方法，其特征在于，步骤2）中所述图论算法包括图的深度优先遍历（DFS）；所述深度优先遍历用于探索图中所有可能的路径，检查状态转换的合理性，并确保时间顺序的依赖关系得到满足。',
  '4.根据权利要求1所述的方法，其特征在于，步骤2）中所述图论算法包括图同构检测；所述图同构检测用于识别和比较不同时序图视图之间的结构相似性和差异性，以辅助发现结构上的不一致。',
  '5.根据权利要求1所述的方法，其特征在于，步骤3）中所述大模型的语义推理和逻辑验证包括：识别时间依赖关系的错误、状态转换的异常或因果链的断裂，以及进行跨视图一致性检查。',
  '6.一种基于图论和大模型的时序图一致性检测装置，其特征在于，包括：',
  '1）结构化转化模块，用于将时序图中的时间元素抽象为节点，并将逻辑关系表示为边，构建结构化图表示；',
  '2）图论分析模块，用于使用图论算法对所述结构化图表示进行分析，识别潜在的不一致节点或节点组合；',
  '3）一致性检测模块，用于将所述潜在不一致节点或节点组合传递给大模型进行推理验证，并获得一致性输出结果。',
  '',
  '',
  '一种基于大模型的多视图一致性检测方法方法',
  '一、技术领域',
  '本发明涉及人工智能领域，尤其涉及一种基于图论和深度学习的系统一致性检测方法、装置、设备和计算机存储介质。',
  '二、背景技术',
  '在软件工程和系统工程领域，时序图（Sequence Diagram）是一种关键的UML（统一建模语言）工具，专门用于描述系统中不同对象或组件之间随时间发生的交互。时序图通过垂直生命线代表对象，通过水平箭头表示对象间的消息传递，能够清晰地展示系统在执行某个用例或操作时的动态行为、事件因果链以及状态转换。它为系统行为的验证提供了至关重要的信息。',
  '然而，随着现代系统（如分布式系统、物联网、微服务架构）的复杂性和规模急剧增长，时序图所承载的交互逻辑也变得异常繁复。一个复杂的业务流程可能涉及数十个组件和数百条消息。在这种情况下，仅依靠手动审查或传统的算法验证方式，已难以有效识别图中隐藏的潜在错误或不一致性。',
  '这些不一致性可能表现为多种形式，例如：时间顺序的依赖关系错误（如一个响应消息先于它的请求消息出现）、状态转换的异常（如一个对象在未被初始化时就被调用）、事件因果链的断裂（如一个关键步骤被遗漏），或是跨越多个不同视图（例如，高层架构时序图与底层详细设计时序图）之间的逻辑矛盾。',
  '为了解决这一问题，业界已有的方法主要集中在基于形式化或图论的算法。例如，可以将时序图结构化为图（Graph）表示，其中时间元素（如事件、状态）被抽象为节点，逻辑关系（如先后顺序）被抽象为边。随后，可以应用图论算法（如图的深度优先遍历DFS）来探索所有可能的执行路径，检查状态转换的合理性。',
  '尽管图论方法能够有效地识别图结构中的某些不一致性，但它们在实际应用中仍存在局限。首先，面对大规模且复杂的图，纯粹的图论算法可能难以应对；其次，更重要的是，这些算法虽然擅长结构分析，但往往缺乏对交互“语义”的深入理解。它们可以发现“A是否总在B之前”，但很难判断“在A之后接着发生B，在逻辑上是否合理”。'])

python
import zipfile, pandas as pd, os, re, textwrap
def has_comments(docx_path):
    with zipfile.ZipFile(docx_path,'r') as z:
        return 'word/comments.xml' in z.namelist(), [n for n in z.namelist() if 'comments' in n]
for path in [ex_path, "/mnt/data/一种基于实体链接库和知识表示进行视图数据一致性检测方法.docx"]:
    print(path, has_comments(path))

python
import zipfile, lxml.etree as ET, datetime
def read_zip_xml(docx_path, internal_path):
    with zipfile.ZipFile(docx_path,'r') as z:
        data=z.read(internal_path)
    return data
ex_comments=read_zip_xml(ex_path,'word/comments.xml')
ex_comments[:500]


b'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n<w:comments xmlns:wpc="http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas" xmlns:cx="http://schemas.microsoft.com/office/drawing/2014/chartex" xmlns:cx1="http://schemas.microsoft.com/office/drawing/2015/9/8/chartex" xmlns:cx2="http://schemas.microsoft.com/office/drawing/2015/10/21/chartex" xmlns:cx3="http://schemas.microsoft.com/office/drawing/2016/5/9/chartex" xmlns:cx4="http://schemas.microsoft.com/office/drawing/2016/5/1'

python
# pretty print first comment id
root=ET.fromstring(ex_comments)
ns=root.nsmap
len(root), list(root)[:1]


(24,
 [<Element {http://schemas.openxmlformats.org/wordprocessingml/2006/main}comment at 0x7edbba4423d0>])

python
# Inspect first few comment elements for attributes
for c in root.findall('.//w:comment', namespaces=ns)[:3]:
    print(c.get('{%s}id'%ns['w']), c.get('{%s}author'%ns['w']), c.get('{%s}date'%ns['w']))
    # get text content
    texts=c.findall('.//w:t', namespaces=ns)
    print('text:', ''.join([t.text or '' for t in texts])[:200])

python
target_path="/mnt/data/一种基于实体链接库和知识表示进行视图数据一致性检测方法.docx"
doc=Document(target_path)
paras=[p.text for p in doc.paragraphs]
len(paras), paras[:40]


(65,
 ['本发明公开了一种基于实体链接库和知识表示进行视图数据一致性检测方法，旨在解决异构数据源集成过程中的一致性冲突问题。该方法首先将来自不同来源或表达形式的两个原始视图分别转换为统一的结构化表示形式（例如RDF三元组）。其次，提取视图中的命名实体并构建一个轻量级的实体链接库，通过实体链接技术实现跨视图的实体消歧与对齐，以检测实体名称层面的不一致性。进一步地，为捕捉更深层次的语义不一致（如关系错配、属性冲突），引入知识表示，利用TransE（Translating Embeddings for Modeling Multi-relational Data）模型对两个视图的结构化三元组进行联合嵌入学习，最后，在此基础上，设计基于嵌入相似度（如余弦相似度、欧氏距离）和向量平移误差的一致性度量机制，通过评估已对齐实体在嵌入空间中的距离或三元组的平移误差来判定语义层面的不一致性。本方法通过“符号级对齐+向量级验证”的双重机制，实现对多视图数据一致性的细粒度、可解释性判断，可广泛应用于数据集成、知识图谱构建、跨模态对齐等场景。',
  '',
  '',
  '',
  '',
  '1. 一种基于实体链接库和知识表示进行视图数据一致性检测方法，其特征在于，包括以下步骤：',
  '1）将来自不同来源或表达形式的两个原始视图分别转换为统一的结构化表示形式；',
  '2）在所述结构化表示的基础上，提取其中显式或隐式的命名实体，并构建一个实体链接库，通过实体链接技术实现跨视图的实体消歧与对齐，检测实体名称层面的不一致性；',
  '3）为捕捉深层次的语义不一致，利用TransE模型对两个视图的所述结构化三元组进行联合嵌入学习，获得每个实体和关系的语义向量表示；',
  '4）设计基于嵌入相似度的一致性度量机制 ：对于在实体链接阶段已对齐的实体对，计算其在嵌入空间中的相似度；对于共享关系路径的三元组，评估其向量平移误差 ，根据所述相似度或平移误差判定是否存在语义层面的不一致性。',
  '2. 根据权利要求1所述的方法，其特征在于，所述统一的结构化表示形式包括RDF三元组或属性值对。',
  '3. 根据权利要求1所述的方法，其特征在于，所述实体链接库包含每个视图中识别出的实体及其可能指向的标准知识库中的规范实体标识符；所述标准知识库包括Wikidata或DBpedia。',
  '4. 根据权利要求1所述的方法，其特征在于，所述TransE模型将实体和关系映射到低维连续向量空间中，并遵循“头实体 + 关系 ≈ 尾实体”的平移假设。',
  '5. 根据权利要求1所述的方法，其特征在于，所述嵌入相似度包括余弦相似度或欧氏距离；所述向量平移误差为∥h+r−t∥的范数。',
  '6. 根据权利要求5所述的方法，其特征在于，若所述相似度低于预设阈值或所述平移误差显著偏高，则判定存在语义层面的不一致性。',
  '7. 根据权利要求1-6任一项所述的方法，其特征在于，所述方法应用于数据集成、知识图谱构建、跨模态对齐或数据治理场景。',
  '',
  '一种基于实体链接库和知识表示进行视图数据一致性检测方法',
  '技术领域',
  '本发明涉及人工智能与数据处理领域，尤其涉及一种多视图数据（Multi-view Data）一致性检测方法、装置、设备和计算机存储介质。本发明具体涉及一种结合了符号级实体对齐与向量级语义验证的双重检测机制，用于数据集成、知识图谱构建及数据治理等场景。',
  '背景技术',
  '在基于模型的系统工程（MBSE）、数据集成、知识图谱构建等实践中，来自不同来源或表达形式的多个视图（View）从不同维度刻画了信息内容，有效增强了体系结构表达的完整性与丰富性。然而，这也带来了模型之间关联复杂、管理困难等问题。尤其在实践过程中，不同视图之间常因数据重叠和相互引用而引发不一致性问题。',
  '这些不一致性主要包括两方面：',
  '数据层面的一致性问题（表层命名冲突）：由于多个视图可能分别由不同的团队或人员在不同时期独立创建，导致对同一体系结构元素（如系统组件、操作节点、信息流等）在不同视图中出现定义不统一、属性描述冲突或命名格式不一致等现象。例如，一个视图中使用“Beijing”，而另一视图中使用“Peking”，尽管两者均指向同一规范实体（如Q956），但传统的基于字符串的检测方法难以识别其一致性。',
  '逻辑层面上的不一致性（深层语义冲突）：此类问题多表现为视图间在系统行为或关系上的矛盾，例如关系错配（Relationship Mismatch）或属性冲突（Attribute Conflicts）。例如，某操作视图中所描述的信息流未在系统视图中体现，或者两个视图对同一实体的同一属性（如“总部地址”）给出了相互矛盾的值。',
  '为解决上述问题，现有技术进行了一些探索。实体链接（Entity Linking）技术被用于解决第一类问题，它通过将视图中的实体提及（Mention）链接到标准知识库（如Wikidata、DBpedia）中的规范实体标识符，实现跨视图的实体消歧与对齐。然而，实体链接本身主要解决“符号对齐”问题，难以检测深层的语义冲突。',
  '另一方面，知识表示学习（Knowledge Representation Learning），特别是像TransE这样的嵌入模型，被引入来捕捉深层语义。TransE将实体和关系映射到低维连续向量空间中，理论上可以量化语义相似性。但是，如果数据在输入嵌入模型之前没有经过有效的符号级对齐，模型可能会将“Beijing”和“Peking”学习为两个完全不同的向量，从而无法利用它们在现实世界中指向同一实体这一先验知识，导致后续的语义冲突检测变得困难或不准确。',
  '综上所述，现有方法或侧重于符号对齐，或侧重于语义表示，缺乏一种能将二者有机结合、同时处理表层命名冲突和深层语义偏差的统一框架。',
  '发明内容',
  '本发明提供了一种基于实体链接库和知识表示进行视图数据一致性检测方法及装置，旨在解决背景技术中提到的、现有技术难以同时处理的表层命名不一致和深层语义不一致的问题。',
  '根据本发明的一方面，提供了一种基于实体链接库和知识表示进行视图数据一致性检测方法，如图1所示，包括以下步骤：',
  '步骤1：数据结构化转换 本步骤属于数据预处理阶段。将来自不同来源或表达形式的两个原始视图（例如，来自XML文件、数据库或API）进行解析与语义抽取。将这些结构化或半结构化的视图数据转换为统一的知识表示形式，即RDF三元组（实体，关系，实体）或属性-值对 。该过程不仅保留了原始数据中的语义信息，也为后续的自动化处理提供了标准化输入。',
  '步骤2：实体链接与符号级对齐 在步骤1获得的结构化表示的基础上，提取其中显式或隐式的命名实体 。构建一个轻量级的实体链接库（Entity Linking Repository），该库依据信息系统框架，涵盖了实体间的规范化要求。该库包含每个视图中识别出的实体及其可能指向的标准知识库（如Wikidata、DBpedia）中的规范实体标识符 。 通过实体链接技术，系统自动检索该库，实现跨视图的实体消歧与对齐 。此步骤用以检测是否存在因命名差异、别名使用或拼写错误导致的实体名称层面的不一致性 。例如，若“Beijing”和“Peking”均能链接至同一规范实体（如Q956），则视为符号级一致；否则标记为潜在冲突。',
  '步骤3：知识表示与语义嵌入 为捕捉步骤2无法检测的深层次语义不一致（如关系错配、属性冲突等），本步骤引入知识表示学习。具体地，利用TransE模型对两个视图（经过步骤2对齐后）的结构化三元组进行联合嵌入学习。TransE模型将实体和关系映射到同一低维连续向量空间中，并遵循“头实体（h） + 关系（r） ≈ 尾实体（t）”的平移假设。通过在统一嵌入空间中编码两个视图的所有三元组，可以获得每个实体和关系的语义向量表示。',
  '步骤4：一致性度量与向量级验证本步骤在步骤3获得的语义向量表示的基础上，设计并执行“符号级对齐 + 向量级验证”的双重一致性度量机制。该机制包括：',
  '实体向量验证：对于在步骤2中已对齐的实体对（如“Beijing”和“Peking”），计算其在嵌入空间中的余弦相似度或欧氏距离 。若相似度低于预设阈值，则表明即使符号对齐，其上下文语义也可能存在不一致。',
  '三元组平移误差验证：对于共享关系路径的三元组（特别是存在属性冲突的），评估其向量平移误差，即∥h+r−t∥的范数。若平移误差显著偏高，则判定该三元组或关联结构存在语义层面的不一致性（例如，关系错配或属性值冲突）。',
  '将上述度量结果组合，系统获得对应的一致性输出结果。',
  '应当理解，本部分所描述的内容并非旨在标识本发明的实施例的关键或重要特征，也不用于限制本发明的权利范围。本发明的其它特征将通过以下的说明书而变得容易理解。',
  '附图说明'])

python
for i,p in enumerate(paras):
    if p.strip():
        print(i, p[:60])

python
for i in range(18,45):
    p=paras[i]
    if p.strip():
        print(i, p[:120])

python
# check attributes keys
c0=root.findall('.//w:comment', namespaces=ns)[0]
c0.attrib.keys()


['{http://schemas.openxmlformats.org/wordprocessingml/2006/main}id',
 '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}author',
 '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}date',
 '{http://schemas.openxmlformats.org/wordprocessingml/2006/main}initials']

python
c0.get('{%s}initials'%ns['w'])


'OM'

python
def comment_xml_structure(comment):
    # print as string limited
    return ET.tostring(comment, encoding='unicode')[:500]
print(comment_xml_structure(c0))

python
# show first comment children tags and first paragraph style
for child in c0:
    print(child.tag)
p=c0.find('.//w:p', namespaces=ns)
pPr=p.find('w:pPr', namespaces=ns)
pStyle=pPr.find('w:pStyle', namespaces=ns) if pPr is not None else None
print("pStyle", pStyle.get('{%s}val'%ns['w']) if pStyle is not None else None)
r=p.find('.//w:r', namespaces=ns)
rStyle=(r.find('w:rPr/w:rStyle', namespaces=ns))
print("rStyle", rStyle.get('{%s}val'%ns['w']) if rStyle is not None else None)

python
ex_doc_xml=read_zip_xml(ex_path,'word/document.xml')
b'commentRangeStart' in ex_doc_xml, b'commentReference' in ex_doc_xml


(True, True)

python
# parse and find one comment reference snippet
rootdoc=ET.fromstring(ex_doc_xml)
nsd=rootdoc.nsmap
# find first commentRangeStart
crs=rootdoc.find('.//w:commentRangeStart', namespaces=nsd)
crs.get('{%s}id'%nsd['w'])


'0'

python
# find parent paragraph text of that comment
def paragraph_text(p):
    return ''.join([t.text or '' for t in p.findall('.//w:t', namespaces=nsd)])
p=crs.getparent()
while p is not None and p.tag != f"{{{nsd['w']}}}p":
    p=p.getparent()
print(paragraph_text(p)[:200])

python
# show children around start
children=list(p)
for idx,ch in enumerate(children[:10]):
    if 'comment' in ch.tag:
        print(idx, ch.tag, ch.attrib)

python
for idx,ch in enumerate(children[:12]):
    tag=ET.QName(ch).localname
    if tag.startswith('comment') or tag=='r':
        # see if it includes commentReference
        if tag=='r' and ch.find('.//w:commentReference', namespaces=nsd) is not None:
            print(idx,'run with commentReference', ET.tostring(ch, encoding='unicode'))
        elif tag.startswith('comment'):
            print(idx, tag, ch.get('{%s}id'%nsd['w']))

python
target_styles=read_zip_xml(target_path,'word/styles.xml')
b'a7' in target_styles, b'CommentText' in target_styles[:2000]


(True, False)

python
b'a8' in target_styles


True

python
for fname in ['word/commentsExtended.xml','word/commentsIds.xml','word/commentsExtensible.xml']:
    data=read_zip_xml(ex_path,fname)
    print(fname, data[:200])

python
for fname in ['word/commentsIds.xml','word/commentsExtensible.xml','word/commentsExtended.xml']:
    root=ET.fromstring(read_zip_xml(ex_path,fname))
    print(fname, ET.QName(root).localname, list(root)[:2])

python
# check number of commentId elements and how they map
cid_root=ET.fromstring(read_zip_xml(ex_path,'word/commentsIds.xml'))
ns=cid_root.nsmap
cids=cid_root.findall('.//cid:commentId', namespaces=ns)
print(len(cids))
print(cids[0].attrib)

python
cid_root=ET.fromstring(read_zip_xml(ex_path,'word/commentsIds.xml'))
cid_root.nsmap


{'wpc': 'http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas',
 'cx': 'http://schemas.microsoft.com/office/drawing/2014/chartex',
 'cx1': 'http://schemas.microsoft.com/office/drawing/2015/9/8/chartex',
 'cx2': 'http://schemas.microsoft.com/office/drawing/2015/10/21/chartex',
 'cx3': 'http://schemas.microsoft.com/office/drawing/2016/5/9/chartex',
 'cx4': 'http://schemas.microsoft.com/office/drawing/2016/5/10/chartex',
 'cx5': 'http://schemas.microsoft.com/office/drawing/2016/5/11/chartex',
 'cx6': 'http://schemas.microsoft.com/office/drawing/2016/5/12/chartex',
 'cx7': 'http://schemas.microsoft.com/office/drawing/2016/5/13/chartex',
 'cx8': 'http://schemas.microsoft.com/office/drawing/2016/5/14/chartex',
 'mc': 'http://schemas.openxmlformats.org/markup-compatibility/2006',
 'aink': 'http://schemas.microsoft.com/office/drawing/2016/ink',
 'am3d': 'http://schemas.microsoft.com/office/drawing/2017/model3d',
 'o': 'urn:schemas-microsoft-com:office:office',
 'oel': 'http://schemas.microsoft.com/office/2019/extlst',
 'r': 'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
 'm': 'http://schemas.openxmlformats.org/officeDocument/2006/math',
 'v': 'urn:schemas-microsoft-com:vml',
 'wp14': 'http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing',
 'wp': 'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
 'w10': 'urn:schemas-microsoft-com:office:word',
 'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
 'w14': 'http://schemas.microsoft.com/office/word/2010/wordml',
 'w15': 'http://schemas.microsoft.com/office/word/2012/wordml',
 'w16cex': 'http://schemas.microsoft.com/office/word/2018/wordml/cex',
 'w16cid': 'http://schemas.microsoft.com/office/word/2016/wordml/cid',
 'w16': 'http://schemas.microsoft.com/office/word/2018/wordml',
 'w16du': 'http://schemas.microsoft.com/office/word/2023/wordml/word16du',
 'w16sdtdh': 'http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash',
 'w16sdtfl': 'http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock',
 'w16se': 'http://schemas.microsoft.com/office/word/2015/wordml/symex',
 'wpg': 'http://schemas.microsoft.com/office/word/2010/wordprocessingGroup',
 'wpi': 'http://schemas.microsoft.com/office/word/2010/wordprocessingInk',
 'wne': 'http://schemas.microsoft.com/office/word/2006/wordml',
 'wps': 'http://schemas.microsoft.com/office/word/2010/wordprocessingShape'}

python
ns=cid_root.nsmap
cids=cid_root.findall('.//w16cid:commentId', namespaces=ns)
len(cids), cids[0].attrib


(24,
 {'{http://schemas.microsoft.com/office/word/2016/wordml/cid}paraId': '0E62C883', '{http://schemas.microsoft.com/office/word/2016/wordml/cid}durableId': '1E3B79D1'})

python
rels=read_zip_xml(target_path,'word/_rels/document.xml.rels')
rels[:200]


b'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId8" Type="http://schemas.openxmlformats'