dt2 0.1.0__tar.gz

dt2-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.11", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Build JS bundle
+        run: |
+          npm ci
+          npm run build
+
+      - name: Verify the committed bundle is up to date
+        run: git diff --exit-code -- src/dt2/static/ || (
+          echo "::error::src/dt2/static is stale — run 'npm run build' and commit." && exit 1)
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install package + test deps
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[shiny,pandas,dev]"
+
+      - name: Run tests
+        run: python -m pytest
+
+  build-js-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+      - run: npm ci
+      - name: Syntax-check adapter sources
+        run: |
+          node --check js/index.js
+          node --check js/extensions.js

dt2-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Release to PyPI
+
+# Fires only when the maintainer publishes a GitHub Release. Uses PyPI Trusted
+# Publishing (OIDC) — configure the publisher on PyPI first; no token is stored.
+on:
+  release:
+    types: [published]
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write # required for trusted publishing
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+
+      - name: Build JS bundle
+        run: |
+          npm ci
+          npm run build
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Publish to PyPI
+        # Pinned to a commit SHA (not a moving branch/tag) — this step runs with
+        # id-token: write (PyPI publish rights), so a hijacked ref must not be
+        # able to execute here. SHA is v1.14.0.
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0

dt2-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+node_modules/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+dist/
+build/
+.DS_Store
+.Rhistory
+*.tsbuildinfo
+src/dt2/static/index.js.map

