tkblend 0.4.0b1__tar.gz

tkblend-0.4.0b1/.agents/rules/platform-build-invariants.md

@@ -0,0 +1,66 @@
+# Multiplatform Build & Packaging Invariants
+
+This rule documents critical invariants, hard-won fixes, and regression prevention guidelines across Linux, macOS, and Windows CI/CD, cibuildwheel, CMake, and native C++ extension workflows for `tkblend`.
+
+---
+
+## 1. 🍎 macOS (`macos-14` ARM64 / `macos-15-intel` x86_64 / delocate)
+
+1. **Static FreeType Compilation**:
+   - **Rule**: FreeType must always be built from source statically via `FetchContent` on `APPLE` with `BUILD_SHARED_LIBS=OFF`.
+   - **Why**: Homebrew's `freetype` dylibs are compiled with `MACOSX_DEPLOYMENT_TARGET >= 14.0`. Linking dynamic Homebrew FreeType causes `delocate-wheel` to reject the wheel for deployment targets `10.15` (Intel) and `11.0` (ARM64).
+
+2. **Static Tcl/Tk Stubs**:
+   - **Rule**: Link only against static stub libraries (`libtkstub8.6.a`, `libtclstub8.6.a`) via `brew install tcl-tk` and `CMAKE_PREFIX_PATH=$(brew --prefix tcl-tk)`.
+   - **Why**: Never dynamically link `Tk.framework` or `Tcl.framework` at build time to ensure wheels load across different Python distributions and Tk versions.
+
+3. **Dynamic Symbol Resolution for Tk Cocoa Internals**:
+   - **Rule**: Resolve Cocoa Tk symbols like `TkMacOSXGetCGContextForDrawable` dynamically at runtime via `dlsym(RTLD_DEFAULT, "TkMacOSXGetCGContextForDrawable")`.
+   - **Why**: Direct linker references or `__attribute__((weak_import))` still require build-time framework linking on older runner images, causing build failures.
+
+4. **No Unsafe ObjC Window Shaping**:
+   - **Rule**: `is_window_shaping_supported()`, `apply_round_rect_shape()`, and `clear_window_shape()` must return `false` on macOS in `src/window_shape.cpp`.
+   - **Why**: In Aqua Cocoa Tk, `widget.winfo_id()` returns a pointer to Tk's internal C struct `MacDrawable`, NOT an Objective-C `NSView*`. Casting this pointer to `NSView*` and calling ObjC selectors (`[view isKindOfClass:...]`) causes an immediate segmentation fault (`EXC_BAD_ACCESS`). Child Tk widgets share the top-level `TKContentView` and rely on Blend2D canvas clipping.
+
+---
+
+## 2. 🪟 Windows (`windows-latest` / MSVC / delvewheel)
+
+1. **CMake Prefix Propagation to cibuildwheel**:
+   - **Rule**: Always pass `CMAKE_PREFIX_PATH` in both the GitHub Actions step `env:` and via `CIBW_ENVIRONMENT_WINDOWS: "CMAKE_PREFIX_PATH='${{ steps.tcltk.outputs.environment-path }}/Library'"`.
+   - **Why**: `cibuildwheel` spawns isolated build subshells that do not inherit `$GITHUB_ENV`.
+
+2. **Excluding Tcl/Tk DLLs in delvewheel**:
+   - **Rule**: Maintain `--exclude tcl86t.dll --exclude tk86t.dll` in `tool.cibuildwheel.windows.repair-wheel-command`.
+   - **Why**: Prevents delvewheel from vendoring host Tcl/Tk DLLs into the wheel, allowing host Python's Tkinter to provide them at runtime.
+
+3. **Headless & Standalone Test Virtualenv Isolation**:
+   - **Rule**: All Tkinter imports in `tkblend/__init__.py` must be wrapped in `try/except ImportError`. The C++ extension `_tkblend` is always imported directly.
+   - **Why**: cibuildwheel's clean Windows test virtualenvs do not bundle `_tkinter.pyd`. Guarding imports allows the smoke test `python -c "from tkblend import _tkblend; print('C++ extension loaded successfully')"` to verify binary integrity without crashing with `ModuleNotFoundError: No module named 'tkinter'`.
+
+4. **Target Installation Destination**:
+   - **Rule**: Configure `install(TARGETS _tkblend LIBRARY DESTINATION tkblend RUNTIME DESTINATION tkblend ARCHIVE DESTINATION tkblend)` in `CMakeLists.txt`.
+   - **Why**: Ensures Windows `.pyd` files are placed inside the `tkblend/` package folder.
+
+---
+
+## 3. 🐧 Linux (`manylinux_2_28` / x86_64 / aarch64 / auditwheel)
+
+1. **Docker Container Dependencies**:
+   - **Rule**: Declare `yum install -y tcl-devel tk-devel xorg-x11-server-Xvfb xorg-x11-xinit` under `tool.cibuildwheel.linux.before-all`.
+   - **Why**: manylinux container environments run in clean isolation from the host runner.
+
+2. **Virtual Display Server for Tests**:
+   - **Rule**: Run test suites using `xvfb-run -a pytest {project}/tests`.
+   - **Why**: Tkinter requires a running X11 display server to initialize widgets in headless CI runners.
+
+---
+
+## 4. 🛠️ Local Development & Testing
+
+- Always run Python commands and test suites using `uv`:
+  ```bash
+  uv run pytest
+  uv run python <script>
+  ```
+- When native C++ sources in `src/` are modified, rebuild the native extension with `cmake --build build` and copy the compiled `_tkblend*.so` / `_tkblend*.pyd` into `tkblend/` and the active `.venv` environment.

