drawio-python 0.1.4__tar.gz → 0.1.6__tar.gz

{drawio_python-0.1.4 → drawio_python-0.1.6}/HISTORY.md

@@ -1,5 +1,15 @@
 # Unreleased
 
+- Route connectors exactly as draw.io does: `drawio/routing.py` ports mxGraph's
+  OrthConnector, SegmentConnector, elbow connectors and perimeters (Apache-2.0). Native
+  renders and lint now follow the editor for unpinned orthogonal connectors and for
+  waypoints that are off the line of a port; tests compare against routes recorded from
+  draw.io.
+- Lint: `edge-hidden` for connectors painted under an opaque shape created after them;
+  `style-ignored` (info) for properties draw.io ignores, such as `ellipse=1`; text boxes
+  collide by their glyphs, not their line boxes; `--select`, `--ignore` and `-v`.
+- Labels collapse runs of spaces as draw.io does.
+
 - Render pages to PNG, SVG, PDF and JPEG on any OS: a built-in native renderer (SVG
   with no dependencies, raster through Pillow), the draw.io desktop exporter, or the
   official diagrams.net viewer in a headless browser.

drawio_python-0.1.6/LICENSES/Apache-2.0.txt

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{drawio_python-0.1.4 → drawio_python-0.1.6}/MANIFEST.in

@@ -1,4 +1,5 @@
 include LICENSE
+graft LICENSES
 include HISTORY.md
 include Containerfile
 include README.md

{drawio_python-0.1.4 → drawio_python-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drawio-python
-Version: 0.1.4
+Version: 0.1.6
 Summary: Build, check and export editable draw.io diagrams in Python; made for people and agents
 Home-page: https://github.com/maycuatroi1/drawio/
 Author: Nguyen Anh Binh
@@ -164,13 +164,16 @@ doc.save("flow.drawio", overwrite=True)
 ```sh
 drawio lint flow.drawio                     # exit status 1 when something is wrong
 drawio lint deck.drawio --fit 8.15x4.85in   # also: text below 12 pt once placed on a slide
+drawio lint flow.drawio --ignore aspect -v  # pick codes with --select/--ignore; -v prints info
 drawio inspect flow.drawio --json           # every shape box and connector route
 ```
 
 Lint reports overflowing labels, overlapping shapes and labels, connectors that run
-through shapes or labels, children outside containers, and (with `--fit`) text that
-ends up too small and aspect-ratio mismatches. Text widths are estimated from
-Helvetica/Arial metrics, close to draw.io's wrapping.
+through shapes or labels or hide under a shape painted after them, children outside
+containers, style properties draw.io ignores, and (with `--fit`) text that ends up too
+small and aspect-ratio mismatches. Connector routes come from a port of draw.io's own
+router (`drawio/routing.py`, checked against the diagrams.net viewer); text widths are
+estimated from Helvetica/Arial metrics, close to draw.io's wrapping.
 
 ## Render
 
@@ -284,3 +287,9 @@ Tests write real XML, render with the native backend and run examples in
 temporary directories. They do not install packages, download browser drivers, or
 launch Chrome. See
 [the API reference](docs/index.md) and [contribution guide](CONTRIBUTING.md).
+
+## License
+
+drawio-python is released into the public domain (see `LICENSE`), except
+`drawio/routing.py`, a port of connector routing from mxGraph by JGraph Ltd, which is
+under the Apache License 2.0 (`LICENSES/Apache-2.0.txt`).

{drawio_python-0.1.4 → drawio_python-0.1.6}/README.md

@@ -126,13 +126,16 @@ doc.save("flow.drawio", overwrite=True)
 ```sh
 drawio lint flow.drawio                     # exit status 1 when something is wrong
 drawio lint deck.drawio --fit 8.15x4.85in   # also: text below 12 pt once placed on a slide
+drawio lint flow.drawio --ignore aspect -v  # pick codes with --select/--ignore; -v prints info
 drawio inspect flow.drawio --json           # every shape box and connector route
 ```
 
 Lint reports overflowing labels, overlapping shapes and labels, connectors that run
-through shapes or labels, children outside containers, and (with `--fit`) text that
-ends up too small and aspect-ratio mismatches. Text widths are estimated from
-Helvetica/Arial metrics, close to draw.io's wrapping.
+through shapes or labels or hide under a shape painted after them, children outside
+containers, style properties draw.io ignores, and (with `--fit`) text that ends up too
+small and aspect-ratio mismatches. Connector routes come from a port of draw.io's own
+router (`drawio/routing.py`, checked against the diagrams.net viewer); text widths are
+estimated from Helvetica/Arial metrics, close to draw.io's wrapping.
 
 ## Render
 
@@ -246,3 +249,9 @@ Tests write real XML, render with the native backend and run examples in
 temporary directories. They do not install packages, download browser drivers, or
 launch Chrome. See
 [the API reference](docs/index.md) and [contribution guide](CONTRIBUTING.md).
+
+## License
+
+drawio-python is released into the public domain (see `LICENSE`), except
+`drawio/routing.py`, a port of connector routing from mxGraph by JGraph Ltd, which is
+under the Apache License 2.0 (`LICENSES/Apache-2.0.txt`).

drawio_python-0.1.6/drawio/VERSION

@@ -0,0 +1 @@
+0.1.6

{drawio_python-0.1.4 → drawio_python-0.1.6}/drawio/cli.py

@@ -95,7 +95,17 @@ def _cmd_lint(args):
     document = Document.load(args.input)
     document.validate()
     fit = parse_fit(args.fit, args.min_pt) if args.fit else None
-    issues = check(document, fit=fit, pages=args.page or None)
+
+    def codes(values):
+        return [c.strip() for v in values or [] for c in v.split(",") if c.strip()] or None
+
+    issues = check(
+        document,
+        fit=fit,
+        pages=args.page or None,
+        select=codes(args.select),
+        ignore=codes(args.ignore),
+    )
     threshold = SEVERITIES.index(args.fail_on)
     failing = [i for i in issues if SEVERITIES.index(i.severity) <= threshold]
     counts = {s: sum(i.severity == s for i in issues) for s in SEVERITIES}
@@ -109,10 +119,14 @@ def _cmd_lint(args):
         )
     else:
         for issue in issues:
