passagemath-planarity 10.6.41__cp314-cp314t-win_arm64.whl

passagemath_planarity/__init__.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-planarity
+
+from sage.all__sagemath_planarity import *

passagemath_planarity-10.6.41.dist-info/DELVEWHEEL

@@ -0,0 +1,2 @@
+Version: 1.11.2
+Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-pxyrz7ob\\cp314t-win_arm64\\build\\venv\\Scripts\\delvewheel', 'repair', '-vv', '--custom-patch', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-pxyrz7ob\\cp314t-win_arm64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-pxyrz7ob\\cp314t-win_arm64\\built_wheel\\passagemath_planarity-10.6.41-cp314-cp314t-win_arm64.whl']

passagemath_planarity-10.6.41.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: passagemath-planarity
+Version: 10.6.41
+Summary: passagemath: Graph planarity with the edge addition planarity suite
+Author-email: The Sage Developers <sage-support@googlegroups.com>
+Maintainer: Matthias Köppe, passagemath contributors
+License-Expression: GPL-2.0-or-later
+Project-URL: release notes, https://github.com/passagemath/passagemath/releases
+Project-URL: repo (upstream), https://github.com/sagemath/sage
+Project-URL: repo, https://github.com/passagemath/passagemath
+Project-URL: documentation, https://passagemath.org/docs/latest
+Project-URL: homepage (upstream), https://www.sagemath.org
+Project-URL: discourse, https://passagemath.discourse.group
+Project-URL: tracker (upstream), https://github.com/sagemath/sage/issues
+Project-URL: tracker, https://github.com/passagemath/passagemath/issues
+Classifier: Development Status :: 6 - Mature
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/x-rst
+Requires-Dist: passagemath-graphs
+Provides-Extra: test
+Requires-Dist: passagemath-repl; extra == "test"
+
+========================================================================
+ passagemath: Graph planarity with the edge addition planarity suite
+========================================================================
+
+`passagemath <https://github.com/passagemath/passagemath>`__ is open
+source mathematical software in Python, released under the GNU General
+Public Licence GPLv2+.
+
+It is a fork of `SageMath <https://www.sagemath.org/>`__, which has been
+developed 2005-2025 under the motto “Creating a Viable Open Source
+Alternative to Magma, Maple, Mathematica, and MATLAB”.
+
+The passagemath fork uses the motto "Creating a Free Passage Between the
+Scientific Python Ecosystem and Mathematical Software Communities."
+It was created in October 2024 with the following goals:
+
+-  providing modularized installation with pip,
+-  establishing first-class membership in the scientific Python
+   ecosystem,
+-  giving `clear attribution of upstream
+   projects <https://groups.google.com/g/sage-devel/c/6HO1HEtL1Fs/m/G002rPGpAAAJ>`__,
+-  providing independently usable Python interfaces to upstream
+   libraries,
+-  offering `platform portability and integration testing
+   services <https://github.com/passagemath/passagemath/issues/704>`__
+   to upstream projects,
+-  inviting collaborations with upstream projects,
+-  `building a professional, respectful, inclusive
+   community <https://groups.google.com/g/sage-devel/c/xBzaINHWwUQ>`__,
+-  `empowering Sage users to participate in the scientific Python ecosystem
+   <https://github.com/passagemath/passagemath/issues/248>`__ by publishing packages,
+-  developing a port to `Pyodide <https://pyodide.org/en/stable/>`__ for
+   serverless deployment with Javascript,
+-  developing a native Windows port.
+
+`Full documentation <https://passagemath.org/docs/latest/html/en/index.html>`__ is
+available online.
+
+passagemath attempts to support and provides binary wheels suitable for
+all major Linux distributions and recent versions of macOS.
+
+Binary wheels for native Windows (x86_64) are are available for a subset of
+the passagemath distributions. Use of the full functionality of passagemath
+on Windows currently requires the use of Windows Subsystem for Linux (WSL)
+or virtualization.
+
+The supported Python versions in the passagemath 10.6.x series are 3.10.x-3.14.x.
+
+
+About this pip-installable distribution package
+-----------------------------------------------
+
+This pip-installable distribution ``passagemath-planarity`` is a small
+optional distribution for use with ``passagemath-graphs``.
+
+It provides a Cython interface to the
+`Edge Addition Planarity Suite <https://github.com/graph-algorithms/edge-addition-planarity-suite/>`_
+by John Boyer.
+
+
+What is included
+----------------
+
+- `Cython interface to Boyer's planarity algorithm <https://passagemath.org/docs/latest/html/en/reference/graphs/sage/graphs/planarity.html>`_
+
+
+Examples
+--------
+
+::
+
+    $ pipx run --pip-args="--prefer-binary" --spec "passagemath-planarity[test]" ipython
+
+    In [1]: from passagemath_planarity import *
+
+    In [2]: g = graphs.PetersenGraph()
+
+    In [3]: g.is_planar()
+    Out[3]: False