tkblend-0.4.0b1/.agents/rules/tooling.md

@@ -0,0 +1,6 @@
+# Tooling & Environment Invariants
+
+- Always run Python commands, scripts, and test suites using `uv`:
+  - `uv run pytest`
+  - `uv run python <script>`
+- When native C++ sources in `src/` are modified, rebuild with `cmake --build build` and copy the resulting `_tkblend*.so` into `.venv/lib/python3.12/site-packages/tkblend/` and `tkblend/`.

tkblend-0.4.0b1/.agents/skills/blend2d-vector-widgets/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: blend2d-vector-widgets
+description: Architecture guide and reference patterns for developing pure Blend2D surface-based vector widgets in tkblend with zero TTK dependencies.
+---
+
+# Blend2D Vector Widgets Architecture & Development Guide
+
+This skill provides the architectural foundation, development workflow, and widget design patterns for `tkblend`'s pure surface-based vector UI components.
+
+## Core Architectural Principles
+
+1. **Zero TTK Dependencies**:
+   - `tkblend` does not use the Tcl/Tk TTK theme engine (`Ttk_RegisterElement`, `Ttk_RegisterTheme`, `ttk.Style`).
+   - All interactive components are self-contained vector widgets powered by Blend2D C++ rendering directly into Tk window drawables via zero-copy blitting without intermediate `PhotoImage` allocations.
+
+2. **DPI-Aware Coordinate Scaling**:
+   - Always route dimensions and layout coordinates through `ScalingTracker`:
+     ```python
+     scale = ScalingTracker.get_scaling_factor(master)
+     widget_w = int(logical_w * scale)
+     widget_h = int(logical_h * scale)
+     ```
+   - Auto-activates process-level high-DPI awareness on Windows and detects scaling factors on macOS / Linux.
+
+3. **BaseControl & NativeController Lifecycle (`tkblend.widgets.BaseControl`)**:
+   - Subclass `BaseControl`, which wraps `tk.Frame` with an integrated `NativeWidgetController` for zero-copy direct drawable blitting.
+   - **Transparent Frame Protocol**: Always initialize `super().__init__(..., background="")` so Tk's internal `DisplayFrame` has `framePtr->border == NULL` and does not erase Blend2D vector surfaces on Expose/Configure events.
+   - Implement `render(self, surf: Surface, pal: Palette, width: int, height: int, scale: float) -> None`:
+     1. Vector shapes, paths, text, or drop shadows are drawn into `surf`.
+     2. Background clearing is handled via `surf.clear(self._resolved_parent_bg)`.
+   - Request redraws via `self.request_redraw()`, which schedules non-blocking idle execution through `self.after_idle(self._execute_idle_redraw)`.
+   - **Direct C++ Hardware Blits on Expose / MapNotify**: `NativeWidgetController` handles X11 `Expose`, `MapNotify`, and `VisibilityNotify` events by immediately executing `blit_active_surface()` in C++ from the backing surface buffer.
+
+4. **Dynamic Theming with `tkblend.theme`**:
+   - Query `get_theme()` for semantic colors: `bg`, `fg`, `primary`, `secondary`, `accent`, `card_bg`, `card_border`, `track_bg`, `thumb_color`.
+   - `BaseControl` automatically registers with `add_theme_listener` and re-renders on `set_theme("light" | "dark")`.
+   - **Avoid Static Color Locking**: Do not pass explicit theme colors in constructors unless a permanent user override is intended. Let child widgets dynamically inherit background via `_resolve_default_bg(master, palette)`.
+   - **Compound Container Protocol (`.bg_color`)**: Any compound container (`ScrollableFrame`, `Tabview`, `Table`, `TextBox`, `Frame`, `Card`) must expose a `.bg_color` property returning its active inner surface fill color so `cascade_bg_to_children()` can properly recurse.
+   - **Subcomponent Cascade in `_on_theme_changed`**:
+     Compound widgets must update their internal frames, canvas viewports, and vector scrollbars with `set_parent_bg()` and call `cascade_bg_to_children(self, inner_bg)`.
+   - **Startup UI Palette Injection**:
+     Call `self._on_theme_changed(pal)` or `tb.cascade_bg_to_children(self, pal.bg)` right after `_build_ui()` so standard helper `tk.Frame`s adapt immediately to theme card colors on first launch.
+
+## Developing a Native Vector Widget
+
+Follow this template for creating custom vector components with `BaseControl`:
+
+```python
+import tkinter as tk
+from typing import Optional
+from tkblend.widgets import BaseControl
+from tkblend.theme import Palette, get_theme
+from tkblend.surface import Surface, ColorLike
+
+class CustomGauge(BaseControl):
+    def __init__(
+        self,
+        master: Optional[tk.Misc] = None,
+        size: int = 100,
+        value: float = 50.0,
+        color: Optional[ColorLike] = None,
+        parent_bg: Optional[str] = None,
+        **kwargs,
+    ):
+        self._value = value
+        self._color = color
+        super().__init__(master=master, width=size, height=size, parent_bg=parent_bg, **kwargs)
+
+    def set_value(self, val: float) -> None:
+        self._value = max(0.0, min(100.0, float(val)))
+        self.request_redraw()
+
+    def render(self, surf: Surface, pal: Palette, width: int, height: int, scale: float) -> None:
+        s = scale
+        cx = width / 2.0
+        cy = height / 2.0
+        r = min(cx, cy) - 6.0 * s
+        
+        # Draw track and progress
+        active_color = self._color or pal.primary
+        surf.stroke_circle(cx, cy, r, pal.track_bg, stroke_width=6.0 * s)
+        surf.fill_circle(cx, cy, r * (self._value / 100.0), active_color)
+```
+
+## C++ Native Extension Concurrency & Memory Safety
+
+1. **GIL Management & Event Loop Thread Safety**:
+   - Never invoke raw `PyGILState_Ensure()` / `PyGILState_Release()` during `_tkinter` `Tcl_Eval` execution; use `nb::gil_scoped_acquire` in C++ event callbacks.
+   - Python-initiated redraws must be scheduled via `widget.after_idle()`.
+   - `Surface::resize()` runs under `nb::call_guard<nb::gil_scoped_release>()`.
+   - All buffer acquisitions (`SurfaceBufferObject`, `Surface::get_buffer()`) must register via `Surface::acquire_buffer_view()` / `Surface::release_buffer_view()` under `Surface::mutex_`.
+   - `active_buffers_` acts as a guard preventing resize and subsequent use-after-free while active memoryviews exist.
+
+2. **Display List & Direct Drawing Parity**:
+   - Every operation in `DrawBatch` (`DrawOp`) must maintain 1:1 parity with direct `Surface` calls (including all shadow blur, spread, offset-x, offset-y, and color arguments).
+   - Any new high-level drawing primitive added to `Surface` must also be added with identical arguments to `DrawBatch`.
+
+3. **Cross-Platform Native Hygiene**:
+   - Objective-C++ sources (macOS window shaping) must be pinned to `-fobjc-arc` and treat native view handles as borrowed references.
+   - Dynamic asset and font resolution must never use hardcoded user paths; dynamic `$HOME` / `$WINDIR` lookups must be used.
+   - Global native types (e.g. `SurfaceBufferType`) must be initialized via `std::call_once` or module init.
+
+## Embedded Sub-widget State Bridging & Controller Parity
+
+When developing compound vector widgets that embed native Tk elements (e.g., `Entry`, `TextBox` embedding `tk.Entry` or `tk.Text`):
+1. **Property & Method Dual Parity**: `NativeController` and widget controllers must provide both property syntax (`controller.is_focused = True`) and method syntax (`controller.set_focused(True)`) for state mutators (`hovered`, `pressed`, `focused`, `disabled`, `checked`).
+2. **Focus Event Delegation**: Child Tk widgets must delegate `<FocusIn>` and `<FocusOut>` events to update the controller state and immediately trigger `self.request_redraw()` so focus rings and border colors render responsively.
+3. **Headless & CI Test Verification**: When testing focus state transitions in pytest fixtures, invoke the widget's focus callback hooks directly (`widget._on_entry_focus_in()`) to ensure reliable assertion across headless and unmapped X11 windows.
+
+## Compound Vector Widget Event Isolation & GIL Safety Protocol
+
+When developing compound, virtualized, or multi-element vector widgets subclassing `BaseControl` (such as `Table`, `CanvasContainer`, or composite charts) that define custom mouse event bindings (`self.bind("<Button-1>", ...)`, `self.bind("<ButtonRelease-1>", ...)`):
+
+1. **Decouple `command` from `BaseControl`**:
+   - Always pass `command=None` to `super().__init__(..., command=None)` so `BaseControl` does not register a generic button-click callback.
+   - Store the user's callback in a widget-specific attribute (e.g., `self._command = command`) and expose it via `@property def command`.
+
+2. **Neutralize C++ Controller Click Interception**:
+   - Explicitly disable button press state tracking and clear native click handlers during `__init__`:
+     ```python
+     self.controller.auto_press = False
+     self.controller.clear_on_click()
+     ```
+   - Override `_on_controller_click` as a no-op:
+     ```python
+     def _on_controller_click(self, x: int, y: int, button: int) -> None:
+         """No-op: Compound widgets manage clicks and interactions internally."""
+         pass
+     ```
+
+3. **Prevent `_tkinter` `tsdPtr->tstate` Desynchronization**:
+   - Never allow C++ `on_tk_event` callbacks to execute arbitrary user callbacks synchronously if the widget also binds Tk events for the same event type.
+   - A nested `Tcl_Eval` executed from a C++ event handler clears `_tkinter`'s saved thread state to `NULL`, triggering a fatal `PyEval_RestoreThread` crash when Tk dispatches downstream Python event bindings for that event.
+

