slikui-python 0.1.1__tar.gz

slikui_python-0.1.1/.github/workflows/cpp.yml

@@ -0,0 +1,79 @@
+name: cpp
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: cpp-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  tests:
+    name: ${{ matrix.os }} / ${{ matrix.cxx }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, cc: gcc, cxx: g++ }
+          - { os: ubuntu-latest, cc: clang, cxx: clang++ }
+          - { os: macos-latest, cc: clang, cxx: clang++ }
+          - { os: windows-latest, cc: msvc, cxx: msvc }
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: set compilers
+        if: matrix.cc != 'msvc'
+        shell: bash
+        run: |
+          echo "CC=${{ matrix.cc }}" >> "$GITHUB_ENV"
+          echo "CXX=${{ matrix.cxx }}" >> "$GITHUB_ENV"
+
+      # Examples pull in GLFW/OpenGL system deps; CI exercises the library
+      # itself. The GL/GLFW backends get a dedicated compile check below.
+      - name: configure
+        run: cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DSLIKUI_BUILD_EXAMPLES=OFF
+
+      - name: build
+        run: cmake --build build --config Release --parallel
+
+      - name: test
+        run: ctest --test-dir build --output-on-failure -C Release
+
+  # Every public header must compile standalone — apple-libc++ hides missing
+  # std includes (cstdint, functional, ...) that libstdc++/MSVC reject.
+  headers:
+    name: every header compiles standalone (linux/gcc)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      # opengl.hpp includes the system <GL/gl.h> unconditionally; GLFW makes
+      # glfw_window.hpp compile its real body instead of self-gating to empty.
+      - name: install dev headers
+        run: sudo apt-get update && sudo apt-get install -y libgl-dev libglfw3-dev
+      - name: standalone header check
+        run: ./tools/check_headers.sh
+        env:
+          CXX: g++
+
+  # Compile-only smoke for the windowing/GL backends: they self-gate on
+  # __has_include(<GLFW/glfw3.h>), so without dev headers installed they
+  # silently compile to nothing and rot. Install them and force the check.
+  gl-backends:
+    name: GL/GLFW backends compile (linux)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: install dev headers
+        run: sudo apt-get update && sudo apt-get install -y libglfw3-dev libgl1-mesa-dev
+      - name: syntax-check backend headers
+        shell: bash
+        run: |
+          cat > /tmp/backends.cpp <<'EOF'
+          #include <slikui/backends/glfw/glfw_window.hpp>
+          #include <slikui/backends/opengl/opengl.hpp>
+          int main() { return 0; }
+          EOF
+          clang++ -std=c++20 -Iinclude -fsyntax-only /tmp/backends.cpp

slikui_python-0.1.1/.github/workflows/python.yml

