QuickGraphLib 0.1.0a0__py3-none-any.whl

QuickGraphLib/GraphItems/Line.qml

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Shapes as QQS
+
+/*!
+    \qmltype Line
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Shapes::ShapePath
+    \brief Displays a line graph.
+
+    Graph a line using a list of X,Y points. The style of the line can be adjusted using the \l {ShapePath::strokeColor} {strokeColor} and \l {ShapePath::strokeWidth} {strokeWidth} properties.
+
+    \qml
+        GraphArea {
+            id: grapharea
+            viewRect: Qt.rect(-20, -1.1, 760, 2.2)
+
+            Line {
+                dataTransform: grapharea.dataTransform
+                path: Helpers.linspace(0, 720, 100).map(x => Qt.point(x, Math.sin(x / 180 * Math.PI)))
+                strokeColor: "red"
+                strokeWidth: 2
+            }
+        }
+    \endqml
+*/
+
+QQS.ShapePath {
+    id: root
+
+    /*!
+        Transform from data coordinates to pixel coordinates (this is usually provided by a GraphArea).
+
+        \qmlproperty list<point> Line::path
+        \omit
+            QDoc seems to read list<x> as x, so override the type of path here.
+        \endomit
+    */
+
+    required property matrix4x4 dataTransform
+
+    /*!
+        Points to graph. Each point is a \l point (containing x and y coordinates) in the data space.
+    */
+    required property list<point> path
+
+    capStyle: QQS.ShapePath.RoundCap
+    fillColor: "transparent"
+    joinStyle: QQS.ShapePath.RoundJoin
+    startX: root.path[0].x
+    startY: root.path[0].y
+
+    PathPolyline {
+        path: root.path.map(p => root.dataTransform.map(p))
+    }
+}

QuickGraphLib/GraphItems/Marker.qml

@@ -0,0 +1,28 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype Marker
+    \inqmlmodule QuickGraphLib.GraphItems
+    \inherits QtQuick::Rectangle
+    \brief Displays a circular marker.
+*/
+
+Rectangle {
+    id: root
+
+    /*! TODO */
+    required property matrix4x4 dataTransform
+    readonly property point pixelPosition: root.dataTransform.map(position)
+    /*! TODO */
+    required property point position
+
+    border.width: 0
+    height: width
+    radius: width / 2
+    width: 5
+    x: pixelPosition.x - width / 2
+    y: pixelPosition.y - width / 2
+}

QuickGraphLib/GraphItems/qmldir

@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+# SPDX-License-Identifier: MIT
+
+module QuickGraphLib.GraphItems
+AxHLine AxHLine.qml
+AxHSpan AxHSpan.qml
+AxVLine AxVLine.qml
+AxVSpan AxVSpan.qml
+BasicLegend BasicLegend.qml
+BasicLegendItem BasicLegendItem.qml
+Contour Contour.qml
+GraphItemDragHandler GraphItemDragHandler.qml
+Grid Grid.qml
+Histogram Histogram.qml
+Line Line.qml
+Marker Marker.qml

QuickGraphLib/Helpers.js