dt2-0.1.0/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to **dt2** (the Python port) are documented here.
+Format loosely follows [Keep a Changelog](https://keepachangelog.com).
+
+## [0.1.0] — 2026-06-26
+
+First release. Feature parity with the R
+[DT2](https://github.com/StrategicProjects/DT2) package, verified live in a
+browser (Shiny for Python).
+
+### Added
+- **Core widget** (`dt2()`, `Dt2`): anywidget binding for DataTables v2 (2.3.4),
+  for Shiny for Python and Jupyter. Accepts pandas/polars frames and records.
+- **Config builder** (`Options`): chainable port of the R `dt2_options` /
+  `dt2_formats` helpers — `order`, `search_global`, `length_menu`, `language`,
+  `use_buttons`, `cols_align/width/hide/escape`,
+  `format_number/datetime/number_abbrev/time_relative`, `cols_render`,
+  `cols_render_orthogonal`, `register_renderer`/`use_renderer`.
+- **`JS()`**: parity for `htmlwidgets::JS()` — renderer source is revived into a
+  real function client-side (with `DataTable`/`$`/`moment` in scope).
+- **Extensions** (all 15 bundled): Buttons, Select, Responsive, FixedHeader,
+  FixedColumns, KeyTable, Scroller, RowGroup, RowReorder, ColReorder, DateTime,
+  SearchBuilder, SearchPanes, StateRestore, ColumnControl. Activation helpers on
+  `Options` + an `extensions()` registry. jszip bundled for Excel/CSV export.
+- **Server-side processing** (`server_side=True`): data stays Python-side and
+  pages are filtered/ordered/paginated over the Comm (`dt2.server.process_ssp`).
+- **Proxy API** on the widget: `replace_data`, `draw`, `reload`, `order`,
+  `search`, `clear_search`, `page`, `select_rows`.
+- **Events**: `selected_rows`, `state`, `row_check`, `row_button` traits
+  (read reactively with `shinywidgets.reactive_read`).
+- **Inline inputs**: `Options.col_checkbox`, `Options.col_button`.
+- **moment.js bundled** — powers `format_datetime` and `format_time_relative`
+  (`DataTable.render.datetime` requires it).
+
+### Fixed
+- Verified end to end in a real browser (Shiny for Python): core render,
+  selection events, SSP (50k rows: render + server-side search), config
+  renderers (number/datetime/custom), extensions (RowGroup, Buttons), and inline
+  inputs with `row_check`/`row_button` events.
+- `format_datetime` failed ("Formatted date without Moment.js or Luxon"), which
+  surfaced as a blocking `alert()` — moment is now bundled and DataTables'
+  `errMode` is set to `throw` so future warnings log instead of freezing the tab.
+- `Options.buttons()` now places buttons in the layout when no `target` is given,
+  so they actually render (DataTables 2.x only shows buttons referenced there).
+
+### Known gaps / deferred
+- PDF export (pdfmake) not bundled; `format_time_relative` needs
+  moment-with-locales for non-`en` locales; extensions are all-bundled (no
+  modular/lazy loading yet); SSP search is global-only (matches R).

dt2-0.1.0/LICENSE

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

dt2-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: dt2
+Version: 0.1.0
+Summary: DataTables v2 for Shiny for Python — anywidget binding, Python port of the R DT2 package
+Project-URL: Homepage, https://github.com/StrategicProjects/dt2py
+Project-URL: Changelog, https://github.com/StrategicProjects/dt2py/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/StrategicProjects/dt2py/issues
+Project-URL: R package, https://github.com/StrategicProjects/DT2
+Author-email: André Leite <leite@de.ufpe.br>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anywidget,datatables,htmlwidgets,shiny,tables
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Jupyter
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Requires-Dist: anywidget>=0.9
+Requires-Dist: traitlets>=5
+Provides-Extra: dev
+Requires-Dist: anywidget[dev]; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: watchfiles; extra == 'dev'
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars; extra == 'polars'
+Provides-Extra: shiny
+Requires-Dist: shiny>=1.2; extra == 'shiny'
+Requires-Dist: shinywidgets>=0.4; extra == 'shiny'
+Description-Content-Type: text/markdown
+
+# dt2 — DataTables v2 for Shiny for Python
+
+A Python port of the R [**DT2**](https://github.com/StrategicProjects/DT2)
+package: an [anywidget](https://anywidget.dev) binding for
+[DataTables v2](https://datatables.net), designed for
+[Shiny for Python](https://shiny.posit.co/py/) (and usable in Jupyter).
+
+It configures DataTables via plain Python (1:1 with the JS API), reusing the
+same DataTables runtime (2.3.4) and extensions as the R package.
+
+> Status: **feature-complete toward R parity, pre-release.** Config, all 15
+> extensions, server-side processing, proxy, events and inline inputs are
+> implemented and unit-tested. The live in-browser Comm transport has not yet
+> been visually verified. See [ROADMAP.md](ROADMAP.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## Install (dev)
+
+```bash
+npm install && npm run build        # build the JS bundle into src/dt2/static/
+uv venv && uv pip install -e ".[shiny,pandas]"
+```
+
+(The built bundle is committed, so an installed wheel needs no Node toolchain.)
+
+## Quick start
+
+```python
+import pandas as pd
+from shiny import App, ui
+from shinywidgets import output_widget, render_widget
+from dt2 import dt2
+
+df = pd.read_csv("data.csv")
+
+app_ui = ui.page_fluid(output_widget("tbl"))
+
+def server(input, output, session):
+    @render_widget
+    def tbl():
+        return dt2(df, select=True, pageLength=10)
+
+app = App(app_ui, server)
+```
+
+## Configure with `Options`
+
+Chainable builder mirroring the R pipe helpers:
+
+```python
+from dt2 import Options, JS, dt2
+
+opts = (Options(df)
+        .cols_align(["revenue"], "right")
+        .format_number(["revenue"], thousands=".", decimal=",", digits=2, prefix="R$ ")
+        .format_datetime(["updated"], from_="YYYY-MM-DD", to="DD/MM/YYYY")
+        .cols_render(["score"], JS("function(d,t){ return t==='display' ? d+'%' : d; }"))
+        .order(("revenue", "desc"))
+        .length_menu([10, 25, -1]))
+
+dt2(df, options=opts)
+```
+
+`JS(...)` is the parity for `htmlwidgets::JS()`: the source is revived into a
+real function in the browser, with `DataTable`, `$` and `moment` in scope.
+
+## Extensions
+
+All 15 DataTables extensions are bundled; activate via `Options`:
+
+```python
+opts = (Options(df)
+        .buttons(["copyHtml5", "csvHtml5", "excelHtml5"])  # jszip bundled; PDF needs pdfmake
+        .select({"style": "os"})
+        .responsive()
+        .fixed_header()
+        .row_group("field"))
+```
+
+`dt2.extensions()` lists what is bundled.
+
+## Server-side processing
+
+Keep large data Python-side; DataTables fetches pages over the Comm:
+
+```python
+dt2(big_df, server_side=True, pageLength=25)
+```
+
+Filtering/ordering/paging run in `dt2.server.process_ssp`.
+
+## Proxy, events and inline inputs
+
+```python
+# proxy (Python -> table): call on the rendered widget
+tbl.widget.search("ada")
+tbl.widget.order(("field", "desc"))
+tbl.widget.select_rows([1, 3])
+
+# events (table -> Python): read reactively
+from shinywidgets import reactive_read
+reactive_read(tbl.widget, "selected_rows")  # also: state, row_check, row_button
+
+# inline row inputs
+opts = Options(df).col_checkbox("select", value_col="active").col_button("act", label="Ping")
+```
+
+See [`examples/`](examples/) for runnable apps:
+`app.py`, `app_config.py`, `app_extensions.py`, `app_serverside.py`,
+`app_proxy_inputs.py`.
+
+## How it relates to the R package
+
+The DataTables runtime is shared conceptually with R DT2. What differs is the
+**transport**: R talks to Shiny via `window.Shiny`; here the widget talks to the
+Python kernel over the anywidget Comm, bridged to Shiny reactivity by
+`shinywidgets`. The `htmlwidgets::JS()` mechanism becomes the `JS()` marker +
+client-side reviver. See the header of `js/index.js` for the full mapping.
+
+## License
+
+MIT © André Leite

dt2-0.1.0/README.md

@@ -0,0 +1,121 @@
+# dt2 — DataTables v2 for Shiny for Python
+
+A Python port of the R [**DT2**](https://github.com/StrategicProjects/DT2)
+package: an [anywidget](https://anywidget.dev) binding for
+[DataTables v2](https://datatables.net), designed for
+[Shiny for Python](https://shiny.posit.co/py/) (and usable in Jupyter).
+
+It configures DataTables via plain Python (1:1 with the JS API), reusing the
+same DataTables runtime (2.3.4) and extensions as the R package.
+
+> Status: **feature-complete toward R parity, pre-release.** Config, all 15
+> extensions, server-side processing, proxy, events and inline inputs are
+> implemented and unit-tested. The live in-browser Comm transport has not yet
+> been visually verified. See [ROADMAP.md](ROADMAP.md) and [CHANGELOG.md](CHANGELOG.md).
+
+## Install (dev)
+
+```bash
+npm install && npm run build        # build the JS bundle into src/dt2/static/
+uv venv && uv pip install -e ".[shiny,pandas]"
+```
+
+(The built bundle is committed, so an installed wheel needs no Node toolchain.)
+
+## Quick start
+
+```python
+import pandas as pd
+from shiny import App, ui
+from shinywidgets import output_widget, render_widget
+from dt2 import dt2
+
+df = pd.read_csv("data.csv")
+
+app_ui = ui.page_fluid(output_widget("tbl"))
+
+def server(input, output, session):
+    @render_widget
+    def tbl():
+        return dt2(df, select=True, pageLength=10)
+
+app = App(app_ui, server)
+```
+
+## Configure with `Options`
+
+Chainable builder mirroring the R pipe helpers:
+
+```python
+from dt2 import Options, JS, dt2
+
+opts = (Options(df)
+        .cols_align(["revenue"], "right")
+        .format_number(["revenue"], thousands=".", decimal=",", digits=2, prefix="R$ ")
+        .format_datetime(["updated"], from_="YYYY-MM-DD", to="DD/MM/YYYY")
+        .cols_render(["score"], JS("function(d,t){ return t==='display' ? d+'%' : d; }"))
+        .order(("revenue", "desc"))
+        .length_menu([10, 25, -1]))
+
+dt2(df, options=opts)
+```
+
+`JS(...)` is the parity for `htmlwidgets::JS()`: the source is revived into a
+real function in the browser, with `DataTable`, `$` and `moment` in scope.
+
+## Extensions
+
+All 15 DataTables extensions are bundled; activate via `Options`:
+
+```python
+opts = (Options(df)
+        .buttons(["copyHtml5", "csvHtml5", "excelHtml5"])  # jszip bundled; PDF needs pdfmake
+        .select({"style": "os"})
+        .responsive()
+        .fixed_header()
+        .row_group("field"))
+```
+
+`dt2.extensions()` lists what is bundled.
+
+## Server-side processing
+
+Keep large data Python-side; DataTables fetches pages over the Comm:
+
+```python
+dt2(big_df, server_side=True, pageLength=25)
+```
+
+Filtering/ordering/paging run in `dt2.server.process_ssp`.
+
+## Proxy, events and inline inputs
+
+```python
+# proxy (Python -> table): call on the rendered widget
+tbl.widget.search("ada")
+tbl.widget.order(("field", "desc"))
+tbl.widget.select_rows([1, 3])
+
+# events (table -> Python): read reactively
+from shinywidgets import reactive_read
+reactive_read(tbl.widget, "selected_rows")  # also: state, row_check, row_button
+
+# inline row inputs
+opts = Options(df).col_checkbox("select", value_col="active").col_button("act", label="Ping")
+```
+
+See [`examples/`](examples/) for runnable apps:
+`app.py`, `app_config.py`, `app_extensions.py`, `app_serverside.py`,
+`app_proxy_inputs.py`.
+
+## How it relates to the R package
+
+The DataTables runtime is shared conceptually with R DT2. What differs is the
+**transport**: R talks to Shiny via `window.Shiny`; here the widget talks to the
+Python kernel over the anywidget Comm, bridged to Shiny reactivity by
+`shinywidgets`. The `htmlwidgets::JS()` mechanism becomes the `JS()` marker +
+client-side reviver. See the header of `js/index.js` for the full mapping.
+
+## License
+
+MIT © André Leite

dt2-0.1.0/ROADMAP.md

@@ -0,0 +1,108 @@
+# dt2 (Python) — parity roadmap
+
+Goal: **feature parity** with the R DT2 package, delivered via anywidget for
+Shiny for Python. The DataTables v2 runtime (2.3.4) and extensions are reused;
+the work is reimplementing the R binding layer in Python and re-wiring the
+Shiny transport onto the anywidget Comm.
+
+## Architecture decisions (locked)
+
+- **Repo:** `StrategicProjects/dt2py` (separate from the R repo).
+- **PyPI / import name:** `dt2`.
+- **Mechanism:** anywidget (`shinywidgets` bridges it to Shiny for Python).
+- **JS:** bundled with esbuild from `js/index.js` → `src/dt2/static/index.{js,css}`.
+- **DataTables:** pinned to `2.3.4` / jQuery `3.7.1` to match the R bundle.
+
+## Transport mapping (R → Python)
+
+| R (htmlwidgets / Shiny)                  | Python (anywidget)                          |
+| ---------------------------------------- | ------------------------------------------- |
+| `Shiny.setInputValue(id+'_state', v)`    | `model.set('state', v); model.save_changes()` |
+| `Shiny.setInputValue(id+'_row_check')`   | trait + `model.save_changes()`              |
+| `Shiny.addCustomMessageHandler(id+'_proxy')` | `model.on('msg:custom', fn)`            |
+| SSP Ajax via custom message round-trip   | `model.send(req)` + `model.on('msg:custom')` reply |
+
+## Phases
+
+### Phase 0 — scaffold ✅ (this commit)
+- [x] Repo, pyproject (hatchling), package.json (esbuild)
+- [x] anywidget adapter `js/index.js` (core render + proxy/event skeleton)
+- [x] `Dt2` widget + `dt2()` constructor (pandas/polars/records)
+- [x] Shiny example app
+- [x] Build bundle; widget constructs, traits populate, app serves (HTTP 200)
+- [ ] Visual in-browser render + selection (needs Chrome extension online)
+
+### Phase 1 — config parity ✅
+- [x] `Options` builder (chainable) covering the R `dt2_options`/`dt2_formats`
+      surface: `order`, `search_global`, `length_menu`, `language`, `use_buttons`,
+      `cols_align/width/hide/escape`, `format_number/datetime/number_abbrev/time_relative`,
+      `cols_render`, `cols_render_orthogonal`, `register/use_renderer`.
+- [x] Name→index resolution (`_name_to_idx`, ported with warnings); seed names
+      from a DataFrame/records via `Options(df)` — removes the R "forgot to set
+      options$columns" footgun.
+- [x] **`JS()` parity for `htmlwidgets::JS()`:** Python marks renderer source as
+      `{"__dt2_js__": code}`; `index.js` `reviveJs()` recursively compiles markers
+      into functions with `DataTable`/`$`/`moment` in scope. Proven in node.
+- [x] `dt2(df, options=opts, **kw)` merge. 22 unit tests + JS revive test green.
+- [x] Quote-safe values via `json.dumps` (`_js_str`, port of `.dt2_js_str`).
+
+### Phase 2 — extensions ✅
+- [x] All 15 extensions bundled via esbuild (`js/extensions.js`): Buttons,
+      Select, Responsive, FixedHeader, FixedColumns, KeyTable, Scroller,
+      RowGroup, RowReorder, ColReorder, DateTime, SearchBuilder, SearchPanes,
+      StateRestore, ColumnControl. Verified present in the built bundle.
+- [x] jszip bundled (Excel/CSV/copy export via `window.JSZip`).
+- [x] Python activation helpers on `Options`: `select/responsive/fixed_header/
+      fixed_columns/key_table/col_reorder/row_reorder/row_group/scroller/
+      search_panes/search_builder/state_restore/column_control/buttons`, plus
+      `extensions()` registry (parity with R `dt2_extensions()`).
+- [x] `buttons(target=...)` relocation (port of R `dt2_buttons`) handled in JS.
+- [x] `_momentLocale` applied client-side. 15 extension tests green (46 total).
+- [ ] **Deferred follow-ups:** pdfmake (PDF export, ~1MB) as an optional extra;
+      moment-with-locales for `format_time_relative`; modular/lazy loading so the
+      base wheel ships only requested extensions (parity with R's per-ext loading).
+
+### Phase 3 — Shiny integration
+- [x] **Server-side processing (de-risked first):** DataTables `ajax` as a
+      function routed over the Comm; `dt2.server.process_ssp` ports the R
+      filter/order/paginate logic (no query-string parse needed — request
+      arrives structured). Widget keeps full data Python-side; `_on_msg`
+      replies with a correlated `dt2_ssp_response`. Unit + handler tests green.
+      **Still to verify:** the live Comm round-trip in a browser (needs frontend).
+- [x] **Proxy parity** (`cmd` protocol mirroring R/dt2_proxy.R): widget methods
+      `replace_data`, `draw`, `reload`, `order`, `search`, `clear_search`,
+      `page`, `select_rows`. Order resolves header names → indices client-side.
+- [x] **Events parity**: enriched `state` ({reason, order, search, page,
+      selected}) + `selected_rows`; a monotonic `_seq` makes event traits
+      re-fire under `reactive_read` (anywidget equivalent of Shiny's
+      `priority:"event"`).
+- [x] **Inline inputs** (port of R/dt2_inputs.R): `Options.col_checkbox` /
+      `col_button` render delegated controls; clicks set `row_check` /
+      `row_button` event traits. Verified in node (render compiles, seeds
+      checked state) + 12 tests (58 total). Example `app_proxy_inputs.py`.
+- [ ] Per-column search in SSP (R does global only — match, then optionally extend)
+
+### Phase 4 — polish & release
+- [x] Tests: 58 pytest cases (config, extensions, SSP, proxy/inputs) + node
+      smoke checks for the JS adapter. `[tool.pytest.ini_options]` configured.
+- [x] CI (`.github/workflows/ci.yml`): builds the JS bundle, asserts the
+      committed `src/dt2/static` is fresh, installs and runs pytest on Python
+      3.9/3.11/3.13; syntax-checks the adapter sources.
+- [x] Wheel verified: includes the built bundle; fresh `pip install` works with
+      no Node toolchain (703kb bundle, 15 extensions, widget builds).
+- [x] Release workflow (`release.yml`): builds + publishes to PyPI via Trusted
+      Publishing on a published GitHub Release (maintainer-triggered).
+- [x] README (full API), CHANGELOG, examples gallery (5 runnable apps).
+- [x] **Live in-browser verification** (Shiny for Python): core render +
+      selection, SSP (50k rows: render + search), config renderers
+      (number/datetime/custom badge), extensions (RowGroup + Buttons), and
+      inline inputs with row_check/row_button events — all confirmed. Two bugs
+      found & fixed: moment.js now bundled (datetime), buttons placed in layout.
+- [ ] **PyPI publish** — maintainer action: configure the PyPI trusted publisher,
+      then publish a GitHub Release to trigger `release.yml`.
+
+## Open questions
+- Bundle size: shipping all extensions vs. lazy/optional extras. Lean toward
+  optional `pip install dt2[buttons,searchpanes,...]` extras mapping to JS
+  chunks, to keep the base wheel small.
+- SSP transport latency over Comm vs. a Starlette route — benchmark in Phase 3.

dt2-0.1.0/build.mjs

@@ -0,0 +1,36 @@
+// Bundles the anywidget adapter + DataTables v2 stack into src/dt2/static/.
+// Output: index.js (ESM, anywidget _esm) and index.css (anywidget _css).
+import * as esbuild from "esbuild";
+
+const watch = process.argv.includes("--watch");
+
+/** @type {import('esbuild').BuildOptions} */
+const opts = {
+  entryPoints: ["js/index.js"],
+  outfile: "src/dt2/static/index.js",
+  bundle: true,
+  format: "esm",
+  minify: !watch,
+  sourcemap: watch,
+  // DataTables ships font/image-free CSS for the bs5 integration; bundle CSS
+  // imported from JS into a sibling index.css that anywidget loads as _css.
+  loader: {
+    ".css": "css",
+    ".woff": "dataurl",
+    ".woff2": "dataurl",
+    ".ttf": "dataurl",
+    ".eot": "dataurl",
+    ".svg": "dataurl",
+    ".png": "dataurl",
+  },
+  logLevel: "info",
+};
+
+if (watch) {
+  const ctx = await esbuild.context(opts);
+  await ctx.watch();
+  console.log("[dt2] watching js/ for changes…");
+} else {
+  await esbuild.build(opts);
+  console.log("[dt2] built src/dt2/static/index.{js,css}");
+}

dt2-0.1.0/examples/app.py

@@ -0,0 +1,39 @@
+"""Minimal Shiny for Python app exercising the dt2 widget.
+
+Run with:  shiny run examples/app.py
+Requires:  pip install -e ".[shiny,pandas]"
+"""
+
+import pandas as pd
+from shiny import App, reactive, render, ui
+from shinywidgets import output_widget, render_widget, reactive_read
+
+from dt2 import dt2
+
+df = pd.DataFrame(
+    {
+        "name": ["Ada", "Alan", "Grace", "Linus", "Margaret"],
+        "field": ["Math", "Logic", "Navy", "Kernel", "Apollo"],
+        "year": [1815, 1912, 1906, 1969, 1936],
+    }
+)
+
+app_ui = ui.page_fluid(
+    ui.h3("dt2 — DataTables v2 in Shiny for Python"),
+    output_widget("tbl"),
+    ui.output_text_verbatim("selection"),
+)
+
+
+def server(input, output, session):
+    @render_widget
+    def tbl():
+        return dt2(df, select=True, pageLength=5)
+
+    @render.text
+    def selection():
+        rows = reactive_read(tbl.widget, "selected_rows")
+        return f"selected rows (1-based): {rows}"
+
+
+app = App(app_ui, server)