+            if issue.severity == "info" and not args.verbose:
+                continue
             print(f"{issue.severity}: [{issue.code}] page {issue.page}: {issue.message}")
             if issue.hint:
                 print(f"    fix: {issue.hint}")
         summary = ", ".join(f"{n} {s}(s)" for s, n in counts.items() if n)
+        if counts["info"] and not args.verbose:
+            summary += " (-v shows the info lines)"
         print(f"{args.input}: {summary or 'no layout problems found'}")
     return 1 if failing else 0
 
@@ -332,6 +346,11 @@ def _parser():
         " smaller than --min-pt",
     )
     lint.add_argument("--min-pt", type=float, default=12)
+    lint.add_argument(
+        "--select", action="append", help="Only these codes (comma list; edge-* for a prefix)"
+    )
+    lint.add_argument("--ignore", action="append", help="Drop these codes (comma list)")
+    lint.add_argument("-v", "--verbose", action="store_true", help="Also print info findings")
     lint.add_argument(
         "--fail-on",
         choices=["error", "warning", "info"],

{drawio_python-0.1.4 → drawio_python-0.1.6}/drawio/lint.py

@@ -203,7 +203,7 @@ def check_scene(scene: Scene, fit: Optional[Fit] = None) -> list[Issue]:
 
     def footprint(shape: Shape) -> Box:
         if shape.id in textlike:
-            return shape.label.box if shape.label else (shape.box[0], shape.box[1], 0, 0)
+            return _ink(shape.label) if shape.label else (shape.box[0], shape.box[1], 0, 0)
         return shape.box
 
     def kind(shape: Shape) -> str:
@@ -425,6 +425,57 @@ def check_scene(scene: Scene, fit: Optional[Fit] = None) -> list[Issue]:
                     )
                 )
 
