word-comment 0.1.0__tar.gz

word_comment-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

word_comment-0.1.0/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: word-comment
+Version: 0.1.0
+Summary: Add Word comments to matching text in .docx files.
+Author: AI-Part-A
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AI-Part-A/word-comment
+Project-URL: Repository, https://github.com/AI-Part-A/word-comment
+Project-URL: Issues, https://github.com/AI-Part-A/word-comment/issues
+Keywords: docx,word,comments,office,xml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=5.0.0
+Dynamic: license-file
+
+# word-comment
+
+`word-comment` adds a Microsoft Word comment to matching text in a `.docx` file.
+
+It targets a specific paragraph by `w14:paraId`, finds the first matching occurrence of `target_text` inside that paragraph, and inserts a standard Word comment range plus comment metadata.
+
+## Installation
+
+```bash
+python -m pip install word-comment
+```
+
+## Python API
+
+```python
+from word_comment import add_comment
+
+result = add_comment(
+    input_path="input.docx",
+    output_path="output.docx",
+    para_id="7BD69366",
+    target_text="keyword",
+    comment_text="comment body",
+    author="Auto_Bot",
+)
+
+print(result.success)
+print(result.inserted_count)
+print(result.reason)
+```
+
+## CLI
+
+```bash
+word-comment input.docx output.docx 7BD69366 "keyword" "comment body" --author Auto_Bot
+```
+
+## Behavior
+
+- Searches for the paragraph whose `w14:paraId` matches `para_id`
+- Finds the first occurrence of `target_text` in that paragraph
+- Inserts a Word comment range and a `commentReference`
+- Creates `word/comments.xml` when it does not already exist
+- Adds the required relationship and content-type entries when needed
+- Copies the input file unchanged when the paragraph or target text is not found
+
+## Return Value
+
+`add_comment(...)` returns `AddCommentResult` with:
+
+- `success: bool`
+- `inserted_count: int`
+- `para_id: str`
+- `output_path: Path`
+- `reason: str | None`
+
+Possible `reason` values:
+
+- `paragraph_not_found`
+- `target_text_not_found`
+
+## Limitations
+
+- The target paragraph must already have a `w14:paraId`
+- `target_text` must exist entirely within a single `w:t` node
+- Only the first match in the selected paragraph is annotated
+- The implementation modifies `word/document.xml` and `word/comments.xml`
+
+## Development Release Check
+
+Build artifacts locally:
+
+```bash
+python -m build
+python -m twine check dist/*
+```

word_comment-0.1.0/README.md

@@ -0,0 +1,76 @@
+# word-comment
+
+`word-comment` adds a Microsoft Word comment to matching text in a `.docx` file.
+
+It targets a specific paragraph by `w14:paraId`, finds the first matching occurrence of `target_text` inside that paragraph, and inserts a standard Word comment range plus comment metadata.
+
+## Installation
+
+```bash
+python -m pip install word-comment
+```
+
+## Python API
+
+```python
+from word_comment import add_comment
+
+result = add_comment(
+    input_path="input.docx",
+    output_path="output.docx",
+    para_id="7BD69366",
+    target_text="keyword",
+    comment_text="comment body",
+    author="Auto_Bot",
+)
+
+print(result.success)
+print(result.inserted_count)
+print(result.reason)
+```
+
+## CLI
+
+```bash
+word-comment input.docx output.docx 7BD69366 "keyword" "comment body" --author Auto_Bot
+```
+
+## Behavior
+
+- Searches for the paragraph whose `w14:paraId` matches `para_id`
+- Finds the first occurrence of `target_text` in that paragraph
+- Inserts a Word comment range and a `commentReference`
+- Creates `word/comments.xml` when it does not already exist
+- Adds the required relationship and content-type entries when needed
+- Copies the input file unchanged when the paragraph or target text is not found
+
+## Return Value
+
+`add_comment(...)` returns `AddCommentResult` with:
+
+- `success: bool`
+- `inserted_count: int`
+- `para_id: str`
+- `output_path: Path`
+- `reason: str | None`
+
+Possible `reason` values:
+
+- `paragraph_not_found`
+- `target_text_not_found`
+
+## Limitations
+
+- The target paragraph must already have a `w14:paraId`
+- `target_text` must exist entirely within a single `w:t` node
+- Only the first match in the selected paragraph is annotated
+- The implementation modifies `word/document.xml` and `word/comments.xml`
+
+## Development Release Check
+
+Build artifacts locally:
+
+```bash
+python -m build
+python -m twine check dist/*
+```

