frameplot 0.1.0__py3-none-any.whl

frameplot/render/svg.py

@@ -0,0 +1,306 @@
+from __future__ import annotations
+
+import hashlib
+import xml.etree.ElementTree as ET
+
+from frameplot.layout.types import (
+    DetailPanelLayout,
+    GraphLayout,
+    GuideLine,
+    LayoutNode,
+    LayoutResult,
+    Point,
+    RoutedEdge,
+)
+from frameplot.theme import Theme
+
+SVG_NS = "http://www.w3.org/2000/svg"
+ET.register_namespace("", SVG_NS)
+
+
+def render_svg(layout: LayoutResult, theme: Theme) -> str:
+    """Serialize a computed layout into an SVG document string."""
+
+    root = ET.Element(
+        ET.QName(SVG_NS, "svg"),
+        attrib={
+            "width": _fmt(layout.width),
+            "height": _fmt(layout.height),
+            "viewBox": f"0 0 {_fmt(layout.width)} {_fmt(layout.height)}",
+            "fill": "none",
+        },
+    )
+
+    defs = ET.SubElement(root, ET.QName(SVG_NS, "defs"))
+    marker_ids = _build_markers(defs, _all_edges(layout), theme)
+
+    ET.SubElement(
+        root,
+        ET.QName(SVG_NS, "rect"),
+        attrib={
+            "x": "0",
+            "y": "0",
+            "width": _fmt(layout.width),
+            "height": _fmt(layout.height),
+            "fill": theme.background_color,
+        },
+    )
+
+    group_layer = ET.SubElement(root, ET.QName(SVG_NS, "g"), attrib={"id": "groups"})
+    _render_groups(group_layer, layout.main, theme)
+
+    if layout.detail_panel is not None:
+        guide_layer = ET.SubElement(root, ET.QName(SVG_NS, "g"), attrib={"id": "detail-panel-guides"})
+        _render_guide_lines(guide_layer, layout.detail_panel.guide_lines, theme)
+
+        panel_layer = ET.SubElement(
+            root,
+            ET.QName(SVG_NS, "g"),
+            attrib={"id": f"detail-panel-{layout.detail_panel.panel.id}"},
+        )
+        _render_detail_panel_container(panel_layer, layout.detail_panel, theme)
+        _render_groups(panel_layer, layout.detail_panel.graph, theme)
+
+    edge_layer = ET.SubElement(root, ET.QName(SVG_NS, "g"), attrib={"id": "edges"})
+    _render_edges(edge_layer, layout.main.edges, marker_ids, theme)
+    if layout.detail_panel is not None:
+        _render_edges(edge_layer, layout.detail_panel.graph.edges, marker_ids, theme)
+
+    node_layer = ET.SubElement(root, ET.QName(SVG_NS, "g"), attrib={"id": "nodes"})
+    _render_nodes(node_layer, layout.main.nodes, theme)
+    if layout.detail_panel is not None:
+        _render_nodes(
+            node_layer,
+            layout.detail_panel.graph.nodes,
+            theme,
+            id_prefix=f"detail-panel-{layout.detail_panel.panel.id}-",
+        )
+
+    return ET.tostring(root, encoding="unicode")
+
+
+def _all_edges(layout: LayoutResult) -> tuple[RoutedEdge, ...]:
+    if layout.detail_panel is None:
+        return layout.main.edges
+    return layout.main.edges + layout.detail_panel.graph.edges
+
+
+def _render_groups(parent: ET.Element, graph: GraphLayout, theme: Theme) -> None:
+    for overlay in graph.groups:
+        ET.SubElement(
+            parent,
+            ET.QName(SVG_NS, "rect"),
+            attrib={
+                "x": _fmt(overlay.bounds.x),
+                "y": _fmt(overlay.bounds.y),
+                "width": _fmt(overlay.bounds.width),
+                "height": _fmt(overlay.bounds.height),
+                "rx": _fmt(theme.group_corner_radius),
+                "ry": _fmt(theme.group_corner_radius),
+                "stroke": overlay.stroke,
+                "stroke-width": _fmt(theme.group_stroke_width),
+                "stroke-dasharray": "8 6",
+                "fill": overlay.fill,
+                "fill-opacity": _fmt(theme.group_fill_opacity),
+            },
+        )
+        ET.SubElement(
+            parent,
+            ET.QName(SVG_NS, "text"),
+            attrib={
+                "x": _fmt(overlay.bounds.x + theme.group_padding),
+                "y": _fmt(overlay.bounds.y + theme.subtitle_font_size + 6),
+                "fill": theme.group_label_color,
+                "font-family": theme.title_font_family,
+                "font-size": _fmt(theme.subtitle_font_size),
+                "font-weight": str(theme.title_font_weight),
+            },
+        ).text = overlay.group.label
+
+
+def _render_guide_lines(parent: ET.Element, guide_lines: tuple[GuideLine, ...], theme: Theme) -> None:
+    for guide_line in guide_lines:
+        ET.SubElement(
+            parent,
+            ET.QName(SVG_NS, "path"),
+            attrib={
+                "d": _path_data(guide_line.points),
+                "stroke": guide_line.stroke,
+                "stroke-width": _fmt(theme.detail_panel_guide_width),
+                "stroke-linecap": "round",
+                "stroke-linejoin": "round",
+            },
+        )
+
+
+def _render_detail_panel_container(
+    parent: ET.Element,
+    detail_panel: DetailPanelLayout,
+    theme: Theme,
+) -> None:
+    ET.SubElement(
+        parent,
+        ET.QName(SVG_NS, "rect"),
+        attrib={
+            "x": _fmt(detail_panel.bounds.x),
+            "y": _fmt(detail_panel.bounds.y),
+            "width": _fmt(detail_panel.bounds.width),
+            "height": _fmt(detail_panel.bounds.height),
+            "rx": _fmt(theme.detail_panel_corner_radius),
+            "ry": _fmt(theme.detail_panel_corner_radius),
+            "stroke": detail_panel.stroke,
+            "stroke-width": _fmt(theme.detail_panel_stroke_width),
+            "fill": detail_panel.fill,
+            "fill-opacity": _fmt(theme.detail_panel_fill_opacity),
+        },
+    )
+    ET.SubElement(
+        parent,
+        ET.QName(SVG_NS, "text"),
+        attrib={
+            "x": _fmt(detail_panel.bounds.x + theme.detail_panel_padding),
+            "y": _fmt(detail_panel.bounds.y + theme.subtitle_font_size + 8),
+            "fill": theme.detail_panel_title_color,
+            "font-family": theme.title_font_family,
+            "font-size": _fmt(theme.subtitle_font_size),
+            "font-weight": str(theme.title_font_weight),
+        },
+    ).text = detail_panel.panel.label
+
+
+def _render_edges(
+    parent: ET.Element,
+    edges: tuple[RoutedEdge, ...],
+    marker_ids: dict[str, str],
+    theme: Theme,
+) -> None:
+    for routed_edge in edges:
+        attributes = {
+            "d": _path_data(routed_edge.points),
+            "stroke": routed_edge.stroke,
+            "stroke-width": _fmt(theme.stroke_width),
+            "stroke-linecap": "round",
+            "stroke-linejoin": "round",
+            "marker-end": f"url(#{marker_ids[routed_edge.stroke]})",
+        }
+        if routed_edge.edge.dashed:
+            attributes["stroke-dasharray"] = "8 6"
+        ET.SubElement(parent, ET.QName(SVG_NS, "path"), attrib=attributes)
+
+
+def _render_nodes(
+    parent: ET.Element,
+    nodes: dict[str, LayoutNode],
+    theme: Theme,
+    *,
+    id_prefix: str = "",
+) -> None:
+    for node_id in sorted(nodes, key=lambda item: (nodes[item].rank, nodes[item].order, item)):
+        _render_node(parent, nodes[node_id], theme, element_id=f"{id_prefix}{node_id}")
+
+
+def _render_node(
+    parent: ET.Element,
+    layout_node: LayoutNode,
+    theme: Theme,
+    *,
+    element_id: str,
+) -> None:
+    node = layout_node.node
+    node_group = ET.SubElement(parent, ET.QName(SVG_NS, "g"), attrib={"id": element_id})
+    ET.SubElement(
+        node_group,
+        ET.QName(SVG_NS, "rect"),
+        attrib={
+            "x": _fmt(layout_node.x),
+            "y": _fmt(layout_node.y),
+            "width": _fmt(layout_node.width),
+            "height": _fmt(layout_node.height),
+            "rx": _fmt(theme.corner_radius),
+            "ry": _fmt(theme.corner_radius),
+            "fill": node.fill or theme.node_fill,
+            "stroke": node.stroke or theme.node_stroke,
+            "stroke-width": _fmt(theme.stroke_width),
+        },
+    )
+
+    text_x = layout_node.x + theme.node_padding_x
+    content_top = layout_node.y + (layout_node.height - layout_node.content_height) / 2
+    current_top = content_top
+    title_ascent = theme.title_font_size * 0.8
+    subtitle_ascent = theme.subtitle_font_size * 0.8
+    text_color = node.text_color or theme.node_text_color
+
+    for line in layout_node.title_lines:
+        current_top += layout_node.title_line_height
+        ET.SubElement(
+            node_group,
+            ET.QName(SVG_NS, "text"),
+            attrib={
+                "x": _fmt(text_x),
+                "y": _fmt(current_top - layout_node.title_line_height + title_ascent),
+                "fill": text_color,
+                "font-family": theme.title_font_family,
+                "font-size": _fmt(theme.title_font_size),
+                "font-weight": str(theme.title_font_weight),
+            },
+        ).text = line
+
+    if layout_node.subtitle_lines:
+        current_top += theme.inter_text_gap
+        for line in layout_node.subtitle_lines:
+            current_top += layout_node.subtitle_line_height
+            ET.SubElement(
+                node_group,
+                ET.QName(SVG_NS, "text"),
+                attrib={
+                    "x": _fmt(text_x),
+                    "y": _fmt(current_top - layout_node.subtitle_line_height + subtitle_ascent),
+                    "fill": text_color,
+                    "font-family": theme.title_font_family,
+                    "font-size": _fmt(theme.subtitle_font_size),
+                    "font-weight": str(theme.subtitle_font_weight),
+                },
+            ).text = line
+
+
+def _build_markers(defs: ET.Element, edges: tuple[RoutedEdge, ...], theme: Theme) -> dict[str, str]:
+    marker_ids: dict[str, str] = {}
+    for color in sorted({routed_edge.stroke for routed_edge in edges}):
+        marker_id = f"arrow-{hashlib.sha1(color.encode('utf-8')).hexdigest()[:10]}"
+        marker_ids[color] = marker_id
+        marker = ET.SubElement(
+            defs,
+            ET.QName(SVG_NS, "marker"),
+            attrib={
+                "id": marker_id,
+                "markerWidth": _fmt(theme.arrow_size),
+                "markerHeight": _fmt(theme.arrow_size),
+                "refX": _fmt(theme.arrow_size),
+                "refY": _fmt(theme.arrow_size / 2),
+                "orient": "auto",
+                "markerUnits": "userSpaceOnUse",
+            },
+        )
+        ET.SubElement(
+            marker,
+            ET.QName(SVG_NS, "path"),
+            attrib={
+                "d": f"M0,0 L{_fmt(theme.arrow_size)},{_fmt(theme.arrow_size / 2)} L0,{_fmt(theme.arrow_size)} z",
+                "fill": color,
+            },
+        )
+    return marker_ids
+
+
+def _path_data(points: tuple[Point, ...]) -> str:
+    commands = [f"M {_fmt(points[0].x)} {_fmt(points[0].y)}"]
+    commands.extend(f"L {_fmt(point.x)} {_fmt(point.y)}" for point in points[1:])
+    return " ".join(commands)
+
+
+def _fmt(value: float) -> str:
+    text = f"{value:.2f}"
+    if "." in text:
+        text = text.rstrip("0").rstrip(".")
+    return text or "0"

