vgplot 0.29.0__py3-none-any.whl

vgplot/_types.py

@@ -0,0 +1,29 @@
+from collections.abc import Sequence
+from datetime import date
+from typing import Any
+
+from .data import DataDef
+from .params import _ParamBase
+from .plot import FromRef
+
+# Value unions: wide enough for column names, constants, param references,
+# dates, and transform dicts; narrow enough that passing a Mark or View
+# where a value belongs is a type error.
+ChannelValue = (
+    str | float | bool | date | dict[str, Any] | Sequence[Any] | _ParamBase | None
+)
+AttrValue = (
+    str | float | bool | date | dict[str, Any] | Sequence[Any] | _ParamBase | None
+)
+MarkData = str | FromRef | DataDef | dict[str, Any] | Sequence[Any] | _ParamBase | None
+TransformArg = str | float | bool | _ParamBase
+
+
+class _Unset:
+    """Sentinel for mark channels that were not passed (distinct from None)."""
+
+    def __repr__(self) -> str:
+        return "UNSET"
+
+
+UNSET: Any = _Unset()

vgplot/data.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class DataDef:
+    payload: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.payload
+
+
+def parquet(file: str, select: Any = None, where: Any = None, **kwargs: Any) -> DataDef:
+    payload: dict[str, Any] = {"type": "parquet", "file": file}
+    if select is not None:
+        payload["select"] = select
+    if where is not None:
+        payload["where"] = where
+    payload.update(kwargs)
+    return DataDef(payload)
+
+
+def csv(file: str, **kwargs: Any) -> DataDef:
+    return DataDef({"type": "csv", "file": file, **kwargs})
+
+
+def spatial(file: str, layer: str | None = None, **kwargs: Any) -> DataDef:
+    payload: dict[str, Any] = {"type": "spatial", "file": file}
+    if layer is not None:
+        payload["layer"] = layer
+    payload.update(kwargs)
+    return DataDef(payload)
+
+
+def table(query: str) -> DataDef:
+    return DataDef({"type": "table", "query": query})
+
+
+def json(data: Any = None, file: str | None = None, **kwargs: Any) -> DataDef:
+    payload: dict[str, Any] = {"type": "json"}
+    if file is not None:
+        payload["file"] = file
+    if data is not None:
+        payload["data"] = data
+    payload.update(kwargs)
+    return DataDef(payload)
+
+
+def data(**named_defs: DataDef) -> dict[str, Any]:
+    out: dict[str, Any] = {}
+    for k, v in named_defs.items():
+        out[k] = v.to_dict() if hasattr(v, "to_dict") else v
+    return out

vgplot/encodings.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def sql(expr: str) -> dict[str, Any]:
+    return {"sql": expr}
+
+
+def channels(**kwargs: str) -> dict[str, str]:
+    return dict(kwargs)

vgplot/params.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+
+def _resolve(v: Any, param_names: dict[int, str] | None) -> Any:
+    """Recursively resolve _ParamBase objects to "$name" ref strings."""
+    if param_names is None:
+        return v
+    if isinstance(v, _ParamBase):
+        name = param_names.get(id(v))
+        return f"${name}" if name is not None else v
+    if isinstance(v, list):
+        return [_resolve(x, param_names) for x in v]
+    if isinstance(v, dict):
+        return {k: _resolve(val, param_names) for k, val in v.items()}
+    return v
+
+
+class _ParamBase:
+    """Base for Param and Selection instances used as param ref tokens."""
+
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
+        raise NotImplementedError
+
+
+class ParamValue(_ParamBase):
+    def __init__(self, value: Any = None) -> None:
+        self._value = value
+
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
+        if isinstance(self._value, date):
+            return {"date": self._value.isoformat()}
+        return self._value
+
+    def __repr__(self) -> str:
+        return f"param.value({self._value!r})"
+
+
+class ParamArray(_ParamBase):
+    def __init__(self, values: list) -> None:
+        self._values = list(values)
+
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
+        return [_resolve(v, param_names) for v in self._values]
+
+    def __repr__(self) -> str:
+        return f"param.array({self._values!r})"
+
+
+class SelectionDef(_ParamBase):
+    def __init__(self, select: str, **opts: Any) -> None:
+        self._select = select
+        self._opts = {k: v for k, v in opts.items() if v is not None}
+
+    def param_def(self, *, param_names: dict[int, str] | None = None) -> Any:
+        d: dict = {"select": self._select}
+        d.update(_resolve(self._opts, param_names))
+        return d
+
+    def __repr__(self) -> str:
+        opts = ", ".join(f"{k}={v!r}" for k, v in self._opts.items())
+        return f"selection.{self._select}({opts})"
+
+
+def param(value: Any = None) -> _ParamBase:
+    if isinstance(value, list):
+        return ParamArray(value)
+    return ParamValue(value)
+
+
+class selection:
+    """Namespace for creating selection params."""
+
+    @staticmethod
+    def intersect(**opts: Any) -> SelectionDef:
+        return SelectionDef("intersect", **opts)
+
+    @staticmethod
+    def crossfilter(**opts: Any) -> SelectionDef:
+        return SelectionDef("crossfilter", **opts)
+
+    @staticmethod
+    def union(**opts: Any) -> SelectionDef:
+        return SelectionDef("union", **opts)
+
+    @staticmethod
+    def single(**opts: Any) -> SelectionDef:
+        return SelectionDef("single", **opts)