ninejs 0.0.1__py3-none-any.whl

ninejs/__init__.py

@@ -0,0 +1,4 @@
+from ninejs.main import interactive, css, save
+
+__version__ = "0.0.1"
+__all__ = ["interactive", "css", "save"]

ninejs/main.py

@@ -0,0 +1,329 @@
+import os
+import re
+import io
+import uuid
+from typing import Any, Text
+from pathlib import Path
+
+import numpy as np
+from jinja2 import Environment, FileSystemLoader
+from narwhals.typing import SeriesT
+import matplotlib.pyplot as plt
+from matplotlib.figure import Figure
+from matplotlib.axes import Axes
+from plotnine import ggplot
+import narwhals.stable.v2 as nw
+from narwhals.stable.v2.dependencies import is_numpy_array, is_into_series
+
+from ninejs import style
+
+
+def _vector_to_list(vector, name="labels and groups") -> list:
+    """
+    Function used to easily convert various kind of iterables to
+    lists in order to have standardised objects passed to javascript.
+
+    It accepts all backend series from narwhals and common objects
+    such as numpy arrays.
+
+    Todo: test this extensively to make sure it behaves as expected.
+
+    Args:
+        vector: A valid iterable.
+        name: The name passed to the error message when type is
+            invalid.
+
+    Returns:
+        A list
+    """
+    if isinstance(vector, (list, tuple)) or is_numpy_array(vector):
+        return list(vector)
+    elif is_into_series(vector):
+        return nw.from_native(vector, allow_series=True).to_list()
+    else:
+        raise ValueError(
+            f"{name} must be a Series or a valid iterable (list, tuple, ndarray...)."
+        )
+
+
+def _get_and_sanitize_js(file_path, after_pattern):
+    with open(file_path) as f:
+        content = f.read()
+
+    match = re.search(after_pattern, content, re.DOTALL)
+    if match:
+        return match.group(0)
+    else:
+        raise ValueError(f"Could not find '{after_pattern}' in the file")
+
+
+MAIN_DIR: Path = Path(__file__).parent
+TEMPLATE_DIR: Path = MAIN_DIR / "static"
+CSS_PATH: str = os.path.join(TEMPLATE_DIR, "default.css")
+JS_PARSER_PATH: str = os.path.join(TEMPLATE_DIR, "PlotParser.js")
+
+env: Environment = Environment(loader=FileSystemLoader(str(TEMPLATE_DIR)))
+
+
+class _InteractivePlot:
+    """
+    Class to convert static plotnine plots to interactive charts.
+    """
+
+    def __init__(
+        self,
+        fig: Figure | None = None,
+        **savefig_kws: Any,
+    ):
+        """
+        Initiate an `_InteractivePlot` instance to convert plotnine
+        figures to interactive charts.
+
+        Args:
+            savefig_kws: Additional keyword arguments passed to `plt.savefig()`.
+        """
+        if fig is None:
+            fig: Figure = plt.gcf()
+        buf: io.StringIO = io.StringIO()
+        fig.savefig(buf, format="svg", **savefig_kws)
+        buf.seek(0)
+        self.svg_content = buf.getvalue()
+
+        self.axes: list[Axes] = fig.get_axes()
+        self.additional_css = ""
+        self.additional_javascript = ""
+        self.template = env.get_template("template.html")
+
+        with open(CSS_PATH) as f:
+            self._default_css = f.read()
+
+        self._js_parser = _get_and_sanitize_js(
+            file_path=JS_PARSER_PATH,
+            after_pattern=r"class PlotSVGParser.*",
+        )
+
+    def add_tooltip(
+        self,
+        *,
+        labels: list | tuple | np.ndarray | SeriesT | None = None,
+        groups: list | tuple | np.ndarray | SeriesT | None = None,
+        tooltip_x_shift: int = 0,
+        tooltip_y_shift: int = 0,
+        ax: Axes | None = None,
+    ) -> "_InteractivePlot":
+        self._tooltip_x_shift = tooltip_x_shift
+        self._tooltip_y_shift = tooltip_y_shift
+
+        if ax is None:
+            ax: Axes = self.axes[0]
+        self._legend_handles, self._legend_handles_labels = (
+            ax.get_legend_handles_labels()
+        )
+
+        if labels is None:
+            self._tooltip_labels = []
+        else:
+            self._tooltip_labels = _vector_to_list(labels)
+            self._tooltip_labels.extend(self._legend_handles_labels)
+        if groups is None:
+            self._tooltip_groups = list(range(len(self._tooltip_labels)))
+        else:
+            self._tooltip_groups = _vector_to_list(groups)
+            self._tooltip_groups.extend(self._legend_handles_labels)
+
+        if not hasattr(self, "axes_tooltip"):
+            self.axes_tooltip: dict = dict()
+        axe_idx: int = self.axes.index(ax) + 1
+        axe_tooltip: dict[str, dict] = {
+            f"axes_{axe_idx}": {
+                "tooltip_labels": self._tooltip_labels,
+                "tooltip_groups": self._tooltip_groups,
+            }
+        }
+        self.axes_tooltip.update(axe_tooltip)
+
+        return self
+
+    def _set_plot_data_json(self):
+        if not hasattr(self, "_tooltip_labels"):
+            self.add_tooltip()
+
+        self.plot_data_json = {
+            "tooltip_labels": self._tooltip_labels,
+            "tooltip_groups": self._tooltip_groups,
+            "tooltip_x_shift": self._tooltip_x_shift,
+            "tooltip_y_shift": self._tooltip_y_shift,
+            "axes": self.axes_tooltip,
+        }
+
+    def _set_html(self):
+        self._set_plot_data_json()
+        self.html: Text = self.template.render(
+            uuid=str(uuid.uuid4()),
+            default_css=self._default_css,
+            additional_css=self.additional_css,
+            svg=self.svg_content,
+            plot_data_json=self.plot_data_json,
+            additional_javascript=self.additional_javascript,
+            js_parser=self._js_parser,
+            favicon_path=self._favicon_path,
+            document_title=self._document_title,
+        )
+
+    def as_html(self) -> str:
+        self._set_html()
+        return self.html
+
+    def add_css(self, css_content: str) -> "_InteractivePlot":
+        self.additional_css += css_content
+        return self
+
+    def save(
+        self,
+        file_path: str,
+        favicon_path: str = "https://github.com/JosephBARBIERDARNAL/static/blob/main/python-libs/plotjs/favicon.ico?raw=true",
+        document_title: str = "Made with ninejs",
+    ) -> "_InteractivePlot":
+        self._favicon_path = favicon_path
+        self._document_title = document_title
+
+        self._set_html()
+
+        if not file_path.endswith(".html"):
+            file_path += ".html"
+        with open(file_path, "w") as f:
+            f.write(self.html)
+
+        return self
+
+
+class interactive:
+    """
+    Wrapper for a plotnine `ggplot` object to make it interactive.
+
+    It automatically extracts
+    tooltips and grouping information from the plot mapping if present.
+
+    Attributes:
+        gg (ggplot): The original plotnine `ggplot` object.
+
+    Example:
+        ```python
+        from plotnine import ggplot, aes, geom_point
+        from ninejs import interactive, css, save
+
+        p = ggplot(df, aes("x", "y", tooltip="label")) + geom_point()
+        (
+            interactive(p)
+            + css(from_file="style.css")
+            + save("chart.html")
+        )
+        ```
+    """
+
+    def __init__(self, gg: ggplot):
+        self.gg = ggplot
+        fig = gg.draw()
+        df: Any = gg.data
+        mapping = gg.mapping
+
+        tooltip_labels = None
+        tooltip_groups = None
+        if df is not None:
+            if "tooltip" in mapping:
+                tooltip_labels = df[mapping["tooltip"]]
+            if "data_id" in mapping:
+                tooltip_groups = df[mapping["data_id"]]
+
+        self.mp = _InteractivePlot(fig=fig).add_tooltip(
+            labels=tooltip_labels, groups=tooltip_groups
+        )
+
+    def __add__(self, other_obj):
+        if isinstance(other_obj, css):
+            self.mp.add_css(other_obj.css_content)
+        elif isinstance(other_obj, save):
+            self.mp.save(file_path=other_obj.file_path)
+
+        return self
+
+
+class css:
+    """
+    Utility class to handle CSS injection for interactive plots.
+
+    This class provides multiple ways to load CSS: directly from a
+    string, from a dictionary, or from a CSS file. It is intended to
+    be combined with `interactive` plots.
+
+    Attributes:
+        css_content (str): The CSS rules to be injected.
+
+    Example:
+        ```python
+        (
+            interactive(p)
+            + css(".tooltip: {font-size: 2rem}")
+            + css(from_dict={".tooltip": {"font-size": "2rem"})
+            + css(from_file="style.css")
+            + save("output.html")
+        )
+        ```
+    """
+
+    def __init__(self, from_string=None, *, from_dict=None, from_file=None):
+        if from_string is not None:
+            self.css_content = from_string
+        elif from_dict is not None:
+            self.css_content = style.from_dict(css_dict=from_dict)
+        elif from_file is not None:
+            self.css_content = style.from_file(css_file=from_file)
+
+
+class save:
+    """
+    Utility class to specify an output HTML file for saving an
+    interactive plot.
+
+    Attributes:
+        file_path (str): Path to the output HTML file.
+
+    Example:
+        ```python
+        (
+            interactive(p)
+            + css(from_file="style.css")
+            + save("output.html")
+        )
+        ```
+    """
+
+    def __init__(self, file_path):
+        self.file_path = file_path
+
+
+if __name__ == "__main__":
+    from plotnine import ggplot, aes, geom_point, theme_minimal
+    from plotnine.data import anscombe_quartet
+
+    gg = (
+        ggplot(
+            data=anscombe_quartet,
+            mapping=aes(
+                x="x",
+                y="y",
+                color="dataset",
+                tooltip="dataset",
+                data_id="dataset",
+            ),
+        )
+        + geom_point(size=7, alpha=0.5)
+        + theme_minimal()
+    )
+
+    (
+        interactive(gg=gg)
+        + css(".tooltip{font-size: 2em;}")
+        + css(from_dict={".tooltip": {"font-size": "5em"}})
+        + save("index.html")
+    )