@@ -0,0 +1,167 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+/*!
+    \qmltype Helpers
+    \inqmlmodule QuickGraphLib
+    \brief Helper functions for building graphs.
+*/
+
+// Indentation due to VSCode's formatter...
+.import QtQuick as QQ
+    .import QtQuick.Shapes as QQS
+
+function linspace(min, max, num) {
+    /*!
+        \qmlmethod list<double> Helpers::linspace(double min, double max, int num)
+
+        Returns a list of \a num values equally spaced from \a min and \a max (inclusive).
+    */
+    return Array.from((new Array(num)).keys(), i => i / (num - 1) * (max - min) + min);
+}
+
+
+function range(min, max, step) {
+    /*!
+        \qmlmethod list<int> Helpers::range(int min, int max, int step = 1)
+
+        Returns a list of values from \a min to \a max (exclusive) with a gap of \a step between each one.
+    */
+    step = step ?? 1;
+    let num = Math.max(0, Math.floor((max - min) / step));
+    return Array.from((new Array(num)).keys(), i => min + step * i);
+}
+
+function tickLocator(min, max, maxNum) {
+    /*!
+        \qmlmethod list<double> Helpers::tickLocator(double min, double max, int maxNum)
+
+        Returns a list of at most \a maxNum nice tick locations values equally spaced between \a min and \a max.
+    */
+    if (min == max || !isFinite(min) || !isFinite(max) || maxNum == 0) {
+        return [];
+    }
+    let steps = [0.2, 0.25, 0.5, 1];
+    let approxTickSpacing = (max - min) / (maxNum - 1);
+    let magnitude = Math.ceil(Math.log10(approxTickSpacing));
+    let normedTickSpacing = approxTickSpacing / Math.pow(10, magnitude);
+    let tickSpacing = steps.find(x => x >= normedTickSpacing) * Math.pow(10, magnitude);
+    let lower = Math.ceil(min / tickSpacing - 1e-4) * tickSpacing;
+    let upper = Math.floor(max / tickSpacing + 1e-4) * tickSpacing;
+    let numTicks = Math.round((upper - lower) / tickSpacing + 1);
+    console.assert(numTicks <= maxNum, "Calculated too many ticks");
+    return Array.from((new Array(numTicks)).keys(), i => lower + i * tickSpacing);
+}
+
+function _exportTransform(t) {
+    if (t instanceof QQ.Translate) {
+        return {
+            "type": "translate",
+            "x": t.x,
+            "y": t.y
+        }
+    } else if (t instanceof QQ.Rotation) {
+        return {
+            "type": "rotation",
+            "angle": t.angle,
+            "origin": t.origin
+        }
+    } else if (t instanceof QQ.Scale) {
+        return {
+            "type": "scale",
+            "xScale": t.xScale,
+            "yScale": t.yScale,
+            "origin": t.origin
+        }
+    } else if (t instanceof QQ.Matrix4x4) {
+        return {
+            "type": "matrix4x4",
+            "matrix": t.matrix
+        }
+    }
+}
+
+function _exportGradient(g) {
+    if (g === null) {
+        return null
+    } else if (g instanceof QQS.LinearGradient) {
+        return {
+            "type": "lineargradient",
+            "x1": g.x1,
+            "x2": g.x2,
+            "y1": g.y1,
+            "y2": g.y2,
+            "stops": g.stops.map(s => ({
+                color: s.color, position: s.position
+            }))
+        }
+    }
+}
+
+function exportData(obj) {
+    /*!
+        \qmlmethod var Helpers::exportData(Item obj)
+
+        Returns information on \a obj which will allow it to be rendered to SVG/PNG using the Python helpers.
+
+        \note Only some QML elements are supported by this export method (e.g. \l {QtQuick::Rectangle} {Rectangle}, PathPolyline).
+        Other elements will be rendered incorrectly or not at all. If an element is not rendered correctly,
+        create a new issue and we'll see if it can be added.
+
+        \sa ExportHelper::exportToSvg, ExportHelper::exportToPng
+    */
+    let data = { "type": null, "js": obj.toString() };
+    if (obj instanceof QQ.Item) {
+        data.x = obj.x;
+        data.y = obj.y;
+        data.z = obj.z;
+        data.width = obj.width;
+        data.height = obj.height;
+        data.children = obj.data.map(exportData);
+        data.clip = obj.clip;
+        data.transform = obj.transform.map(_exportTransform);
+        data.opacity = obj.opacity;
+        data.visible = obj.visible;
+
+        if (obj instanceof QQ.Text) {
+            data.type = "text";
+            data.text = obj.text;
+            data.color = obj.color;
+            data.fontFamily = obj.font.family;
+            data.fontSize = obj.font.pixelSize;
+            data.fontWeight = obj.font.weight;
+        }
+        else if (obj instanceof QQ.Rectangle) {
+            data.type = "rectangle";
+            data.border_color = obj.border.color;
+            data.border_width = obj.border.width;
+            data.color = obj.color;
+            data.radius = obj.radius;
+            data.gradient = _exportGradient(obj.gradient);
+        }
+    }
+    else if (obj instanceof QQS.ShapePath) {
+        data.type = "shape_path";
+        data.elements = obj.pathElements.map(exportData);
+        data.capStyle = obj.capStyle;
+        data.dashOffset = obj.dashOffset;
+        data.dashPattern = obj.dashPattern.map(x => x);
+        data.fillColor = obj.fillColor;
+        data.fillGradient = _exportGradient(obj.fillGradient);
+        data.fillRule = obj.fillRule;
+        data.joinStyle = obj.joinStyle;
+        data.miterLimit = obj.miterLimit;
+        data.strokeColor = obj.strokeColor;
+        data.strokeStyle = obj.strokeStyle;
+        data.strokeWidth = obj.strokeWidth;
+    }
+    else if (obj instanceof QQ.PathPolyline) {
+        data.type = "polyline";
+        data.path = obj.path;
+    }
+    else if (obj instanceof QQ.PathMultiline) {
+        data.type = "multiline";
+        data.paths = obj.paths;
+    }
+    return data;
+}

