hiveplotlib 0.26.2__tar.gz → 0.27.0__tar.gz

{hiveplotlib-0.26.2/src/hiveplotlib.egg-info → hiveplotlib-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hiveplotlib
-Version: 0.26.2
+Version: 0.27.0
 Summary: Visualize Network Data with Hive Plots
 Author-email: Gary Koplik <gary.koplik@geomdata.com>
 License: Copyright (c) 2020 - 2024, Geometric Data Analytics, Inc.
@@ -41,20 +41,20 @@ Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: pandas
 Provides-Extra: bokeh
-Requires-Dist: bokeh; extra == "bokeh"
+Requires-Dist: bokeh>=3.0.0; extra == "bokeh"
 Provides-Extra: datashader
 Requires-Dist: dask[dataframe]; extra == "datashader"
 Requires-Dist: datashader; extra == "datashader"
 Requires-Dist: numba>0.54.0; extra == "datashader"
 Requires-Dist: seaborn; extra == "datashader"
 Provides-Extra: dev
-Requires-Dist: bokeh; extra == "dev"
+Requires-Dist: bokeh>=3.0.0; extra == "dev"
 Requires-Dist: cartopy; extra == "dev"
 Requires-Dist: dask[dataframe]; extra == "dev"
 Requires-Dist: datashader; extra == "dev"
 Requires-Dist: flexitext; extra == "dev"
 Requires-Dist: geopandas; extra == "dev"
-Requires-Dist: holoviews; extra == "dev"
+Requires-Dist: holoviews>=1.15; extra == "dev"
 Requires-Dist: jupyter; extra == "dev"
 Requires-Dist: networkx; extra == "dev"
 Requires-Dist: numba>0.54.0; extra == "dev"
@@ -63,6 +63,7 @@ Requires-Dist: pybadges; extra == "dev"
 Requires-Dist: seaborn; extra == "dev"
 Requires-Dist: tqdm; extra == "dev"
 Provides-Extra: docs
+Requires-Dist: ipywidgets; extra == "docs"
 Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: nbsphinx; extra == "docs"
 Requires-Dist: pydata-sphinx-theme; extra == "docs"
@@ -70,11 +71,15 @@ Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-copybutton; extra == "docs"
 Requires-Dist: toml; extra == "docs"
 Provides-Extra: holoviews
-Requires-Dist: bokeh; extra == "holoviews"
-Requires-Dist: holoviews; extra == "holoviews"
+Requires-Dist: bokeh>=3.0.0; extra == "holoviews"
+Requires-Dist: holoviews>=1.15; extra == "holoviews"
 Requires-Dist: numba>0.54.0; extra == "holoviews"
 Provides-Extra: networkx
 Requires-Dist: networkx; extra == "networkx"
+Provides-Extra: perf
+Requires-Dist: pyinstrument; extra == "perf"
+Requires-Dist: snakeviz; extra == "perf"
+Requires-Dist: memory_profiler; extra == "perf"
 Provides-Extra: plotly
 Requires-Dist: plotly; extra == "plotly"
 Provides-Extra: ruff
@@ -86,6 +91,8 @@ Requires-Dist: pytest-html; extra == "testing"
 Requires-Dist: pytest-timeout; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: toml; extra == "testing"
+Provides-Extra: ty
+Requires-Dist: ty==0.0.20; extra == "ty"
 Dynamic: license-file
 
 ![Hiveplotlib Logo](https://hiveplotlib.readthedocs.io/stable/_static/hiveplotlib.svg)

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "hiveplotlib"
 requires-python = ">=3.10"
-version = "0.26.2"
+version = "0.27.0"
 authors = [
     {name="Gary Koplik", email="gary.koplik@geomdata.com"}
 ]
@@ -20,13 +20,13 @@ urls = {Documentation="https://hiveplotlib.readthedocs.io/stable/", Source="http
 dependencies = [
     "matplotlib",
     "numpy",
-    "pandas"
+    "pandas",
 ]
 
 [project.optional-dependencies]
 
 bokeh = [
-    "bokeh"
+    "bokeh>=3.0.0"
 ]
 
 datashader = [
@@ -38,13 +38,13 @@ datashader = [
 
 # developer dependencies
 dev = [
-    "bokeh",
+    "bokeh>=3.0.0",
     "cartopy",
     "dask[dataframe]",  # https://github.com/holoviz/datashader/issues/1319
     "datashader",
     "flexitext",
     "geopandas",
-    "holoviews",
+    "holoviews>=1.15",
     "jupyter",
     "networkx",
     "numba>0.54.0",  # https://github.com/numba/numba/issues/9708
@@ -56,6 +56,7 @@ dev = [
 
 # for building documentation
 docs = [
+    "ipywidgets",  # so nbsphinx can handle notebooks with widget metadata (e.g. tqdm progress bars)
     "myst-parser",
     "nbsphinx",
     "pydata-sphinx-theme",
@@ -65,8 +66,8 @@ docs = [
 ]
 
 holoviews = [
-    "bokeh",
-    "holoviews",
+    "bokeh>=3.0.0",
+    "holoviews>=1.15",
     "numba>0.54.0",  # https://github.com/numba/numba/issues/9708
 ]
 
@@ -74,13 +75,20 @@ networkx = [
     "networkx"
 ]
 
+# performance profiling extras
+perf = [
+    "pyinstrument",
+    "snakeviz",
+    "memory_profiler",
+]
+
 plotly = [
     "plotly"
 ]
 
 # ruff code hygeine checks
 ruff = [
-    "ruff" 
+    "ruff",
 ]
 
 testing = [
@@ -92,10 +100,23 @@ testing = [
     "toml",
 ]
 
+# ty code hygeine checks
+ty = [
+    "ty==0.0.20",  # pinning for now, 0.0.21 would require non trivial type hint changes that affect the user
+]
+
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["hiveplotlib*"]
 
+[tool.ty.src]
+exclude = [
+    "docs",
+    "examples",
+    "runners",
+    "sandbox",
+]
+
 [tool.ruff]
 # ruff performs our linting and formatting.
 # if you receive an error you don't understand, you can run `ruff rule <error code>` to learn more.

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/__init__.py

@@ -12,5 +12,9 @@ from hiveplotlib.hiveplot import (  # noqa: F401
     HivePlot,
     hive_plot_n_axes,
 )
+from hiveplotlib.hiveplot_matrix import (  # noqa: F401
+    HPM_SUPPORTED_VIZ_BACKENDS,
+    HivePlotMatrix,
+)
 from hiveplotlib.node import Node, NodeCollection  # noqa: F401
 from hiveplotlib.p2cp import P2CP, p2cp_n_axes  # noqa: F401

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/axis.py

@@ -6,6 +6,7 @@ Definition of ``Axis`` instance and helper static methods for generating and wor
 
 from typing import Hashable, Optional
 
+import numpy as np
 import pandas as pd
 
 from hiveplotlib.utils import polar2cartesian
@@ -93,7 +94,9 @@ class Axis:
         self.sorting_variable = None
 
         # hold all the cartesian coordinates, polar rho, corresponding labels, and node metadata in a pandas dataframe
-        self.node_placements = pd.DataFrame(columns=["x", "y", "unique_id", "rho"])
+        self.node_placements = pd.DataFrame(
+            columns=np.array(["x", "y", "unique_id", "rho"])
+        )
 
         # hold the current vmin and vmax used to place nodes on an axis in a ``HivePlot`` instance.
         self.vmin = None

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/converters.py

@@ -4,22 +4,22 @@
 Converters from various data structures to ``hiveplotlib``-ready structures.
 """
 
-from typing import Tuple
-
 import pandas as pd
 
-from hiveplotlib import Edges, Node, NodeCollection
-from hiveplotlib.node import node_collection_from_node_list
+from hiveplotlib import Edges, NodeCollection
 
-# say the graph type instead of calling `nx.Graph` to keep networkx dep out of this file.
-NetworkXGraph = "networkx.classes.graph.Graph instance"
+try:
+    import networkx as nx
+except ImportError as ie:  # pragma: no cover
+    msg = "`networkx` dependencies not installed, but can be installed by running `pip install hiveplotlib[networkx]`"
+    raise ImportError(msg) from ie
 
 
 def networkx_to_nodes_edges(
-    graph: NetworkXGraph,
+    graph: nx.Graph,
     unique_id_name: str = "unique_id",
     check_uniqueness: bool = True,
-) -> Tuple[NodeCollection, Edges]:  # type: ignore
+) -> tuple[NodeCollection, Edges]:
     """
     Take a ``networkx`` graph and return ``hiveplotlib``-friendly data structures.
 
@@ -31,11 +31,14 @@ def networkx_to_nodes_edges(
     :param check_uniqueness: whether or not to check that provided ``Node`` instances have unique IDs.
     :return: ``list`` of ``Node`` instances, ``(n, 2)`` ``np.ndarray`` of edges.
     """
-    nodes = [Node(unique_id=i, data=data) for i, data in list(graph.nodes.data())]
-    edge_keys = pd.DataFrame(list(graph.edges.keys()), columns=["from", "to"])
-    edge_values = pd.DataFrame(list(graph.edges.values()))
-    return node_collection_from_node_list(
-        node_list=nodes,
-        unique_id_name=unique_id_name,
+    node_data = []
+    for node, attributes in graph.nodes(data=True):
+        node_data.append({unique_id_name: node, **attributes})
+
+    node_df = pd.DataFrame(node_data)
+    edge_df = nx.to_pandas_edgelist(graph, source="from", target="to")
+    return NodeCollection(
+        data=node_df,
+        unique_id_column=unique_id_name,
         check_uniqueness=check_uniqueness,
-    ), Edges(data=edge_keys.join(edge_values))
+    ), Edges(data=edge_df)

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/datasets/international_trade.py

@@ -52,7 +52,7 @@ def international_trade_data(
     csv_years = [i.split("_")[2] for i in csv_files]
     csv_hs92 = [i.split("_")[-1] for i in csv_files]
     hiveplotlib_supported_values = pd.DataFrame(
-        np.c_[csv_years, csv_hs92], columns=["Year", "Trade Code"]
+        np.c_[csv_years, csv_hs92], columns=np.array(["Year", "Trade Code"])
     )
 
     # check that our implied data and metadata files exist

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/datasets/toy_hive_plots.py

@@ -13,6 +13,7 @@ from hiveplotlib import (
     NodeCollection,
     hive_plot_n_axes,
 )
+from hiveplotlib.datasets.international_trade import international_trade_data
 from hiveplotlib.edges import Edges
 from hiveplotlib.hiveplot import HivePlot
 from hiveplotlib.node import dataframe_to_node_list
@@ -52,7 +53,7 @@ def example_base_hive_plot(
             rng.uniform(low=10, high=20, size=num_nodes),
             rng.uniform(low=20, high=30, size=num_nodes),
         ],
-        columns=["low", "med", "high"],
+        columns=np.array(["low", "med", "high"]),
     )
 
     # make indices a column
@@ -106,7 +107,7 @@ def example_node_data(num_nodes: int = 100, seed: int = 0) -> pd.DataFrame:
             rng.uniform(low=10, high=19.99, size=num_nodes),
             rng.uniform(low=20, high=29.99, size=num_nodes),
         ],
-        columns=["low", "med", "high"],
+        columns=np.array(["low", "med", "high"]),
     )
     # make indices a column
     return data.reset_index(names="unique_id")
@@ -162,7 +163,9 @@ def example_edge_data(
     node_ids = nodes.data[nodes.unique_id_column].to_numpy()
     rng = np.random.default_rng(seed)
     edge_array = rng.choice(node_ids, size=num_edges * 2).reshape(-1, 2)
-    return pd.DataFrame(edge_array, columns=[from_column_name, to_column_name])
+    return pd.DataFrame(
+        edge_array, columns=np.array([from_column_name, to_column_name])
+    )
 
 
 def example_edges(
@@ -199,6 +202,85 @@ def example_edges(
     )
 
 
+def example_trade_nodes_and_edges() -> Tuple[NodeCollection, Edges]:
+    """
+    Load the international trade nodes and edges.
+
+    Used in the
+    :doc:`Hive Plots with More Than 3 Groups </notebooks/hive_plots_more_than_three_groups>`
+    notebook.
+
+    Uses :py:func:`hiveplotlib.datasets.international_trade.international_trade_data` to load 2019 trade data for HS92
+    trade group 8112 ("beryllium, chromium, germanium, vanadium, gallium, hafnium, indium, niobium
+    (columbium), rhenium and thallium, articles thereof, and waste or scrap") from the
+    `Harvard Growth Lab <https://dataverse.harvard.edu/dataset.xhtml?persistentId=doi%3A10.7910%2FDVN%2FT4CHWJ>`_.
+
+    **Node columns** (152 nodes):
+
+    - ``"country"``: ISO 3166-1 alpha-3 country code (unique ID).
+    - ``"continent"``: continent of the country (Africa, Asia, Europe, North America, Oceania, or South America).
+    - ``"export_value"``: total USD exported by that country within trade group 8112 in 2019.
+      Countries with no exports are assigned 0.
+
+    **Edge columns** (1158 edges):
+
+    Each edge represents non-zero trade from an origin country to a destination country.
+
+    - ``"origin_country"``: ISO 3166-1 alpha-3 code of the exporting country (from column).
+    - ``"destination_country"``: ISO 3166-1 alpha-3 code of the importing country (to column).
+    - ``"export_value"``: USD exported from the origin to the destination.
+    - ``"origin_continent"``: continent of the origin country.
+    - ``"destination_continent"``: continent of the destination country.
+
+    :return: tuple of ``(NodeCollection, Edges)`` representing the trade network.
+    """
+    data, _ = international_trade_data(year=2019, hs92_code=8112)
+
+    export_totals_per_country = (
+        data.loc[:, ["origin_country", "export_value"]]
+        .groupby("origin_country")
+        .sum()
+        .reset_index()
+    )
+
+    node_data = pd.concat(
+        [
+            data.loc[:, ["origin_country", "origin_continent"]].rename(
+                columns={
+                    "origin_country": "country",
+                    "origin_continent": "continent",
+                }
+            ),
+            data.loc[:, ["destination_country", "destination_continent"]].rename(
+                columns={
+                    "destination_country": "country",
+                    "destination_continent": "continent",
+                }
+            ),
+        ]
+    ).drop_duplicates()
+
+    node_data = node_data.merge(
+        export_totals_per_country,
+        how="left",
+        left_on="country",
+        right_on="origin_country",
+    ).drop(columns=["origin_country"])
+
+    # fill in countries with no exports as 0, not NaN
+    node_data.export_value = node_data.export_value.fillna(0)
+
+    nodes = NodeCollection(node_data, unique_id_column="country")
+
+    edges = Edges(
+        data,
+        from_column_name="origin_country",
+        to_column_name="destination_country",
+    )
+
+    return nodes, edges
+
+
 def example_nodes_and_edges(
     num_nodes: int = 100,
     num_edges: int = 200,
@@ -238,8 +320,8 @@ def example_hive_plot(
     num_nodes: int = 100,
     num_edges: int = 100,
     partition_data_column: Literal["low", "med", "high"] = "low",
-    labels: Optional[List[Hashable]] = ("A", "B", "C"),
-    cutoffs: Optional[Union[List[float], int]] = 3,
+    labels: Optional[List[Hashable]] = ["A", "B", "C"],  # noqa: B006
+    cutoffs: Union[List[Union[int, float]], int] = 3,
     partition_variable_name: Optional[Hashable] = None,
     sorting_variables: Union[Hashable, Dict[Hashable, Hashable]] = "low",
     seed: int = 0,
@@ -310,7 +392,7 @@ def example_hive_plot(
             node_collection.data,
             left_on="to",
             right_on=node_unique_id_column,
-            suffixes=[None, "_to"],
+            suffixes=(None, "_to"),
         )
     )
     for col in ["low", "med", "high"]:
@@ -329,3 +411,219 @@ def example_hive_plot(
         sorting_variables=sorting_variables,
         **hive_plot_kwargs,
     )
+
+
+def example_hpm_nodes_and_edges(
+    num_groups: int = 3,
+    nodes_per_group: int = 10,
+    edge_tag_counts: Optional[Dict[str, int]] = None,
+    edge_structure: Optional[Dict[str, str]] = None,
+    seed: int = 42,
+) -> Tuple["NodeCollection", "Edges"]:
+    """
+    Generate a shared toy dataset that works well with ``HivePlotMatrix`` examples.
+
+    Returns a ``NodeCollection`` of ``num_groups * nodes_per_group`` nodes across
+    ``num_groups`` groups (A, B, C, ...) with structured numeric columns, and a
+    multi-tag ``Edges`` object.
+
+    **Node columns**:
+
+    - ``"unique_id"``: integers 0 to (num_groups * nodes_per_group - 1).
+    - ``"group"``: group label, assigned in consecutive blocks. With ``num_groups=3``,
+      nodes 0-9 are ``"A"``, 10-19 are ``"B"``, 20-29 are ``"C"``.
+    - ``"value1"``: *correlated with group* - each group draws from a distinct sub-interval
+      of [0, 10] in ascending order. Sorting by ``value1`` places groups at distinct,
+      separated positions along each axis if setting axes ``vmin`` and ``vmax`` values to the same fixed range.
+    - ``"value2"``: *uncorrelated noise* - all nodes draw from Uniform(0, 10). Sorting
+      by ``value2`` produces little visible group separation.
+    - ``"value3"``: *inversely correlated with group* - the mirror image of ``value1``.
+      The first group draws from the highest sub-interval, the last from the lowest.
+
+    **Default edge tags** (decreasing density):
+
+    - ``"official"``: 40 edges.
+    - ``"social"``: 30 edges.
+    - ``"informal"``: 20 edges.
+
+    :param num_groups: number of groups to generate (A, B, C, ...). Default 3.
+    :param nodes_per_group: number of nodes in each group. Default 10.
+    :param edge_tag_counts: dictionary mapping edge tag names to edge counts. Defaults to
+        ``{"official": 40, "social": 30, "informal": 20}``.
+    :param edge_structure: dictionary mapping edge tag names to structure types.
+        Supported types:
+
+        - ``"random"``: edges connect any two nodes uniformly at random (default).
+        - ``"intragroup"``: edges connect nodes within the same group only.
+        - ``"intergroup"``: edges connect nodes in different groups only.
+
+        Tags not listed in this dictionary default to ``"random"``.
+    :param seed: base random seed. Seeds ``seed``, ``seed+1``, ... are used for
+        successive edge tags respectively.
+    :return: tuple of ``(NodeCollection, Edges)``.
+    """
+    _valid_structures = {"random", "intragroup", "intergroup"}
+    if edge_tag_counts is None:
+        edge_tag_counts = {"official": 40, "social": 30, "informal": 20}
+    if edge_structure is None:
+        edge_structure = {}
+    for tag, structure in edge_structure.items():
+        if structure not in _valid_structures:
+            msg = (
+                f"edge_structure[{tag!r}] = {structure!r} is not valid. "
+                f"Must be one of {_valid_structures}."
+            )
+            raise ValueError(msg)
+    num_nodes = num_groups * nodes_per_group
+    rng = np.random.default_rng(seed)
+
+    # Deterministic block group assignment
+    group_labels = [chr(ord("A") + i) for i in range(num_groups)]
+    groups: list = []
+    for label in group_labels:
+        groups.extend([label] * nodes_per_group)
+
+    # Divide [0, 10] into num_groups equal sub-intervals
+    breakpoints = np.linspace(0, 10, num_groups + 1)
+
+    # value1: correlated - group i draws from [breakpoints[i], breakpoints[i+1]]
+    value1_parts = []
+    for i in range(num_groups):
+        lo, hi = breakpoints[i], breakpoints[i + 1]
+        value1_parts.append(rng.uniform(lo, hi, size=nodes_per_group))
+    value1 = np.concatenate(value1_parts)
+
+    value2 = rng.uniform(0, 10, size=num_nodes)
+
+    # value3: inversely correlated - group i draws from the reversed sub-interval
+    value3_parts = []
+    for i in range(num_groups):
+        j = num_groups - 1 - i
+        lo, hi = breakpoints[j], breakpoints[j + 1]
+        value3_parts.append(rng.uniform(lo, hi, size=nodes_per_group))
+    value3 = np.concatenate(value3_parts)
+
+    data = pd.DataFrame(
+        {
+            "unique_id": np.arange(num_nodes),
+            "group": groups,
+            "value1": value1,
+            "value2": value2,
+            "value3": value3,
+        }
+    )
+    nodes = NodeCollection(data=data, unique_id_column="unique_id")
+    node_ids = data["unique_id"].to_numpy()
+    groups_array = np.array(groups)
+
+    def _make_edges(n_edges: int, edge_seed: int, structure: str) -> pd.DataFrame:
+        edge_rng = np.random.default_rng(edge_seed)
+        if structure == "random":
+            return pd.DataFrame(
+                edge_rng.choice(node_ids, size=n_edges * 2).reshape(-1, 2),
+                columns=np.array(["from", "to"]),
+            )
+
+        from_nodes = edge_rng.choice(node_ids, size=n_edges)
+        to_nodes = np.empty(n_edges, dtype=node_ids.dtype)
+        for j in range(n_edges):
+            src_group = groups_array[from_nodes[j]]
+            if structure == "intragroup":
+                candidates = node_ids[groups_array == src_group]
+            else:  # intergroup
+                candidates = node_ids[groups_array != src_group]
+            to_nodes[j] = edge_rng.choice(candidates)
+        return pd.DataFrame(
+            {"from": from_nodes, "to": to_nodes},
+        )
+
+    edges = Edges(
+        data={
+            tag: _make_edges(count, seed + i, edge_structure.get(tag, "random"))
+            for i, (tag, count) in enumerate(edge_tag_counts.items())
+        }
+    )
+    return nodes, edges
+
+
+def example_minimal_hive_plot() -> HivePlot:
+    """
+    Generate a minimal ``HivePlot`` instance with edge color styling.
+
+    Uses :py:func:`example_hive_plot` with 6 nodes and 6 edges (seed 42) and adds
+    a uniform edge color of ``"#006BA4"`` to all axis pairs that have edges.
+
+    :return: ``HivePlot`` instance.
+    """
+    return example_hive_plot(
+        num_nodes=6,
+        num_edges=6,
+        seed=42,
+        all_edge_kwargs={"color": "#006BA4"},
+    )
+
+
+def example_multi_tag_hive_plot() -> HivePlot:
+    """
+    Generate a ``HivePlot`` instance with two edge tags and ``repeat_axes=True``.
+
+    Creates 12 nodes (seed 10) with two independent sets of 15 edges (seeds 10 and 20)
+    stored under tags ``"tag_red"`` and ``"tag_blue"``. Edge colors are ``"#FF0000"``
+    and ``"#0000FF"`` respectively.
+
+    :return: ``HivePlot`` instance with two edge tags.
+    """
+    nodes = example_node_collection(num_nodes=12, seed=10)
+    edge_data_1 = example_edge_data(nodes=nodes, num_edges=15, seed=10)
+    edge_data_2 = example_edge_data(nodes=nodes, num_edges=15, seed=20)
+    multi_tag_edges = Edges(data={"tag_red": edge_data_1, "tag_blue": edge_data_2})
+    partition_variable = nodes.create_partition_variable(
+        data_column="low", labels=["A", "B", "C"]
+    )
+    hp = HivePlot(
+        nodes=nodes,
+        edges=multi_tag_edges,
+        partition_variable=partition_variable,
+        sorting_variables="low",
+        repeat_axes=True,
+    )
+    hp.edges.update_edge_viz_kwargs(tag="tag_red", color="#FF0000")
+    hp.edges.update_edge_viz_kwargs(tag="tag_blue", color="#0000FF")
+    return hp
+
+
+def example_full_kwargs_hive_plot() -> HivePlot:
+    """
+    Generate a ``HivePlot`` instance with data-dependent edge kwargs, colormaps, and node styling.
+
+    Uses :py:func:`example_hive_plot` with 9 nodes, 10 edges (seed 99), and
+    ``repeat_axes=True``. Scaled edge data columns are created for alpha and linewidth,
+    and all edge visualization kwargs are set via
+    :py:meth:`~hiveplotlib.HivePlot.update_edge_plotting_keyword_arguments` using column
+    name references:
+
+    - **color**: the ``"low"`` edge data column mapped through a ``"cividis"`` colormap.
+    - **alpha**: the ``"alpha_scaled"`` column (``low / 10``, yielding values in ~0.3-1.0).
+    - **linewidth**: the ``"lw_scaled"`` column (``low / 3``, yielding values in ~1.0-3.3).
+
+    Node styling is applied via ``update_node_viz_kwargs`` with a ``"viridis"`` colormap mapped to the ``"low"``
+    data column.
+
+    :return: ``HivePlot`` instance with node and edge kwargs.
+    """
+    hp = example_hive_plot(num_nodes=9, num_edges=10, seed=99, repeat_axes=True)
+    # create scaled edge data columns for alpha (0-1 range) and linewidth
+    hp.edges.data["alpha_scaled"] = hp.edges.data["low"] / 10
+    hp.edges.data["lw_scaled"] = hp.edges.data["low"] / 3
+    # data-dependent edge kwargs: color, alpha, and linewidth all from edge data columns
+    hp.update_edge_plotting_keyword_arguments(
+        array="low",
+        cmap="cividis",
+        clim=(0, 10),
+        alpha="alpha_scaled",
+        linewidth="lw_scaled",
+    )
+    hp.update_node_viz_kwargs(
+        c="low", s=30, alpha=0.8, edgecolor="black", cmap="viridis"
+    )
+    return hp

{hiveplotlib-0.26.2 → hiveplotlib-0.27.0}/src/hiveplotlib/datasets/toy_p2cps.py

@@ -34,7 +34,7 @@ def four_gaussian_blobs_3d(
     corners_to_keep = [0, 1, 2, 4]
 
     # name of the features we will create for each set of data generated below
-    feature_names = ["X", "Y", "Z", "Label"]
+    feature_names = np.array(["X", "Y", "Z", "Label"])
 
     # set seed for consistent data
     rng = np.random.default_rng(random_seed)
@@ -63,7 +63,7 @@ def four_gaussian_blobs_3d(
     # make the labels ints
     df.Label = df.Label.astype(int)
     # replace the 4s with 3s so our labels are just range(4)
-    df.Label.to_numpy()[df.Label.to_numpy() == 4] = 3
+    df.loc[df["Label"] == 4, "Label"] = 3
 
     return df