ninejs/static/PlotParser.js

@@ -0,0 +1,76 @@
+import * as d3 from "d3-selection";
+
+export default class PlotSVGParser {
+  constructor(svg, tooltip, tooltip_x_shift, tooltip_y_shift) {
+    this.svg = svg;
+    this.tooltip = tooltip;
+    this.tooltip_x_shift = tooltip_x_shift;
+    this.tooltip_y_shift = tooltip_y_shift;
+  }
+
+  findBars(svg, axes_class) {
+    const bars = svg.selectAll(`g#${axes_class} g[id^="PolyCollection_"] path`);
+
+    bars.attr("class", "bar plot-element");
+    return bars;
+  }
+
+  findPoints(svg, axes_class, tooltip_groups) {
+    const points = svg.selectAll(
+      `g#${axes_class} g[id^="PathCollection"] path`
+    );
+
+    points.each(function (_, i) {
+      d3.select(this).attr("data-group", tooltip_groups[i]);
+    });
+    points.attr("class", "point plot-element");
+    return points;
+  }
+
+  findLines(svg, axes_class) {
+    const lines = svg
+      .selectAll(`g#${axes_class} g[id^="line2d"] path`)
+      .filter(function () {
+        return !this.closest('g[id^="matplotlib.axis"]');
+      });
+
+    lines.attr("class", "line plot-element");
+    return lines;
+  }
+
+  findAreas(svg, axes_class) {
+    const areas = svg.selectAll(
+      `g#${axes_class} g[id^="FillBetweenPolyCollection"] path`
+    );
+    areas.attr("class", "area plot-element");
+    return areas;
+  }
+
+  setHoverEffect(plot_element, tooltip_labels, tooltip_groups, show_tooltip) {
+    const self = this;
+    plot_element
+      .on("mouseover", function (event, d) {
+        const nodes = plot_element.nodes();
+        let i = nodes.indexOf(this);
+
+        const hovered_group = tooltip_groups[i];
+        plot_element.classed("not-hovered", true);
+        plot_element
+          .filter((_, j) => {
+            return tooltip_groups[j] === hovered_group;
+          })
+          .classed("not-hovered", false)
+          .classed("hovered", true);
+
+        self.tooltip
+          .style("display", show_tooltip)
+          .style("left", event.pageX + self.tooltip_x_shift + "px")
+          .style("top", event.pageY + self.tooltip_y_shift + "px")
+          .html(tooltip_labels[i]);
+      })
+      .on("mouseout", function () {
+        plot_element.classed("not-hovered", false).classed("hovered", false);
+        self.tooltip.style("display", "none");
+      });
+  }
+}