QuickGraphLib/PreFabs/XYAxes.qml

@@ -0,0 +1,103 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+import QtQuick.Layouts as QQL
+import QuickGraphLib as QuickGraphLib
+import QuickGraphLib.GraphItems as QGLGraphItems
+
+/*!
+    \qmltype Line
+    \inqmlmodule QuickGraphLib.PreFabs
+    \inherits QuickGraphLib::AntialiasingContainer
+    \brief Displays an XY axis with a grid.
+*/
+
+QuickGraphLib.AntialiasingContainer {
+    id: root
+
+    /*! TODO */
+    property alias axes: axes
+    /*! TODO */
+    property alias dataTransform: grapharea.dataTransform
+    /*! TODO */
+    default property alias graphChildren: grapharea.data
+    /*! TODO */
+    property alias grapharea: grapharea
+    /*! TODO */
+    property int numXTicks: 11
+    /*! TODO */
+    property int numYTicks: 11
+    /*! TODO */
+    property bool showXTickLabels: true
+    /*! TODO */
+    property bool showYTickLabels: true
+    /*! TODO */
+    property alias title: titleLabel.text
+    /*! TODO */
+    required property rect viewRect
+    /*! TODO */
+    property alias xLabel: xAxis.label
+    /*! TODO */
+    property alias yLabel: yAxis.label
+
+    QQL.GridLayout {
+        id: axes
+
+        anchors.bottomMargin: 4
+        anchors.fill: parent
+        anchors.leftMargin: 15
+        anchors.rightMargin: 15
+        anchors.topMargin: 4
+        columnSpacing: 0
+        columns: 2
+        rowSpacing: 0
+
+        Text {
+            id: titleLabel
+
+            QQL.Layout.alignment: Qt.AlignCenter
+            QQL.Layout.columnSpan: 2
+            visible: text != ""
+        }
+        QuickGraphLib.Axis {
+            id: yAxis
+
+            QQL.Layout.fillHeight: true
+            dataTransform: grapharea.dataTransform
+            direction: QuickGraphLib.Axis.Direction.Left
+            showTickLabels: root.showYTickLabels
+            ticks: grid.yTicks
+        }
+        QuickGraphLib.GraphArea {
+            id: grapharea
+
+            QQL.Layout.fillHeight: true
+            QQL.Layout.fillWidth: true
+            viewRect: root.viewRect
+
+            QGLGraphItems.Grid {
+                id: grid
+
+                dataTransform: grapharea.dataTransform
+                parentHeight: grapharea.height
+                parentWidth: grapharea.width
+                strokeColor: "#11000000"
+                strokeWidth: 1
+                xTicks: QuickGraphLib.Helpers.tickLocator(grapharea.effectiveViewRect.x, grapharea.effectiveViewRect.x + grapharea.effectiveViewRect.width, root.numXTicks)
+                yTicks: QuickGraphLib.Helpers.tickLocator(grapharea.effectiveViewRect.y, grapharea.effectiveViewRect.y + grapharea.effectiveViewRect.height, root.numYTicks)
+            }
+        }
+        Item {
+        }
+        QuickGraphLib.Axis {
+            id: xAxis
+
+            QQL.Layout.fillWidth: true
+            dataTransform: grapharea.dataTransform
+            direction: QuickGraphLib.Axis.Direction.Bottom
+            showTickLabels: root.showXTickLabels
+            ticks: grid.xTicks
+        }
+    }
+}

QuickGraphLib/PreFabs/qmldir

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+# SPDX-License-Identifier: MIT
+
+module QuickGraphLib.GraphItems
+XYAxes XYAxes.qml