frameplot/theme.py

@@ -0,0 +1,59 @@
+"""Styling defaults for frameplot layout and rendering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class Theme:
+    """Control colors, typography, spacing, and routing defaults.
+
+    A theme applies global defaults to the whole diagram. Per-node, per-edge,
+    per-group, and per-detail-panel overrides still win when provided.
+    """
+
+    background_color: str = "#FFFFFF"
+    node_fill: str = "#F8FAFC"
+    node_stroke: str = "#0F172A"
+    node_text_color: str = "#0F172A"
+    edge_color: str = "#334155"
+    group_stroke: str = "#94A3B8"
+    group_fill: str = "#E2E8F0"
+    group_label_color: str = "#475569"
+    title_font_family: str = "DejaVu Sans, Arial, sans-serif"
+    title_font_size: float = 16.0
+    subtitle_font_size: float = 12.0
+    title_font_weight: int = 600
+    subtitle_font_weight: int = 400
+    outer_margin: float = 32.0
+    node_padding_x: float = 18.0
+    node_padding_y: float = 14.0
+    inter_text_gap: float = 8.0
+    rank_gap: float = 96.0
+    node_gap: float = 32.0
+    component_gap: float = 64.0
+    group_padding: float = 18.0
+    max_text_width: float = 220.0
+    min_node_width: float = 140.0
+    min_node_height: float = 72.0
+    corner_radius: float = 16.0
+    group_corner_radius: float = 20.0
+    stroke_width: float = 2.0
+    group_stroke_width: float = 1.5
+    group_fill_opacity: float = 0.14
+    detail_panel_gap: float = 48.0
+    detail_panel_padding: float = 20.0
+    detail_panel_header_height: float = 30.0
+    detail_panel_fill: str = "#FFFFFF"
+    detail_panel_stroke: str = "#CBD5E1"
+    detail_panel_title_color: str = "#475569"
+    detail_panel_stroke_width: float = 1.2
+    detail_panel_fill_opacity: float = 1.0
+    detail_panel_corner_radius: float = 18.0
+    detail_panel_guide_color: str = "#CBD5E1"
+    detail_panel_guide_width: float = 1.2
+    arrow_size: float = 8.0
+    route_track_gap: float = 18.0
+    back_edge_gap: float = 26.0
+    self_loop_size: float = 28.0

frameplot-0.1.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: frameplot
+Version: 0.1.0
+Summary: Turn Python-defined pipeline graphs into presentation-ready SVG and PNG diagrams.
+Author: Small Turtle 2
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/smturtle2/frameplot
+Project-URL: Repository, https://github.com/smturtle2/frameplot
+Project-URL: Issues, https://github.com/smturtle2/frameplot/issues
+Project-URL: Releases, https://github.com/smturtle2/frameplot/releases
+Keywords: diagram,graph,pipeline,png,svg,visualization
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: CairoSVG>=2.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# frameplot
+
+[![PyPI version](https://img.shields.io/pypi/v/frameplot.svg)](https://pypi.org/project/frameplot/)
+[![Python versions](https://img.shields.io/pypi/pyversions/frameplot.svg)](https://pypi.org/project/frameplot/)
+[![CI](https://github.com/smturtle2/frameplot/actions/workflows/workflow.yml/badge.svg?branch=main)](https://github.com/smturtle2/frameplot/actions/workflows/workflow.yml)
+[![License](https://img.shields.io/github/license/smturtle2/frameplot)](https://github.com/smturtle2/frameplot/blob/main/LICENSE)
+
+Turn Python-defined pipeline graphs into presentation-ready SVG and PNG diagrams.
+
+[한국어 README](https://github.com/smturtle2/frameplot/blob/main/README.ko.md)
+
+![frameplot hero image](https://raw.githubusercontent.com/smturtle2/frameplot/main/docs/assets/frameplot-hero.png)
+
+`frameplot` is a compact Python library for rendering left-to-right pipeline diagrams with clean defaults. Define nodes, edges, groups, and optional detail panels in plain Python, then export polished SVG for documentation or PNG for slides and papers.
+
+## Why frameplot?
+
+- Clean left-to-right layout for architecture diagrams, data pipelines, and model overviews
+- SVG-first output with optional PNG export through CairoSVG
+- Detail panels for expanding a summary node into a lower inset mini-graph
+- Themeable typography, spacing, colors, and routing defaults
+- Deterministic rendering from simple dataclass-based inputs
+
+## Install
+
+```bash
+python -m pip install frameplot
+```
+
+PNG export depends on CairoSVG and may require Cairo or libffi packages from the host OS.
+
+## Quickstart
+
+```python
+from frameplot import Edge, Group, Node, Pipeline
+
+pipeline = Pipeline(
+    nodes=[
+        Node("start", "Start", "Receive request"),
+        Node("fetch", "Fetch Data", "Load source tables"),
+        Node("retry", "Retry", "Loop on transient failure", fill="#FFF2CC"),
+        Node("done", "Done", "Return result", fill="#D9EAD3"),
+    ],
+    edges=[
+        Edge("e1", "start", "fetch"),
+        Edge("e2", "fetch", "retry", dashed=True),
+        Edge("e3", "retry", "fetch", color="#C0504D"),
+        Edge("e4", "fetch", "done"),
+    ],
+    groups=[
+        Group("g1", "Execution", ["start", "fetch", "retry"], edge_ids=["e2"]),
+    ],
+)
+
+svg = pipeline.to_svg()
+pipeline.save_svg("pipeline.svg")
+pipeline.save_png("pipeline.png")
+```
+
+## Public API
+
+Top-level imports are the supported public API:
+
+- `Node(id, title, subtitle=None, fill=None, stroke=None, text_color=None, metadata=None, width=None, height=None)`
+- `Edge(id, source, target, color=None, dashed=False, metadata=None)`
+- `Group(id, label, node_ids, edge_ids=(), stroke=None, fill=None, metadata=None)`
+- `DetailPanel(id, focus_node_id, label, nodes, edges, groups=(), stroke=None, fill=None, metadata=None)`
+- `Theme(...)`
+- `Pipeline(nodes, edges, groups=(), detail_panel=None, theme=None)`
+
+`Pipeline` exposes:
+
+- `to_svg() -> str`
+- `save_svg(path) -> None`
+- `to_png_bytes() -> bytes`
+- `save_png(path) -> None`
+
+## Advanced Example
+
+The hero image above is generated from [`examples/sar_backbone_example.py`](https://github.com/smturtle2/frameplot/blob/main/examples/sar_backbone_example.py), which demonstrates:
+
+- custom `Theme` values
+- split decoder branches
+- grouped overlays
+- a `DetailPanel` attached to a summary node
+
+## Design Notes
+
+- Layout is intentionally left-to-right in v0.x.
+- Edge labels are not supported yet.
+- Groups are visual overlays and do not constrain layout.
+- Detail panels render as separate lower insets attached to a focus node in the main flow.
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+python -m pytest -q
+```
+
+Release publishing is automated through GitHub Actions and PyPI Trusted Publishing. Bump the version in `pyproject.toml`, create a tag like `v0.1.0`, and push the tag to trigger a release from `.github/workflows/workflow.yml`.

frameplot-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+frameplot/__init__.py,sha256=sFaxPWRSlnA0HjBf-1XCL2CI9GSMVD3AjBop5Ec1Lio,266
+frameplot/api.py,sha256=LTjY3qg1nY0rhB4PtNi1IrD4jypneaLQvdoFrDY9dWE,1865
+frameplot/model.py,sha256=3ruaNf36JfaQcxtAUYQtY0jupbLaf2wxxxHoAvVbuCQ,4371
+frameplot/theme.py,sha256=D2ujyFIuVf7I7AN-iZYaZN2KJxsw-ySnneusce6bZU4,1984
+frameplot/layout/__init__.py,sha256=AfmzjPLX_Vqv_Rvm-SlhNVGZmMc2gHVim2Eupl0BV6w,10040
+frameplot/layout/order.py,sha256=pRvH6Yitem_29slUAbblcXPPV0UTccAwoLGaB-QZ9Uk,5585
+frameplot/layout/place.py,sha256=_hM92R0LS5-rcdLvF427VxnAxWwlnnkfmkCboRmBzZc,7091
+frameplot/layout/rank.py,sha256=T95P10lAV-3hc-T-uQeBJ7zxnLILg7ihBVpPzzsILHM,2279
+frameplot/layout/route.py,sha256=nuu64g7E1byBvyVoyGHMBdQZglVIUFJ1QNCmk64MfbQ,33086
+frameplot/layout/scc.py,sha256=D6fWWvbcb62eKDxDhqJoxuPGQj93tPNV8x6i5jYHvo0,2216
+frameplot/layout/text.py,sha256=pT9EYm0vtcr1ipuOhHzchHjh2wYY4yRyyuGzkrzjOd0,2587
+frameplot/layout/types.py,sha256=v_4Ld_Eb4zBP5P-1q3DH89o9eGlaGeuWYWPvwPIqBqw,3524
+frameplot/layout/validate.py,sha256=rLhjzoqMtXY7nfwDbwIHJoqkAqEFmzxad1uZGP8jxW8,3977
+frameplot/render/__init__.py,sha256=-HFtKujLTvZKcY9ZFIn9-5zRWJTnnmDheUkvC2Ln9qA,162
+frameplot/render/png.py,sha256=p-aGIa0hTJTOfLm70pNqdTDHVqwNBDYiHDKqo0ZGvy4,587
+frameplot/render/svg.py,sha256=-oHav_7S8bart9vGIPa6UmF3X5ws5SJsK5Hmo0kWkG8,10701
+frameplot-0.1.0.dist-info/licenses/LICENSE,sha256=K6I_4F9xoqE32M-CpGHLV7WmetFHWZwj60bJ5X4bbR0,1071
+frameplot-0.1.0.dist-info/METADATA,sha256=nuh72IvnII6txTM7neEBi2apTRskwRJO2VXOTZ2xxf0,5148
+frameplot-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+frameplot-0.1.0.dist-info/top_level.txt,sha256=yQ12_9t2dlReyty9T1ahzWzWNPywPZ6WZ3zwBrlPsxg,10
+frameplot-0.1.0.dist-info/RECORD,,

frameplot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

frameplot-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Small Turtle 2
+
+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.

frameplot-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+frameplot