ninejs/static/default.css

@@ -0,0 +1,40 @@
+:root {
+  --default-opacity: 1;
+  --default-not-hovered-opacity: 0.2;
+  --default-transition: opacity 0.1s ease;
+}
+
+svg {
+  width: 100%;
+  height: auto;
+}
+
+.tooltip {
+  position: absolute;
+  background: #001d3d;
+  padding: 8px 12px;
+  border-radius: 6px;
+  color: #ffffff;
+  font-size: 14px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+  pointer-events: none;
+  display: none;
+  font-family: "Helvetica Neue", "Arial", sans-serif;
+}
+
+.plot-element {
+  opacity: var(--default-opacity);
+  transition: var(--default-transition);
+}
+
+.plot-element:hover {
+  opacity: var(--default-opacity);
+}
+
+.plot-element.not-hovered {
+  opacity: var(--default-not-hovered-opacity);
+}
+
+.plot-element.hovered {
+  opacity: var(--default-opacity);
+}

ninejs/static/template.html

@@ -0,0 +1,96 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>{{ document_title | safe }}</title>
+    <link rel="icon" href="{{ favicon_path | safe }}" type="image/x-icon" />
+    <style>
+      {{ default_css | safe }}
+      {{ additional_css | safe }}
+    </style>
+  </head>
+  <body>
+    {% set chart_id = "plot-container-" + uuid %}
+
+    <div id="{{ chart_id }}">
+      {{ svg | safe }}
+      <div class="tooltip" id="tooltip-{{ uuid }}"></div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/d3/7.9.0/d3.min.js"></script>
+    <script type="module">
+      (function () {
+        // prettier-ignore
+        {{ js_parser | safe }}
+
+        const container = document.getElementById("{{ chart_id }}");
+
+        const tooltip = d3.select("#tooltip-{{ uuid }}");
+        const svg = d3.select(container).select("svg");
+
+        const plot_data = JSON.parse(`{{ plot_data_json | tojson | safe }}`);
+        const tooltip_x_shift = plot_data["tooltip_x_shift"];
+        const tooltip_y_shift = -plot_data["tooltip_y_shift"];
+        const axes = plot_data["axes"];
+
+        const plotParser = new PlotSVGParser(
+          svg,
+          tooltip,
+          tooltip_x_shift,
+          tooltip_y_shift,
+        );
+
+        // Process each axes that has tooltip configuration
+        for (const axes_class in axes) {
+          if (axes.hasOwnProperty(axes_class)) {
+            const axe_data = axes[axes_class];
+            const tooltip_labels = axe_data["tooltip_labels"];
+            const tooltip_groups = axe_data["tooltip_groups"];
+            const show_tooltip = tooltip_labels.length === 0 ? "none" : "block";
+
+            // Find plot elements within this specific axes
+            const lines = plotParser.findLines(svg, axes_class);
+            const bars = plotParser.findBars(svg, axes_class);
+            const points = plotParser.findPoints(
+              svg,
+              axes_class,
+              tooltip_groups,
+            );
+            const areas = plotParser.findAreas(svg, axes_class);
+
+            // Apply hover effects only to elements in this axes
+            plotParser.setHoverEffect(
+              points,
+              tooltip_labels,
+              tooltip_groups,
+              show_tooltip,
+            );
+            plotParser.setHoverEffect(
+              lines,
+              tooltip_labels,
+              tooltip_groups,
+              show_tooltip,
+            );
+            plotParser.setHoverEffect(
+              bars,
+              tooltip_labels,
+              tooltip_groups,
+              show_tooltip,
+            );
+            plotParser.setHoverEffect(
+              areas,
+              tooltip_labels,
+              tooltip_groups,
+              show_tooltip,
+            );
+          }
+        }
+      })();
+    </script>
+
+    <script type="module">
+      // prettier-ignore
+      {{ additional_javascript | safe }}
+    </script>
+  </body>
+</html>

