hiplot-plus 0.1.0__py3-none-any.whl

hiplot/__init__.py

@@ -0,0 +1,38 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+from . import fetchers
+from .experiment import (
+    Datapoint,
+    Displays,
+    Experiment,
+    ExperimentDisplayed,
+    ExperimentFetcherDoesntApply,
+    ExperimentValidationCircularRef,
+    ExperimentValidationError,
+    ExperimentValidationMissingParent,
+    ValueDef,
+    ValueType,
+)
+from .pkginfo import __version__, package_name
+from .server import run_server, run_server_main
+
+__all__ = [
+    "Datapoint",
+    "Displays",
+    "Experiment",
+    "ExperimentDisplayed",
+    "ExperimentFetcherDoesntApply",
+    "ExperimentValidationCircularRef",
+    "ExperimentValidationError",
+    "ExperimentValidationMissingParent",
+    "ValueDef",
+    "ValueType",
+    "__package__",
+    "__version__",
+    "fetchers",
+    "package_name",
+    "run_server",
+    "run_server_main",
+]

hiplot/__main__.py

@@ -0,0 +1,10 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import sys
+
+from .server import run_server_main
+
+# Only ever executed by `python -m hiplot`, so it needs no __name__ guard.
+sys.exit(run_server_main())

hiplot/compress.py

@@ -0,0 +1,70 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+"""Compact encodings of an experiment's datapoints for the frontend.
+
+`src/lib/compress.ts` decodes both formats; the two sides change together.
+"""
+
+import math
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from .experiment import Datapoint
+
+RESERVED_COLUMNS = frozenset(("uid", "from_uid"))
+
+#: Key of the JSON object standing for a non-finite float, which JSON cannot represent.
+NON_FINITE_KEY = "$f"
+
+
+def _build_columns_list(datapoints: Iterable[Datapoint]) -> list[str]:
+    """Value columns in first-seen order, so the output is deterministic."""
+    columns: dict[str, None] = {}
+    for dp in datapoints:
+        columns.update(dict.fromkeys(dp.values))
+    return [column for column in columns if column not in RESERVED_COLUMNS]
+
+
+def compress(datapoints: list[Datapoint]) -> dict[str, Any]:
+    """Row-major encoding: column names once, then one array per row."""
+    columns = _build_columns_list(datapoints)
+    rows = [[dp.uid, dp.from_uid, *(dp.values.get(c) for c in columns)] for dp in datapoints]
+    return {"columns": columns, "rows": rows}
+
+
+def encode_value(value: Any) -> Any:
+    """A JSON-safe value: non-finite floats become {"$f": "inf" | "-inf" | "nan"}."""
+    if isinstance(value, float) and not math.isfinite(value):
+        return {NON_FINITE_KEY: "nan" if math.isnan(value) else ("inf" if value > 0 else "-inf")}
+    return value
+
+
+def compress_columnar(datapoints: Sequence[Datapoint]) -> dict[str, Any]:
+    """Column-major encoding, valid strict JSON.
+
+    Each column is one array with a value per row, so column names are not
+    repeated per row. A datapoint without a value for a column is listed in
+    `missing` (its slot holds null), keeping "absent" distinct from None.
+    """
+    columns = _build_columns_list(datapoints)
+    values: dict[str, list[Any]] = {}
+    missing: dict[str, list[int]] = {}
+    for column in columns:
+        column_values: list[Any] = []
+        column_missing: list[int] = []
+        for index, dp in enumerate(datapoints):
+            if column in dp.values:
+                column_values.append(encode_value(dp.values[column]))
+            else:
+                column_values.append(None)
+                column_missing.append(index)
+        values[column] = column_values
+        if column_missing:
+            missing[column] = column_missing
+    return {
+        "uid": [dp.uid for dp in datapoints],
+        "from_uid": [dp.from_uid for dp in datapoints],
+        "columns": values,
+        "missing": missing,
+    }

hiplot/csvvalues.py

@@ -0,0 +1,83 @@
+"""Reads the numbers out of CSV cells, which the csv module leaves as text.
+
+A column is numeric when every one of its cells spells a number: decimal or
+exponent notation, ``inf``/``infinity``/``nan`` in any case with an optional
+sign, or a missing value: blank, or ``na``/``n/a``/``null``/``none`` in any
+case. At least one cell must be finite. The
+grammar is the one the frontend applies to text cells (``src/lib/d3_scales.ts``),
+so both sides agree on which columns are numeric.
+"""
+
+import math
+import re
+import typing as tp
+from collections.abc import Iterable
+
+_FINITE = re.compile(r"[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?")
+_INTEGER = re.compile(r"[+-]?\d+")
+_INFINITE = re.compile(r"([+-]?)(?:inf|infinity)", re.IGNORECASE)
+_NAN = re.compile(r"[+-]?nan", re.IGNORECASE)
+_MISSING = re.compile(r"na|n/a|null|none", re.IGNORECASE)
+
+#: Columns that identify rows and are never read as numbers.
+_IDENTIFIER_COLUMNS = frozenset({"uid", "from_uid"})
+
+
+def parse_number(cell: str | None) -> int | float | None:
+    """The number a CSV cell spells: an int, a float (inf and nan included), or None when missing.
+
+    Blank cells, the missing-value spellings, and a short row's missing cells
+    (None from ``csv.DictReader``) are missing.
+
+    :raises ValueError: when the cell spells no number.
+    """
+    text = "" if cell is None else cell.strip()
+    if _is_missing_spelling(text):
+        return None
+    if _INTEGER.fullmatch(text):
+        return int(text)
+    if _FINITE.fullmatch(text):
+        return float(text)
+    infinite = _INFINITE.fullmatch(text)
+    if infinite is not None:
+        return -math.inf if infinite.group(1) == "-" else math.inf
+    if _NAN.fullmatch(text):
+        return math.nan
+    raise ValueError(f"Not a number: {cell!r}")
+
+
+def _is_missing_spelling(text: str) -> bool:
+    return text == "" or _MISSING.fullmatch(text) is not None
+
+
+def _is_number_spelling(cell: str | None) -> bool:
+    text = "" if cell is None else cell.strip()
+    return (
+        _is_missing_spelling(text)
+        or _FINITE.fullmatch(text) is not None
+        or _INFINITE.fullmatch(text) is not None
+        or _NAN.fullmatch(text) is not None
+    )
+
+
+def _has_finite_number(cells: Iterable[str | None]) -> bool:
+    return any(cell is not None and _FINITE.fullmatch(cell.strip()) is not None for cell in cells)
+
+
+def typed_rows(rows: Iterable[dict[str, str | None]]) -> list[dict[str, tp.Any]]:
+    """The rows of a ``csv.DictReader`` with the cells of each numeric column read as numbers.
+
+    Columns holding any other text keep all of their cells as text, so a column
+    never mixes numbers and strings.
+    """
+    table = list(rows)
+    columns = {column for row in table for column in row} - _IDENTIFIER_COLUMNS
+    numeric = {
+        column
+        for column in columns
+        if all(_is_number_spelling(row[column]) for row in table if column in row)
+        and _has_finite_number(row[column] for row in table if column in row)
+    }
+    return [
+        {column: parse_number(cell) if column in numeric else cell for column, cell in row.items()} for row in table
+    ]