yoga-python 0.1.0__tar.gz

yoga_python-0.1.0/.github/workflows/create-release.yml

@@ -0,0 +1,91 @@
+name: Create Release Tag
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_type:
+        description: 'Release type'
+        required: true
+        type: choice
+        options:
+          - patch
+          - minor
+          - major
+        default: patch
+
+jobs:
+  create-tag:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        token: ${{ secrets.RELEASE_TOKEN }}
+    
+    - name: Configure Git
+      run: |
+        git config user.name "${{ github.actor }}"
+        git config user.email "${{ github.actor }}@users.noreply.github.com"
+    
+    - name: Get current version and calculate next version
+      id: version
+      run: |
+        CURRENT_VERSION=$(grep "^version = " pyproject.toml | cut -d'"' -f2)
+        echo "Current version: $CURRENT_VERSION"
+        
+        if [ -z "$CURRENT_VERSION" ]; then
+          echo "Error: Could not extract version"
+          exit 1
+        fi
+        
+        IFS='.' read -r MAJOR MINOR PATCH <<< "$CURRENT_VERSION"
+        
+        RELEASE_TYPE="${{ inputs.release_type }}"
+        case $RELEASE_TYPE in
+          major)
+            NEW_MAJOR=$((MAJOR + 1)); NEW_MINOR=0; NEW_PATCH=0
+            ;;
+          minor)
+            NEW_MAJOR=$MAJOR; NEW_MINOR=$((MINOR + 1)); NEW_PATCH=0
+            ;;
+          patch)
+            NEW_MAJOR=$MAJOR; NEW_MINOR=$MINOR; NEW_PATCH=$((PATCH + 1))
+            ;;
+        esac
+        
+        NEW_VERSION="$NEW_MAJOR.$NEW_MINOR.$NEW_PATCH"
+        
+        echo "Current: $CURRENT_VERSION -> New: $NEW_VERSION ($RELEASE_TYPE)"
+        echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+        echo "new=$NEW_VERSION" >> $GITHUB_OUTPUT
+    
+    - name: Check if version already exists
+      run: |
+        VERSION="v${{ steps.version.outputs.new }}"
+        if git rev-parse "$VERSION" >/dev/null 2>&1; then
+          echo "Tag $VERSION already exists!"
+          exit 1
+        fi
+        echo "Tag $VERSION does not exist"
+    
+    - name: Update version in pyproject.toml
+      run: |
+        VERSION="${{ steps.version.outputs.new }}"
+        sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+        grep "^version = " pyproject.toml
+    
+    - name: Commit and push
+      run: |
+        git add pyproject.toml
+        git commit -m "chore: bump version to ${{ steps.version.outputs.new }}"
+        git push origin main
+    
+    - name: Create and push tag
+      run: |
+        VERSION="v${{ steps.version.outputs.new }}"
+        git tag -a "$VERSION" -m "Release $VERSION"
+        git push origin "$VERSION"
+        echo "Created tag $VERSION - this will trigger release workflow"

yoga_python-0.1.0/.github/workflows/quality.yml

@@ -0,0 +1,54 @@
+name: Code Quality
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+      
+    - name: Set up Python ${{ matrix.python-version }}
+      run: uv python install ${{ matrix.python-version }}
+      
+    - name: Install dependencies and build extension
+      run: uv sync --all-extras
+      
+    - name: Lint with ruff
+      run: |
+        uv run ruff check
+        uv run ruff format --check
+        
+    - name: Type check with pyright
+      run: uv run pyright
+      
+    - name: Run tests
+      run: |
+        uv run pytest tests/ -v --tb=short --cov=src/yoga --cov-report=term-missing --cov-report=xml
+        
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      if: matrix.python-version == '3.12'
+      with:
+        file: ./coverage.xml
+        flags: unittests
+        name: codecov-umbrella
+        fail_ci_if_error: false
+
+  quality-check:
+    runs-on: ubuntu-latest
+    needs: quality
+    steps:
+      - name: All quality checks passed
+        run: echo "✅ All quality checks passed!"

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