ninejs/style.py

@@ -0,0 +1,100 @@
+import re
+import warnings
+
+
+def from_dict(css_dict: dict) -> str:
+    """
+    Get raw CSS in a string from a dictionnary. It's a
+    utility function useful to write CSS from a Python
+    dictionnary.
+
+    Args:
+        css_dict: A dictionnary with keys (selectors) and value
+            (dictionnary of property-value).
+
+    Returns:
+        A string of raw CSS.
+
+    Examples:
+        ```python
+        from plotjs import css
+
+        css.from_dict({
+            ".tooltip": {"color": "red", "background": "blue !important"},
+            ".point": {"width": "10px", "height": "200px"},
+        })
+        ```
+    """
+    css: str = ""
+
+    for selector, css_props in css_dict.items():
+        css += f"{selector}{{"
+        for prop, value in css_props.items():
+            css += f"{prop}:{value};"
+        css += "}"
+
+    if not is_css_like(css):
+        warnings.warn(f"CSS may be invalid:\n{css}")
+
+    return css
+
+
+def from_file(css_file: str) -> str:
+    """
+    Get raw CSS from a CSS file. This function just
+    reads the CSS from a given file and checks that
+    it looks like valid CSS.
+
+    Args:
+        css_file: Path to a CSS file.
+
+    Returns:
+        A string of raw CSS
+
+    Examples:
+        ```python
+        from plotjs import css
+
+        css.from_file("path/to/style.css")
+        ```
+    """
+    with open(css_file, "r") as f:
+        css: str = f.read()
+
+    if not is_css_like(css):
+        warnings.warn(f"CSS may be invalid: {css}")
+    return css
+
+
+def is_css_like(s: str) -> bool:
+    """
+    Check whether a string looks like valid CSS. This function
+    is primarly used internally, but you can use it too.
+
+    Args:
+        s: A string to evaluate.
+
+    Returns:
+        Whether or not `s` looks like valid CSS.
+
+    Examples:
+        ```python
+        from plotjs import is_css_like
+
+        is_css_like("This is not CSS.") # False
+        is_css_like(".box { broken }") # False
+        is_css_like(".tooltip { color: red; background: blue; }") # True
+        ```
+    """
+    css_block_pattern = re.compile(
+        r"""
+        [^{]+\s*              # Selector (at least one char that's not '{')
+        \{\s*                 # Opening brace
+        ([^:{}]+:\s*[^;{}]+;\s*)+  # At least one prop: value; pair
+        \}                    # Closing brace
+        """,
+        re.VERBOSE,
+    )
+
+    matches = css_block_pattern.findall(s)
+    return bool(matches)