@@ -0,0 +1,128 @@
+name: python
+
+on:
+  push:
+    branches: [main]
+    tags: ['v*']
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: python-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  sdist:
+    name: sdist + wheel-from-sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: build sdist
+        run: |
+          python -m pip install build
+          python -m build --sdist --outdir dist .
+
+      - name: build a wheel FROM the sdist
+        run: |
+          python -m pip wheel --no-deps -w wheelhouse dist/*.tar.gz
+          python -m pip install wheelhouse/*.whl
+          python -c "import slikui; print('sdist round-trip OK,', slikui.__version__)"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+
+  wheels:
+    name: wheels ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest }     # linux x86_64
+          - { os: ubuntu-24.04-arm }  # linux aarch64
+          - { os: macos-latest }      # macOS arm64 (no x86_64: Intel Macs build from the sdist)
+          - { os: windows-latest }    # windows amd64
+    env:
+      CIBW_BUILD: "cp310-* cp311-* cp312-* cp313-* cp314-*"
+      # gcc 13 on manylinux_2_28 — C++20 needs more than 2014's devtoolset
+      CIBW_MANYLINUX_X86_64_IMAGE: manylinux_2_28
+      CIBW_MANYLINUX_AARCH64_IMAGE: manylinux_2_28
+      CIBW_TEST_REQUIRES: "pytest numpy"
+      CIBW_TEST_COMMAND: "python -m pytest {package}/python/tests -q"
+      CIBW_BUILD_VERBOSITY: 1
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: build + test wheels
+        uses: pypa/cibuildwheel@v3.4
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.os }}
+          path: wheelhouse/*.whl
+
+  # Tag push (v*) -> GitHub Release with the sdist + every wheel attached;
+  # the pypi job below then uploads the same files to PyPI.
+  release:
+    name: GitHub Release
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [sdist, wheels]          # every platform built and tested, or no release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write               # create the release + upload assets
+    steps:
+      - uses: actions/checkout@v4
+
+      # Not into dist/: that's the tracked folder holding the amalgamated
+      # C++ headers (attached to the release explicitly below).
+      - uses: actions/download-artifact@v4
+        with:
+          path: packages
+          merge-multiple: true      # sdist + wheels-* -> one flat folder
+
+      # The built files carry the version from include/slikui/version.hpp (via
+      # the pyproject regex provider) in their names; the tag must agree.
+      - name: tag must match package version
+        run: |
+          v="${GITHUB_REF_NAME#v}"
+          bad=$(ls packages | grep -v -e "^slikui_python-$v\.tar\.gz$" -e "^slikui_python-$v-.*\.whl$" || true)
+          if [ ! -f "packages/slikui_python-$v.tar.gz" ] || [ -n "$bad" ]; then
+            echo "::error::tag $GITHUB_REF_NAME does not match the built version (include/slikui/version.hpp)"
+            ls packages
+            exit 1
+          fi
+
+      - name: create release
+        run: |
+          ls -l packages dist
+          gh release create "$GITHUB_REF_NAME" packages/* dist/slikui.hpp dist/slikui_default_font.hpp \
+            --generate-notes --verify-tag
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+  # Tag push (v*) -> upload the same sdist + wheels to PyPI via Trusted
+  # Publishing (OIDC): no stored token. PyPI must list this repo, workflow
+  # python.yml and environment "pypi" as a trusted publisher for slikui-python.
+  pypi:
+    name: publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [release]                # tag/version check passed, GitHub Release exists
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/slikui-python
+    permissions:
+      id-token: write               # mint the OIDC token PyPI exchanges for an upload token
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true      # sdist + wheels-* -> one flat folder
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

slikui_python-0.1.1/.gitignore

@@ -0,0 +1,14 @@
+build/
+build-asan/
+.cache/
+.venv/
+.jimbo/
+python/build/
+__pycache__/
+*.pyc
+.pytest_cache/
+.DS_Store
+compile_commands.json
+shots/
+hello_raw.ppm
+.venv-asan/

slikui_python-0.1.1/CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 3.20)
+
+# Version comes from include/slikui/version.hpp — the single source of truth
+# for C++ and Python alike.
+set(_slikui_version "")
+foreach(_part MAJOR MINOR PATCH)
+  file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/slikui/version.hpp" _line
+       REGEX "^#define SLIKUI_VERSION_${_part} [0-9]+$")
+  if(NOT _line)
+    message(FATAL_ERROR "SLIKUI_VERSION_${_part} not found in include/slikui/version.hpp")
+  endif()
+  string(REGEX REPLACE "^#define SLIKUI_VERSION_${_part} ([0-9]+)$" "\\1" _num "${_line}")
+  list(APPEND _slikui_version "${_num}")
+endforeach()
+list(JOIN _slikui_version "." _slikui_version)
+
+project(slikui VERSION "${_slikui_version}" LANGUAGES CXX)
+message(STATUS "slikui ${PROJECT_VERSION}")
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(slikui INTERFACE)
+target_include_directories(slikui INTERFACE
+  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:include>)
+target_compile_features(slikui INTERFACE cxx_std_20)
+
+option(SLIKUI_BUILD_TESTS "Build slikui tests" ON)
+option(SLIKUI_BUILD_EXAMPLES "Build slikui examples" ON)
+
+if(SKBUILD)
+  # Python wheel build (scikit-build-core): only the bindings, which install
+  # into the wheel — the install/export rules below don't apply.
+  add_subdirectory(python)
+else()
+  if(SLIKUI_BUILD_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+  endif()
+
+  if(SLIKUI_BUILD_EXAMPLES)
+    add_subdirectory(examples)
+  endif()
+
+  # --- install / export: FetchContent / find_package(slikui) support ---
+  include(GNUInstallDirs)
+  include(CMakePackageConfigHelpers)
+
+  install(TARGETS slikui EXPORT slikuiTargets)
+  install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+
+  set(SLIKUI_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/slikui")
+  install(EXPORT slikuiTargets
+          FILE slikuiTargets.cmake
+          NAMESPACE slikui::
+          DESTINATION "${SLIKUI_INSTALL_CMAKEDIR}")
+
+  configure_package_config_file(
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/slikuiConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/slikuiConfig.cmake"
+    INSTALL_DESTINATION "${SLIKUI_INSTALL_CMAKEDIR}")
+  write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/slikuiConfigVersion.cmake"
+    VERSION "${PROJECT_VERSION}"
+    COMPATIBILITY SameMajorVersion)
+  install(FILES
+          "${CMAKE_CURRENT_BINARY_DIR}/slikuiConfig.cmake"
+          "${CMAKE_CURRENT_BINARY_DIR}/slikuiConfigVersion.cmake"
+          DESTINATION "${SLIKUI_INSTALL_CMAKEDIR}")
+endif()

slikui_python-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 slikui contributors
+
+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.

slikui_python-0.1.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: slikui-python
+Version: 0.1.1
+Summary: Python bindings for slikui — a header-only C++20 UI library
+Author: slikui contributors
+License-Expression: MIT
+License-File: LICENSE
+License-File: third_party/fonts/LICENSE-DejaVu.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: User Interfaces
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://github.com/jamesgregson/slikui
+Project-URL: Documentation, https://github.com/jamesgregson/slikui/tree/main/python
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Provides-Extra: demo
+Requires-Dist: glfw>=2.5; extra == "demo"
+Requires-Dist: PyOpenGL; extra == "demo"
+Description-Content-Type: text/markdown
+
+# slikui — Python bindings for slikui
+
+Install from PyPI · import `slikui` · compiled module `slikui._slikui`.
+
+```sh
+pip install slikui-python
+```
+
+pip picks the wheel matching your OS, CPU and Python (3.10–3.14 on Linux
+x86_64/aarch64, macOS arm64, Windows x64). No wheel for your platform (e.g.
+Intel macOS)? pip builds from the sdist instead — that needs a C++20 compiler.
+
+The same wheels and sdist are attached to every
+[GitHub Release](https://github.com/jamesgregson/slikui/releases).
+
+Headless, testable UI: the software rasterizer renders into a `numpy`
+framebuffer — no window, no GPU, no event loop required.
+
+```python
+import slikui
+
+ui = slikui.App(320, 200)                     # Target + Sink + Context + font (system, else bundled)
+root = ui.set_root(slikui.Column, padding=16, gap=8)
+root.add(slikui.Label, "Hello, slikui!", font_size=26)
+root.add(slikui.Button, "Save", variant=slikui.ButtonVariant.Primary)
+
+ui.tick(0.0, 1 / 60)                        # layout + animation
+frame = ui.render()                         # zero-copy np.ndarray (H, W) uint32
+```
+
+`App.close()` — also run by `with App(...)` and automatically at exit —
+destroys the tree and releases Python callbacks it holds, so shutdown is
+leak-free even when callbacks capture widget wrappers.
+
+Build from source (the C++ side is header-only, nothing to link):
+
+```
+pip install -e .                # editable, into your venv — from the repo root
+python -m pytest python/tests   # 38 tests: widgets, events, renderer parity
+python python/examples/hello.py # writes hello.ppm
+```
+
+Events are first-class: build slikui events in Python and drive the real
+dispatch path (see `python/tests/test_events.py`):
+
+```python
+ui.handle(slikui.mouse_press((60, 40)))   # click through hit-testing
+ui.handle(slikui.text_input("h"))         # into the focused TextField
+ui.handle(slikui.scroll(pos, (0, -1)))    # wheel, "ctrl+shift" mods supported
+```
+
+Interactive demo — a Python-native GLFW + OpenGL host with the slikui software
+rasterizer as the UI layer (`pip install glfw PyOpenGL`):
+
+```
+python python/examples/glfw_demo.py
+```
+
+Lit cube/sphere/torus over a procedural sky; the controls panel is rasterized
+on the CPU into a `uint32` buffer and blended over the GL scene as one
+texture. Drag orbits, wheel zooms, the panel edits material/sky/light/camera.
+
+**Your own renderer.** `slikui.RenderSink` is a trampoline over C++
+`IRenderSink`: subclass it, implement `upload(tex)` and `render(commands,
+fb_size)`, and slikui hands you every frame as a flat command list — point it at
+pygame, moderngl, PIL, anything. `slikui.CanvasSink` is a worked example: a
+pure-numpy rasterizer that produces **pixel-identical** output to the C++
+software backend (same blend/SDF/sampling math, verified by test):
+
+```python
+sink = slikui.CanvasSink(320, 240)
+ctx = slikui.Context(sink)          # any RenderSink subclass works here
+ctx.set_frame_size(320, 240)
+ctx.load_default_font()           # bundled DejaVu Sans subset; or load_font_file(path)
+# ... build the tree, tick ...
+ctx.render()
+frame = sink.buffer               # (240, 320) uint32, 0xAABBGGRR
+```
+
+See it side by side: `python python/examples/pyrenderer_demo.py` renders one
+tree through both renderers and reports the pixel diff (it is 0).
+
+Design and milestones: `docs/python-bindings-plan.md` — M0 (values, software
+backend, core widgets), M1 (full widget surface + themes) and M2 (events,
+popups, tooltips, simulated-input tests) are done; M3 (wheels/CI/docs) and
+M4 (GLFW+GL backend bindings) are tabled.