passagemath_planarity-10.6.41.dist-info/RECORD

@@ -0,0 +1,11 @@
+passagemath_planarity/__init__.py,sha256=LfRGKlFg1VdJAq-0ZQWm_fWqDTdEh_e7V2AIVDIoe9I,92
+passagemath_planarity-10.6.41.dist-info/DELVEWHEEL,sha256=D0tU6PohUx4pPCt6js2wEMAz4TUnuowkiLmaw6aWNx0,445
+passagemath_planarity-10.6.41.dist-info/METADATA,sha256=7_1IB67z7CPFo4S-Z3_fXilv8dhQYnEHSeTvhnieiJ8,5018
+passagemath_planarity-10.6.41.dist-info/RECORD,,
+passagemath_planarity-10.6.41.dist-info/top_level.txt,sha256=3hlvD84OACDgl2cRvSDRxjGVpKRYmBvksz4-Bo5tM5c,28
+passagemath_planarity-10.6.41.dist-info/WHEEL,sha256=zXchtPDG49pF0-WydodiT6g5I4rYIqRMLOrUzYY4Dyw,102
+passagemath_planarity.libs/libplanarity-2-6d6ffc6ee4acfc5a3368537cfe91fe86.dll,sha256=bW_8buSs_FozaFN8_pH-htkaz6eRUKDmBVGp2vOv7xA,599552
+sage/all__sagemath_planarity.py,sha256=Ud1K-uR7M1F4tD5v5Av38Tg-Qf8Jq7iX5lebmguJZkM,413
+sage/graphs/all__sagemath_planarity.py,sha256=CYZamBzI163p8V2TX9c1rV2S9cGAOxEOhc82QQkpTvQ,48
+sage/graphs/planarity.cp314t-win_arm64.pyd,sha256=_JVUbgzLY03JsSWYpfzkwIehC8YZ9DkErS6-GtDC89s,50688
+sage/graphs/planarity.pyx,sha256=2OQXReYJKYQ6MjVMO0uAj3I-z_X7fN4nau1aCfe_EUU,7093

passagemath_planarity-10.6.41.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp314-cp314t-win_arm64
+

passagemath_planarity-10.6.41.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+
+passagemath_planarity
+sage

sage/all__sagemath_planarity.py

@@ -0,0 +1,13 @@
+# sage_setup: distribution = sagemath-planarity
+# start delvewheel patch
+def _delvewheel_patch_1_11_2():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'passagemath_planarity.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_11_2()
+del _delvewheel_patch_1_11_2
+# end delvewheel patch
+
+from sage.all__sagemath_graphs import *

sage/graphs/all__sagemath_planarity.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-planarity

sage/graphs/planarity.pyx