ninejs/utils.py

@@ -0,0 +1,43 @@
+import re
+
+import narwhals.stable.v2 as nw
+from narwhals.stable.v2.dependencies import is_numpy_array, is_into_series
+
+
+def _vector_to_list(vector, name="labels and groups") -> list:
+    """
+    Function used to easily convert various kind of iterables to
+    lists in order to have standardised objects passed to javascript.
+
+    It accepts all backend series from narwhals and common objects
+    such as numpy arrays.
+
+    Todo: test this extensively to make sure it behaves as expected.
+
+    Args:
+        vector: A valid iterable.
+        name: The name passed to the error message when type is
+            invalid.
+
+    Returns:
+        A list
+    """
+    if isinstance(vector, (list, tuple)) or is_numpy_array(vector):
+        return list(vector)
+    elif is_into_series(vector):
+        return nw.from_native(vector, allow_series=True).to_list()
+    else:
+        raise ValueError(
+            f"{name} must be a Series or a valid iterable (list, tuple, ndarray...)."
+        )
+
+
+def _get_and_sanitize_js(file_path, after_pattern):
+    with open(file_path) as f:
+        content = f.read()
+
+    match = re.search(after_pattern, content, re.DOTALL)
+    if match:
+        return match.group(0)
+    else:
+        raise ValueError(f"Could not find '{after_pattern}' in the file")