tkblend-0.4.0b1/.github/workflows/ci.yml

@@ -0,0 +1,263 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  test:
+    name: Test (${{ matrix.os }} - Py ${{ matrix.python-version }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-14, windows-latest]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        exclude:
+          # macos-14 runner is ARM64 and only supports Python >= 3.10
+          - os: macos-14
+            python-version: "3.9"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python ${{ matrix.python-version }}
+        if: runner.os != 'Windows'
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+
+      - name: Install Linux build & display dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y tcl8.6-dev tk8.6-dev xvfb libx11-dev
+
+      - name: Install macOS Tcl/Tk development files
+        if: runner.os == 'macOS'
+        run: |
+          brew install tcl-tk
+          echo "CMAKE_PREFIX_PATH=$(brew --prefix tcl-tk)" >> $GITHUB_ENV
+
+      - name: Install Windows Tcl/Tk development files
+        if: runner.os == 'Windows'
+        id: tcltk
+        uses: mamba-org/setup-micromamba@v3
+        with:
+          environment-name: tkblend-tcltk
+          create-args: >-
+            --channel conda-forge
+            python=${{ matrix.python-version }}
+            tk=8.6.13
+          init-shell: none
+
+      - name: Install build tools & dependencies
+        if: runner.os != 'Windows'
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install cmake ninja nanobind scikit-build-core pytest Pillow darkdetect
+
+      - name: Install Windows build tools & dependencies
+        if: runner.os == 'Windows'
+        run: |
+          micromamba run -n tkblend-tcltk python -m pip install --upgrade pip setuptools wheel
+          micromamba run -n tkblend-tcltk python -m pip install cmake ninja nanobind scikit-build-core pytest Pillow darkdetect
+
+      - name: Verify Windows tkinter
+        if: runner.os == 'Windows'
+        run: micromamba run -n tkblend-tcltk python -c "import tkinter; print(tkinter.TkVersion)"
+
+      - name: Build and install tkblend (Windows)
+        if: runner.os == 'Windows'
+        run: micromamba run -n tkblend-tcltk python -m pip install -e . --no-build-isolation -v
+        env:
+          CMAKE_PREFIX_PATH: ${{ steps.tcltk.outputs.environment-path }}/Library
+
+      - name: Build and install tkblend (macOS / Linux)
+        if: runner.os != 'Windows'
+        run: |
+          python -m pip install -e . --no-build-isolation -v
+
+      - name: Run tests (Linux with Xvfb)
+        if: runner.os == 'Linux'
+        run: |
+          xvfb-run -a pytest -v
+
+      - name: Run tests (macOS / Windows)
+        if: runner.os == 'macOS'
+        run: pytest -v
+
+      - name: Run tests (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          micromamba run -n tkblend-tcltk python -m pytest -v
+
+  sanitizers:
+    name: ASan & UBSan (Linux - Py 3.12)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Install Linux build & display dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y tcl8.6-dev tk8.6-dev xvfb libx11-dev libasan8
+
+      - name: Install build tools & test dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install cmake ninja nanobind scikit-build-core pytest Pillow darkdetect
+
+      - name: Run ASan & UBSan Sanitizer Test Suite
+        run: |
+          ./scripts/run_sanitizers.sh
+
+  coverage:
+    name: Dual Code Coverage (Python + C++)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "pip"
+
+      - name: Install Linux build & display dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y tcl8.6-dev tk8.6-dev xvfb libx11-dev gcovr
+
+      - name: Install build tools & coverage dependencies
+        run: |
+          python -m pip install --upgrade pip setuptools wheel
+          python -m pip install cmake ninja nanobind scikit-build-core pytest pytest-cov coverage gcovr Pillow darkdetect
+
+      - name: Run Dual Coverage Suite (Python + C++)
+        run: |
+          ./scripts/run_coverage.sh
+
+      - name: Upload Python Coverage HTML Report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: python-coverage-report
+          path: build/coverage/python_html/
+
+      - name: Upload C++ Coverage HTML Report
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: cpp-coverage-report
+          path: build/coverage/cpp_html/
+
+  windows_direct_link:
+    name: Windows Direct-Link Validation (Py 3.12)
+    runs-on: windows-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Windows Tcl/Tk development files
+        id: tcltk
+        uses: mamba-org/setup-micromamba@v3
+        with:
+          environment-name: tkblend-tcltk-direct
+          create-args: >-
+            --channel conda-forge
+            python=3.12
+            tk=8.6.13
+          init-shell: none
+
+      - name: Install Windows build tools & dependencies
+        run: |
+          micromamba run -n tkblend-tcltk-direct python -m pip install --upgrade pip setuptools wheel
+          micromamba run -n tkblend-tcltk-direct python -m pip install cmake ninja nanobind scikit-build-core pytest Pillow darkdetect
+
+      - name: Verify Windows tkinter
+        run: micromamba run -n tkblend-tcltk-direct python -c "import tkinter; print(tkinter.TkVersion)"
+
+      - name: Build and install tkblend (Direct-Link mode)
+        run: micromamba run -n tkblend-tcltk-direct python -m pip install -e . --no-build-isolation -v -Ccmake.define.TKBLEND_PURE_STUBS=OFF
+        env:
+          CMAKE_PREFIX_PATH: ${{ steps.tcltk.outputs.environment-path }}/Library
+          CMAKE_ARGS: "-DTKBLEND_PURE_STUBS=OFF"
+
+      - name: Verify PE imports for direct Tk linking
+        run: |
+          micromamba run -n tkblend-tcltk-direct python -c "
+          import glob, struct, sys
+
+          pyd_files = glob.glob('tkblend/_tkblend*.pyd')
+          if not pyd_files:
+              print('Error: Could not find _tkblend*.pyd in tkblend/', file=sys.stderr)
+              sys.exit(1)
+
+          pyd_path = pyd_files[0]
+          print(f'Inspecting PE imports for: {pyd_path}')
+
+          with open(pyd_path, 'rb') as f:
+              data = f.read()
+
+          e_lfanew = struct.unpack_from('<I', data, 0x3C)[0]
+          magic = struct.unpack_from('<H', data, e_lfanew + 24)[0]
+
+          if magic == 0x20B:
+              import_rva, import_size = struct.unpack_from('<II', data, e_lfanew + 24 + 120)
+          else:
+              import_rva, import_size = struct.unpack_from('<II', data, e_lfanew + 24 + 104)
+
+          num_sections = struct.unpack_from('<H', data, e_lfanew + 6)[0]
+          opt_header_size = struct.unpack_from('<H', data, e_lfanew + 20)[0]
+          section_offset = e_lfanew + 24 + opt_header_size
+
+          def rva_to_offset(rva):
+              for i in range(num_sections):
+                  sec = section_offset + i * 40
+                  sec_vsize, sec_va, sec_raw_size, sec_raw_offset = struct.unpack_from('<IIII', data, sec + 8)
+                  if sec_va <= rva < sec_va + max(sec_vsize, sec_raw_size):
+                      return sec_raw_offset + (rva - sec_va)
+              return None
+
+          imports = []
+          curr = rva_to_offset(import_rva)
+          while curr is not None and curr + 20 <= len(data):
+              orig_first_thunk, ts, fchain, name_rva, first_thunk = struct.unpack_from('<IIIII', data, curr)
+              if name_rva == 0:
+                  break
+              name_offset = rva_to_offset(name_rva)
+              if name_offset:
+                  name = data[name_offset:data.find(b'\x00', name_offset)].decode('ascii', errors='ignore')
+                  imports.append(name.lower())
+              curr += 20
+
+          print(f'Imported DLLs: {imports}')
+          assert any('tk86' in imp or 'tk' in imp for imp in imports), f'Expected direct link to Tk DLL in PE imports, found: {imports}'
+          print('Verified: Direct link to Tk is active in PE imports.')
+          "
+
+      - name: Run tests (Windows Direct-Link)
+        run: |
+          micromamba run -n tkblend-tcltk-direct python -m pytest -v -m "not slow"
+

tkblend-0.4.0b1/.github/workflows/release.yml

@@ -0,0 +1,139 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build_sdist:
+    name: Build Source Distribution (sdist)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build
+        run: python -m pip install --upgrade build
+
+      - name: Build sdist
+        run: python -m build --sdist
+
+      - name: Upload sdist artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-sdist
+          path: dist/*.tar.gz
+
+  build_wheels:
+    name: Build Wheels (${{ matrix.os }} - ${{ matrix.cibw_archs }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            cibw_archs: "x86_64"
+          - os: ubuntu-latest
+            cibw_archs: "aarch64"
+            use_qemu: true
+          - os: macos-15-intel
+            cibw_archs: "x86_64"
+          - os: macos-14
+            cibw_archs: "arm64"
+          - os: windows-latest
+            cibw_archs: "AMD64"
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up QEMU
+        if: matrix.use_qemu
+        uses: docker/setup-qemu-action@v3
+        with:
+          platforms: arm64
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install macOS Tcl/Tk development files
+        if: runner.os == 'macOS'
+        run: |
+          brew install tcl-tk
+          echo "CMAKE_PREFIX_PATH=$(brew --prefix tcl-tk)" >> $GITHUB_ENV
+
+      - name: Install Windows Tcl/Tk development files
+        if: runner.os == 'Windows'
+        id: tcltk
+        uses: mamba-org/setup-micromamba@v3
+        with:
+          environment-name: tkblend-tcltk
+          create-args: >-
+            --channel conda-forge
+            tk=8.6.13
+          init-shell: none
+
+      - name: Set Windows CMake Prefix Path
+        if: runner.os == 'Windows'
+        run: |
+          echo "CMAKE_PREFIX_PATH=${{ steps.tcltk.outputs.environment-path }}/Library" >> $GITHUB_ENV
+
+      - name: Install cibuildwheel
+        run: python -m pip install cibuildwheel==2.22.0 delvewheel
+
+      - name: Build wheels via cibuildwheel
+        run: python -m cibuildwheel --output-dir wheelhouse
+        env:
+          CIBW_ARCHS: ${{ matrix.cibw_archs }}
+          CMAKE_PREFIX_PATH: ${{ steps.tcltk.outputs.environment-path && format('{0}/Library', steps.tcltk.outputs.environment-path) || '' }}
+          CIBW_ENVIRONMENT_WINDOWS: "CMAKE_PREFIX_PATH='${{ steps.tcltk.outputs.environment-path }}/Library'"
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-wheels-${{ matrix.os }}-${{ matrix.cibw_archs }}
+          path: wheelhouse/*.whl
+
+  github_release:
+    name: Create GitHub Release
+    needs: [build_sdist, build_wheels]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'workflow_dispatch'
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+          pattern: dist-*
+          merge-multiple: true
+
+      - name: List distribution files
+        run: |
+          ls -lh dist/
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*
+          generate_release_notes: true
+          draft: false
+          prerelease: ${{ contains(github.ref, 'b') || contains(github.ref, 'beta') || contains(github.ref, 'rc') || contains(github.ref, 'alpha') }}

tkblend-0.4.0b1/.gitignore

@@ -0,0 +1,49 @@
+# Python bytecode and caches
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.pyd
+*.dll
+*.dylib
+
+# Build directories and eggs
+build/
+dist/
+*.egg-info/
+.eggs/
+_skbuild/
+CMakeLocalConfig.cmake
+
+# Virtual environments
+.venv/
+env/
+venv/
+ENV/
+
+# Testing and coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+*.gcda
+*.gcno
+*.gcov
+
+# IDE and OS files
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+REFERENCE ONLY/
+tests/visual_baselines/
+CustomTkinter-6.0.0/
+snapshots/
+
+
+*.whl
+*.tar.*
+log/
+artifacts/
+screenshots/