nveil 0.0.1.dev1__py3-none-any.whl

nveil/__init__.py

@@ -0,0 +1,243 @@
+"""NVEIL Python SDK — no-code AI data visualization.
+
+Usage::
+
+    import nveil
+    import pandas as pd
+
+    nveil.configure(api_key="nveil_...")
+
+    df = pd.read_csv("sales.csv")
+    spec = nveil.generate_spec("Show revenue by region", df)
+
+    fig = spec.render(df)
+    fig.show()
+
+    spec.save("revenue.nveil")
+    spec = nveil.load_spec("revenue.nveil")
+    fig = spec.render(new_df)
+"""
+
+import logging as _logging
+import os as _os
+from typing import Any
+
+from importlib.metadata import version as _pkg_version
+try:
+    __version__ = _pkg_version("nveil")
+except Exception:
+    __version__ = "0.0.0"
+
+# Silence verbose internal logging by default.
+if not _os.environ.get("NVEIL_VERBOSE"):
+    for _name in (
+        "kedro", "kedro.io", "kedro.runner", "kedro.pipeline",
+        "kedro.framework", "dive", "dive.builder", "choregraph",
+    ):
+        _logging.getLogger(_name).setLevel(_logging.WARNING)
+    _logging.getLogger().setLevel(_logging.WARNING)
+
+from .client import NveilClient
+from .exceptions import (
+    AuthenticationError,
+    IncompatibleDataError,
+    NveilError,
+    QuotaExceededError,
+    ScopeError,
+    SpecGenerationError,
+)
+from .spec import NveilSpec, show, save_image, save_html
+from .session import Session
+
+__all__ = [
+    "configure",
+    "session",
+    "generate_spec",
+    "load_spec",
+    "show",
+    "save_image",
+    "save_html",
+    "NveilClient",
+    "NveilSpec",
+    "Session",
+    "NveilError",
+    "AuthenticationError",
+    "ScopeError",
+    "QuotaExceededError",
+    "SpecGenerationError",
+    "IncompatibleDataError",
+]
+
+_client: NveilClient | None = None
+_timing_enabled: bool = False
+
+
+def configure(
+    api_key: str,
+    base_url: str = "https://app.nveil.com",
+    verify: bool = True,
+    verbose: bool = False,
+    timing: bool = False,
+    **kwargs,
+):
+    """Configure the global NVEIL client.
+
+    Args:
+        api_key: Your NVEIL API key (starts with ``nveil_``).
+        base_url: NVEIL server URL (default: ``https://app.nveil.com``).
+        verify: Verify SSL certificates (set ``False`` for local dev with self-signed certs).
+        verbose: Enable internal library logging (default: silent).
+        timing: Enable timing instrumentation (default: ``False``).
+    """
+    global _client, _timing_enabled
+    _timing_enabled = timing
+    if verbose:
+        for name in ("kedro", "kedro.io", "kedro.runner", "kedro.pipeline", "kedro.framework"):
+            _logging.getLogger(name).setLevel(_logging.INFO)
+    _client = NveilClient(api_key=api_key, base_url=base_url, verify=verify, **kwargs)
+
+
+def _get_client() -> NveilClient:
+    if _client is None:
+        raise NveilError(
+            "NVEIL not configured. Call nveil.configure(api_key='nveil_...') first."
+        )
+    return _client
+
+
+def session() -> Session:
+    """Create a scoped session with a shared workspace.
+
+    Use as a context manager to keep the workspace alive across
+    ``generate_spec`` and ``render`` calls — the data pipeline
+    runs once, not on every render.
+
+    Example::
+
+        with nveil.session() as s:
+            spec = s.generate_spec("bar chart of revenue", df)
+            fig = spec.render(df)  # reuses pipeline — no re-run
+            nveil.show(fig)
+        # workspace cleaned up here
+    """
+    return Session(client=_client, timing=_timing_enabled)
+
+
+def _normalize_to_dict(data) -> dict:
+    """Normalize input to a dict of named DataFrames."""
+    import pandas as pd
+    import numpy as np
+
+    if isinstance(data, pd.DataFrame):
+        return {"dataset": data}
+    if isinstance(data, dict):
+        result = {}
+        for name, value in data.items():
+            if isinstance(value, pd.DataFrame):
+                result[name] = value
+            else:
+                result[name] = pd.DataFrame(value)
+        return result
+    if isinstance(data, np.ndarray):
+        return {"dataset": pd.DataFrame(data)}
+    if isinstance(data, list):
+        if data and isinstance(data[0], (list, tuple)):
+            return {"dataset": pd.DataFrame(data[1:], columns=data[0])}
+        return {"dataset": pd.DataFrame(data)}
+    raise TypeError(f"Cannot convert {type(data).__name__} to DataFrame")
+
+
+_MAX_RETRIES = 2
+
+
+def generate_spec(prompt: str, data: Any) -> NveilSpec:
+    """Generate a visualization specification from data and a prompt.
+
+    Only metadata leaves your machine — never raw data.
+    All internal processing is handled by the compiled engine.
+
+    If the server-generated data pipeline fails locally, the SDK retries
+    with a new server call (the plan is non-deterministic).
+
+    Args:
+        prompt: Natural language description of the desired visualization.
+        data: pandas DataFrame, dict of DataFrames, numpy array, or list of lists.
+
+    Returns:
+        NveilSpec that can render locally and be saved/reused.
+    """
+    import logging
+    import shutil
+    from dive._engine import prepare, apply_plan, finalize
+
+    log = logging.getLogger("nveil")
+    client = _get_client()
+    dataframes = _normalize_to_dict(data)
+    last_error = None
+
+    for attempt in range(_MAX_RETRIES + 1):
+        workspace = prepare(dataframes)
+
+        try:
+            # Step 1: Send request to server for processing plan
+            plan_response = client.processing_plan(
+                prompt=prompt,
+                request_blob=workspace["request_blob"],
+                catalogue_stats=workspace["catalogue_stats"],
+            )
+
+            # Step 2: Apply plan + run pipeline locally
+            pipeline = apply_plan(
+                server_plan_response=plan_response,
+                workspace_state=workspace,
+            )
+
+            # Step 3: Send request to server for visualization
+            viz_response = client.visualization_generate(
+                session_id=plan_response.get("session_id", ""),
+                request_blob=pipeline["request_blob"],
+            )
+
+            # Surface server warnings
+            for warning in viz_response.get("warnings", []):
+                log.warning(warning)
+
+            # Step 4: Package final spec as opaque blob
+            spec_blob = finalize(
+                server_viz_response=viz_response,
+                pipeline_state_blob=pipeline["request_blob"],
+            )
+
+            return NveilSpec(spec_blob=spec_blob)
+
+        except RuntimeError as e:
+            last_error = e
+            if attempt < _MAX_RETRIES:
+                log.warning(
+                    "Pipeline execution failed (attempt %d/%d): %s — retrying",
+                    attempt + 1, _MAX_RETRIES + 1, e,
+                )
+            continue
+        finally:
+            # Clean up workspace (standalone flow — no session to keep it alive)
+            ws = workspace.get("_workspace")
+            if ws and ws.exists():
+                shutil.rmtree(ws, ignore_errors=True)
+
+    raise SpecGenerationError(
+        f"Pipeline execution failed after {_MAX_RETRIES + 1} attempts: {last_error}"
+    )
+
+
+def load_spec(path: str) -> NveilSpec:
+    """Load a spec from an opaque .nveil file.
+
+    No API call — loaded specs can be rendered locally for free.
+
+    Args:
+        path: Path to a ``.nveil`` file.
+
+    Returns:
+        NveilSpec ready to render.
+    """
+    return NveilSpec.load(path)