@@ -0,0 +1,191 @@
+# sage_setup: distribution = sagemath-planarity
+# distutils: libraries = planarity
+"""
+Wrapper for Boyer's (C) planarity algorithm
+"""
+
+cdef extern from "planarity/graph.h":
+    ctypedef struct vertexRec:
+        int link[2]
+        int index
+    ctypedef vertexRec * vertexRecP
+
+    ctypedef struct edgeRec:
+        int link[2]
+        int neighbor
+    ctypedef edgeRec * edgeRecP
+
+    ctypedef struct BM_graph:
+        vertexRecP V
+        edgeRecP E
+        int N
+    ctypedef BM_graph * graphP
+
+    cdef int OK, EMBEDFLAGS_PLANAR, NONEMBEDDABLE, NOTOK
+
+    cdef graphP gp_New()
+    cdef void gp_Free(graphP *pGraph)
+    cdef int gp_InitGraph(graphP theGraph, int N)
+    cdef int gp_AddEdge(graphP theGraph, int u, int ulink, int v, int vlink)
+    cdef int gp_Embed(graphP theGraph, int embedFlags)
+    cdef int gp_SortVertices(graphP theGraph)
+
+
+def is_planar(g, kuratowski=False, set_pos=False, set_embedding=False):
+    r"""
+    Check whether ``g`` is planar using Boyer's planarity algorithm.
+
+    If ``kuratowski`` is ``False``, returns ``True`` if ``g`` is planar,
+    ``False`` otherwise.  If ``kuratowski`` is ``True``, returns a tuple, first
+    entry is a boolean (whether or not the graph is planar) and second entry is
+    a Kuratowski subgraph, i.e. an edge subdivision of `K_5` or `K_{3,3}` (if
+    not planar) or ``None`` (if planar).  Also, will set an ``_embedding``
+    attribute for the graph ``g`` if ``set_embedding`` is set to ``True``.
+
+    INPUT:
+
+    - ``kuratowski`` -- boolean (default: ``False``); when set to ``True``,
+      return a tuple of a boolean and either ``None`` or a Kuratowski subgraph
+      (i.e. an edge subdivision of `K_5` or `K_{3,3}`). When set to ``False``,
+      returns ``True`` if ``g`` is planar, ``False`` otherwise.
+
+    - ``set_pos`` -- boolean (default: ``False``); whether to use Schnyder's
+      algorithm to determine and set positions
+
+    - ``set_embedding`` -- boolean (default: ``False``); whether to record the
+      combinatorial embedding returned (see
+      :meth:`~sage.graphs.generic_graph.GenericGraph.get_embedding`)
+
+    EXAMPLES::
+
+        sage: G = graphs.DodecahedralGraph()
+        sage: from sage.graphs.planarity import is_planar
+        sage: is_planar(G)
+        True
+        sage: Graph('@').is_planar()
+        True
+
+    TESTS:
+
+    We try checking the planarity of all graphs on 7 or fewer
+    vertices.  In fact, to try to track down a segfault, we do it
+    twice. ::
+
+        sage: # long time, needs networkx
+        sage: import networkx.generators.atlas
+        sage: atlas_graphs = [Graph(i) for i in networkx.generators.atlas.graph_atlas_g()]
+        sage: a = [i for i in [1..1252] if atlas_graphs[i].is_planar()]
+        sage: b = [i for i in [1..1252] if atlas_graphs[i].is_planar()]
+        sage: a == b
+        True
+
+    There were some problems with ``set_pos`` stability in the past,
+    so let's check if this runs without exception::
+
+        sage: for i, g in enumerate(atlas_graphs):      # long time                     # needs networkx
+        ....:     if (not g.is_connected() or i == 0):
+        ....:         continue
+        ....:     _ = g.is_planar(set_embedding=True, set_pos=True)
+
+        Argument saving::
+
+            sage: G = Graph([(1, 2)])
+            sage: for set_embedding, set_pos in ((True,True), (True,False), (False, True), (False, False)):
+            ....:     G = Graph([(1, 2)])
+            ....:     assert is_planar(G, set_embedding=set_embedding, set_pos=set_pos)
+            ....:     assert (hasattr(G, '_embedding') and G._embedding is not None) == set_embedding, (set_embedding, set_pos)
+            ....:     assert (hasattr(G, '_pos') and G._pos is not None) == set_pos, (set_embedding, set_pos)
+    """
+    g._scream_if_not_simple()
+    if set_pos and not g.is_connected():
+        raise ValueError("is_planar() cannot set vertex positions for a disconnected graph")
+
+    # First take care of a trivial cases
+    if not g.size():
+        # There are no edges
+        if set_embedding:
+            g._embedding = {v: [] for v in g}
+        return (True, None) if kuratowski else True
+    if g.order() == 2 and g.is_connected():
+        # P_2 is too small to be triangulated
+        u, v = list(g)
+        if set_embedding:
+            g._embedding = {u: [v], v: [u]}
+        if set_pos:
+            g._pos = {u: [0, 0], v: [0, 1]}
+        return (True, None) if kuratowski else True
+
+    # Create to and from mappings to relabel vertices to the set {1,...,n}
+    # (planarity 3 uses 1-based array indexing, with 0 representing NIL)
+    cdef int i
+    cdef list listto = list(g)
+    cdef dict ffrom = {vvv: i for i, vvv in enumerate(listto, start=1)}
+    cdef dict to = {i: vvv for i, vvv in enumerate(listto, start=1)}
+
+    cdef graphP theGraph
+    theGraph = gp_New()
+    cdef int status
+    status = gp_InitGraph(theGraph, g.order())
+    if status != OK:
+        raise RuntimeError("gp_InitGraph status is not ok")
+    for u, v in g.edge_iterator(labels=False):
+        status = gp_AddEdge(theGraph, ffrom[u], 0, ffrom[v], 0)
+        if status == NOTOK:
+            raise RuntimeError("gp_AddEdge status is not ok")
+        elif status == NONEMBEDDABLE:
+            # We now know that the graph is nonplanar.
+            if not kuratowski:
+                gp_Free(&theGraph)
+                return False
+            # With just the current edges, we have a nonplanar graph,
+            # so to isolate a kuratowski subgraph, just keep going.
+            break
+
+    status = gp_Embed(theGraph, EMBEDFLAGS_PLANAR)
+
+    if status == NOTOK:
+        raise RuntimeError("status is not ok")
+
+    gp_SortVertices(theGraph)
+
+    if status == NONEMBEDDABLE:
+        # Kuratowski subgraph isolator
+        if not kuratowski:
+            gp_Free(&theGraph)
+            return False
+        g_dict = {}
+        for i in range(1, theGraph.N + 1):
+            linked_list = []
+            j = theGraph.V[i].link[1]
+            while j:
+                linked_list.append(to[theGraph.E[j].neighbor])
+                j = theGraph.E[j].link[1]
+            if linked_list:
+                g_dict[to[i]] = linked_list
+        gp_Free(&theGraph)
+        G = g.__class__(data=g_dict, weighted=g._weighted,
+                        loops=g.allows_loops(),
+                        multiedges=g.allows_multiple_edges(),
+                        name="Kuratowski subgraph of (%s)" % g.name())
+        if g.get_pos():
+            G.set_pos({u: g._pos[u] for u in g_dict})
+        return (False, G)
+
+    if set_pos or set_embedding:
+        emb_dict = {}
+        for i in range(1, theGraph.N + 1):
+            linked_list = []
+            j = theGraph.V[i].link[1]
+            while j:
+                linked_list.append(to[theGraph.E[j].neighbor])
+                j = theGraph.E[j].link[1]
+            emb_dict[to[i]] = linked_list
+        if set_embedding:
+            g._embedding = emb_dict
+        if set_pos:
+            g.layout(layout='planar', save_pos=True, on_embedding=emb_dict)
+
+    gp_Free(&theGraph)
+    if kuratowski:
+        return (True, None)
+    return True