@@ -0,0 +1,159 @@
+name: 🚀 Release to PyPI and GitHub
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release (e.g., 0.1.0)'
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-validate:
+    name: 🏗️ Build and Validate Package
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+
+    - name: Install uv
+      uses: astral-sh/setup-uv@v4
+      
+    - name: Set up Python
+      run: uv python install 3.12
+        
+    - name: Install Python build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install twine check-wheel-contents validate-pyproject auditwheel
+
+    - name: Validate pyproject.toml
+      run: validate-pyproject pyproject.toml
+
+    - name: Build Python package
+      run: uv build
+
+    - name: Repair Linux wheel for PyPI (manylinux tag)
+      run: |
+        for whl in dist/*linux_x86_64.whl dist/*linux_aarch64.whl; do
+          [ -f "$whl" ] || continue
+          auditwheel repair "$whl" -w dist
+          rm -f "$whl"
+        done
+
+    - name: Validate package contents
+      run: |
+        echo "📦 Validating package structure..."
+        check-wheel-contents dist/*.whl --ignore W004,W005,W009,W010
+
+        echo "📋 Package contents summary:"
+        python -m zipfile -l dist/*.whl | grep -E "\.py$|\.so$" | head -25
+        echo "..."
+    
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+        retention-days: 7
+
+  publish-to-testpypi:
+    name: 🧪 Publish to TestPyPI
+    needs: [build-and-validate]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch'
+    environment:
+      name: test-pypi
+      url: https://test.pypi.org/p/yoga-python
+    permissions:
+      id-token: write  # OIDC trusted publishing
+    
+    steps:
+    - name: Download package distributions
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    
+    - name: Publish to TestPyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/
+        print-hash: true
+
+  publish-to-pypi:
+    name: 🚀 Publish to PyPI
+    needs: [build-and-validate]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/yoga-python
+    permissions:
+      id-token: write  # OIDC trusted publishing
+      contents: write  # For GitHub release creation
+    
+    steps:
+    - name: Download package distributions
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        print-hash: true
+
+  create-github-release:
+    name: 📋 Create GitHub Release
+    needs: [publish-to-pypi]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    permissions:
+      contents: write
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Download package distributions
+      uses: actions/download-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+    
+    - name: Determine release type
+      id: release-type
+      run: |
+        if [[ ${{ github.ref_name }} =~ -alpha|-beta|-rc ]]; then
+          echo "prerelease=true" >> $GITHUB_OUTPUT
+        else
+          echo "prerelease=false" >> $GITHUB_OUTPUT
+        fi
+    
+    - name: Create GitHub Release
+      run: |
+        gh release create ${{ github.ref_name }} \
+          --title "yoga-python ${{ github.ref_name }}" \
+          --generate-notes \
+          ${{ steps.release-type.outputs.prerelease == 'true' && '--prerelease' || '--latest' }} \
+          dist/*
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

yoga_python-0.1.0/.gitignore

@@ -0,0 +1,30 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv/
+
+# Cache directories
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+
+# Build artifacts
+*.so
+*.cmake/
+CMakeFiles/
+CMakeCache.txt
+build_test/
+src/yoga/*.so
+src/yoga/CMakeInit.txt
+src/yoga/install_manifest.txt
+src/yoga/__pycache__/
+
+# Reference C++ code (used for porting, not part of this repo)
+reference/
+

yoga_python-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

yoga_python-0.1.0/CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.15)
+project(yoga_python)
+
+# Allow FetchContent_Populate (we use it to add only inner yoga, not root install)
+if(POLICY CMP0169)
+  cmake_policy(SET CMP0169 OLD)
+endif()
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(PYBIND11_FINDPYTHON ON)
+
+set(yoga_BUILD_TESTS OFF CACHE BOOL "Build Yoga tests" FORCE)
+
+# Use local reference yoga if present, otherwise fetch from GitHub
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/reference/yoga/CMakeLists.txt)
+  message(STATUS "Using local reference yoga")
+  find_package(pybind11 REQUIRED)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/reference/yoga ${CMAKE_BINARY_DIR}/yoga-build EXCLUDE_FROM_ALL)
+else()
+  message(STATUS "Fetching yoga from GitHub...")
+  include(FetchContent)
+  FetchContent_Declare(
+    yoga
+    GIT_REPOSITORY https://github.com/facebook/yoga.git
+    GIT_TAG cfdacac0e3c2e91ab15939027688756271a66025
+    GIT_PROGRESS TRUE
+  )
+  # Populate but do not add root project (avoids root install of include/lib).
+  # We only add the inner yoga library so we get yogacore without extra installs.
+  FetchContent_GetProperties(yoga)
+  if(NOT yoga_POPULATED)
+    FetchContent_Populate(yoga)
+  endif()
+  set(_yoga_root ${yoga_SOURCE_DIR})
+  set(yoga_SOURCE_DIR ${_yoga_root}/yoga)
+  set(yoga_BUILD_TESTS OFF CACHE BOOL "Build Yoga tests" FORCE)
+  add_subdirectory(${yoga_SOURCE_DIR} ${CMAKE_BINARY_DIR}/yoga-build EXCLUDE_FROM_ALL)
+endif()
+
+find_package(pybind11 REQUIRED)
+pybind11_add_module(yoga src/yoga/yoga.cpp)
+target_include_directories(yoga PRIVATE ${yoga_SOURCE_DIR})
+target_link_libraries(yoga PRIVATE yogacore)
+
+# Install the compiled extension to the yoga package directory
+install(TARGETS yoga DESTINATION "yoga")

yoga_python-0.1.0/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.2
+Name: yoga-python
+Version: 0.1.0
+Summary: Python binding for Facebook Yoga layout engine
+Requires-Python: >=3.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Requires-Dist: ruff>=0.3; extra == "dev"
+Description-Content-Type: text/markdown
+
+# yoga-python
+
+Python bindings for [Facebook's Yoga](https://github.com/facebook/yoga) layout engine — a cross-platform implementation of [CSS Flexbox](https://www.w3.org/TR/css-flexbox-1/).
+
+Yoga computes a layout tree of nodes with flexbox styles and outputs pixel-perfect positions. This package wraps the full C++ engine via [pybind11](https://github.com/pybind/pybind11), giving you the same layout behavior you get in React Native, Litho, and other Yoga-backed frameworks — directly from Python.
+
+## Installation
+
+```bash
+pip install yoga-python
+```
+
+Building from source requires a C++20 compiler, CMake 3.15+, and pybind11:
+
+```bash
+pip install scikit-build-core pybind11
+pip install .
+```
+
+## Quick start
+
+```python
+from yoga import (
+    Node, Config, Direction, FlexDirection, Justify,
+    Align, Edge, YGValuePoint, YGValuePercent,
+)
+
+root = Node()
+root.flex_direction = FlexDirection.Row
+root.width = YGValuePoint(300)
+root.height = YGValuePoint(200)
+root.set_padding(Edge.All, 10)
+
+child_a = Node()
+child_a.flex_grow = 1
+child_a.set_margin(Edge.Right, 10)
+root.insert_child(child_a, 0)
+
+child_b = Node()
+child_b.flex_grow = 2
+root.insert_child(child_b, 1)
+
+root.calculate_layout(300, 200, Direction.LTR)
+
+print(f"child_a: {child_a.layout_left}, {child_a.layout_top}, "
+      f"{child_a.layout_width}x{child_a.layout_height}")
+# child_a: 10.0, 10.0, 90.0x180.0
+
+print(f"child_b: {child_b.layout_left}, {child_b.layout_top}, "
+      f"{child_b.layout_width}x{child_b.layout_height}")
+# child_b: 110.0, 10.0, 180.0x180.0
+```
+
+## API overview
+
+### Node
+
+The primary object. Create nodes, configure their styles, build a tree, then call `calculate_layout`.
+
+```python
+node = Node()           # default config
+node = Node(config)     # with explicit config
+```
+
+**Style properties** (set directly as attributes):
+
+| Property | Type | Example |
+|---|---|---|
+| `flex_direction` | `FlexDirection` | `node.flex_direction = FlexDirection.Row` |
+| `justify_content` | `Justify` | `node.justify_content = Justify.Center` |
+| `align_items` | `Align` | `node.align_items = Align.Stretch` |
+| `align_self` | `Align` | `node.align_self = Align.FlexEnd` |
+| `align_content` | `Align` | `node.align_content = Align.SpaceBetween` |
+| `flex_wrap` | `Wrap` | `node.flex_wrap = Wrap.Wrap` |
+| `overflow` | `Overflow` | `node.overflow = Overflow.Hidden` |
+| `display` | `Display` | `node.display = Display.Flex` |
+| `position_type` | `PositionType` | `node.position_type = PositionType.Absolute` |
+| `flex_grow` | `float` | `node.flex_grow = 1.0` |
+| `flex_shrink` | `float` | `node.flex_shrink = 0.0` |
+| `flex_basis` | `YGValue` | `node.flex_basis = YGValuePoint(100)` |
+| `width` / `height` | `YGValue` | `node.width = YGValuePercent(50)` |
+| `min_width` / `max_width` | `YGValue` | `node.min_width = YGValuePoint(80)` |
+| `min_height` / `max_height` | `YGValue` | `node.max_height = YGValuePoint(400)` |
+| `aspect_ratio` | `float` | `node.aspect_ratio = 16 / 9` |
+| `box_sizing` | `BoxSizing` | `node.box_sizing = BoxSizing.ContentBox` |
+| `direction` | `Direction` | `node.direction = Direction.LTR` |
+
+**Edge-based properties** (margin, padding, border, position):
+
+```python
+node.set_margin(Edge.Left, 10)           # points
+node.set_margin(Edge.Top, YGValuePercent(5))  # percent
+node.set_padding(Edge.All, 20)
+node.set_border(Edge.Bottom, 1)
+node.set_position(Edge.Left, YGValuePoint(50))
+```
+
+**Tree manipulation:**
+
+```python
+node.insert_child(child, index)
+node.remove_child(child)
+node.remove_all_children()
+node.set_children([child_a, child_b])
+node.child_count                     # int
+node[index]                          # Node (supports indexing)
+```
+
+**Layout:**
+
+```python
+node.calculate_layout(width, height, Direction.LTR)
+
+node.layout_left       # float
+node.layout_top        # float
+node.layout_width      # float
+node.layout_height     # float
+node.layout_direction  # Direction
+node.layout_margin(Edge.Left)   # float
+node.layout_padding(Edge.Top)   # float
+node.layout_border(Edge.Right)  # float
+```
+
+**Measure functions** for leaf nodes with custom content sizing:
+
+```python
+def measure(node, width, width_mode, height, height_mode):
+    return {"width": 100, "height": 50}
+
+node.set_measure_func(measure)
+```
+
+**Baseline functions** for custom baseline alignment:
+
+```python
+def baseline(node, width, height):
+    return height * 0.8
+
+node.set_baseline_func(baseline)
+```
+
+### Config
+
+```python
+config = Config()
+config.use_web_defaults = True
+config.point_scale_factor = 2.0
+config.errata = Errata.StretchFlexBasis
+```
+
+### Values
+
+```python
+YGValuePoint(100)       # 100px
+YGValuePercent(50)      # 50%
+YGValueAuto             # auto
+YGValueUndefined        # undefined
+```
+
+## Enums
+
+All Yoga enums are available as Python enum types (pybind11 enums, int-convertible):
+
+`Direction`, `FlexDirection`, `Justify`, `Align`, `PositionType`, `Wrap`, `Overflow`, `Display`, `Edge`, `Unit`, `MeasureMode`, `Dimension`, `BoxSizing`, `Gutter`, `Errata`, `NodeType`, `LogLevel`, `ExperimentalFeature`
+
+## Development
+
+```bash
+git clone https://github.com/banditburai/yoga-python.git
+cd yoga-python
+uv sync --dev
+
+# Run tests
+uv run pytest tests/ -v
+
+# Lint & type checking
+uv run ruff check
+uv run ruff format --check
+uv run pyright
+```
+
+## Test coverage
+
+The test suite is a 1:1 port of the [Yoga C++ test suite](https://github.com/facebook/yoga/tree/main/tests) — 822 tests covering all layout modes, edge cases, and behaviors. Tests that the C++ suite itself skips (`GTEST_SKIP`) are also skipped in Python.
+
+## License
+
+MIT — same as [Yoga](https://github.com/facebook/yoga/blob/main/LICENSE).