nveil/client.py

@@ -0,0 +1,114 @@
+"""NVEIL API client — handles HTTP communication with the NVEIL server."""
+
+import logging
+import httpx
+
+from .exceptions import (
+    AuthenticationError,
+    QuotaExceededError,
+    ScopeError,
+    SpecGenerationError,
+)
+
+DEFAULT_BASE_URL = "https://app.nveil.com"
+DEFAULT_TIMEOUT = 120.0
+
+
+class NveilClient:
+    """HTTP client for the NVEIL public API."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        verify: bool = True,
+    ):
+        from . import __version__
+
+        if not verify:
+            logging.getLogger("nveil").warning(
+                "SSL verification disabled (verify=False). "
+                "Only use this for local development with self-signed certificates."
+            )
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            headers={
+                "X-API-Key": api_key,
+                "X-Nveil-Schema-Version": __version__,
+            },
+            timeout=timeout,
+            verify=verify,
+        )
+
+    def _handle_response(self, resp: httpx.Response) -> dict:
+        if resp.status_code == 401:
+            raise AuthenticationError(
+                "Invalid, expired, or revoked API key"
+            )
+        if resp.status_code == 403:
+            raise ScopeError(resp.json().get("detail", "Missing required scope"))
+        if resp.status_code == 429:
+            raise QuotaExceededError("Rate limit exceeded")
+        if resp.status_code >= 400:
+            detail = resp.text
+            try:
+                detail = resp.json().get("detail", resp.text)
+            except Exception:
+                pass
+            raise SpecGenerationError(f"API error ({resp.status_code}): {detail}")
+        return resp.json()
+
+    def processing_plan(
+        self,
+        prompt: str,
+        request_blob: str,
+        catalogue_stats: str,
+    ) -> dict:
+        """Request a data processing plan from the server.
+
+        Args:
+            prompt: User's natural language prompt.
+            request_blob: Base64-encoded encrypted request payload.
+            catalogue_stats: JSON string of dataset metadata.
+        """
+        resp = self._client.post(
+            "/api/v1/processing/plan",
+            json={
+                "prompt": prompt,
+                "request_blob": request_blob,
+                "catalogue_stats": catalogue_stats,
+            },
+        )
+        return self._handle_response(resp)
+
+    def visualization_generate(
+        self,
+        session_id: str,
+        request_blob: str,
+    ) -> dict:
+        """Request visualization generation from the server.
+
+        Args:
+            session_id: Session ID from processing_plan response.
+            request_blob: Base64-encoded encrypted request payload.
+        """
+        resp = self._client.post(
+            "/api/v1/visualization/generate",
+            json={
+                "session_id": session_id,
+                "request_blob": request_blob,
+            },
+        )
+        return self._handle_response(resp)
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

nveil/exceptions.py

@@ -0,0 +1,25 @@
+"""NVEIL SDK exceptions."""
+
+
+class NveilError(Exception):
+    """Base exception for all NVEIL SDK errors."""
+
+
+class AuthenticationError(NveilError):
+    """Raised when the API key is invalid, expired, or revoked."""
+
+
+class ScopeError(NveilError):
+    """Raised when the API key is missing a required scope."""
+
+
+class QuotaExceededError(NveilError):
+    """Raised when the rate limit or quota is exceeded."""
+
+
+class SpecGenerationError(NveilError):
+    """Raised when the server fails to generate a specification."""
+
+
+class IncompatibleDataError(NveilError):
+    """Raised when data columns don't match the spec's expected schema."""

nveil/session.py

@@ -0,0 +1,137 @@
+"""Scoped session — owns a temporary workspace for the duration of a ``with:`` block.
+
+Usage::
+
+    with nveil.session() as s:
+        spec = s.generate_spec("bar chart of revenue", df)
+        fig = spec.render(df)    # reuses the same workspace — no re-run
+        nveil.show(fig)
+        print(s.timer.summary())
+    # workspace cleaned up here
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any, Optional
+
+from .exceptions import NveilError, SpecGenerationError
+from .spec import NveilSpec
+from .timing import Timer
+
+
+class Session:
+    """Scoped workspace session.
+
+    The session owns a temporary workspace and a pipeline instance.
+    ``generate_spec`` builds and runs the pipeline once; subsequent
+    ``render()`` calls reuse the already-computed outputs.
+
+    When ``timing=True``, all operations are tracked in ``self.timer``.
+    """
+
+    def __init__(self, client=None, timing: bool = False):
+        self._client = client
+        self._pipeline = None  # Pipeline instance — alive for the session
+        self._workspace: Optional[Path] = None
+        self._session_id: Optional[str] = None
+        self.timer = Timer(enabled=timing)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        if self._workspace and self._workspace.exists():
+            shutil.rmtree(self._workspace, ignore_errors=True)
+        self._pipeline = None
+        self._workspace = None
+        self._session_id = None
+
+    def _get_client(self):
+        if self._client:
+            return self._client
+        from . import _get_client
+        return _get_client()
+
+    def generate_spec(self, prompt: str, data: Any) -> NveilSpec:
+        """Generate a visualization specification.
+
+        All internal processing is done by the compiled engine.
+        The session keeps the pipeline instance alive for render() reuse.
+
+        If the server-generated data pipeline fails locally, retries
+        with a new server call (the plan is non-deterministic).
+
+        Args:
+            prompt: Natural language visualization request.
+            data: pandas DataFrame, dict of DataFrames, or compatible input.
+
+        Returns:
+            NveilSpec bound to this session's workspace.
+        """
+        import logging
+        import shutil
+        from dive._engine import prepare, apply_plan, finalize
+        from . import _normalize_to_dict, _MAX_RETRIES
+
+        log = logging.getLogger("nveil")
+        client = self._get_client()
+        dataframes = _normalize_to_dict(data)
+        last_error = None
+
+        for attempt in range(_MAX_RETRIES + 1):
+            with self.timer.measure("build workspace"):
+                workspace = prepare(dataframes)
+
+            try:
+                with self.timer.measure("API: processing plan"):
+                    plan_response = client.processing_plan(
+                        prompt=prompt,
+                        request_blob=workspace["request_blob"],
+                        catalogue_stats=workspace["catalogue_stats"],
+                    )
+                    self._session_id = plan_response.get("session_id", "")
+
+                with self.timer.measure("pipeline run"):
+                    pipeline = apply_plan(
+                        server_plan_response=plan_response,
+                        workspace_state=workspace,
+                    )
+                    self._pipeline = pipeline.get("_choregraph")
+                    self._workspace = pipeline.get("_workspace")
+
+                with self.timer.measure("API: visualization"):
+                    viz_response = client.visualization_generate(
+                        session_id=self._session_id,
+                        request_blob=pipeline["request_blob"],
+                    )
+
+                for warning in viz_response.get("warnings", []):
+                    log.warning(warning)
+
+                spec_blob = finalize(
+                    server_viz_response=viz_response,
+                    pipeline_state_blob=pipeline["request_blob"],
+                )
+
+                spec = NveilSpec(spec_blob=spec_blob)
+                spec._session = self
+                return spec
+
+            except RuntimeError as e:
+                last_error = e
+                if attempt < _MAX_RETRIES:
+                    log.warning(
+                        "Pipeline execution failed (attempt %d/%d): %s — retrying",
+                        attempt + 1, _MAX_RETRIES + 1, e,
+                    )
+                    # Clean up failed workspace before retry
+                    ws = workspace.get("_workspace")
+                    if ws and ws.exists():
+                        shutil.rmtree(ws, ignore_errors=True)
+                continue
+
+        raise SpecGenerationError(
+            f"Pipeline execution failed after {_MAX_RETRIES + 1} attempts: {last_error}"
+        )