word_comment-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "word-comment"
+version = "0.1.0"
+description = "Add Word comments to matching text in .docx files."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "AI-Part-A" }
+]
+dependencies = [
+  "lxml>=5.0.0"
+]
+keywords = ["docx", "word", "comments", "office", "xml"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+  "Topic :: Office/Business",
+  "Topic :: Software Development :: Libraries :: Python Modules"
+]
+
+[project.scripts]
+word-comment = "word_comment.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/AI-Part-A/word-comment"
+Repository = "https://github.com/AI-Part-A/word-comment"
+Issues = "https://github.com/AI-Part-A/word-comment/issues"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

word_comment-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

word_comment-0.1.0/src/word_comment/__init__.py

@@ -0,0 +1,3 @@
+from .core import AddCommentResult, add_comment
+
+__all__ = ["AddCommentResult", "add_comment"]

word_comment-0.1.0/src/word_comment/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

word_comment-0.1.0/src/word_comment/cli.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from .core import add_comment
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="word-comment",
+        description="Add a Word comment to matching text inside a specific paragraph ID.",
+    )
+    parser.add_argument("input_path", help="Source .docx file")
+    parser.add_argument("output_path", help="Destination .docx file")
+    parser.add_argument("para_id", help="Target paragraph ID (w14:paraId)")
+    parser.add_argument("target_text", help="Text to search for")
+    parser.add_argument("comment_text", help="Comment body to attach")
+    parser.add_argument(
+        "--author",
+        default="Auto_Bot",
+        help="Comment author name",
+    )
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    result = add_comment(
+        input_path=Path(args.input_path),
+        output_path=Path(args.output_path),
+        para_id=args.para_id,
+        target_text=args.target_text,
+        comment_text=args.comment_text,
+        author=args.author,
+    )
+
+    print(f"output: {result.output_path}")
+    print(f"success: {result.success}")
+    print(f"inserted_comments: {result.inserted_count}")
+    print(f"para_id: {result.para_id}")
+    if result.reason:
+        print(f"reason: {result.reason}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

word_comment-0.1.0/src/word_comment/core.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import copy
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from shutil import copy2
+from tempfile import TemporaryDirectory
+from zipfile import ZIP_DEFLATED, ZipFile
+
+from lxml import etree
+
+NS_W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NS_R = "http://schemas.openxmlformats.org/package/2006/relationships"
+NS_W14 = "http://schemas.microsoft.com/office/word/2010/wordml"
+NS_CT = "http://schemas.openxmlformats.org/package/2006/content-types"
+XML_SPACE = "http://www.w3.org/XML/1998/namespace"
+
+NS_MAP = {
+    "w": NS_W,
+    "r": NS_R,
+    "w14": NS_W14,
+    "ct": NS_CT,
+}
+
+
+@dataclass(frozen=True)
+class AddCommentResult:
+    success: bool
+    inserted_count: int
+    para_id: str
+    output_path: Path
+    reason: str | None = None
+
+
+def _extract_docx(docx_path: Path, work_dir: Path) -> None:
+    with ZipFile(docx_path, "r") as archive:
+        archive.extractall(work_dir)
+
+
+def _prepare_comments_xml(work_dir: Path) -> tuple[etree._ElementTree, etree._Element]:
+    comments_path = work_dir / "word" / "comments.xml"
+    if comments_path.exists():
+        tree = etree.parse(str(comments_path))
+        return tree, tree.getroot()
+
+    root = etree.Element(f"{{{NS_W}}}comments", nsmap=NS_MAP)
+    return etree.ElementTree(root), root
+
+
+def _next_comment_id(root_comments: etree._Element) -> int:
+    existing_ids = [
+        int(node.get(f"{{{NS_W}}}id"))
+        for node in root_comments.findall(f".//{{{NS_W}}}comment")
+        if node.get(f"{{{NS_W}}}id") is not None
+    ]
+    return max(existing_ids) + 1 if existing_ids else 0
+
+
+def _append_comment(root_comments: etree._Element, comment_id: int, author: str, text: str) -> int:
+    created_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    comment = etree.Element(
+        f"{{{NS_W}}}comment",
+        {
+            f"{{{NS_W}}}id": str(comment_id),
+            f"{{{NS_W}}}author": author,
+            f"{{{NS_W}}}date": created_at,
+        },
+    )
+
+    paragraph = etree.SubElement(comment, f"{{{NS_W}}}p")
+    paragraph_props = etree.SubElement(paragraph, f"{{{NS_W}}}pPr")
+    etree.SubElement(paragraph_props, f"{{{NS_W}}}pStyle", {f"{{{NS_W}}}val": "CommentText"})
+
+    run = etree.SubElement(paragraph, f"{{{NS_W}}}r")
+    run_props = etree.SubElement(run, f"{{{NS_W}}}rPr")
+    etree.SubElement(run_props, f"{{{NS_W}}}rStyle", {f"{{{NS_W}}}val": "CommentReference"})
+    text_node = etree.SubElement(run, f"{{{NS_W}}}t")
+    text_node.text = text
+
+    root_comments.append(comment)
+    return comment_id
+
+
+def _detect_target_para_ids(root_doc: etree._Element, target_text: str) -> list[str]:
+    para_ids: list[str] = []
+    for paragraph in root_doc.findall(".//w:p", namespaces=NS_MAP):
+        paragraph_text = "".join(
+            text_node.text or ""
+            for text_node in paragraph.findall(".//w:t", namespaces=NS_MAP)
+        )
+        if target_text in paragraph_text:
+            para_id = paragraph.get(f"{{{NS_W14}}}paraId")
+            if para_id:
+                para_ids.append(para_id)
+    return para_ids
+
+
+def _make_text_run(text: str, source_run_props: etree._Element | None) -> etree._Element:
+    run = etree.Element(f"{{{NS_W}}}r")
+    if source_run_props is not None:
+        run.append(copy.deepcopy(source_run_props))
+    text_node = etree.SubElement(run, f"{{{NS_W}}}t")
+    if text.strip() != text:
+        text_node.set(f"{{{XML_SPACE}}}space", "preserve")
+    text_node.text = text
+    return run
+
+
+def _split_run_and_insert_comment(
+    paragraph_elem: etree._Element,
+    run_element: etree._Element,
+    text_elem: etree._Element,
+    target_text: str,
+    comment_id: int,
+) -> bool:
+    full_text = text_elem.text
+    if not full_text or target_text not in full_text:
+        return False
+
+    pre_text, post_text = full_text.split(target_text, 1)
+    insertion_index = paragraph_elem.index(run_element)
+    run_props = run_element.find("w:rPr", namespaces=NS_MAP)
+
+    new_elements: list[etree._Element] = []
+
+    if pre_text:
+        new_elements.append(_make_text_run(pre_text, run_props))
+
+    cid = str(comment_id)
+    new_elements.append(etree.Element(f"{{{NS_W}}}commentRangeStart", {f"{{{NS_W}}}id": cid}))
+    new_elements.append(_make_text_run(target_text, run_props))
+    new_elements.append(etree.Element(f"{{{NS_W}}}commentRangeEnd", {f"{{{NS_W}}}id": cid}))
+
+    reference_run = etree.Element(f"{{{NS_W}}}r")
+    reference_props = etree.SubElement(reference_run, f"{{{NS_W}}}rPr")
+    etree.SubElement(reference_props, f"{{{NS_W}}}rStyle", {f"{{{NS_W}}}val": "CommentReference"})
+    etree.SubElement(reference_run, f"{{{NS_W}}}commentReference", {f"{{{NS_W}}}id": cid})
+    new_elements.append(reference_run)
+
+    if post_text:
+        new_elements.append(_make_text_run(post_text, run_props))
+
+    paragraph_elem.remove(run_element)
+    for element in reversed(new_elements):
+        paragraph_elem.insert(insertion_index, element)
+    return True
+
+
+def _insert_comment_by_para_id(
+    root_doc: etree._Element,
+    target_para_id: str,
+    target_text: str,
+    comment_id: int,
+) -> bool:
+    paragraphs = root_doc.xpath(
+        f".//w:p[@w14:paraId='{target_para_id}']",
+        namespaces=NS_MAP,
+    )
+    if not paragraphs:
+        return False
+
+    paragraph = paragraphs[0]
+    text_elements = [(text_node.getparent(), text_node) for text_node in paragraph.findall(".//w:t", namespaces=NS_MAP)]
+
+    for run_node, text_node in text_elements:
+        if text_node.text and target_text in text_node.text:
+            return _split_run_and_insert_comment(
+                paragraph_elem=paragraph,
+                run_element=run_node,
+                text_elem=text_node,
+                target_text=target_text,
+                comment_id=comment_id,
+            )
+    return False
+
+
+def _update_relationships(work_dir: Path) -> None:
+    rels_path = work_dir / "word" / "_rels" / "document.xml.rels"
+    tree = etree.parse(str(rels_path))
+    root = tree.getroot()
+
+    for rel in root.findall(f".//{{{NS_R}}}Relationship"):
+        if rel.get("Target") == "comments.xml":
+            return
+
+    existing_rel_ids = []
+    for rel in root.findall(f".//{{{NS_R}}}Relationship"):
+        rel_id = rel.get("Id", "")
+        if rel_id.startswith("rId"):
+            try:
+                existing_rel_ids.append(int(rel_id.replace("rId", "")))
+            except ValueError:
+                continue
+
+    next_id = max(existing_rel_ids) + 1 if existing_rel_ids else 1
+    relation = etree.Element(
+        f"{{{NS_R}}}Relationship",
+        {
+            "Id": f"rId{next_id}",
+            "Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments",
+            "Target": "comments.xml",
+        },
+    )
+    root.append(relation)
+    tree.write(str(rels_path), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+
+def _update_content_types(work_dir: Path) -> None:
+    content_types_path = work_dir / "[Content_Types].xml"
+    tree = etree.parse(str(content_types_path))
+    root = tree.getroot()
+
+    existing = root.xpath(
+        ".//ct:Override[@PartName='/word/comments.xml']",
+        namespaces=NS_MAP,
+    )
+    if existing:
+        return
+
+    etree.SubElement(
+        root,
+        f"{{{NS_CT}}}Override",
+        {
+            "PartName": "/word/comments.xml",
+            "ContentType": "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",
+        },
+    )
+    tree.write(str(content_types_path), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+
+def _save_and_repack(
+    work_dir: Path,
+    output_path: Path,
+    tree_doc: etree._ElementTree,
+    tree_comments: etree._ElementTree,
+) -> None:
+    document_path = work_dir / "word" / "document.xml"
+    comments_path = work_dir / "word" / "comments.xml"
+
+    tree_doc.write(str(document_path), xml_declaration=True, encoding="UTF-8", standalone="yes")
+    tree_comments.write(str(comments_path), xml_declaration=True, encoding="UTF-8", standalone="yes")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with ZipFile(output_path, "w", compression=ZIP_DEFLATED) as archive:
+        for file_path in work_dir.rglob("*"):
+            if file_path.is_file():
+                archive.write(file_path, arcname=file_path.relative_to(work_dir))
+
+
+def add_comment(
+    input_path: str | Path,
+    output_path: str | Path,
+    para_id: str,
+    target_text: str,
+    comment_text: str,
+    author: str = "Auto_Bot",
+) -> AddCommentResult:
+    source = Path(input_path)
+    destination = Path(output_path)
+
+    if not source.exists():
+        raise FileNotFoundError(f"Input .docx not found: {source}")
+    if not para_id:
+        raise ValueError("para_id must not be empty")
+    if not target_text:
+        raise ValueError("target_text must not be empty")
+
+    with TemporaryDirectory(prefix="word_comment_") as temp_dir:
+        work_dir = Path(temp_dir)
+        _extract_docx(source, work_dir)
+
+        document_path = work_dir / "word" / "document.xml"
+        tree_doc = etree.parse(str(document_path))
+        root_doc = tree_doc.getroot()
+        tree_comments, root_comments = _prepare_comments_xml(work_dir)
+        comment_id = _next_comment_id(root_comments)
+        inserted = _insert_comment_by_para_id(root_doc, para_id, target_text, comment_id)
+
+        if inserted:
+            _append_comment(root_comments, comment_id, author, comment_text)
+            _update_relationships(work_dir)
+            _update_content_types(work_dir)
+            _save_and_repack(work_dir, destination, tree_doc, tree_comments)
+            return AddCommentResult(
+                success=True,
+                inserted_count=1,
+                para_id=para_id,
+                output_path=destination,
+            )
+
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        copy2(source, destination)
+
+        paragraph_exists = bool(
+            root_doc.xpath(
+                f".//w:p[@w14:paraId='{para_id}']",
+                namespaces=NS_MAP,
+            )
+        )
+        reason = "target_text_not_found" if paragraph_exists else "paragraph_not_found"
+        return AddCommentResult(
+            success=False,
+            inserted_count=0,
+            para_id=para_id,
+            output_path=destination,
+            reason=reason,
+        )

word_comment-0.1.0/src/word_comment.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: word-comment
+Version: 0.1.0
+Summary: Add Word comments to matching text in .docx files.
+Author: AI-Part-A
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AI-Part-A/word-comment
+Project-URL: Repository, https://github.com/AI-Part-A/word-comment
+Project-URL: Issues, https://github.com/AI-Part-A/word-comment/issues
+Keywords: docx,word,comments,office,xml
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml>=5.0.0
+Dynamic: license-file
+
+# word-comment
+
+`word-comment` adds a Microsoft Word comment to matching text in a `.docx` file.
+
+It targets a specific paragraph by `w14:paraId`, finds the first matching occurrence of `target_text` inside that paragraph, and inserts a standard Word comment range plus comment metadata.
+
+## Installation
+
+```bash
+python -m pip install word-comment
+```
+
+## Python API
+
+```python
+from word_comment import add_comment
+
+result = add_comment(
+    input_path="input.docx",
+    output_path="output.docx",
+    para_id="7BD69366",
+    target_text="keyword",
+    comment_text="comment body",
+    author="Auto_Bot",
+)
+
+print(result.success)
+print(result.inserted_count)
+print(result.reason)
+```
+
+## CLI
+
+```bash
+word-comment input.docx output.docx 7BD69366 "keyword" "comment body" --author Auto_Bot
+```
+
+## Behavior
+
+- Searches for the paragraph whose `w14:paraId` matches `para_id`
+- Finds the first occurrence of `target_text` in that paragraph
+- Inserts a Word comment range and a `commentReference`
+- Creates `word/comments.xml` when it does not already exist
+- Adds the required relationship and content-type entries when needed
+- Copies the input file unchanged when the paragraph or target text is not found
+
+## Return Value
+
+`add_comment(...)` returns `AddCommentResult` with:
+
+- `success: bool`
+- `inserted_count: int`
+- `para_id: str`
+- `output_path: Path`
+- `reason: str | None`
+
+Possible `reason` values:
+
+- `paragraph_not_found`
+- `target_text_not_found`
+
+## Limitations
+
+- The target paragraph must already have a `w14:paraId`
+- `target_text` must exist entirely within a single `w:t` node
+- Only the first match in the selected paragraph is annotated
+- The implementation modifies `word/document.xml` and `word/comments.xml`
+
+## Development Release Check
+
+Build artifacts locally:
+
+```bash
+python -m build
+python -m twine check dist/*
+```

word_comment-0.1.0/src/word_comment.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/word_comment/__init__.py
+src/word_comment/__main__.py
+src/word_comment/cli.py
+src/word_comment/core.py
+src/word_comment.egg-info/PKG-INFO
+src/word_comment.egg-info/SOURCES.txt
+src/word_comment.egg-info/dependency_links.txt
+src/word_comment.egg-info/entry_points.txt
+src/word_comment.egg-info/requires.txt
+src/word_comment.egg-info/top_level.txt

word_comment-0.1.0/src/word_comment.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

word_comment-0.1.0/src/word_comment.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+word-comment = word_comment.cli:main

word_comment-0.1.0/src/word_comment.egg-info/requires.txt

@@ -0,0 +1 @@
+lxml>=5.0.0

word_comment-0.1.0/src/word_comment.egg-info/top_level.txt

@@ -0,0 +1 @@
+word_comment