Prepare 0.15.0 release (#1228)

* Prepare 0.15.0 release

This commit prepares the 0.15.0 release. It moves the release notes for
the release into a separate directory and adds a prelude to the release
notes. This should be the last commit to merge for the 0.15.0 release
and after it merges that commit will be what is should be tagged as the
0.15.0 release.

As part of this there are few small changes other changes being made.
The release notes are update to have consistent formatting and wording.

* Add missing release notes

* Apply suggestions from code review

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>

* Move new release note

* Reword Dorogovtsev-Goltsev-Mendes rustworkx-core release note slightly

* Update releasenotes/notes/0.15/swap-nox-tox-dea2bb14c400641c.yaml

* Update releasenotes/notes/0.15/prepare-0.15.0-771047bc5b71c569.yaml

---------

Co-authored-by: Raynel Sanchez <87539502+raynelfss@users.noreply.github.com>
Co-authored-by: Ivan Carvalho <8753214+IvanIsCoding@users.noreply.github.com>

docs/source/api/algorithm_functions/connectivity_and_cycles.rst

@@ -28,3 +28,4 @@ Connectivity and Cycles
    rustworkx.is_bipartite
    rustworkx.isolates
    rustworkx.has_path
+   rustworkx.connected_subgraphs

docs/source/api/algorithm_functions/other.rst

@@ -12,3 +12,4 @@ Other Algorithm Functions
    rustworkx.graph_line_graph
    rustworkx.metric_closure
    rustworkx.is_planar
+   rustworkx.digraph_maximum_bisimulation

docs/source/api/custom_return_types.rst

@@ -22,3 +22,5 @@ Custom Return Types
    rustworkx.NodeMap
    rustworkx.ProductNodeMap
    rustworkx.BiconnectedComponents
+   rustworkx.RelationalCoarsestPartition
+   rustworkx.IndexPartitionBlock

releasenotes/notes/0.15/add-node-link-json-parse-ef74e5b0d97c0941.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    Added two new functions, :func:`~rustworkx.from_node_link_json_file` and
+    :func:`~rustworkx.parse_node_link_json`, which are used to parse a node
+    link json object and generate a rustworkx :class:`.PyGraph` or
+    :class:`.PyDiGraph` object from it.

releasenotes/notes/0.15/collect_runs_core-13073cc7041bc2f5.yaml

@@ -0,0 +1,7 @@
+---
+features:
+  - |
+    Added a new function ``collect_runs`` to rustworkx-core's ``dag_algo``
+    module. Previously, the :func:`~.collect_runs` functionality for DAGs was
+    only exposed via the Python interface. Now Rust users can take advantage of
+    this functionality in ``rustworkx-core``.

releasenotes/notes/connected-subgraphs-b6fd8d5e37276240.yaml → releasenotes/notes/0.15/connected-subgraphs-b6fd8d5e37276240.yaml

@@ -1,10 +1,10 @@
 ---
 features:
   - |
-    Added a function :func:`~rustworkx.connected_subgraphs` to determine all connected subgraphs of size `k` in 
-    polynomial delay for undirected graphs. This improves upon the brute-force method by two orders of magnitude for 
-    sparse graphs such as heavy-hex, enabling addressing larger graphs and for a larger `k`. The introduced method is 
-    based on "Enumerating Connected Induced Subgraphs: Improved Delay and Experimental Comparison" by Christian 
-    Komusiewicz and Frank Sommer. In particular, the procedure `Simple` is implemented. Possible runtime improvement can
+    Added a function :func:`~rustworkx.connected_subgraphs` to determine all connected subgraphs of size :math:`k` in
+    polynomial delay for undirected graphs. This improves upon the brute-force method by two orders of magnitude for
+    sparse graphs such as heavy-hex, enabling addressing larger graphs and for a larger :math:`k`. The introduced method is
+    based on "Enumerating Connected Induced Subgraphs: Improved Delay and Experimental Comparison" by Christian
+    Komusiewicz and Frank Sommer. In particular, the procedure ``Simple`` is implemented. Possible runtime improvement can
     be gained by parallelization over each recursion or by following the discussion in Lemma 4 of above work and thus
-    implementing intermediate sets `X` and `P` more efficiently.
+    implementing intermediate sets :math:`X` and :math:`P` more efficiently.

releasenotes/notes/0.15/dorogovtsev-goltsev-mendes-generator-d7fd575b693bd652.yaml

@@ -0,0 +1,18 @@
+---
+features:
+  - |
+    Added :func:`rustworkx.generators.dorogovtsev_goltsev_mendes_graph` that generates
+    deterministic scale-free graphs using the Dorogovtsev-Goltsev-Mendes iterative procedure.
+
+    .. jupyter-execute::
+
+      import rustworkx as rx
+      from rustworkx.visualization import mpl_draw
+
+      graph = rx.generators.dorogovtsev_goltsev_mendes_graph(2)
+      mpl_draw(graph)
+
+  - |
+    Added a new function, ``rustworkx_core::generators::dorogovtsev_goltsev_mendes_graph``, to
+    rustworkx-core that is used to generate deterministic scale-free graphs using the
+    Dorogovtsev-Goltsev-Mendes iterative procedure.

releasenotes/notes/fix-digraph-find-cycle-141e302ff4a8fcd4.yaml → releasenotes/notes/0.15/fix-digraph-find-cycle-141e302ff4a8fcd4.yaml

@@ -6,7 +6,9 @@ fixes:
     for a cycle at an arbitrary node which was not guaranteed to return a cycle.
     Now, the function will smartly choose a source node to start the search from
     such that if a cycle exists, it will be found.
-other:
+upgrade:
   - |
-    The `rustworkx-core` function `rustworkx_core::connectivity::find_cycle` now
-    requires the `petgraph::visit::Visitable` trait.
+    The ``rustworkx-core`` function ``rustworkx_core::connectivity::find_cycle``
+    now requires the ``petgraph::visit::Visitable`` trait for its input
+    argument ``graph``. This was required to fix the behavior when ``source``
+    is ``None`` to ensure we always find a cycle if one exists.

releasenotes/notes/0.15/fix-graphviz-draw-tooltip-3f697d71c4b79e60.yaml

@@ -0,0 +1,18 @@
+---
+fixes:
+  - |
+    Fixed an issue with the :func:`.graphviz_draw` where it would not correctly
+    escape special characters in all scenarios. This has been corrected so
+    you can now use special characters with the function, for example:
+
+    .. jupyter-execute::
+
+        import rustworkx as rx
+        from rustworkx.visualization import graphviz_draw
+
+        graphviz_draw(
+            rx.generators.path_graph(2),
+            node_attr_fn=lambda x: {"label": "the\nlabel", "tooltip": "the\ntooltip"},
+        )
+
+    Fixed: `#750 <https://github.com/Qiskit/rustworkx/issues/750>`__

releasenotes/notes/fix-mpl-draw-digraph-plots-aecf86738ab9b0db.yaml → releasenotes/notes/0.15/fix-mpl-draw-digraph-plots-aecf86738ab9b0db.yaml

@@ -24,6 +24,4 @@ fixes:
 
             mpl_draw(graph, with_labels=True, labels=str, edge_labels=str, alpha=0.5)
 
-  - |
-    Refer to `#774 <https://github.com/Qiskit/rustworkx/issues/774>` for more
-    details.
+    Fixed `#774 <https://github.com/Qiskit/rustworkx/issues/774>`__

releasenotes/notes/0.15/fix-mpl-draw-kargs-typing-6cf7cfde0db072d5.yaml

@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed a bug in the type hint for the :func:`~rustworkx.visualization.mpl_draw`.
+    Previously, the type hint indicated that all ``kwargs`` were required when calling the method. The type annotation has been updated to indicate that
+    ``kwargs`` with partial arguments is allowed.

releasenotes/notes/fix-panic-3962ad36788cab00.yaml → releasenotes/notes/0.15/fix-panic-3962ad36788cab00.yaml

@@ -9,6 +9,7 @@ fixes:
       * :func:`rustworkx.bellman_ford_shortest_paths`
       * :func:`rustworkx.astar_shortest_path`
 
-    where a `Pyo3.PanicException`were raise with no much detail at the moment
-    of pass in the `source` argument the index of an out of bound node.
+    where a ``PanicException`` was raised without much detail when an
+    invalid node index was passed in to the ``source`` argument. This has been
+    corrected so an ``IndexError`` is raised instead.
     Fixed `#1117 <https://github.com/Qiskit/rustworkx/issues/1117>`__

releasenotes/notes/0.15/graphml-long-type-support-05e66d139e685dfe.yaml

@@ -0,0 +1,6 @@
+---
+fixes:
+  - |
+    Fixed support for handling ``Long`` type attributes from input GraphML
+    in the :func:`~rustworkx.read_graphml` function.
+    Fixed `#1140 <https://github.com/Qiskit/rustworkx/issues/1140>`__.

releasenotes/notes/0.15/hyperbolic-random-graph-d85c115930d8ac08.yaml

@@ -0,0 +1,21 @@
+features:
+  - |
+    Adds new random graph generator function, :func:`.hyperbolic_random_graph`
+    to sample the hyperbolic random graph model. For example:
+
+    .. jupyter-execute::
+
+        import math
+
+        import rustworkx as rx
+        from rustworkx.visualization import mpl_draw
+
+        graph = rx.hyperbolic_random_graph(
+          [[math.sinh(0.5), 0, 3.14159], [-math.sinh(1), 0, -3.14159]],
+            2.55,
+            None,
+        )
+        mpl_draw(graph)
+  - |
+    Adds new function to the rustworkx-core module ``rustworkx_core::generators``
+    ``hyperbolic_random_graph()`` that samples the hyperbolic random graph model.

releasenotes/notes/0.15/is-semi-connected-d4176b228aa62baf.yaml

@@ -0,0 +1,5 @@
+---
+features:
+  - |
+    Added a new function, :func:`~rustworkx.is_semi_connected` which will
+    check if a :class: `~rustworkx.PyDiGraph` object is semi-connected.

releasenotes/notes/maximum-bisimulation-942a9d0dc9b46ee4.yaml → releasenotes/notes/0.15/maximum-bisimulation-942a9d0dc9b46ee4.yaml

@@ -5,8 +5,7 @@ features:
     graph. This function is based on the algorithm described in the publication
     "Three partition refinement algorithms" by Paige and Tarjan. This function
     recieves a graph and returns a
-    :class:`~rustworkx.RelationalCoarsestPartition`. This function is in regards
-    to issue `#1075 <https://github.com/Qiskit/rustworkx/issues/1075>`__.
+    :class:`~rustworkx.RelationalCoarsestPartition`.
   - |
     Added a new class :class:`~rustworkx.RelationalCoarsestPartition` to output
     the maximum bisimulation or relational coarsest partition of a graph. This

releasenotes/notes/migrate-collect-bicolor-runs-ff95d7fdbc546e2e.yaml → releasenotes/notes/0.15/migrate-collect-bicolor-runs-ff95d7fdbc546e2e.yaml

@@ -2,5 +2,5 @@
 features:
   - |
     Added a new function ``collect_bicolor_runs`` to rustworkx-core's ``dag_algo`` module. 
-    Previously, the ``collect_bicolor_runs`` functionality for DAGs was only exposed
+    Previously, the :func:`~.collect_bicolor_runs` functionality for DAGs was only exposed
     via the Python interface. Now Rust users can take advantage of this functionality in ``rustworkx-core``. 

releasenotes/notes/migrate-longest_path-7c11cf2c8ac9781f.yaml → releasenotes/notes/0.15/migrate-longest_path-7c11cf2c8ac9781f.yaml

@@ -2,6 +2,5 @@
 features:
   - |
     Added a new module ``dag_algo`` to rustworkx-core which contains a new function ``longest_path``
-    function to rustworkx-core. Previously the ``longest_path`` functionality for DAGs was only exposed
-    via the Python interface. Now Rust users can take advantage of this functionality in rustworkx-core. 
-    
+    function to rustworkx-core. Previously the :func:`~.longest_path` functionality for DAGs was only exposed
+    via the Python interface. Now Rust users can take advantage of this functionality in rustworkx-core.

releasenotes/notes/0.15/prepare-0.15.0-771047bc5b71c569.yaml

@@ -0,0 +1,43 @@
+---
+prelude: >
+  This is a new feature release of Rustworkx that adds many new features to
+  the library. The highlights of this release are:
+
+    * An expansion of functions in rustworkx-core that previously only existed
+      in the Python API.
+    * Expanded graph coloring algorithms
+
+  This release moves to using the `Python Stable ABI <https://docs.python.org/3.9/c-api/stable.html>`__,
+  while this release officially supports Python 3.8 through 3.12, the published
+  binaries should be compatible with future Python versions too. Although there
+  is no guarantee provided about future versions. Additionally, the minimum
+  supported Rust version for building rustworkx and more importantly
+  rustworkx-core is now 1.70.0. Additionally, in this release the macOS arm64
+  platform has been promoted from :ref:`tier-4` to :ref:`tier-1`.
+features:
+  - |
+    Added two new keyword arguments, ``periodic`` an ``with_positions``, to the generator functions
+    :func:`.hexagonal_lattice_graph` and :func:`.directed_hexagonal_lattice_graph`. If periodic is
+    set to ``True`` the boundaries of the lattice will be joined to form a periodic grid. If the
+    ``with_positions`` argument is set to ``True`` than the data payload of all the nodes will
+    be set to a tuple of the form ``(x, y)`` where x and y represent the node's position in the
+    lattice. For example:
+
+    .. jupyter-execute::
+
+        import rustworkx as rx
+        from rustworkx.visualization import mpl_draw
+
+        graph = rx.generators.hexagonal_lattice_graph(4, 4, periodic=True, with_positions=True)
+        mpl_draw(graph, with_labels=True, labels=str)
+  - |
+    Added a new rustworkx-core function ``rustworkx_core::generators::hexagonal_lattice_graph_weighted()``
+    which is used to generate a hexagonal lattice graph where a callback is used to generate the node
+    weights for each node from a tuple of the form ``(usize, usize)``.
+upgrade:
+  - |
+    The interface of the ``rustworkx_core::generators::hexagonal_lattice_graph()`` function has been
+    changed, there is a new required boolean argument ``periodic`` which is used to indicate whether
+    the output graph should join the bondaries of the lattice to form a periodic grid or not. This
+    argument didn't exist in prior releases of rustworkx-core and it will need to be added when
+    upgrading to this new release.

releasenotes/notes/sbm-random-graph-bf7ccd8e938f4218.yaml → releasenotes/notes/0.15/sbm-random-graph-bf7ccd8e938f4218.yaml

@@ -3,6 +3,21 @@ features:
     Adds new random graph generator in rustworkx for the stochastic block model.
     There is a generator for directed :func:`.directed_sbm_random_graph` and
     undirected graphs :func:`.undirected_sbm_random_graph`.
+
+    .. jupyter-execute::
+
+        import numpy as np
+
+        import rustworkx as rx
+        from rustworkx.visualization import mpl_draw
+
+        graph = rx.undirected_sbm_random_graph(
+            [2, 1],
+            np.array([[1, 1], [1, 0]], dtype=float),
+            False,
+        )
+        mpl_draw(graph)
+
   - |
     Adds new function ``sbm_random_graph`` to the rustworkx-core module
     ``rustworkx_core::generators`` that samples a graph from the stochastic

releasenotes/notes/0.15/swap-nox-tox-dea2bb14c400641c.yaml

@@ -0,0 +1,7 @@
+---
+other:
+  - |
+    For developement of rustworkx the automated testing environment
+    tooling used has switched from Tox to instead
+    `Nox <https://nox.thea.codes/en/stable/>`__. This is has no impact for
+    end users and is only relevant if you contribute code to rustworkx.