@cteno/sdk-linux-x64 0.0.0-stage → 2.10.13

package/skills/docx/scripts/cjk_fonts.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""Make Chinese/Japanese/Korean text render with a real CJK font in a .docx or .pptx.
+
+Why: Word and PowerPoint pick the font for CJK characters from a separate slot
+(`w:eastAsia` in Word, `<a:ea>` in PowerPoint). Most generators (python-docx,
+python-pptx, docx-js, pptxgenjs) only set the Latin slot, so CJK text falls back
+to whatever the viewer has - SimSun on one machine, a tofu box or a
+mismatched-width font on another. This script sets the East Asian slot on the
+document defaults, every style, and every run/text run, plus the eastAsia
+language, without touching Latin fonts.
+
+Usage:
+  python3 cjk_fonts.py FILE [-o OUT] [--body FONT] [--heading FONT] [--lang zh-CN]
+
+Defaults (safe on Windows Office, macOS Office, WPS and LibreOffice):
+  --body     "Microsoft YaHei" for pptx, "SimSun" for docx   (宋体 正文 / 雅黑 屏显)
+  --heading  "Microsoft YaHei" for pptx, "SimHei" for docx   (黑体 标题)
+For government documents (GB/T 9704) use --body "FangSong_GB2312" --heading "SimHei".
+
+Docx headings (styles Heading*/Title, or outline-level paragraphs) get --heading,
+everything else --body. In pptx, title placeholders get --heading.
+Prints JSON {"ok": true, "file": OUT, "runs": N, "styles": N}.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import sys
+import tempfile
+import zipfile
+
+from lxml import etree
+
+W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+A = "http://schemas.openxmlformats.org/drawingml/2006/main"
+P = "http://schemas.openxmlformats.org/presentationml/2006/main"
+NS = {"w": W, "a": A, "p": P}
+q = lambda ns, tag: f"{{{NS[ns]}}}{tag}"  # noqa: E731
+
+
+def _rfonts(rpr, font: str) -> None:
+    rf = rpr.find(q("w", "rFonts"))
+    if rf is None:
+        rf = etree.Element(q("w", "rFonts"))
+        rpr.insert(0, rf)  # rFonts is the first child of rPr in the schema
+    rf.set(q("w", "eastAsia"), font)
+    for theme_attr in ("eastAsiaTheme",):
+        rf.attrib.pop(q("w", theme_attr), None)
+
+
+def _lang(rpr, lang: str) -> None:
+    lg = rpr.find(q("w", "lang"))
+    if lg is None:
+        lg = etree.SubElement(rpr, q("w", "lang"))
+    lg.set(q("w", "eastAsia"), lang)
+
+
+def _ensure(parent, tag: str, first: bool = False):
+    el = parent.find(tag)
+    if el is None:
+        el = etree.Element(tag)
+        if first:
+            parent.insert(0, el)
+        else:
+            parent.append(el)
+    return el
+
+
+HEADING_STYLE = re.compile(r"^(heading|title|subtitle|标题)", re.I)
+
+
+def fix_docx_styles(xml: bytes, body: str, heading: str, lang: str) -> tuple[bytes, int, set[str]]:
+    root = etree.fromstring(xml)
+    n = 0
+    heading_ids: set[str] = set()
+    dd = root.find(q("w", "docDefaults"))
+    if dd is None:
+        dd = etree.Element(q("w", "docDefaults"))
+        root.insert(0, dd)
+    rpd = _ensure(dd, q("w", "rPrDefault"), first=True)
+    rpr = _ensure(rpd, q("w", "rPr"))
+    _rfonts(rpr, body)
+    _lang(rpr, lang)
+    for st in root.findall(q("w", "style")):
+        sid = st.get(q("w", "styleId"), "")
+        name_el = st.find(q("w", "name"))
+        name = name_el.get(q("w", "val"), "") if name_el is not None else ""
+        if st.get(q("w", "type")) not in ("paragraph", "character"):
+            continue
+        is_heading = bool(HEADING_STYLE.match(name) or HEADING_STYLE.match(sid))
+        if is_heading:
+            heading_ids.add(sid)
+        rpr = st.find(q("w", "rPr"))
+        if rpr is None:
+            rpr = etree.SubElement(st, q("w", "rPr"))
+        _rfonts(rpr, heading if is_heading else body)
+        n += 1
+    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone=True), n, heading_ids
+
+
+def fix_docx_part(xml: bytes, body: str, heading: str, heading_ids: set[str]) -> tuple[bytes, int]:
+    root = etree.fromstring(xml)
+    n = 0
+    for para in root.iter(q("w", "p")):
+        ppr = para.find(q("w", "pPr"))
+        sid = ""
+        outline = False
+        if ppr is not None:
+            ps = ppr.find(q("w", "pStyle"))
+            sid = ps.get(q("w", "val"), "") if ps is not None else ""
+            outline = ppr.find(q("w", "outlineLvl")) is not None
+        font = heading if (sid in heading_ids or outline) else body
+        for run in para.findall(q("w", "r")) + para.findall(f".//{q('w', 'hyperlink')}/{q('w', 'r')}"):
+            rpr = run.find(q("w", "rPr"))
+            if rpr is None:
+                rpr = etree.Element(q("w", "rPr"))
+                run.insert(0, rpr)
+            rf = rpr.find(q("w", "rFonts"))
+            # keep an explicit East Asian choice the author already made
+            if rf is not None and rf.get(q("w", "eastAsia")):
+                continue
+            _rfonts(rpr, font)
+            n += 1
+    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone=True), n
+
+
+def _a_ea(rpr, font: str) -> None:
+    ea = rpr.find(q("a", "ea"))
+    if ea is None:
+        ea = etree.Element(q("a", "ea"))
+        latin = rpr.find(q("a", "latin"))
+        # schema order inside rPr: ln, fill, effect, highlight, uLnTx/uLn, uFillTx/uFill, latin, ea, cs, sym, hlinkClick...
+        if latin is not None:
+            latin.addnext(ea)
+        else:
+            anchor = None
+            for tag in ("cs", "sym", "hlinkClick", "hlinkMouseOver", "rtl", "extLst"):
+                anchor = rpr.find(q("a", tag))
+                if anchor is not None:
+                    break
+            if anchor is not None:
+                anchor.addprevious(ea)
+            else:
+                rpr.append(ea)
+    ea.set("typeface", font)
+
+
+def fix_pptx_part(xml: bytes, body: str, heading: str, lang: str, is_theme: bool) -> tuple[bytes, int]:
+    root = etree.fromstring(xml)
+    n = 0
+    if is_theme:
+        for tag, font in (("majorFont", heading), ("minorFont", body)):
+            for el in root.iter(q("a", tag)):
+                ea = el.find(q("a", "ea"))
+                if ea is not None:
+                    ea.set("typeface", font)
+                    n += 1
+        return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone=True), n
+    for sp in root.iter(q("p", "sp")):
+        ph = sp.find(f".//{q('p', 'ph')}")
+        is_title = ph is not None and ph.get("type") in ("title", "ctrTitle")
+        font = heading if is_title else body
+        for r in sp.iter(q("a", "r"), q("a", "fld")):
+            rpr = r.find(q("a", "rPr"))
+            if rpr is None:
+                rpr = etree.Element(q("a", "rPr"))
+                r.insert(0, rpr)
+            rpr.set("lang", rpr.get("lang") or lang)
+            rpr.set("altLang", rpr.get("altLang") or "en-US")
+            _a_ea(rpr, font)
+            n += 1
+        for epr in sp.iter(q("a", "endParaRPr")):
+            _a_ea(epr, font)
+    for tc in root.iter(q("a", "tc")):
+        for r in tc.iter(q("a", "r")):
+            rpr = r.find(q("a", "rPr"))
+            if rpr is None:
+                rpr = etree.Element(q("a", "rPr"))
+                r.insert(0, rpr)
+            _a_ea(rpr, body)
+            n += 1
+    return etree.tostring(root, xml_declaration=True, encoding="UTF-8", standalone=True), n
+
+
+def process(path: str, out: str, body: str | None, heading: str | None, lang: str) -> dict:
+    ext = os.path.splitext(path)[1].lower()
+    if ext not in (".docx", ".dotx", ".pptx", ".potx"):
+        raise SystemExit(f"unsupported file type {ext} (docx/dotx/pptx/potx)")
+    is_docx = ext in (".docx", ".dotx")
+    body = body or ("SimSun" if is_docx else "Microsoft YaHei")
+    heading = heading or ("SimHei" if is_docx else "Microsoft YaHei")
+    runs = styles = 0
+    with zipfile.ZipFile(path) as zin:
+        names = zin.namelist()
+        data = {n: zin.read(n) for n in names}
+        infos = {i.filename: i for i in zin.infolist()}
+    if is_docx:
+        heading_ids: set[str] = set()
+        if "word/styles.xml" in data:
+            data["word/styles.xml"], styles, heading_ids = fix_docx_styles(data["word/styles.xml"], body, heading, lang)
+        for n in names:
+            if re.match(r"word/(document|header\d*|footer\d*|footnotes|endnotes|comments)\.xml$", n):
+                data[n], k = fix_docx_part(data[n], body, heading, heading_ids)
+                runs += k
+    else:
+        for n in names:
+            if re.match(r"ppt/theme/theme\d+\.xml$", n):
+                data[n], k = fix_pptx_part(data[n], body, heading, lang, True)
+                styles += k
+            elif re.match(r"ppt/(slides/slide|slideLayouts/slideLayout|slideMasters/slideMaster|notesSlides/notesSlide)\d+\.xml$", n):
+                data[n], k = fix_pptx_part(data[n], body, heading, lang, False)
+                runs += k
+    fd, tmp = tempfile.mkstemp(suffix=ext, dir=os.path.dirname(os.path.abspath(out)) or ".")
+    os.close(fd)
+    with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED) as zout:
+        for n in names:  # keep original order: [Content_Types].xml must stay first
+            info = infos[n]
+            zi = zipfile.ZipInfo(n, date_time=info.date_time)
+            zi.compress_type = zipfile.ZIP_DEFLATED
+            zout.writestr(zi, data[n])
+    shutil.move(tmp, out)
+    return {"ok": True, "file": out, "runs": runs, "styles": styles, "body": body, "heading": heading}
+
+
+def main(argv=None) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0], epilog=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("file")
+    ap.add_argument("-o", "--output", help="default: rewrite FILE in place")
+    ap.add_argument("--body")
+    ap.add_argument("--heading")
+    ap.add_argument("--lang", default="zh-CN")
+    a = ap.parse_args(argv)
+    print(json.dumps(process(a.file, a.output or a.file, a.body, a.heading, a.lang), ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/docx/scripts/docx_comments.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+# MIT License. Part of the Hermes docx skill.
+"""List, add, and delete comments in a .docx.
+
+Subcommands:
+  list    JSON per comment: id, author, initials, date, text, anchored_text
+  add     add a comment anchored to the first occurrence of --target
+  delete  remove a comment (and its range markers) by --id
+
+Examples:
+  docx_comments.py list report.docx
+  docx_comments.py add report.docx --target "Q3 revenue" \
+      --text "Needs a source" --author "Reviewer" -o out.docx
+  docx_comments.py delete report.docx --id 0 -o out.docx
+
+Uses the native python-docx comments API (>= 1.2) when available; falls
+back to building word/comments.xml and the range markers directly for
+older versions (or when --xml is passed). Listing and deletion always
+work at the XML level so they handle documents from any producer.
+"""
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import json
+import sys
+from copy import deepcopy
+
+from docx import Document
+from docx.opc.constants import RELATIONSHIP_TYPE as RT
+from lxml import etree
+
+from docx_common import iter_part_roots
+
+W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+COMMENTS_CT = ("application/vnd.openxmlformats-officedocument"
+               ".wordprocessingml.comments+xml")
+
+
+def q(tag: str) -> str:
+    return f"{{{W}}}{tag}"
+
+
+# ---------------------------------------------------------------- reading
+
+def _comments_root(doc):
+    """Return the XML root of the comments part, or None."""
+    for rel in doc.part.rels.values():
+        if rel.reltype == RT.COMMENTS:
+            part = rel.target_part
+            el = getattr(part, "_element", None)
+            if el is not None:
+                return el
+            return etree.fromstring(part.blob)
+    return None
+
+
+def _anchored_texts(doc) -> dict:
+    """Map comment id -> document text between its range markers."""
+    anchored: dict[str, list[str]] = {}
+    for root in iter_part_roots(doc):
+        active: set[str] = set()
+        for el in root.iter():
+            if el.tag == q("commentRangeStart"):
+                cid = el.get(q("id"))
+                active.add(cid)
+                anchored.setdefault(cid, [])
+            elif el.tag == q("commentRangeEnd"):
+                active.discard(el.get(q("id")))
+            elif el.tag == q("t") and active:
+                for cid in active:
+                    anchored[cid].append(el.text or "")
+    return {cid: "".join(parts) for cid, parts in anchored.items()}
+
+
+def list_comments(doc) -> list:
+    root = _comments_root(doc)
+    if root is None:
+        return []
+    anchored = _anchored_texts(doc)
+    out = []
+    for c in root.iter(q("comment")):
+        cid = c.get(q("id"))
+        text = "\n".join(
+            "".join(t.text or "" for t in p.iter(q("t")))
+            for p in c.iter(q("p")))
+        out.append({"id": cid, "author": c.get(q("author")),
+                    "initials": c.get(q("initials")),
+                    "date": c.get(q("date")), "text": text,
+                    "anchored_text": anchored.get(cid, "")})
+    return out
+
+
+# ---------------------------------------------------------------- anchoring
+
+def _split_run(para, run_el, offset: int):
+    """Split a run element at text offset; return the new right-hand run."""
+    text = "".join(t.text or "" for t in run_el.iter(q("t")))
+    right = deepcopy(run_el)
+    run_el.addnext(right)
+    for el, s in ((run_el, text[:offset]), (right, text[offset:])):
+        for t in list(el.iter(q("t"))):
+            el.remove(t)
+        t = etree.SubElement(el, q("t"))
+        t.text = s
+        t.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+    return right
+
+
+def find_anchor_runs(doc, target: str):
+    """Isolate `target`'s first occurrence into whole runs; return them."""
+    from docx_common import iter_all_paragraphs
+    for para in iter_all_paragraphs(doc):
+        full = para.text
+        start = full.find(target)
+        if start < 0:
+            continue
+        end = start + len(target)
+        pos = 0
+        covered = []
+        for run_el in para._p.iter(q("r")):
+            rtext = "".join(t.text or "" for t in run_el.iter(q("t")))
+            r_start, r_end = pos, pos + len(rtext)
+            pos = r_end
+            if r_end <= start or r_start >= end:
+                continue
+            if r_start < start:  # split off the left part
+                run_el = _split_run(para, run_el, start - r_start)
+                r_start = start
+            if r_end > end:      # split off the right part
+                _split_run(para, run_el, end - r_start)
+            covered.append(run_el)
+        return para, covered
+    return None, []
+
+
+# ---------------------------------------------------------------- adding
+
+def _next_id(doc) -> int:
+    root = _comments_root(doc)
+    if root is None:
+        return 0
+    ids = [int(c.get(q("id"), "0")) for c in root.iter(q("comment"))
+           if c.get(q("id"), "").isdigit()]
+    return max(ids) + 1 if ids else 0
+
+
+def add_comment_native(doc, runs, text, author, initials):
+    from docx.text.run import Run
+    run_objs = [Run(r, None) for r in runs]
+    comment = doc.add_comment(run_objs, text=text, author=author,
+                              initials=initials or "")
+    return str(comment.comment_id)
+
+
+def add_comment_xml(doc, runs, text, author, initials) -> str:
+    cid = str(_next_id(doc))
+    root = _comments_root(doc)
+    if root is None:
+        root = etree.fromstring(
+            f'<w:comments xmlns:w="{W}"/>'.encode())
+        from docx.opc.packuri import PackURI
+        from docx.opc.part import Part
+        blob = etree.tostring(root, xml_declaration=True,
+                              encoding="UTF-8", standalone=True)
+        part = Part(PackURI("/word/comments.xml"), COMMENTS_CT, blob,
+                    doc.part.package)
+        doc.part.relate_to(part, RT.COMMENTS)
+        # keep a live element on the part so edits reach save()
+        part._element = root
+        part.blob_ = None
+
+        def _blob(self=part):
+            return etree.tostring(self._element, xml_declaration=True,
+                                  encoding="UTF-8", standalone=True)
+        part.__class__ = type("CommentsXmlPart", (Part,),
+                              {"blob": property(lambda self: _blob(self))})
+    now = _dt.datetime.now(_dt.UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+    comment = etree.SubElement(root, q("comment"))
+    comment.set(q("id"), cid)
+    comment.set(q("author"), author)
+    if initials:
+        comment.set(q("initials"), initials)
+    comment.set(q("date"), now)
+    p = etree.SubElement(comment, q("p"))
+    r = etree.SubElement(p, q("r"))
+    t = etree.SubElement(r, q("t"))
+    t.text = text
+    # range markers around the anchor runs + reference run after them
+    first, last = runs[0], runs[-1]
+    start = first.makeelement(q("commentRangeStart"), {q("id"): cid})
+    first.addprevious(start)
+    end = last.makeelement(q("commentRangeEnd"), {q("id"): cid})
+    last.addnext(end)
+    ref_run = last.makeelement(q("r"), {})
+    ref = etree.SubElement(ref_run, q("commentReference"))
+    ref.set(q("id"), cid)
+    end.addnext(ref_run)
+    return cid
+
+
+# ---------------------------------------------------------------- deleting
+
+def delete_comment(doc, cid: str) -> bool:
+    root = _comments_root(doc)
+    found = False
+    if root is not None:
+        for c in list(root.iter(q("comment"))):
+            if c.get(q("id")) == cid:
+                c.getparent().remove(c)
+                found = True
+    for part_root in iter_part_roots(doc):
+        for tag in ("commentRangeStart", "commentRangeEnd",
+                    "commentReference"):
+            for el in list(part_root.iter(q(tag))):
+                if el.get(q("id")) == cid:
+                    parent = el.getparent()
+                    # remove the wrapping run for reference marks
+                    if tag == "commentReference" and parent.tag == q("r"):
+                        parent.getparent().remove(parent)
+                    else:
+                        parent.remove(el)
+                    found = True
+    return found
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(
+        description="List, add, or delete comments in a .docx.")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p = sub.add_parser("list", help="list comments as JSON")
+    p.add_argument("path", help="input .docx")
+
+    p = sub.add_parser("add", help="add a comment anchored to text")
+    p.add_argument("path", help="input .docx")
+    p.add_argument("-o", "--output", help="output path (default: in place)")
+    p.add_argument("--target", required=True,
+                   help="anchor: first occurrence of this text")
+    p.add_argument("--text", required=True, help="comment body")
+    p.add_argument("--author", default="Hermes")
+    p.add_argument("--initials", default="")
+    p.add_argument("--xml", action="store_true",
+                   help="force the XML fallback (skip native API)")
+
+    p = sub.add_parser("delete", help="delete a comment by id")
+    p.add_argument("path", help="input .docx")
+    p.add_argument("-o", "--output", help="output path (default: in place)")
+    p.add_argument("--id", required=True, help="comment id")
+
+    args = ap.parse_args()
+    doc = Document(args.path)
+
+    if args.cmd == "list":
+        print(json.dumps({"ok": True, "comments": list_comments(doc)},
+                         ensure_ascii=False))
+        return 0
+
+    if args.cmd == "add":
+        _para, runs = find_anchor_runs(doc, args.target)
+        if not runs:
+            print(json.dumps({"ok": False,
+                              "error": f"target not found: {args.target}"}))
+            return 1
+        native = hasattr(doc, "add_comment") and not args.xml
+        if native:
+            cid = add_comment_native(doc, runs, args.text, args.author,
+                                     args.initials)
+        else:
+            cid = add_comment_xml(doc, runs, args.text, args.author,
+                                  args.initials)
+        result = {"ok": True, "comment_id": cid,
+                  "native_api": native, "anchored_to": args.target}
+    else:  # delete
+        if not delete_comment(doc, args.id):
+            print(json.dumps({"ok": False,
+                              "error": f"no comment with id {args.id}"}))
+            return 1
+        result = {"ok": True, "deleted_id": args.id}
+
+    out = args.output or args.path
+    doc.save(out)
+    result["output"] = out
+    print(json.dumps(result, ensure_ascii=False))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/docx/scripts/docx_common.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+# MIT License. Shared helpers for the docx skill scripts.
+"""Shared helpers: paragraph iteration and run-preserving text replacement."""
+from __future__ import annotations
+
+
+def iter_all_paragraphs(doc, include_headers_footers: bool = True):
+    """Yield every paragraph in body, tables (recursively), headers, footers."""
+    yield from _iter_container(doc)
+    if include_headers_footers:
+        for section in doc.sections:
+            for part in (
+                section.header, section.footer,
+                section.first_page_header, section.first_page_footer,
+                section.even_page_header, section.even_page_footer,
+            ):
+                if part is not None:
+                    yield from _iter_container(part)
+
+
+def _iter_container(container):
+    yield from container.paragraphs
+    for table in container.tables:
+        yield from _iter_table(table)
+
+
+def _iter_table(table):
+    for row in table.rows:
+        for cell in row.cells:
+            yield from cell.paragraphs
+            for nested in cell.tables:
+                yield from _iter_table(nested)
+
+
+def iter_part_roots(doc):
+    """Yield the XML root of the body plus every header/footer part."""
+    yield doc.element.body
+    seen = set()
+    for section in doc.sections:
+        for part in (
+            section.header, section.footer,
+            section.first_page_header, section.first_page_footer,
+            section.even_page_header, section.even_page_footer,
+        ):
+            if part is not None and id(part._element) not in seen:
+                seen.add(id(part._element))
+                yield part._element
+
+
+def replace_in_paragraph(para, old: str, new: str) -> int:
+    """Replace `old` with `new` in a paragraph, preserving run formatting.
+
+    Strategy: first replace occurrences fully contained in a single run
+    (formatting fully preserved). If the needle spans multiple runs, the
+    matched runs are collapsed: the replacement inherits the formatting of
+    the run where the match starts. Returns number of replacements made.
+    """
+    if not old or old not in para.text:
+        return 0
+    count = 0
+    # Pass 1: within-run replacements.
+    for run in para.runs:
+        if old in run.text:
+            count += run.text.count(old)
+            run.text = run.text.replace(old, new)
+    # Pass 2: cross-run occurrences.
+    while old in para.text:
+        runs = para.runs
+        # Map paragraph text offsets to (run_index, offset_in_run).
+        full = "".join(r.text for r in runs)
+        start = full.find(old)
+        if start < 0:
+            break
+        end = start + len(old)
+        pos = 0
+        spans = []  # (run_idx, cut_start, cut_end) portions inside the match
+        for i, r in enumerate(runs):
+            r_start, r_end = pos, pos + len(r.text)
+            if r_end > start and r_start < end:
+                spans.append((i, max(start, r_start) - r_start,
+                              min(end, r_end) - r_start))
+            pos = r_end
+        first = True
+        for i, cs, ce in spans:
+            t = runs[i].text
+            if first:
+                runs[i].text = t[:cs] + new + t[ce:]
+                first = False
+            else:
+                runs[i].text = t[:cs] + t[ce:]
+        count += 1
+    return count