MatplotLibAPI 3.2.21__py3-none-any.whl → 4.0.0__py3-none-any.whl

MatplotLibAPI/word_cloud.py

@@ -0,0 +1,489 @@
+"""Word cloud plotting utilities."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, Optional, Sequence, Tuple, Union
+
+from matplotlib.transforms import BboxBase
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib import colormaps
+from matplotlib.axes import Axes
+from matplotlib.backend_bases import FigureCanvasBase
+from matplotlib.figure import Figure, SubFigure
+from wordcloud import WordCloud
+
+from .base_plot import BasePlot
+
+from .utils import _get_axis
+
+from .style_template import (
+    FIG_SIZE,
+    MAX_RESULTS,
+    TITLE_SCALE_FACTOR,
+    WORDCLOUD_STYLE_TEMPLATE,
+    StyleTemplate,
+    string_formatter,
+    validate_dataframe,
+)
+
+
+def _filter_stopwords(
+    words: Iterable[str], stopwords: Optional[Iterable[str]]
+) -> np.ndarray:
+    """Remove stopwords from a sequence of words.
+
+    Parameters
+    ----------
+    words : Iterable[str]
+        Words to filter.
+    stopwords : Iterable[str], optional
+        Collection of stopwords to exclude. Defaults to ``None``.
+
+    Returns
+    -------
+    numpy.ndarray
+        Filtered words.
+    """
+    if stopwords is None:
+        return np.array(list(words))
+
+    stop_set: set[str] = {word.lower() for word in stopwords}
+    return np.array([word for word in words if word.lower() not in stop_set])
+
+
+def from_pandas_nodelist(
+    nodes_df: pd.DataFrame,
+    node_col: str = "node",
+    weight_col: str = "weight",
+):
+    """Create SankeyData from a DataFrame."""
+    validate_dataframe(nodes_df, cols=[node_col, weight_col])
+    return nodes_df[[node_col, weight_col]].set_index(node_col)[weight_col].to_dict()
+
+
+def _prepare_word_frequencies(
+    pd_df: pd.DataFrame,
+    text_column: str,
+    weight_column: str,
+    max_words: int,
+    stopwords: Optional[Iterable[str]],
+) -> Tuple[list[str], list[float]]:
+    """Aggregate and filter word frequencies.
+
+    Parameters
+    ----------
+    pd_df : pandas.DataFrame
+        Input DataFrame containing word data.
+    text_column : str
+        Column containing words or phrases.
+    weight_column : str, optional
+        Column containing numeric weights. Defaults to ``None``.
+    max_words : int
+        Maximum number of words to include.
+    stopwords : Iterable[str], optional
+        Words to exclude from the visualization. Defaults to ``None``.
+
+    Returns
+    -------
+    tuple of list
+        Lists of filtered words and their corresponding weights.
+
+    Raises
+    ------
+    AttributeError
+        If required columns are missing from the DataFrame.
+    """
+    validate_dataframe(pd_df, cols=[text_column], sort_by=weight_column)
+    word_frequencies = from_pandas_nodelist(
+        pd_df, node_col=text_column, weight_col=weight_column
+    )
+    words: np.ndarray = np.asarray(list(word_frequencies.keys()), dtype=np.str_)
+    weights: np.ndarray = np.asarray(list(word_frequencies.values()), dtype=np.float64)
+
+    filtered_words = _filter_stopwords(words, stopwords)
+    mask: np.ndarray = np.asarray(np.isin(words, filtered_words), dtype=bool)
+    filtered_weights: np.ndarray = np.asarray(weights[mask], dtype=np.float64)
+
+    sorted_indices = np.argsort(filtered_weights)[::-1]
+    sorted_words = filtered_words[sorted_indices][:max_words].tolist()
+    sorted_weights = filtered_weights[sorted_indices][:max_words].tolist()
+
+    return sorted_words, sorted_weights
+
+
+def _create_circular_mask(size: int = 300, radius: Optional[int] = None) -> np.ndarray:
+    """Construct a binary mask with a circular opening for a word cloud.
+
+    Parameters
+    ----------
+    size : int, optional
+        Width and height of the mask in pixels. Defaults to ``300``.
+    radius : int, optional
+        Radius of the circular opening in pixels. Defaults to ``size // 2``.
+
+    Returns
+    -------
+    numpy.ndarray
+        Two-dimensional array suitable for the ``mask`` argument of
+        ``wordcloud.WordCloud`` where ``0`` values define the drawable region.
+
+    Raises
+    ------
+    ValueError
+        If ``size`` or ``radius`` are non-positive.
+    """
+    if size <= 0:
+        raise ValueError("size must be a positive integer.")
+
+    resolved_radius: int = radius if radius is not None else size // 2
+    if resolved_radius <= 0:
+        raise ValueError("radius must be a positive integer.")
+
+    center: float = (size - 1) / 2
+    x, y = np.ogrid[:size, :size]
+    mask_region = (x - center) ** 2 + (y - center) ** 2 > resolved_radius**2
+    return 255 * mask_region.astype(np.uint8)
+
+
+def _plot_words(
+    ax: Axes,
+    words: Sequence[str],
+    weights: Sequence[float],
+    style: StyleTemplate,
+    title: Optional[str],
+    random_state: Optional[int],
+    mask: Optional[np.ndarray],
+) -> Axes:
+    """Render words on the provided axes with sizes proportional to weights.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        Axes on which to draw.
+    words : Sequence[str]
+        Words to render.
+    weights : Sequence[float]
+        Corresponding weights for sizing.
+    style : StyleTemplate
+        Style configuration for the plot.
+    title : str, optional
+        Title of the plot. Defaults to ``None``.
+    random_state : int, optional
+        Seed for reproducible placement. Defaults to ``None``.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        Axes containing the rendered word cloud.
+    """
+    ax.set_facecolor(style.background_color)
+    ax.axis("off")
+
+    if not words:
+        if title:
+            ax.set_title(
+                title,
+                color=style.font_color,
+                fontsize=style.font_size * TITLE_SCALE_FACTOR * 0.75,
+            )
+        return ax
+
+    fig_raw = ax.figure
+    if not isinstance(fig_raw, (Figure, SubFigure)):
+        raise RuntimeError("Axes is not associated with a Figure.")
+
+    fig_obj: Union[Figure, SubFigure] = fig_raw
+    canvas: FigureCanvasBase = fig_obj.canvas
+    if canvas is None:
+        raise RuntimeError("Figure does not have an attached canvas.")
+
+    canvas.draw()
+    ax_bbox: BboxBase = ax.get_window_extent()
+
+    if mask is None:
+        mask_dimension: int = max(int(ax_bbox.width), int(ax_bbox.height), 1)
+        resolved_mask: np.ndarray = _create_circular_mask(size=mask_dimension)
+    else:
+        resolved_mask: np.ndarray = np.asarray(mask, dtype=np.uint8)
+
+    if resolved_mask.ndim != 2:
+        raise ValueError("mask must be a 2D array.")
+
+    height, width = resolved_mask.shape
+
+    frequency_map: Dict[str, float] = {
+        string_formatter(word): float(weight) for word, weight in zip(words, weights)
+    }
+    if frequency_map and max(frequency_map.values()) <= 0:
+        frequency_map = {word: 1.0 for word in frequency_map}
+
+    max_font_size = int(style.font_mapping[max(style.font_mapping.keys())] * 20)
+
+    wc: WordCloud = WordCloud(
+        width=width,
+        height=height,
+        background_color=style.background_color,
+        colormap=colormaps.get_cmap(style.palette),
+        # min_font_size=min_font_size,
+        # max_font_size=max_font_size,
+        random_state=random_state,
+        mask=resolved_mask,
+    ).generate_from_frequencies(frequency_map, max_font_size=max_font_size)
+
+    ax.imshow(wc.to_array(), interpolation="bilinear")
+
+    if title:
+        ax.set_title(
+            title,
+            color=style.font_color,
+            fontsize=style.font_size * TITLE_SCALE_FACTOR * 0.75,
+        )
+    return ax
+
+
+class WordCloudPlot(BasePlot):
+    """Represent a word-cloud plot builder.
+
+    Methods
+    -------
+    aplot
+        Plot the word cloud on an existing Matplotlib axes.
+    fplot
+        Plot the word cloud on a new Matplotlib figure.
+    """
+
+    def __init__(self, pd_df: pd.DataFrame, text_column: str, weight_column: str):
+        validate_dataframe(pd_df, cols=[text_column], sort_by=weight_column)
+        super().__init__(pd_df=pd_df)
+        self.text_column = text_column
+        self.weight_column = weight_column
+
+    def aplot(
+        self,
+        title: Optional[str] = None,
+        style: StyleTemplate = WORDCLOUD_STYLE_TEMPLATE,
+        max_words: int = MAX_RESULTS,
+        stopwords: Optional[Iterable[str]] = None,
+        random_state: Optional[int] = None,
+        ax: Optional[Axes] = None,
+        mask: Optional[np.ndarray] = None,
+        **kwargs: Any,
+    ) -> Axes:
+        """Plot the configured word cloud on existing axes.
+
+        Parameters
+        ----------
+        title : str, optional
+            Plot title.
+        style : StyleTemplate, optional
+            Style configuration. The default is ``WORDCLOUD_STYLE_TEMPLATE``.
+        max_words : int, optional
+            Maximum number of words to include. The default is ``MAX_RESULTS``.
+        stopwords : Iterable[str], optional
+            Words to exclude from the cloud.
+        random_state : int, optional
+            Random seed used by word-cloud placement.
+        ax : Axes, optional
+            Matplotlib axes to draw on. If None, use the current axes.
+        mask : np.ndarray, optional
+            Binary mask controlling drawable pixels.
+        **kwargs : Any
+            Additional keyword arguments reserved for compatibility.
+
+        Returns
+        -------
+        Axes
+            Matplotlib axes containing the rendered word cloud.
+        """
+        words, weights = _prepare_word_frequencies(
+            pd_df=self._obj,
+            text_column=self.text_column,
+            weight_column=self.weight_column,
+            max_words=max_words,
+            stopwords=stopwords,
+        )
+        plot_ax = _get_axis(ax)
+        return _plot_words(
+            plot_ax,
+            words,
+            weights,
+            style=style,
+            title=title,
+            random_state=random_state,
+            mask=mask,
+        )
+
+    def fplot(
+        self,
+        title: Optional[str] = None,
+        style: StyleTemplate = WORDCLOUD_STYLE_TEMPLATE,
+        max_words: int = MAX_RESULTS,
+        stopwords: Optional[Iterable[str]] = None,
+        random_state: Optional[int] = None,
+        figsize: Tuple[float, float] = FIG_SIZE,
+        mask: Optional[np.ndarray] = None,
+    ) -> Figure:
+        """Plot the configured word cloud on a new figure.
+
+        Parameters
+        ----------
+        title : str, optional
+            Plot title.
+        style : StyleTemplate, optional
+            Style configuration. The default is ``WORDCLOUD_STYLE_TEMPLATE``.
+        max_words : int, optional
+            Maximum number of words to include. The default is ``MAX_RESULTS``.
+        stopwords : Iterable[str], optional
+            Words to exclude from the cloud.
+        random_state : int, optional
+            Random seed used by word-cloud placement.
+        figsize : tuple[float, float], optional
+            Figure size. The default is ``FIG_SIZE``.
+        mask : np.ndarray, optional
+            Binary mask controlling drawable pixels.
+
+        Returns
+        -------
+        Figure
+            Matplotlib figure containing the rendered word cloud.
+        """
+        fig = Figure(
+            figsize=figsize,
+            facecolor=style.background_color,
+            edgecolor=style.background_color,
+        )
+        ax = Axes(fig=fig, facecolor=style.background_color)
+        self.aplot(
+            title=title,
+            style=style,
+            max_words=max_words,
+            stopwords=stopwords,
+            random_state=random_state,
+            ax=ax,
+            mask=mask,
+        )
+        return fig
+
+
+def aplot_wordcloud(
+    pd_df: pd.DataFrame,
+    text_column: str,
+    weight_column: str,
+    title: Optional[str] = None,
+    style: StyleTemplate = WORDCLOUD_STYLE_TEMPLATE,
+    max_words: int = MAX_RESULTS,
+    stopwords: Optional[Iterable[str]] = None,
+    random_state: Optional[int] = None,
+    ax: Optional[Axes] = None,
+    mask: Optional[np.ndarray] = None,
+    **kwargs: Any,
+) -> Axes:
+    """Plot a word cloud on the provided axes.
+
+    Parameters
+    ----------
+    pd_df : pandas.DataFrame
+        DataFrame containing the words to visualize.
+    text_column : str
+        Column containing words or phrases.
+    weight_column : str, optional
+        Column containing numeric weights. Defaults to ``None`` for equal weights.
+    title : str, optional
+        Plot title. Defaults to ``None``.
+    style : StyleTemplate, optional
+        Styling options. Defaults to ``WORDCLOUD_STYLE_TEMPLATE``.
+    max_words : int, optional
+        Maximum number of words to display. Defaults to ``MAX_RESULTS``.
+    stopwords : Iterable[str], optional
+        Words to exclude from the visualization. Defaults to ``None``.
+    random_state : int, optional
+        Seed for word placement. Defaults to ``None``.
+    ax : matplotlib.axes.Axes or numpy.ndarray, optional
+        Axes to draw on. Defaults to ``None`` which uses the current axes.
+    mask : numpy.ndarray, optional
+        Two-dimensional mask array defining the drawable region of the word cloud.
+        Defaults to a circular mask generated by :func:`create_circular_mask`.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        Axes containing the rendered word cloud.
+
+    Raises
+    ------
+    AttributeError
+        If required columns are missing from the DataFrame.
+    TypeError
+        If ``ax`` is not a ``matplotlib.axes.Axes`` instance.
+    """
+    return WordCloudPlot(
+        pd_df=pd_df,
+        text_column=text_column,
+        weight_column=weight_column,
+    ).aplot(
+        title=title,
+        style=style,
+        max_words=max_words,
+        stopwords=stopwords,
+        random_state=random_state,
+        ax=ax,
+        mask=mask,
+        **kwargs,
+    )
+
+
+def fplot_wordcloud(
+    pd_df: pd.DataFrame,
+    text_column: str,
+    weight_column: str,
+    title: Optional[str] = None,
+    style: StyleTemplate = WORDCLOUD_STYLE_TEMPLATE,
+    max_words: int = MAX_RESULTS,
+    stopwords: Optional[Iterable[str]] = None,
+    random_state: Optional[int] = None,
+    figsize: Tuple[float, float] = FIG_SIZE,
+    mask: Optional[np.ndarray] = None,
+) -> Figure:
+    """Return a new figure containing a word cloud.
+
+    Parameters
+    ----------
+    pd_df : pd.DataFrame
+        DataFrame containing text and optional weight columns.
+    text_column : str
+        Column containing text terms.
+    weight_column : str, optional
+        Column containing numeric weights. The default is None.
+    title : str, optional
+        Plot title. The default is None.
+    style : StyleTemplate, optional
+        Style configuration. The default is ``WORDCLOUD_STYLE_TEMPLATE``.
+    max_words : int, optional
+        Maximum number of words to include. The default is ``MAX_RESULTS``.
+    stopwords : Iterable[str], optional
+        Words to exclude from the cloud. The default is None.
+    random_state : int, optional
+        Random seed used by word cloud layout. The default is None.
+    figsize : tuple[float, float], optional
+        Size of the created figure. The default is ``FIG_SIZE``.
+    mask : np.ndarray, optional
+        Optional 2D mask limiting word cloud shape. The default is None.
+
+    Returns
+    -------
+    Figure
+        Matplotlib figure containing the word cloud.
+    """
+    return WordCloudPlot(
+        pd_df=pd_df, text_column=text_column, weight_column=weight_column
+    ).fplot(
+        title=title,
+        style=style,
+        max_words=max_words,
+        stopwords=stopwords,
+        random_state=random_state,
+        figsize=figsize,
+        mask=mask,
+    )

{matplotlibapi-3.2.21.dist-info → matplotlibapi-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MatplotLibAPI
-Version: 3.2.21
+Version: 4.0.0
 License-File: LICENSE
 Requires-Python: >=3.8
 Requires-Dist: kaleido
@@ -21,6 +21,8 @@ Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest-pydocstyle; extra == 'dev'
 Requires-Dist: tomli; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.0.0; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 # MatplotLibAPI
@@ -47,23 +49,98 @@ This will create a `data` directory with CSV files for each plot type.
 
 ## Usage
 
-Here's a simple example of how to create a bubble chart using MatplotLibAPI with a sample CSV file:
+Here's a simple example of how to create a bubble chart using the object-based API with a sample CSV file:
 
 ```python
 import pandas as pd
 import matplotlib.pyplot as plt
-from MatplotLibAPI import fplot_bubble
+from MatplotLibAPI.bubble import Bubble
 
 # Load the sample data
 df = pd.read_csv('data/bubble.csv')
 
-# Generate the bubble chart
-fig = fplot_bubble(df, label='country', x='gdp_per_capita', y='population', z='population', title='Country Statistics')
+# Build and render the bubble chart
+fig = Bubble(
+    pd_df=df,
+    label='country',
+    x='gdp_per_capita',
+    y='population',
+    z='population',
+).fplot(title='Country Statistics')
 
 # Display the plot
 plt.show()
 ```
 
+
+## MCP Integration
+
+You can run a dedicated MCP server that exposes MatplotLibAPI plotting tools for LLM agents.
+
+1. Install MCP dependencies:
+
+```bash
+pip install -e .[mcp]
+```
+
+2. Start the MCP server over stdio:
+
+```bash
+matplotlibapi-mcp
+```
+
+### Tool surface
+
+The MCP server provides these tools:
+
+- `plot_bubble`: dedicated bubble-chart rendering.
+- `plot_network`: dedicated network-chart rendering.
+- `plot_module`: generic module renderer for `bar`, `histogram`, `box_violin`, `heatmap`, `correlation_matrix`, `area`, `pie`, `waffle`, `sankey`, `table`, `timeserie`, `wordcloud`, `treemap`, and `sunburst`.
+- Explicit module endpoints such as `plot_bar`, `plot_heatmap`, `plot_sankey`, `plot_treemap`, and others for direct LLM tool selection with no module-dispatch step.
+- `describe_plot_modules`: discoverability endpoint that returns supported modules, shared input contract, parameter hints, and dedicated-tool mapping.
+
+All rendering tools accept either:
+
+- `csv_path`: filesystem path to a CSV file, or
+- `table`: in-memory records (`list[dict]`).
+
+All rendering tools return PNG bytes (octet payload) for downstream transport.
+
+For LLM orchestration, explicit endpoints are generally easier to select and ground (for example `plot_heatmap` rather than `plot_module` + `plot_module="heatmap"`). Keep `plot_module` for dynamic clients that need one generic surface.
+
+### Discoverability-first workflow
+
+For dynamic clients and agent exploration, use this sequence:
+
+1. Call `describe_plot_modules`.
+2. Select a module from `supported_plot_modules`.
+3. Read recommended keys from `parameter_hints[module_name]`.
+4. Call `plot_module` with `params` + `csv_path` or `table`.
+
+If a module key is invalid, `plot_module` returns a clear error with supported values.
+
+### Example generic call
+
+Example payload for `plot_module` with in-memory table records:
+
+```json
+{
+  "plot_module": "heatmap",
+  "table": [
+    {"month": "Jan", "channel": "Email", "engagements": 120},
+    {"month": "Jan", "channel": "Social", "engagements": 200}
+  ],
+  "params": {
+    "x": "month",
+    "y": "channel",
+    "value": "engagements",
+    "title": "Engagement Heatmap"
+  }
+}
+```
+
+The package exposes a single MCP entry point: `matplotlibapi-mcp`.
+
 ## Plot Types
 
 The library supports the following plot types:
@@ -92,10 +169,16 @@ This repository includes a `data` directory with sample CSV files for each plot
 
 ```python
 import pandas as pd
-from MatplotLibAPI import fplot_bubble
+from MatplotLibAPI.bubble import Bubble
 
 df = pd.read_csv('data/bubble.csv')
-fig = fplot_bubble(df, label='country', x='gdp_per_capita', y='life_expectancy', z='population')
+fig = Bubble(
+    pd_df=df,
+    label='country',
+    x='gdp_per_capita',
+    y='life_expectancy',
+    z='population',
+).fplot()
 fig.show()
 ```
 
@@ -103,10 +186,16 @@ fig.show()
 
 ```python
 import pandas as pd
-from MatplotLibAPI import fplot_network
+from MatplotLibAPI.network import NetworkGraph
 
 df = pd.read_csv('data/network.csv')
-fig = fplot_network(df)
+graph = NetworkGraph.from_pandas_edgelist(
+    df,
+    source='city_a',
+    target='city_b',
+    edge_weight_col='distance_km',
+)
+fig = graph.fplot(title='City Network', edge_weight_col='distance_km')
 fig.show()
 ```
 

matplotlibapi-4.0.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+MatplotLibAPI/__init__.py,sha256=RRT8uq3WQT16lUVs4DgwmL3pCeK6Jo6nOu8LIZFjMH4,200
+MatplotLibAPI/accessor.py,sha256=XfPQrDqYBmNiGRHwD8kPZ0m-O8qU4FWZRT0OHsMFhzY,64092
+MatplotLibAPI/area.py,sha256=DZXmn8vZIaRiPlZq0CIhwXtBQ8vgyNBq1bqEern4Wqo,4714
+MatplotLibAPI/bar.py,sha256=zh5mcCP9FYjzi9WDlO9D6x9tuYpHN195j9Pf6_jSjrA,5107
+MatplotLibAPI/base_plot.py,sha256=ubbjfk5cRr7YvlEzZ9wiZ_V_KsbUV_S5pmirHxD9fR8,2621
+MatplotLibAPI/box_violin.py,sha256=xsa-hNV0hp2zjPg4_bLjBp0lMOezBxTTOtvmooJF65M,4849
+MatplotLibAPI/bubble.py,sha256=-BLEclKxVpagW3dk8qwEruemehJmy-kALttatgcMILI,17035
+MatplotLibAPI/composite.py,sha256=vhPSWpXDzVKcy5BZAgyvtKOKEukepgtZzDAU473Tv1E,9531
+MatplotLibAPI/heatmap.py,sha256=pXmB5GzU8Gg8JRoIoMc3ZzSej80GgYO3m7j8PKZV7JQ,5855
+MatplotLibAPI/histogram.py,sha256=k8MpTR76c8FpKMyNOsq3oVHIj2Wwj73hSpeXQmJonik,4743
+MatplotLibAPI/mcp_server.py,sha256=hjyW7PipY78rLb5uBU5s9tf3bYRM4GBcR91MzMSX794,19192
+MatplotLibAPI/pie.py,sha256=VGgTJoPu42JYqXlvI9WC4QB7IEXmHDj3BXDPjRzqyGc,4605
+MatplotLibAPI/pivot.py,sha256=rk5wQYxPzSb6gkvtuTmDc9ZpaNThoeSl03BCQ4azOWw,7098
+MatplotLibAPI/sankey.py,sha256=OtQWzzQP9iPJAWylFnuKnmNFEkjHnzw7zyMQBUl9RIM,3022
+MatplotLibAPI/style_template.py,sha256=AFihe6twpMLYc_4-o0mhEvVMitTRtdAayZB-ECzUSsA,8498
+MatplotLibAPI/sunburst.py,sha256=9UPzov1H9hUHQZ1DtH9pVMjpbeSnnIdRVPpr7majgt8,3767
+MatplotLibAPI/table.py,sha256=LAzsVPZ4cpbqqaQ-mBAI-2X715hkFA9bhV6LbRaNBXw,7086
+MatplotLibAPI/timeserie.py,sha256=iE_MIDwQ19dWgxoxa0kd27DdfBe5__XsxrDp5qk1W-k,11899
+MatplotLibAPI/treemap.py,sha256=jmaBMlMbP9DY7ox49q1ispuK16Fz0lBNvuyZOrrwcFk,4903
+MatplotLibAPI/typing.py,sha256=zZSz7cpqPSEIrryUEW5C1_QFjEjBeeAVjBu5jktskAk,441
+MatplotLibAPI/utils.py,sha256=SZvDGsm1pt9rp1JxeXkQ4wUmOj6b3b04U2KiBmFwwJ4,1792
+MatplotLibAPI/waffle.py,sha256=KXnJ5A_4_9bICt1MAj9ExwlmB9EV_W34HRuXFAV99W8,5247
+MatplotLibAPI/word_cloud.py,sha256=qMBLFL1E5vGsclaz5ty-CxaD60aOQwmvaQiDkuroHwQ,15420
+MatplotLibAPI/mcp/__init__.py,sha256=KzF8wOB2dQrAs7i1YMqQWyLnpu0vO8OS7HGyFIGkyoA,434
+MatplotLibAPI/mcp/metadata.py,sha256=G0SJSG4XX5fZQy5F2Ii3FVOM1uprFcBvbGpK7BxMDrg,2880
+MatplotLibAPI/mcp/renderers.py,sha256=mB7B9ytr1ahxkK8MSIFQKtQ3nz5jYmX2JgKhQUe0W4k,1293
+MatplotLibAPI/network/__init__.py,sha256=jyef46y8-3u7hVhUHfFVEvYx65jSptyIbuJP6VE_f2Y,728
+MatplotLibAPI/network/constants.py,sha256=ugU0w1del8XFa-fzHaiKIGXQVhVj4TUyeYEtyDc68JM,466
+MatplotLibAPI/network/core.py,sha256=6h5eR6fwkIbO_GjDjO_Y4fBwbnvTR51jEn5d0-7qjxU,45759
+MatplotLibAPI/network/plot.py,sha256=bktXpQuJRriqhCzELYS9HU1NlsM99nqpSOgww6WRVTk,20435
+MatplotLibAPI/network/scaling.py,sha256=gdbusWHN-yKYWJjSZ0viqM5S31tZfLH8hojoc2fML2c,1632
+matplotlibapi-4.0.0.dist-info/METADATA,sha256=EVMDbThu5oKgPI3iuPiqSx3H_wP_Yw9PGBgGoFbWG4E,8451
+matplotlibapi-4.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+matplotlibapi-4.0.0.dist-info/entry_points.txt,sha256=x_X45-YKZXmwaEiyYqQiPVHFJ5Rj66qwNesDDq3-rWg,68
+matplotlibapi-4.0.0.dist-info/licenses/LICENSE,sha256=hMErKLb6YZR3lRR5zr-vxeFkvY69QAaafgSpZ5-P1dQ,1067
+matplotlibapi-4.0.0.dist-info/RECORD,,

{matplotlibapi-3.2.21.dist-info → matplotlibapi-4.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any

matplotlibapi-4.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+matplotlibapi-mcp = MatplotLibAPI.mcp_server:main