QuickGraphLib/ScalingContainer.qml

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype ScalingContainer
+    \inqmlmodule QuickGraphLib
+    \inherits AntialiasingContainer
+    \brief Scales it's contents while preserving the aspect ratio.
+*/
+
+AntialiasingContainer {
+    id: container
+
+    /*! TODO */
+    default property alias contentChildren: graph.children
+    /*! TODO */
+    property alias contentHeight: graph.height
+    /*! TODO */
+    property alias contentWidth: graph.width
+
+    implicitHeight: 100
+    implicitWidth: 100
+
+    Item {
+        id: graph
+
+        anchors.centerIn: parent
+
+        transform: Scale {
+            origin.x: graph.width / 2
+            origin.y: graph.height / 2
+            xScale: Math.min(container.width / graph.width, container.height / graph.height)
+            yScale: Math.min(container.width / graph.width, container.height / graph.height)
+        }
+    }
+}

QuickGraphLib/ZoomPanHandler.qml

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+// SPDX-License-Identifier: MIT
+
+import QtQuick
+
+/*!
+    \qmltype ZoomPanHandler
+    \inqmlmodule QuickGraphLib
+    \inherits QtQuick::PinchArea
+    \brief Pinch/drag handling for graph or image zoom/pan interactions.
+*/
+
+PinchArea {
+    id: root
+
+    /*! TODO */
+    property matrix4x4 baseTransform
+    /*! TODO */
+    property bool limitMovement: true
+    /*! TODO */
+    property size maxScale: Qt.size(10, 10)
+    /*! TODO */
+    property size minScale: Qt.size(1, 1)
+    /*! TODO */
+    readonly property matrix4x4 viewTransform: Qt.matrix4x4(baseTransform.m11, baseTransform.m12, baseTransform.m13, baseTransform.m14 * width, baseTransform.m21, baseTransform.m22, baseTransform.m23, baseTransform.m24 * height, baseTransform.m31, baseTransform.m32, baseTransform.m33, baseTransform.m34, baseTransform.m41, baseTransform.m42, baseTransform.m43, baseTransform.m44)
+    /*! TODO */
+    property double wheelZoomFactor: 1.05
+
+    function _applyLimitedMovement() {
+        if (limitMovement) {
+            // X bounds
+            baseTransform.m14 = Math.min(0, Math.max(1 - baseTransform.m11, baseTransform.m14));
+            // Y bounds
+            baseTransform.m24 = Math.min(0, Math.max(1 - baseTransform.m22, baseTransform.m24));
+        }
+    }
+    function _move(amount: vector3d) {
+        let change = Qt.matrix4x4();
+        change.translate(amount);
+        baseTransform = change.times(baseTransform);
+        _applyLimitedMovement();
+    }
+    function _zoom(center: vector3d, amount: double) {
+        let change = Qt.matrix4x4();
+        change.translate(center);
+        let xScale = Math.min(Math.max(baseTransform.m11 * amount, minScale.width), maxScale.width) / baseTransform.m11;
+        let yScale = Math.min(Math.max(baseTransform.m22 * amount, minScale.height), maxScale.height) / baseTransform.m22;
+        change.scale(xScale, yScale, 1);
+        change.translate(center.times(-1));
+        baseTransform = change.times(baseTransform);
+        _applyLimitedMovement();
+    }
+    function reset() {
+        baseTransform = Qt.matrix4x4();
+    }
+
+    onPinchUpdated: pinch => root._zoom(Qt.vector3d(pinch.startCenter.x / width, pinch.startCenter.y / height, 0), pinch.scale / pinch.previousScale)
+
+    MouseArea {
+        id: dragArea
+
+        property vector3d prevPosition
+
+        anchors.fill: parent
+        drag.filterChildren: true
+        hoverEnabled: true
+
+        onPositionChanged: mouse => {
+            if (pressed) {
+                let newPosition = Qt.vector3d(mouse.x / width, mouse.y / height, 0);
+                root._move(newPosition.minus(prevPosition));
+                prevPosition = newPosition;
+            }
+        }
+        onPressed: prevPosition = Qt.vector3d(mouseX / width, mouseY / height, 0)
+        onWheel: wheel => root._zoom(Qt.vector3d(mouseX / width, mouseY / height, 0), Math.pow(root.wheelZoomFactor, wheel.angleDelta.y / 15))
+    }
+}