+    # Connectors covered by an opaque shape drawn after them (draw.io paints in order).
+    for edge in connectors:
+        total = sum(math.dist(a, b) for a, b in zip(edge.points, edge.points[1:]))
+        if total <= 0:
+            continue
+        ends = {e for e in (edge.source, edge.target) if e}
+        protected = set(ends)
+        for end in ends:
+            protected |= lineage.get(end, set())
+        for shape in shapes:
+            if shape.id in protected or depth[shape.id] < depth[edge.id] or not _opaque(shape):
+                continue
+            box = _shrink(shape.box, 1)  # a connector along the outline stays visible
+            if shape.kind in _ROUND:
+                box = _shrink(box, min(box[2], box[3]) * 0.15)
+            hidden = sum(_inside_length(a, b, box) for a, b in zip(edge.points, edge.points[1:]))
+            # Half the line, or the arrow head: a mark placed over a short stretch on purpose
+            # (a cross on a broken link) is not reported.
+            if hidden >= total * 0.5 or _contains_point(box, edge.points[-1]):
+                issues.append(
+                    Issue(
+                        "edge-hidden",
+                        "warning",
+                        page,
+                        [edge.id, shape.id],
+                        f"Connector {edge.id} is drawn under {_name(shape)}, which covers"
+                        f" {hidden:.0f} of its {total:.0f} px"
+                        + (
+                            " including the arrow head."
+                            if _contains_point(box, edge.points[-1])
+                            else "."
+                        ),
+                        "draw.io paints cells in order: create the connector after the shape, give"
+                        " the shape fillColor=none, or move it off the route.",
+                        {"route": [list(p) for p in edge.points], "shape": _round(shape.box)},
+                    )
+                )
+
+    for item in scene.items:
+        for problem in _style_problems(item.style):
+            issues.append(
+                Issue(
+                    "style-ignored",
+                    "info",
+                    page,
+                    [item.id],
+                    f"draw.io ignores the style property {problem[0]!r} on {item.id}.",
+                    problem[1],
+                )
+            )
+
     for shape in shapes:
         if not shape.known:
             issues.append(
@@ -518,13 +569,112 @@ def _name(shape: Shape) -> str:
     return shape.id
 
 
-def check(document, *, fit: Optional[Fit] = None, pages=None) -> list[Issue]:
-    """Run every layout check on a Document (or only on the pages whose IDs are given)."""
+def _ink(label: Label) -> Box:
+    """The part of a label's line boxes that glyphs cover: no leading above the first line,
+    no space under the last line's descenders."""
+    x, y, w, h = label.box
+    top, bottom = 0.18 * label.font_size, 0.09 * label.font_size
+    return x, y + top, w, max(h - top - bottom, 0)
+
+
+def _opaque(shape: Shape) -> bool:
+    if shape.kind in ("text", "image", "line") and shape.style.get("fillColor") in (None, "none"):
+        return False
+    fill = shape.style.get("fillColor", "#ffffff")
+    if fill in ("none", ""):
+        return False
+    try:
+        alpha = float(shape.style.get("opacity", 100)) * float(shape.style.get("fillOpacity", 100))
+    except ValueError:
+        alpha = 10000
+    return alpha >= 5000
+
+
+def _contains_point(box: Box, p) -> bool:
+    return box[0] < p[0] < box[0] + box[2] and box[1] < p[1] < box[1] + box[3]
+
+
+def _inside_length(a, b, box: Box) -> float:
+    """Length of segment a-b inside box (Liang-Barsky clipping)."""
+    x0, y0 = a
+    dx, dy = b[0] - x0, b[1] - y0
+    t0, t1 = 0.0, 1.0
+    for p, q in ((-dx, x0 - box[0]), (dx, box[0] + box[2] - x0),
+                 (-dy, y0 - box[1]), (dy, box[1] + box[3] - y0)):  # fmt: skip
+        if p == 0:
+            if q < 0:
+                return 0.0
+        else:
+            t = q / p
+            if p < 0:
+                t0 = max(t0, t)
+            else:
+                t1 = min(t1, t)
+    return max(0.0, t1 - t0) * math.hypot(dx, dy)
+
+
+# Shape names that only work as `shape=NAME` or as a bare style name, never as NAME=1.
+_SHAPE_KEYS = {
+    "ellipse", "doubleEllipse", "rhombus", "triangle", "cloud", "hexagon", "cylinder",
+    "swimlane", "image", "line", "text", "actor", "process", "note", "card", "step",
+    "document", "parallelogram", "trapezoid", "circle", "diamond",
+}  # fmt: skip
+# Common style properties, to catch case mistakes such as fontsize for fontSize.
+_KNOWN_KEYS = {
+    "fillColor", "strokeColor", "fontColor", "fontSize", "fontFamily", "fontStyle",
+    "strokeWidth", "dashed", "dashPattern", "rounded", "arcSize", "absoluteArcSize",
+    "whiteSpace", "html", "align", "verticalAlign", "labelPosition", "verticalLabelPosition",
+    "spacing", "spacingTop", "spacingLeft", "spacingRight", "spacingBottom", "opacity",
+    "fillOpacity", "strokeOpacity", "textOpacity", "shadow", "glass", "gradientColor",
+    "gradientDirection", "edgeStyle", "curved", "endArrow", "startArrow", "endFill",
+    "startFill", "endSize", "startSize", "exitX", "exitY", "entryX", "entryY", "exitDx",
+    "exitDy", "entryDx", "entryDy", "exitPerimeter", "entryPerimeter", "labelBackgroundColor",
+    "labelBorderColor", "container", "collapsible", "recursiveResize", "shape", "perimeter",
+    "aspect", "image", "imageAspect", "direction", "rotation", "flipH", "flipV", "size",
+    "fixedSize", "boundedLbl", "backgroundOutline", "horizontal", "jettySize", "elbow",
+    "orthogonalLoop", "noLabel", "editable", "movable", "resizable", "deletable",
+    "connectable", "portConstraint", "swimlaneFillColor", "swimlaneLine", "childLayout",
+}  # fmt: skip
+_BY_LOWER = {k.lower(): k for k in _KNOWN_KEYS}
+
+
+def _style_problems(style: dict) -> list[tuple[str, str]]:
+    found = []
+    for key, value in style.items():
+        if value is not None and key in _SHAPE_KEYS and key not in _KNOWN_KEYS:
+            name = {"circle": "ellipse", "diamond": "rhombus", "cylinder": "cylinder3"}.get(
+                key, key
+            )
+            found.append((f"{key}={value}", f"Use shape={name} (or page.box(..., shape={key!r}))."))
+        elif key not in _KNOWN_KEYS and key.lower() in _BY_LOWER:
+            found.append((key, f"Property names are case-sensitive: use {_BY_LOWER[key.lower()]}."))
+    return found
+
+
+def _wanted(code: str, select, ignore) -> bool:
+    if select and not any(code == s or code.startswith(s.rstrip("*")) for s in select):
+        return False
+    return not (ignore and any(code == s or code.startswith(s.rstrip("*")) for s in ignore))
+
+
+def check(
+    document,
+    *,
+    fit: Optional[Fit] = None,
+    pages=None,
+    select=None,
+    ignore=None,
+) -> list[Issue]:
+    """Run every layout check on a Document (or only on the pages whose IDs are given).
+
+    `select` keeps only the listed finding codes and `ignore` drops them; a trailing `*`
+    matches a prefix, e.g. ignore=["edge-*"].
+    """
     result = []
     for page in document.pages:
         if pages and page.id not in pages and page.name not in pages:
             continue
-        result.extend(check_scene(build(page), fit))
+        result.extend(i for i in check_scene(build(page), fit) if _wanted(i.code, select, ignore))
     return result
 
 

{drawio_python-0.1.4 → drawio_python-0.1.6}/drawio/render/desktop.py

@@ -12,6 +12,7 @@ import os
 import shutil
 import subprocess
 import sys
+import sysconfig
 from pathlib import Path
 from typing import Optional
 
@@ -34,13 +35,27 @@ _CANDIDATES = {
 
 
 def _is_ours(path: str) -> bool:
-    """The `drawio` command of this Python package also sits on PATH; skip it."""
+    """Whether `path` is the `drawio` command of a Python package rather than draw.io desktop.
+
+    pip installs that command as a script with a Python shebang on Linux and macOS, and as
+    an .exe launcher with the script appended (uncompressed) on Windows. Anything inside a
+    Python scripts directory counts as ours too.
+    """
+    resolved = Path(path).resolve()
+    scripts = {sysconfig.get_path("scripts"), str(Path(sys.executable).parent)}
+    if any(d and Path(d).resolve() == resolved.parent for d in scripts):
+        return True
     try:
-        with open(path, "rb") as stream:
+        with open(resolved, "rb") as stream:
             head = stream.read(256)
+            stream.seek(0, os.SEEK_END)
+            stream.seek(max(0, stream.tell() - 65536))
+            tail = stream.read()
     except OSError:
         return False
-    return head.startswith(b"#!") and b"python" in head.lower()
+    if head.startswith(b"#!") and b"python" in head.lower():
+        return True
+    return b"drawio.__main__" in tail or b"from drawio" in tail
 
 
 def find() -> Optional[str]: