fastpygrid 0.1.0__tar.gz

fastpygrid-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,37 @@
+name: publish
+
+# Build the Windows wheel + sdist, then publish to PyPI when a GitHub Release is
+# published (or run manually). Uses PyPI Trusted Publishing (OIDC) -- no token.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:      # adds a manual "Run workflow" button in the Actions tab
+
+jobs:
+  build:
+    runs-on: windows-latest        # needs MSVC + CMake to compile the DLLs (preinstalled)
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build wheel + sdist
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest         # gh-action-pypi-publish only runs on Linux
+    permissions:
+      id-token: write              # required for Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - uses: pypa/gh-action-pypi-publish@release/v1

fastpygrid-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+__pycache__/
+*.py[cod]
+*.obj
+*.exp
+*.lib
+*.dll
+.venv/
+venv/
+
+# build output (build.bat -> .py + .dll)
+dist/
+# cmake build tree
+build/
+
+# staged library copy (setup.bat)
+demos/fastgrid/
+
+# python packaging
+*.egg-info/

fastpygrid-0.1.0/CMakeLists.txt

@@ -0,0 +1,22 @@
+cmake_minimum_required(VERSION 3.15)
+project(fastgrid_native CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+# The two native DLLs. Their .cpp #pragma comment(lib, ...) the Windows libs, so
+# no target_link_libraries needed. No "lib" prefix -> ctypes loads them by name.
+add_library(surface  SHARED src/core/_gpu/surface.cpp)
+add_library(gridcore SHARED src/core/_gridstore/gridcore.cpp)
+set_target_properties(surface gridcore PROPERTIES PREFIX "")
+
+# Install lays out the `fastgrid` package: each .dll beside its module, plus the
+# .py sources (no .cpp). Destinations are under fastgrid/ so this works both for
+# build.bat (--prefix dist -> dist/fastgrid) and the scikit-build-core wheel
+# (prefix = wheel root -> fastgrid/ in site-packages).
+install(TARGETS surface  RUNTIME DESTINATION fastgrid/core/_gpu       LIBRARY DESTINATION fastgrid/core/_gpu)
+install(TARGETS gridcore RUNTIME DESTINATION fastgrid/core/_gridstore LIBRARY DESTINATION fastgrid/core/_gridstore)
+install(DIRECTORY src/ DESTINATION fastgrid FILES_MATCHING PATTERN "*.py")

fastpygrid-0.1.0/LICENSE

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

fastpygrid-0.1.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: fastpygrid
+Version: 0.1.0
+Summary: Fast, GPU-painted spreadsheet grid for tens of thousands of rows (Windows, Direct2D).
+Keywords: grid,spreadsheet,table,gpu,direct2d,tkinter,qt
+Author: Flynn Crochon
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: User Interfaces
+Project-URL: Homepage, https://github.com/flynncrochon/Fast-Python-Grid
+Project-URL: Repository, https://github.com/flynncrochon/Fast-Python-Grid
+Requires-Python: >=3.8
+Provides-Extra: qt
+Requires-Dist: PySide6; extra == "qt"
+Description-Content-Type: text/markdown
+
+# Fast Python Grid
+
+A fast, GPU-painted spreadsheet grid for tens of thousands of rows. Scroll,
+select, filter and find stay instant because only the visible cells are ever
+built. The grid logic lives in a GUI-free core; a single toolkit-neutral
+Direct2D engine draws it, hosted by a thin Tk or Qt adapter.
+
+```
+src/                   fastgrid .py sources (no DLLs live here; becomes dist/fastgrid)
+  core/      model, geometry, selection, paint() -> display list, gpu.py (Direct2D engine)
+    _gpu/        surface.cpp
+    _gridstore/  gridcore.cpp
+  render/    gpu_tk.py (tkinter host) · gpu_qt.py (PySide6 host)
+CMakeLists.txt  builds the DLLs + installs the .py into dist/fastgrid/
+build.bat    runs CMake (configure/build/install) -> dist/fastgrid/ (the runnable library)
+demos/       demo_gpu_tk.py · demo_gpu_qt.py · _data.py · setup.bat (stages demos/fastgrid + demos/.venv)
+scripts/
+  tests/       check_select.py · fuzz_coremodel.py       (import dist/fastgrid)
+  benchmarks/  bench_geometry.py                          (import dist/fastgrid)
+```
+
+`core.paint()` returns a display list (plain-data draw ops for the visible
+cells); the engine just blits it. The host only owns the window and translates
+events, so the Tk and Qt hosts behave identically:
+
+```
+dl.cells    = [(x, y, w, h, text, bg, fg, flags), ...]      # ~visible cells, back-to-front
+dl.overlays = [("line"|"vline"|"hline"|"ring"|"tri", ...)]  # chrome drawn after cells
+```
+
+`core.paint` decides every colour, position and z-order; the engine is ~"for
+each cell fill a rect + draw text; for each overlay draw a line/rect/triangle".
+
+![fastgrid sample grid: headers, frozen columns, per-column filters](docs/screenshot.png)
+
+## Requirements
+
+| Requirement | Details |
+|---|---|
+| **Windows only** | The renderer is Direct2D (`_gpu/surface.dll`), so it needs Windows and a Direct3D 11-capable GPU (falls back to the WARP software device if there's no GPU). There is no macOS/Linux backend. |
+| **Python 3.8+** | |
+| **Tk host** | Standard library only (`tkinter`, ships with Python). |
+| **Qt host** | Needs `PySide6` (`pip install PySide6`), the only dependency, and only if you use the Qt host. |
+| **Native DLLs** | Not committed -- `build.bat` runs CMake (which finds MSVC itself) to compile them into `dist/fastgrid/`. `surface.dll` draws the Direct2D surface and `gridcore.dll` is an optional C++ data core (the model falls back to pure Python if it's missing). Needs CMake + MSVC on the machine. Run `build.bat` once (and after any `.cpp` or `.py` change), then run the demos. |
+
+## Example
+
+```python
+from fastgrid.render.gpu_tk import make_sheet         # tkinter host (stdlib only)
+win = make_sheet(
+    ["Ticker", "Company", "Sector", "Price"],
+    [["AAPL", "Apple Inc.", "Technology", "189.20"],
+     ["XOM",  "Exxon Mobil", "Energy",   "104.10"]],
+    frozen_columns=2,   # pin the first 2 columns against horizontal scroll
+)
+win.mainloop()
+```
+
+Double-click or type to edit. Enter/Tab commit, Ctrl+Z/Y undo/redo, Ctrl+C/V
+copy/paste, Ctrl+A select-all, Ctrl+F find, ▼ on a header to filter/sort.
+
+```python
+from fastgrid.render.gpu_qt import make_sheet          # PySide6 host
+win = make_sheet(headers, rows, frozen_columns=2)
+win.mainloop()                                          # aliases app.exec()
+```
+
+## Build
+
+```bash
+build.bat
+```
+
+Runs CMake to compile the DLLs and assemble the runnable library into
+`dist/fastgrid/` (`.py` + `.dll` only). Needs CMake and MSVC. Re-run after any
+`.cpp` or `.py` change, then `demos/setup.bat` to stage `demos/fastgrid` + `demos/.venv`.
+
+## Run
+
+```bash
+python demos/demo_gpu_tk.py                 # tkinter host, 100k rows
+python demos/demo_gpu_qt.py                 # Qt host, same data
+python demos/demo_gpu_tk.py --rows 500000   # stress it
+python scripts/tests/check_select.py        # selection-state-machine check
+python scripts/tests/fuzz_coremodel.py      # C++ data core vs pure-Python oracle
+```
+
+## Performance
+
+Only the visible cells are built, so the row count barely matters. 10k rows
+and 1M rows do the same work per frame.
+
+```
+rows         core paint()
+10,000       0.13 ms
+100,000      0.13 ms
+1,000,000    0.13 ms
+```
+
+The Direct2D surface redraws that frame on the GPU, vsync-capped (~60 fps), and
+stays smooth while scrolling millions of rows.
+
+## Features
+
+The engine handles all of this, so both the Tk and Qt hosts get it for free.
+
+| Feature | Details |
+|---|---|
+| Frozen columns | Pin leading columns against horizontal scroll. |
+| Pinned selectable header rows | Pass a list of lists as `headers` for a multi-row header; adjacent same-label cells in the upper rows merge into spanning group bands, e.g. `[["", "FY 2023", "FY 2023"], ["Ticker", "Q1", "Q2"]]`. |
+| Excel-style selection | Click/drag/Ctrl/Shift, whole row/column, select-all, Ctrl+arrow block jumps. |
+| In-cell editing | Double-click or type to edit; copy/paste/delete, undo/redo. |
+| Filter & sort | Per-column value and text filters, A→Z/Z→A sort. |
+| Find | Ctrl+F with prev/next, case, and selection scope. |
+
+Per-cell styling and dropdowns, and thick black section dividers, are set on
+the model (display only, positional):
+
+```python
+model.set_cell_style(gr, col, fg="#c0392b", bold=True)   # gr/col are GRID coords
+model.set_cell_choices(gr, col, ["Buy", "Hold", "Sell"]) # editing offers a dropdown
+model.set_vline(col)          # thick rule on the RIGHT edge of a column
+model.set_hline(gr)           # thick rule on the BOTTOM edge of a grid row
+model.set_readonly_col(col)   # block edits/paste/delete in a column (still selectable)
+```

fastpygrid-0.1.0/README.md

@@ -0,0 +1,125 @@
+# Fast Python Grid
+
+A fast, GPU-painted spreadsheet grid for tens of thousands of rows. Scroll,
+select, filter and find stay instant because only the visible cells are ever
+built. The grid logic lives in a GUI-free core; a single toolkit-neutral
+Direct2D engine draws it, hosted by a thin Tk or Qt adapter.
+
+```
+src/                   fastgrid .py sources (no DLLs live here; becomes dist/fastgrid)
+  core/      model, geometry, selection, paint() -> display list, gpu.py (Direct2D engine)
+    _gpu/        surface.cpp
+    _gridstore/  gridcore.cpp
+  render/    gpu_tk.py (tkinter host) · gpu_qt.py (PySide6 host)
+CMakeLists.txt  builds the DLLs + installs the .py into dist/fastgrid/
+build.bat    runs CMake (configure/build/install) -> dist/fastgrid/ (the runnable library)
+demos/       demo_gpu_tk.py · demo_gpu_qt.py · _data.py · setup.bat (stages demos/fastgrid + demos/.venv)
+scripts/
+  tests/       check_select.py · fuzz_coremodel.py       (import dist/fastgrid)
+  benchmarks/  bench_geometry.py                          (import dist/fastgrid)
+```
+
+`core.paint()` returns a display list (plain-data draw ops for the visible
+cells); the engine just blits it. The host only owns the window and translates
+events, so the Tk and Qt hosts behave identically:
+
+```
+dl.cells    = [(x, y, w, h, text, bg, fg, flags), ...]      # ~visible cells, back-to-front
+dl.overlays = [("line"|"vline"|"hline"|"ring"|"tri", ...)]  # chrome drawn after cells
+```
+
+`core.paint` decides every colour, position and z-order; the engine is ~"for
+each cell fill a rect + draw text; for each overlay draw a line/rect/triangle".
+
+![fastgrid sample grid: headers, frozen columns, per-column filters](docs/screenshot.png)
+
+## Requirements
+
+| Requirement | Details |
+|---|---|
+| **Windows only** | The renderer is Direct2D (`_gpu/surface.dll`), so it needs Windows and a Direct3D 11-capable GPU (falls back to the WARP software device if there's no GPU). There is no macOS/Linux backend. |
+| **Python 3.8+** | |
+| **Tk host** | Standard library only (`tkinter`, ships with Python). |
+| **Qt host** | Needs `PySide6` (`pip install PySide6`), the only dependency, and only if you use the Qt host. |
+| **Native DLLs** | Not committed -- `build.bat` runs CMake (which finds MSVC itself) to compile them into `dist/fastgrid/`. `surface.dll` draws the Direct2D surface and `gridcore.dll` is an optional C++ data core (the model falls back to pure Python if it's missing). Needs CMake + MSVC on the machine. Run `build.bat` once (and after any `.cpp` or `.py` change), then run the demos. |
+
+## Example
+
+```python
+from fastgrid.render.gpu_tk import make_sheet         # tkinter host (stdlib only)
+win = make_sheet(
+    ["Ticker", "Company", "Sector", "Price"],
+    [["AAPL", "Apple Inc.", "Technology", "189.20"],
+     ["XOM",  "Exxon Mobil", "Energy",   "104.10"]],
+    frozen_columns=2,   # pin the first 2 columns against horizontal scroll
+)
+win.mainloop()
+```
+
+Double-click or type to edit. Enter/Tab commit, Ctrl+Z/Y undo/redo, Ctrl+C/V
+copy/paste, Ctrl+A select-all, Ctrl+F find, ▼ on a header to filter/sort.
+
+```python
+from fastgrid.render.gpu_qt import make_sheet          # PySide6 host
+win = make_sheet(headers, rows, frozen_columns=2)
+win.mainloop()                                          # aliases app.exec()
+```
+
+## Build
+
+```bash
+build.bat
+```
+
+Runs CMake to compile the DLLs and assemble the runnable library into
+`dist/fastgrid/` (`.py` + `.dll` only). Needs CMake and MSVC. Re-run after any
+`.cpp` or `.py` change, then `demos/setup.bat` to stage `demos/fastgrid` + `demos/.venv`.
+
+## Run
+
+```bash
+python demos/demo_gpu_tk.py                 # tkinter host, 100k rows
+python demos/demo_gpu_qt.py                 # Qt host, same data
+python demos/demo_gpu_tk.py --rows 500000   # stress it
+python scripts/tests/check_select.py        # selection-state-machine check
+python scripts/tests/fuzz_coremodel.py      # C++ data core vs pure-Python oracle
+```
+
+## Performance
+
+Only the visible cells are built, so the row count barely matters. 10k rows
+and 1M rows do the same work per frame.
+
+```
+rows         core paint()
+10,000       0.13 ms
+100,000      0.13 ms
+1,000,000    0.13 ms
+```
+
+The Direct2D surface redraws that frame on the GPU, vsync-capped (~60 fps), and
+stays smooth while scrolling millions of rows.
+
+## Features
+
+The engine handles all of this, so both the Tk and Qt hosts get it for free.
+
+| Feature | Details |
+|---|---|
+| Frozen columns | Pin leading columns against horizontal scroll. |
+| Pinned selectable header rows | Pass a list of lists as `headers` for a multi-row header; adjacent same-label cells in the upper rows merge into spanning group bands, e.g. `[["", "FY 2023", "FY 2023"], ["Ticker", "Q1", "Q2"]]`. |
+| Excel-style selection | Click/drag/Ctrl/Shift, whole row/column, select-all, Ctrl+arrow block jumps. |
+| In-cell editing | Double-click or type to edit; copy/paste/delete, undo/redo. |
+| Filter & sort | Per-column value and text filters, A→Z/Z→A sort. |
+| Find | Ctrl+F with prev/next, case, and selection scope. |
+
+Per-cell styling and dropdowns, and thick black section dividers, are set on
+the model (display only, positional):
+
+```python
+model.set_cell_style(gr, col, fg="#c0392b", bold=True)   # gr/col are GRID coords
+model.set_cell_choices(gr, col, ["Buy", "Hold", "Sell"]) # editing offers a dropdown
+model.set_vline(col)          # thick rule on the RIGHT edge of a column
+model.set_hline(gr)           # thick rule on the BOTTOM edge of a grid row
+model.set_readonly_col(col)   # block edits/paste/delete in a column (still selectable)
+```

fastpygrid-0.1.0/build.bat

@@ -0,0 +1,14 @@
+@echo off
+REM Build the runnable fastgrid library into dist\fastgrid : the .py sources plus
+REM freshly compiled .dll (via CMake), nothing else. CMake finds MSVC itself.
+REM Run after changing any .py or .cpp, then run the demos against dist\fastgrid.
+setlocal
+set "ROOT=%~dp0"
+
+if exist "%ROOT%dist" rmdir /s /q "%ROOT%dist"
+cmake -S "%ROOT%." -B "%ROOT%build" -DCMAKE_BUILD_TYPE=Release || exit /b 1
+cmake --build "%ROOT%build" --config Release || exit /b 1
+cmake --install "%ROOT%build" --prefix "%ROOT%dist" --config Release || exit /b 1
+
+echo [build] dist -^> %ROOT%dist\fastgrid
+exit /b 0

fastpygrid-0.1.0/demos/_data.py

@@ -0,0 +1,113 @@
+"""Shared sample data for the demos + benchmarks. Pure data: each caller puts
+fastgrid on sys.path itself (demos use demos/fastgrid, scripts use dist/)."""
+
+HEADERS = ["Ticker", "Company", "Sector", "Price", "Chg%", "Volume", "Note"]
+SECTORS = ["Technology", "Energy", "Finance", "Health", "Consumer", "Utilities"]
+COL_W = [110, 190, 155, 90, 80, 110, 90]   # Sector (idx 2) widened for its ▼ dropdown arrow
+
+# A batch of extra columns so the demo scrolls horizontally (exercises column
+# resize / autofit). 8 quarters of revenue + a few text fields.
+QUARTERS = ["%s %d" % (q, y) for y in (2023, 2024) for q in ("Q1", "Q2", "Q3", "Q4")]
+HEADERS += QUARTERS + ["Analyst", "Rating", "Country", "Notes"]
+COL_W += [95] * len(QUARTERS) + [140, 120, 120, 260]   # Rating widened for its ▼ dropdown arrow
+
+# Two-row grouped header: a band of "FY 2023"/"FY 2024" spanning each year's
+# quarters above the field names (adjacent same-label cells merge into one
+# spanning cell). Pass GROUPED_HEADERS instead of HEADERS to exercise it.
+GROUPS = ([""] * 7 + ["FY %d" % y for y in (2023, 2024) for _q in range(4)]
+          + [""] * 4)
+GROUPED_HEADERS = [GROUPS, HEADERS]
+RATINGS = ["Buy", "Hold", "Sell", "Strong Buy", "Underweight"]
+COUNTRIES = ["USA", "Germany", "Japan", "United Kingdom", "South Korea", "Brazil"]
+
+
+def gen_rows(n):
+    return [[
+        "TIK%05d" % i,
+        "Company %d Inc." % i,
+        SECTORS[i % len(SECTORS)],
+        "%.2f" % (10 + (i * 7 % 9000) / 10.0),
+        "%+.2f" % (((i * 13) % 800 - 400) / 100.0),
+        str((i * 3779) % 5_000_000),
+        "watch" if i % 17 == 0 else "",
+        *("%.1fM" % (((i * (q + 7)) % 9000) / 10.0) for q in range(len(QUARTERS))),
+        "Analyst %d" % (i % 40),
+        RATINGS[i % len(RATINGS)],
+        COUNTRIES[i % len(COUNTRIES)],
+        "Longer free-text note for row %d to show autofit clipping." % i if i % 5 == 0 else "",
+    ] for i in range(n)]
+
+
+def rows_arg(argv, default=100_000):
+    return int(argv[argv.index("--rows") + 1]) if "--rows" in argv else default
+
+
+def style_demo(model, lo=None, hi=None):
+    """Data-driven per-cell styling so the demos exercise fg / bold / bg:
+    Chg% red/green by sign, 'Strong Buy' ratings bold-green, 'watch' notes flagged
+    amber. Optional [lo, hi) GRID-row range so stream_styles() can apply it in
+    chunks; defaults to the whole dataset."""
+    chg, rating, note = HEADERS.index("Chg%"), HEADERS.index("Rating"), HEADERS.index("Note")
+    lo = model.header_rows if lo is None else lo
+    hi = model._real_rows() if hi is None else hi
+    for gr in range(lo, hi):
+        v = model.cell(gr, chg)
+        if v:
+            model.set_cell_style(gr, chg, fg="#c0392b" if v.startswith("-") else "#1e8449", bold=True)
+        if model.cell(gr, rating) == "Strong Buy":
+            model.set_cell_style(gr, rating, fg="#1e8449", bold=True)
+        if model.cell(gr, note) == "watch":
+            model.set_cell_style(gr, note, bg="#fff3b0")
+
+
+def stream_styles(win, chunk=4000):
+    """Apply the per-cell style pass in chunks AFTER the first frame, so the grid
+    shows instantly and never freezes on load. The first chunk covers the visible
+    rows, so what you see is styled within a frame; the rest streams in behind it."""
+    m, view = win.model, win.grid_view
+    total = m._real_rows()
+
+    def step(lo):
+        style_demo(m, lo, min(lo + chunk, total))
+        m.changed()
+        if lo + chunk < total:
+            view.after(1, lambda: step(lo + chunk))
+
+    view.after(0, lambda: step(m.header_rows))
+
+
+# Stress dropdown: 1000 options, most far wider than any column -- exercises the
+# popup-widening (list grows to the text) and large option lists. The whole column
+# shares one interned tuple, so this costs one list, not one copy per row.
+_LONG = ("Comprehensive multi-word option label that is far wider than the column",
+         "Another lengthy descriptive choice overflowing the narrow cell by a lot",
+         "Short",
+         "Medium-length option text")
+LONG_OPTS = ["%04d — %s" % (i, _LONG[i % len(_LONG)]) for i in range(1000)]
+
+
+def lines_demo(model):
+    """Thick black section dividers: a vertical rule right of the Chg% column
+    (splits the identity/price block from the quarterly financials) and a couple
+    of horizontal rules to band the data. Positional -- they mark a fixed place."""
+    model.set_vline(HEADERS.index("Chg%"))
+    model.set_hline(10)                        # under grid row 10 (a data row)
+    model.set_hline(25)
+
+
+def readonly_demo(model):
+    """Lock the Ticker + Price columns: still selectable and copyable, but edits,
+    paste and delete are rejected (try double-clicking a Ticker cell -- no editor)."""
+    model.set_readonly_col(HEADERS.index("Ticker"))
+    model.set_readonly_col(HEADERS.index("Price"))
+
+
+def choices_demo(model):
+    """Make Sector/Rating dropdowns, plus a 1000-option long-text dropdown on the
+    narrow Note column (to exercise popup widening). Same bulk-before-build note as
+    style_demo."""
+    sector, rating, note = (HEADERS.index("Sector"), HEADERS.index("Rating"),
+                            HEADERS.index("Note"))
+    model.set_col_choices(sector, SECTORS)     # whole-column dropdowns: O(1), not per row
+    model.set_col_choices(rating, RATINGS)
+    model.set_col_choices(note, LONG_OPTS)

fastpygrid-0.1.0/demos/demo.bat

@@ -0,0 +1,43 @@
+@echo off
+REM Launch the fastgrid Tk or Qt GPU demo using the project's .venv (Python 3.10).
+REM Usage:  demo.bat            -> prompts for tk or qt
+REM         demo.bat qt         -> runs the Qt (PySide6) demo
+REM         demo.bat tk         -> runs the Tk demo
+REM         demo.bat qt --rows 500000   -> extra args pass through to the demo
+
+setlocal
+REM This bat lives in demos/, so ROOT is its parent (the repo root).
+for %%I in ("%~dp0..") do set "ROOT=%%~fI\"
+set "PY=%~dp0.venv\Scripts\python.exe"
+
+if not exist "%PY%" (
+    echo [demo] demos\.venv not found. Run setup.bat first.
+    exit /b 1
+)
+
+set "TARGET=%~1"
+if /i "%TARGET%"=="qt" goto run
+if /i "%TARGET%"=="tk" goto run
+
+set /p TARGET=Which demo? [tk/qt]:
+if /i not "%TARGET%"=="qt" if /i not "%TARGET%"=="tk" (
+    echo [demo] Unknown demo "%TARGET%". Choose tk or qt.
+    exit /b 1
+)
+set "REST="
+goto launch
+
+:run
+REM Drop the first arg (tk/qt); keep the rest to pass through.
+shift
+set "REST="
+:collect
+if "%~1"=="" goto launch
+set "REST=%REST% %1"
+shift
+goto collect
+
+:launch
+echo [demo] Launching %TARGET% demo...
+"%PY%" "%ROOT%demos\demo_gpu_%TARGET%.py"%REST%
+exit /b %errorlevel%

fastpygrid-0.1.0/demos/demo_gpu_qt.py

@@ -0,0 +1,75 @@
+"""Direct2D/GPU demo under a Qt (PySide6) host -- same engine as demo_gpu_tk.py.
+
+    python demos/demo_gpu_qt.py                 # 100k rows on the GPU surface
+    python demos/demo_gpu_qt.py --rows 500000   # stress it
+
+Tabs across the top open separate whole sheets, each with different options, so you
+can compare them live. The "Uncapped" tabs scroll past the last row/column into
+empty space (Excel-style): the scrollbar thumb shrinks as you overscroll and snaps
+back when you scroll in again -- unless you typed out there, which grows the sheet.
+
+Proves the toolkit-neutral GpuEngine runs unchanged under Qt. Build the DLL once:
+    python -m fastgrid.core.gpu --build
+"""
+import sys
+
+# _data.py and fastgrid/ both live next to this file (fastgrid staged by setup.bat).
+from _data import (HEADERS, COL_W, gen_rows, rows_arg, stream_styles, choices_demo,
+                   lines_demo, readonly_demo)
+
+# Each tab = a whole separate sheet with its own scroll-cap options.
+SHEETS = [
+    ("Capped (default)", {}),
+    ("Uncapped rows", dict(uncap_rows=True)),
+    ("Uncapped rows + cols", dict(uncap_rows=True, uncap_cols=True)),
+]
+
+
+def _add_sheet(tabs, title, headers, rows, col_w, scale, lib, **opts):
+    """Build one grid (its own model + engine) into a fresh Qt tab page."""
+    from PySide6 import QtWidgets
+    from fastgrid.render.gpu_qt import GpuQtGrid
+    from fastgrid.core.coremodel import make_model
+    page = QtWidgets.QWidget()
+    lay = QtWidgets.QVBoxLayout(page)
+    lay.setContentsMargins(0, 0, 0, 0)
+    model = make_model(headers, rows, editable=True)
+    grid = GpuQtGrid(page, model, frozen=2, col_w=col_w, scale=scale, lib=lib, **opts)
+    lay.addWidget(grid)
+    page.model, page.grid_view = model, grid   # stream_styles() reads these
+    tabs.addTab(page, title)
+    choices_demo(model)            # Sector/Rating dropdowns (O(1), whole-column)
+    lines_demo(model)              # thick section dividers
+    readonly_demo(model)           # locked Ticker + Price columns
+    model.changed()                # first frame paints instantly with data + dropdowns
+    stream_styles(page)            # per-cell fg/bold/bg streams in after the first frame
+
+
+def main():
+    from PySide6 import QtWidgets
+    from fastgrid.core.gpu import _load_lib, _enable_dpi_awareness, _screen_scale
+    lib = _load_lib()
+    if lib is None:
+        raise SystemExit("Gpu surface unavailable -- build it with "
+                         "`python -m fastgrid.core.gpu --build`.")
+    app = QtWidgets.QApplication.instance()
+    if app is None:
+        _enable_dpi_awareness()
+        app = QtWidgets.QApplication([])
+    n = rows_arg(sys.argv)
+    data = gen_rows(n)             # generate once; each sheet's model copies it
+    scale = _screen_scale(None)
+    # uncapped tabs use a SMALL sheet so the empty repeatable cells are right past
+    # the data (with 100k rows you'd never scroll to the phantom region to see them).
+    small = data if n <= 30 else gen_rows(30)
+    win = QtWidgets.QTabWidget()
+    win.setWindowTitle("fastgrid (gpu-qt) — sheet options — %s rows" % f"{n:,}")
+    win.resize(round(980 * scale), round(620 * scale))
+    for title, opts in SHEETS:
+        _add_sheet(win, title, HEADERS, (small if opts else data), COL_W, scale, lib, **opts)
+    win.show()
+    app.exec()
+
+
+if __name__ == "__main__":
+    main()