QuickGraphLib/qmldir

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+# SPDX-License-Identifier: MIT
+
+module QuickGraphLib
+AntialiasingContainer AntialiasingContainer.qml
+Axis Axis.qml
+Helpers 1.0 Helpers.js
+GraphArea GraphArea.qml
+ScalingContainer ScalingContainer.qml
+ZoomPanHandler ZoomPanHandler.qml

QuickGraphLib-0.1.0a0.dist-info/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+
+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.

QuickGraphLib-0.1.0a0.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: QuickGraphLib
+Version: 0.1.0a0
+Summary: A scientific graphing library for QtQuick
+Author-email: Matthew Joyce <matthew.joyce@refeyn.com>
+License: MIT License
+        
+        Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+        
+        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.
+Project-URL: Homepage, https://github.com/refeyn/QuickGraphLib
+Project-URL: Issues, https://github.com/refeyn/QuickGraphLib/issues
+Project-URL: Source, https://github.com/refeyn/QuickGraphLib
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Multimedia :: Graphics :: Presentation
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: PySide6
+Requires-Dist: contourpy
+Provides-Extra: analyse
+Requires-Dist: black ; extra == 'analyse'
+Requires-Dist: pylint ; extra == 'analyse'
+Requires-Dist: mypy ; extra == 'analyse'
+Requires-Dist: pre-commit ; extra == 'analyse'
+Requires-Dist: lxml ; extra == 'analyse'
+Requires-Dist: pytest ; extra == 'analyse'
+Requires-Dist: pytest-cov ; extra == 'analyse'
+
+# QuickGraphLib
+
+A scientific graphing library for [QtQuick](https://doc.qt.io/qt-6/qtquick-index.html) using Qt6.
+
+Key advantages:
+
+ - Written in pure QML (with some optional Python helpers), so it can be used in both C++ and Python projects
+ - QtQuick's hardware-based rendering makes this library render very fast
+ - Support for line graphs, histograms, contour plots and more
+ - Interactivity supported natively though declarative bindings and QtQuick
+ - Support for PNG and SVG export
+
+## Examples
+
+The example gallery can be run using (provided the Python environment has [PySide6](https://pypi.org/project/PySide6/) and [contourpy](https://pypi.org/project/contourpy/) installed):
+
+```bash
+python examples\gallery.py
+```
+
+<p align="center"><img src="./examples/ExampleGallery.png" width="80%"></p>

QuickGraphLib-0.1.0a0.dist-info/RECORD

@@ -0,0 +1,32 @@
+QuickGraphLib/AntialiasingContainer.qml,sha256=rwY_q8BcNFvVWkx7vwCgHx2qgqvXJiyi5aaCpjJnxqI,459
+QuickGraphLib/Axis.qml,sha256=42F2zPiAvqCoHsJZki_4KOPG8Cyb7N3qmVIUzHHIJYc,7198
+QuickGraphLib/GraphArea.qml,sha256=WPwwsKFxvZWbZf6r6QIND8pIc2P_1R_Dcwe3dRGJeXA,1877
+QuickGraphLib/Helpers.js,sha256=_NRRQssV1QAN2rGQsufa2BPwi8Sb1aq6PcNoQ9ZJWoU,5836
+QuickGraphLib/ScalingContainer.qml,sha256=Vb5VF_9M5KK4iTvKGGcOmnV3EuAEWI3nfzghHI-yr7M,1019
+QuickGraphLib/ZoomPanHandler.qml,sha256=S23_pXHqwy6mPbVPMWbIF5XlH_RO33Nw5CGzaFq0iw8,3081
+QuickGraphLib/qmldir,sha256=6bdW8Uyv_Krun8Mylv0SClVtJNGB6pQ1ThDP8eCZDBE,338
+QuickGraphLib/GraphItems/AxHLine.qml,sha256=EiKeHH92uPFQJgKlSz8XdLsrFUjvJ-XBat2Nwe0M00E,609
+QuickGraphLib/GraphItems/AxHSpan.qml,sha256=sR8uRIb91bbcZ-BMm8RszbEjKjA34ZTn-Nk3T-J-dyg,749
+QuickGraphLib/GraphItems/AxVLine.qml,sha256=tPfVFMyCrOxRUGO_oESGydY4XZqWykUoUfnh20SolEI,608
+QuickGraphLib/GraphItems/AxVSpan.qml,sha256=MgJIm_IcK95Z6RcAumW6ron2g_T2I2HiiBiDVBcCCV8,749
+QuickGraphLib/GraphItems/BasicLegend.qml,sha256=4HVmZkOOLtTgpbuVv1XNA7ZpS6LXjVyNPG2p7nM5pz0,660
+QuickGraphLib/GraphItems/BasicLegendItem.qml,sha256=rQHM2hatw4YVf16yo9mL2mugtsD_TluApN-ZQIYXFU0,1311
+QuickGraphLib/GraphItems/Contour.qml,sha256=cSKBLKWlKLNIoFBuAwkZbMIJBO0WvJKG7At5T2PI_Tc,736
+QuickGraphLib/GraphItems/GraphItemDragHandler.qml,sha256=l8QY8LLmXJPbcNGbnilvUVMmCRTAvG_o2POKstKn2d8,1024
+QuickGraphLib/GraphItems/Grid.qml,sha256=wshlBVn8j04VwMoqfVmPWzstmcKuH34WsOExEVB5fYI,1742
+QuickGraphLib/GraphItems/Histogram.qml,sha256=Cdn2aGK2SN6KPDhCVf1M_BLgKwifw-cI6LZIQwu9pkg,1384
+QuickGraphLib/GraphItems/Line.qml,sha256=a0n3XiFB3U3DSZpLpmMZ3mjSHMIEy_tyoTDJE3aAnzY,1714
+QuickGraphLib/GraphItems/Marker.qml,sha256=Spt6dpfGaGJko15MlczL6YeJn4VGhTVD2wHoXjhvPAU,679
+QuickGraphLib/GraphItems/qmldir,sha256=Oei-JPCGE0DDk2AjeciCWp3wJWlp9wFRLzAwyLyGpDo,454
+QuickGraphLib/PreFabs/XYAxes.qml,sha256=L14EwcMDWS_yPqLmHP2z3Jy_Y8mepRVlDCwgIFIewZk,3122
+QuickGraphLib/PreFabs/qmldir,sha256=Xe48hN_BxIgW6eWPncGFMtMA2Bt43ewzZIPrw4I37QM,183
+quickgraphlib_helpers/__init__.py,sha256=p_DRi1Th5mQoPYGtm-QxzEmtTpXTGTdJhkdt9lpK7aM,163
+quickgraphlib_helpers/consts.py,sha256=EZrKEs6HvzBMjkruvdEYnsMXt_XSILmuIcSd0Lzfs-Y,240
+quickgraphlib_helpers/contours.py,sha256=P8MlPPNRtd6L16l2VU2iKHCnni6HJ2AyjkX4f8PAKyA,2380
+quickgraphlib_helpers/export.py,sha256=xFCjg_kpbuQ-uMPrG7Svz0VgVit928HdlSsl59os5e8,6235
+quickgraphlib_helpers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QuickGraphLib-0.1.0a0.dist-info/LICENCE,sha256=9DG9VQDWNuDQKZfh0_q6akoun4YTVRkfeRMExpzQ7kA,1126
+QuickGraphLib-0.1.0a0.dist-info/METADATA,sha256=Q48D0oEIZC1v2hN05ZU1IRwD-VURjMK6AM-8uZqN3Kg,3445
+QuickGraphLib-0.1.0a0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+QuickGraphLib-0.1.0a0.dist-info/top_level.txt,sha256=xau871wpLkl9FHY1B72h6DJXmBpPWDoB63swiG_NmN8,36
+QuickGraphLib-0.1.0a0.dist-info/RECORD,,

QuickGraphLib-0.1.0a0.dist-info/WHEEL

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

QuickGraphLib-0.1.0a0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+QuickGraphLib
+quickgraphlib_helpers

quickgraphlib_helpers/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+# SPDX-License-Identifier: MIT
+
+from . import contours, export

quickgraphlib_helpers/consts.py

@@ -0,0 +1,6 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Joyce and other QuickGraphLib contributors
+# SPDX-License-Identifier: MIT
+
+QML_IMPORT_NAME = "QuickGraphLib.PythonHelpers"
+QML_IMPORT_MAJOR_VERSION = 1
+QML_IMPORT_MINOR_VERSION = 0