nveil/spec.py

@@ -0,0 +1,141 @@
+"""NveilSpec — opaque visualization specification with local rendering.
+
+Once generated, a spec can be reused unlimited times on new data with
+compatible columns — no API call, no cost.
+
+All internal processing is handled by the compiled engine. The SDK
+only stores and passes opaque byte blobs.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class NveilSpec:
+    """Opaque visualization specification with local rendering.
+
+    Once generated, ``spec.render(new_data)`` is 100% local — no API call,
+    no cost. Reusable on any data with compatible columns.
+    """
+
+    def __init__(self, spec_blob: bytes):
+        self._blob = spec_blob
+        self._session = None  # set by Session.generate_spec for workspace reuse
+
+    def render(self, data: Any = None) -> Any:
+        """Render using the auto-detected best backend (Plotly, VTK, DeckGL).
+
+        100% local execution — no API call.
+
+        If called within a session context (``with nveil.session()``),
+        reuses the session's already-computed pipeline outputs —
+        no pipeline re-run.
+
+        Args:
+            data: pandas DataFrame, dict of DataFrames, numpy array, or list.
+
+        Returns:
+            Backend-specific figure object (plotly.graph_objects.Figure, etc.)
+        """
+        from dive._engine import render as engine_render
+        from .timing import Timer
+
+        session = self._session
+        timer = session.timer if session else Timer()
+
+        pipeline_instance = None
+        if session and session._pipeline:
+            pipeline_instance = session._pipeline
+
+        with timer.measure("render"):
+            return engine_render(
+                spec_blob=self._blob,
+                data=data,
+                choregraph_instance=pipeline_instance,
+            )
+
+    @property
+    def explanation(self) -> str:
+        """Human-readable description of what was generated."""
+        from dive._engine import get_explanation
+        return get_explanation(self._blob)
+
+    def save(self, path: str) -> None:
+        """Save to opaque .nveil file (encrypted binary)."""
+        from dive._engine import save_spec
+        save_spec(self._blob, path)
+
+    @staticmethod
+    def load(path: str) -> NveilSpec:
+        """Load from opaque .nveil file."""
+        from dive._engine import load_spec
+        blob = load_spec(path)
+        return NveilSpec(spec_blob=blob)
+
+
+# ── Module-level display/export functions ──
+
+
+def show(fig: Any, theme: str = "dark") -> None:
+    """Display a figure in the default browser.
+
+    Args:
+        fig: Figure object returned by ``NveilSpec.render()``.
+        theme: Display theme ("dark" or "light").
+    """
+    if fig is None:
+        raise RuntimeError("No figure to display")
+
+    import tempfile
+    import webbrowser
+    from dive.builder.export import export_image
+
+    html = export_image(fig, extension="html", theme=theme)
+
+    tmp = tempfile.NamedTemporaryFile(
+        suffix=".html", delete=False, mode="w", encoding="utf-8",
+    )
+    tmp.write(html)
+    tmp.close()
+    webbrowser.open(f"file://{tmp.name}")
+
+
+def save_image(
+    fig: Any,
+    path: str,
+    theme: str = "dark",
+    width: int = 1200,
+    height: int = 800,
+    scale: int = 1,
+) -> None:
+    """Save a figure as a static image.
+
+    Format is inferred from the file extension.
+    Supported: .png, .jpg, .svg, .pdf (require kaleido), .html
+
+    Args:
+        fig: Figure object returned by ``NveilSpec.render()``.
+        path: Output file path (e.g. ``"chart.png"``).
+        theme: Export theme ("dark" or "light").
+        width: Image width in pixels.
+        height: Image height in pixels.
+        scale: Font/margin scale factor.
+    """
+    if fig is None:
+        raise RuntimeError("No figure to export")
+
+    from dive.builder.export import export_to_file
+    export_to_file(fig, path, theme=theme, width=width, height=height, scale=scale)
+
+
+def save_html(fig: Any, path: str, theme: str = "dark") -> None:
+    """Save a figure as an interactive HTML file.
+
+    Args:
+        fig: Figure object returned by ``NveilSpec.render()``.
+        path: Output file path (e.g. ``"chart.html"``).
+        theme: Export theme ("dark" or "light").
+    """
+    from dive.builder.export import export_to_file
+    export_to_file(fig, path, theme=theme)

nveil/timing.py

@@ -0,0 +1,76 @@
+"""Lightweight timing instrumentation for the NVEIL SDK.
+
+Controlled via ``nveil.configure(timing=True)``. When disabled (default),
+all operations are no-ops with zero overhead.
+"""
+
+import time
+
+
+class Timer:
+    """Tracks named durations as an ordered list of (label, seconds) pairs."""
+
+    def __init__(self, enabled: bool = False):
+        self.enabled = enabled
+        self._entries: list[tuple[str, float]] = []
+
+    def measure(self, label: str):
+        """Context manager that records the duration of a block.
+
+        Usage::
+
+            with timer.measure("API call"):
+                response = client.post(...)
+        """
+        if not self.enabled:
+            return _NOOP
+        return _TimerContext(self, label)
+
+    def record(self, label: str, duration: float):
+        """Manually record a duration."""
+        if self.enabled:
+            self._entries.append((label, duration))
+
+    def summary(self) -> str:
+        """Return a formatted terminal table of all recorded timings."""
+        if not self._entries:
+            return ""
+        max_label = max(len(label) for label, _ in self._entries)
+        total = sum(d for _, d in self._entries)
+        width = max_label + 14
+        lines = ["", "\u2500" * width]
+        for label, dur in self._entries:
+            lines.append(f"  {label:<{max_label}}  {dur:>6.2f}s")
+        lines.append("\u2500" * width)
+        lines.append(f"  {'Total':<{max_label}}  {total:>6.2f}s")
+        lines.append("")
+        return "\n".join(lines)
+
+    def clear(self):
+        """Reset all recorded entries."""
+        self._entries.clear()
+
+
+class _TimerContext:
+    __slots__ = ("_timer", "_label", "_t0")
+
+    def __init__(self, timer: Timer, label: str):
+        self._timer = timer
+        self._label = label
+
+    def __enter__(self):
+        self._t0 = time.perf_counter()
+        return self
+
+    def __exit__(self, *_):
+        self._timer.record(self._label, time.perf_counter() - self._t0)
+
+
+class _NoOp:
+    """Singleton no-op context manager — zero allocation when timing is off."""
+    __slots__ = ()
+    def __enter__(self): return self
+    def __exit__(self, *_): pass
+
+
+_NOOP = _NoOp()

nveil-0.0.1.dev1.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: nveil
+Version: 0.0.1.dev1
+Summary: NVEIL Python SDK — no-code AI data visualization with auditable, deterministic results
+Author-email: NVEIL <contact@nveil.com>
+License: Proprietary
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25
+Requires-Dist: pydantic>=2.0
+Requires-Dist: nveil-dive[builder]
+Requires-Dist: nveil-choregraph
+Requires-Dist: lxml>=4.9
+Requires-Dist: xmlschema>=3.0
+Requires-Dist: natsort>=8.0
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: cryptography>=41.0
+Requires-Dist: clingo>=5.6
+Requires-Dist: plotly>=5.0
+Requires-Dist: kaleido>=0.2
+Requires-Dist: vtk>=9.0
+Requires-Dist: pydeck>=0.8
+Requires-Dist: scipy>=1.10
+Requires-Dist: kedro>=0.19.0
+Requires-Dist: kedro-datasets[pillow]>=3.0.0
+Requires-Dist: pyarrow>=22.0.0
+Requires-Dist: python-dotenv
+Requires-Dist: geopandas
+Requires-Dist: geonamescache
+Requires-Dist: langdetect
+Requires-Dist: simplemma
+Requires-Dist: unidecode
+Requires-Dist: rapidfuzz
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: openpyxl
+Requires-Dist: pyexcel
+Requires-Dist: pyexcel-xlsx
+Requires-Dist: pyexcel-xls
+Requires-Dist: pyexcel-ods3
+Requires-Dist: statsmodels
+Provides-Extra: agent
+Requires-Dist: watchdog>=3.0; extra == "agent"
+Requires-Dist: pystray>=0.19; extra == "agent"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5; extra == "docs"
+Requires-Dist: mkdocs-material>=9.0; extra == "docs"
+Requires-Dist: mkdocs-section-index>=0.3; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24; extra == "docs"
+Dynamic: license-file
+Dynamic: requires-dist
+
+# NVEIL Python SDK
+
+**Turn your data into production-ready visualizations in seconds.**
+
+NVEIL is a no-code AI data visualization platform. Describe what you want in plain language, and the SDK generates auditable, deterministic visualizations — no hallucinations, no manual chart building.
+
+Your data stays on your machine. Only metadata (column names, types, and statistics) is sent to the NVEIL server.
+
+## Installation
+
+```bash
+pip install nveil
+```
+
+## Quickstart
+
+```python
+import nveil
+import pandas as pd
+
+nveil.configure(api_key="nveil_...")
+
+df = pd.read_csv("sales.csv")
+spec = nveil.generate_spec("Revenue by region, colored by quarter", df)
+
+fig = spec.render(df)
+nveil.show(fig)
+
+# Save for later — renders offline, no API call
+spec.save("revenue.nveil")
+```
+
+## Key Features
+
+- **No-code AI** — describe your visualization in plain language.
+- **Auditable results** — deterministic output, no hallucinations.
+- **Data stays local** — only column names, types, and aggregate statistics are sent. Raw data never leaves your machine.
+- **Offline rendering** — once generated, `render()` runs 100% locally with no API call.
+- **Reusable specs** — save to `.nveil` files, load later, render on new data.
+- **Multi-backend** — auto-detects the best rendering engine (Plotly, VTK, DeckGL).
+
+## Getting an API Key
+
+1. Create an account at [app.nveil.com](https://app.nveil.com)
+2. Go to **Settings** in your account
+3. Generate an API key
+
+## Documentation
+
+Full documentation: [https://docs.nveil.com](https://docs.nveil.com)
+
+## License
+
+Proprietary. See [LICENSE](LICENSE) for details.

nveil-0.0.1.dev1.dist-info/RECORD

@@ -0,0 +1,11 @@
+nveil/__init__.py,sha256=Sff2TT0v1DDLTWxXIrn02ukQLAsApOXOkzHG-03izp4,7500
+nveil/client.py,sha256=STEy5MnVuP7Iwy9zcPuAskofpPBVRXHQ08pbMjxFG4I,3427
+nveil/exceptions.py,sha256=H5uS3Yx8bHervtx3B3azJLSfm3Lf_cIkxQ12A8j6sRs,664
+nveil/session.py,sha256=6ILOFJjGdVQPG6T0GrMJSL3gGs4QebtNTiGxGKPpNAQ,5018
+nveil/spec.py,sha256=7swyjvBMC1awricqHKTUFvk7QU93bU4zke54OlwY8Q0,4453
+nveil/timing.py,sha256=T2lATFPRgbKSg3tse-GbdnVp0Eo67Xn1X_uBdKvBEXM,2250
+nveil-0.0.1.dev1.dist-info/licenses/LICENSE,sha256=OJQKdgGM9BWFndOy0ItoA20LjQDEzt-jfqyH-mq2trw,3228
+nveil-0.0.1.dev1.dist-info/METADATA,sha256=Mm_FGJlNg6vL3CuNJFbZm8cK5cDBSjxkn0U5cyrNxtc,3350
+nveil-0.0.1.dev1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nveil-0.0.1.dev1.dist-info/top_level.txt,sha256=ZHHSexRTpJpasRnJJWnb3xytUMI4LWQhtEvbAGbrobs,6
+nveil-0.0.1.dev1.dist-info/RECORD,,

nveil-0.0.1.dev1.dist-info/WHEEL

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

nveil-0.0.1.dev1.dist-info/licenses/LICENSE

@@ -0,0 +1,105 @@
+NVEIL SOFTWARE LICENSE AGREEMENT
+
+Version 1.0 — Effective April 2026
+
+Copyright (c) 2025-2026 NVEIL SAS. All rights reserved.
+
+By installing or using the NVEIL SDK and its bundled libraries
+("Software"), you agree to the following terms.
+
+
+1. LICENSE GRANT
+
+NVEIL grants you a limited, non-exclusive, non-transferable,
+revocable license to:
+
+  (a) Install and use the Software to develop applications that
+      connect to the NVEIL platform via authorized API keys.
+
+  (b) Distribute applications that include the Software as a
+      runtime dependency, for both commercial and non-commercial
+      purposes.
+
+
+2. RESTRICTIONS
+
+You may not:
+
+  (a) Reverse engineer, decompile, disassemble, or attempt to
+      derive the source code of any compiled component of the
+      Software, including but not limited to the visualization
+      engine and data processing libraries.
+
+  (b) Modify, adapt, or create derivative works of the Software.
+
+  (c) Remove or alter any copyright, trademark, or other
+      proprietary notices contained in the Software.
+
+  (d) Redistribute the Software as a standalone package or
+      include it in a software distribution unrelated to your
+      application.
+
+  (e) Use the Software to develop a product or service that
+      competes with or substitutes for the NVEIL platform.
+
+  (f) Share, publish, or transfer your API key to unauthorized
+      third parties.
+
+
+3. API KEY AND USAGE
+
+The Software requires a valid API key issued through the NVEIL
+platform (https://app.nveil.com). Usage is subject to the rate
+limits and terms associated with your account. NVEIL may revoke
+API keys that violate these terms.
+
+
+4. INTELLECTUAL PROPERTY
+
+The Software, including all algorithms, data formats, compiled
+libraries, and documentation, is and remains the exclusive
+intellectual property of NVEIL SAS. This license does not convey
+any ownership rights.
+
+
+5. DATA PRIVACY
+
+The Software is designed so that your raw data is processed
+locally. Only metadata (column names, types, and aggregate
+statistics) is transmitted to the NVEIL server. NVEIL does not
+store or access your raw data.
+
+
+6. DISCLAIMER OF WARRANTIES
+
+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
+NON-INFRINGEMENT. NVEIL DOES NOT WARRANT THAT THE SOFTWARE
+WILL BE ERROR-FREE OR UNINTERRUPTED.
+
+
+7. LIMITATION OF LIABILITY
+
+IN NO EVENT SHALL NVEIL BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
+SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES ARISING FROM YOUR
+USE OF THE SOFTWARE, REGARDLESS OF THE CAUSE OF ACTION.
+
+
+8. TERMINATION
+
+This license is effective until terminated. It terminates
+automatically if you breach any of its terms. NVEIL may also
+terminate it at any time by providing notice. Upon termination,
+you must cease all use of the Software and destroy all copies.
+
+
+9. GOVERNING LAW
+
+This agreement is governed by the laws of France. Any disputes
+shall be subject to the exclusive jurisdiction of the courts
+of Paris, France.
+
+
+Contact: contact@nveil.com
+Website: https://nveil.com

nveil-0.0.1.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+nveil