ninejs-0.0.1.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: ninejs
+Version: 0.0.1
+Summary: Bringing interactivity to plotnine
+Author-email: Joseph Barbier <joseph@ysunflower.com>
+License-Expression: MIT
+Project-URL: Documentation, https://y-sunflower.github.io/ninejs/
+Project-URL: Homepage, https://y-sunflower.github.io/ninejs/
+Project-URL: Issues, https://github.com/y-sunflower/ninejs/issues
+Project-URL: Repository, https://github.com/y-sunflower/ninejs
+Keywords: a,keywords,list,of
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jinja2>=3.0.0
+Requires-Dist: narwhals>=2.0.0
+Requires-Dist: plotnine>=0.13.0
+Dynamic: license-file
+
+# `ninejs`: Adding interactivity to plotnine

ninejs-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+ninejs/__init__.py,sha256=VcWS-QmhPzCkp-T6pauMLItzJ7ym-cqaVeX2F3JI6gQ,111
+ninejs/main.py,sha256=0AngL6JWKxx9In9X62wgv5MkM7Mij1HPnExSEWKEB4g,9568
+ninejs/style.py,sha256=dqrZ-43KPUpILBsaCxsgAXXA0qA1duFoc__d8MFHbps,2403
+ninejs/utils.py,sha256=185aSFpgY0zyzt0TTQ4vJbcqnYhuN-bSnSZccSEcG2Q,1283
+ninejs/static/PlotParser.js,sha256=IeDBQNwFMEfdChTtFBM77BbGKyapcZ18sTJ_9lSre-g,2220
+ninejs/static/default.css,sha256=eSaoCCCwJKSSN4eU4WwAPHzvXX_hIGKM-TCIxENhTVI,729
+ninejs/static/template.html,sha256=yePygz4zAGhlcvH2Z_-6H1MS9Uvn8IgR3oaGwHppIGA,2936
+ninejs-0.0.1.dist-info/licenses/LICENSE,sha256=mjh43o45EMFItxUq2TPJPK2PUglVPzVd9PtJV_t-c0k,1071
+ninejs-0.0.1.dist-info/METADATA,sha256=KK1qUh5oqDWUyYU0tk_xSlk8RVccMYaYQq6rNFLOF7A,841
+ninejs-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ninejs-0.0.1.dist-info/top_level.txt,sha256=PqnT7by5e5krXGKDHIY2XqFKoZB38J-eB_sRxEhATuc,7
+ninejs-0.0.1.dist-info/RECORD,,

ninejs-0.0.1.dist-info/WHEEL

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

ninejs-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Joseph Barbier
+
+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.

ninejs-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ninejs