session-py 0.1.3__tar.gz

session_py-0.1.3/.github/workflows/publish.yml

@@ -0,0 +1,71 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install and test
+        run: |
+          pip install -e ".[dev]"
+          pytest
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/session_py
+    permissions:
+      id-token: write   # PyPI trusted publisher
+      contents: write   # create GitHub releases + tags
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Set version
+        run: echo "VERSION=0.1.${{ github.run_number }}" >> $GITHUB_ENV
+
+      - name: Patch pyproject.toml version
+        run: sed -i "s/^version = .*/version = \"$VERSION\"/" pyproject.toml
+
+      - name: Commit version bump
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add pyproject.toml
+          git commit -m "chore: bump version to $VERSION [skip ci]"
+          git push
+
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ env.VERSION }}
+          name: v${{ env.VERSION }}
+          files: dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

session_py-0.1.3/.gitignore

@@ -0,0 +1,27 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+.Python
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+venv/
+env/
+ENV/
+uvsession/
+session/
+
+# Documentation
+docs_output/
+_build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store

session_py-0.1.3/.gitmodules

@@ -0,0 +1,6 @@
+[submodule "session_proto"]
+	path = session_proto
+	url = https://github.com/petrasvestartas/session_proto.git
+[submodule "session_data"]
+	path = session_data
+	url = https://github.com/petrasvestartas/session_data.git

session_py-0.1.3/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: session_py
+Version: 0.1.3
+Summary: A minimal Python geometry library
+Project-URL: Homepage, https://github.com/petrasvestartas/session_py
+Project-URL: Repository, https://github.com/petrasvestartas/session_py
+Author-email: Petras Vestartas <petrasvestartas@gmail.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Requires-Dist: grpcio-tools>=1.60.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: protobuf>=5.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: performance
+Requires-Dist: numba>=0.56.0; extra == 'performance'
+Description-Content-Type: text/markdown
+
+# session_py
+
+Python NURBS geometry library.
+
+## Setup
+
+```bash
+# Create environment
+uv venv uvsession --python 3.11
+source uvsession/bin/activate
+
+# Install
+uv pip install -e .
+```
+
+## Test
+
+```bash
+source uvsession/bin/activate
+pytest -v
+```
+
+## Publish
+
+```bash
+    Edit pyproject.toml version: "0.1.0" → "0.1.1"
+    cd session_py
+    git add pyproject.toml .github/
+    git commit -m "setup PyPI publish workflow"
+    git tag v0.1.0
+    git push && git push --tags
+```

session_py-0.1.3/README.md

@@ -0,0 +1,32 @@
+# session_py
+
+Python NURBS geometry library.
+
+## Setup
+
+```bash
+# Create environment
+uv venv uvsession --python 3.11
+source uvsession/bin/activate
+
+# Install
+uv pip install -e .
+```
+
+## Test
+
+```bash
+source uvsession/bin/activate
+pytest -v
+```
+
+## Publish
+
+```bash
+    Edit pyproject.toml version: "0.1.0" → "0.1.1"
+    cd session_py
+    git add pyproject.toml .github/
+    git commit -m "setup PyPI publish workflow"
+    git tag v0.1.0
+    git push && git push --tags
+```

session_py-0.1.3/doc.bat

@@ -0,0 +1,40 @@
+@echo off
+REM Script to build session_py documentation using Sphinx
+
+echo Building session_py documentation...
+
+REM Change to docs directory
+cd docs
+
+REM Clean previous build
+echo Cleaning previous build...
+if exist _build rmdir /s /q _build
+if exist Makefile.bat (
+    call make.bat clean
+) else (
+    sphinx-build -M clean . _build
+)
+
+REM Build HTML documentation
+echo Building HTML documentation...
+if exist Makefile.bat (
+    call make.bat html
+) else (
+    sphinx-build -M html . _build
+)
+
+if %errorlevel% equ 0 (
+    REM Copy built HTML to a stable output directory used by CI deployment
+    if exist ..\docs_output\html rmdir /s /q ..\docs_output\html
+    if not exist ..\docs_output mkdir ..\docs_output
+    xcopy /e /i _build\html ..\docs_output\html
+    echo.
+    echo Documentation built successfully!
+    echo Open docs_output\html\index.html in your browser to view the documentation.
+    echo.
+    echo To serve locally, run:
+    echo   cd docs_output\html ^&^& python -m http.server 8000
+) else (
+    echo Build failed!
+    exit /b 1
+)

session_py-0.1.3/doc.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+# Script to build session_py documentation using Sphinx
+
+echo "Building session_py documentation..."
+
+# Change to docs directory
+cd docs
+
+# Clean previous build
+echo "Cleaning previous build..."
+make clean
+
+# Build HTML documentation
+echo "Building HTML documentation..."
+make html
+
+if [ $? -eq 0 ]; then
+    # Copy built HTML to a stable output directory used by CI deployment
+    rm -rf ../docs_output/html
+    mkdir -p ../docs_output
+    cp -r _build/html ../docs_output/
+    echo ""
+    echo "Documentation built successfully!"
+    echo "Open docs_output/html/index.html in your browser to view the documentation."
+    echo ""
+    echo "To serve locally, run:"
+    echo "  cd docs_output/html && python -m http.server 8000"
+else
+    echo "Build failed!"
+    exit 1
+fi

session_py-0.1.3/examples/bvh_demo.py

@@ -0,0 +1,174 @@
+"""BVH Collision Detection Demo
+
+This example demonstrates how to use the BVH (Boundary Volume Hierarchy)
+for efficient collision detection among many objects.
+"""
+
+import random
+import time
+from session_py import BVH, BoundingBox, Point, Vector
+
+
+def create_random_boxes(count, world_size=100.0, min_size=0.5, max_size=3.0):
+    """Create random bounding boxes in 3D space.
+
+    Parameters
+    ----------
+    count : int
+        Number of boxes to create.
+    world_size : float
+        Size of the world bounds.
+    min_size : float
+        Minimum box dimension.
+    max_size : float
+        Maximum box dimension.
+
+    Returns
+    -------
+    list of BoundingBox
+        List of randomly positioned and sized bounding boxes.
+    """
+    boxes = []
+    for i in range(count):
+        # Random center position
+        center = Point(
+            random.uniform(-world_size / 2, world_size / 2),
+            random.uniform(-world_size / 2, world_size / 2),
+            random.uniform(-world_size / 2, world_size / 2),
+        )
+
+        # Random half-size (dimensions)
+        half_size = Vector(
+            random.uniform(min_size, max_size) / 2,
+            random.uniform(min_size, max_size) / 2,
+            random.uniform(min_size, max_size) / 2,
+        )
+
+        # Create axis-aligned bounding box
+        bbox = BoundingBox(
+            center,
+            Vector(1, 0, 0),  # X axis
+            Vector(0, 1, 0),  # Y axis
+            Vector(0, 0, 1),  # Z axis
+            half_size,
+        )
+        boxes.append(bbox)
+
+    return boxes
+
+
+def naive_collision_detection(boxes):
+    """Naive O(n²) collision detection for comparison.
+
+    Parameters
+    ----------
+    boxes : list of BoundingBox
+        List of bounding boxes to check.
+
+    Returns
+    -------
+    tuple
+        (collisions, check_count) where collisions is a list of (i, j) pairs.
+    """
+    collisions = []
+    check_count = 0
+
+    for i in range(len(boxes)):
+        for j in range(i + 1, len(boxes)):
+            check_count += 1
+            # Simple AABB intersection test
+            box1 = boxes[i]
+            box2 = boxes[j]
+
+            min1_x = box1.center.x - box1.half_size.x
+            max1_x = box1.center.x + box1.half_size.x
+            min2_x = box2.center.x - box2.half_size.x
+            max2_x = box2.center.x + box2.half_size.x
+
+            min1_y = box1.center.y - box1.half_size.y
+            max1_y = box1.center.y + box1.half_size.y
+            min2_y = box2.center.y - box2.half_size.y
+            max2_y = box2.center.y + box2.half_size.y
+
+            min1_z = box1.center.z - box1.half_size.z
+            max1_z = box1.center.z + box1.half_size.z
+            min2_z = box2.center.z - box2.half_size.z
+            max2_z = box2.center.z + box2.half_size.z
+
+            if (
+                min1_x <= max2_x
+                and max1_x >= min2_x
+                and min1_y <= max2_y
+                and max1_y >= min2_y
+                and min1_z <= max2_z
+                and max1_z >= min2_z
+            ):
+                collisions.append((i, j))
+
+    return collisions, check_count
+
+
+def main():
+    """Run BVH collision detection demo."""
+    print("=" * 60)
+    print("BVH Collision Detection Demo")
+    print("=" * 60)
+
+    # Set random seed for reproducibility
+    random.seed(42)
+
+    # Test with different box counts
+    box_counts = [10, 50, 100, 500, 1000]
+
+    for count in box_counts:
+        print(f"\n--- Testing with {count} boxes ---")
+
+        # Create random boxes
+        boxes = create_random_boxes(count, world_size=100.0)
+
+        # Build BVH
+        bvh = BVH(world_size=100.0)
+        start_time = time.time()
+        bvh.build(boxes)
+        build_time = (time.time() - start_time) * 1000  # Convert to ms
+
+        # BVH collision detection
+        start_time = time.time()
+        bvh_collisions, bvh_checks = bvh.check_all_collisions(boxes)
+        bvh_time = (time.time() - start_time) * 1000  # Convert to ms
+
+        # Naive collision detection (only for smaller counts)
+        if count <= 100:
+            start_time = time.time()
+            naive_collisions, naive_checks = naive_collision_detection(boxes)
+            naive_time = (time.time() - start_time) * 1000
+
+            # Verify results match
+            assert len(bvh_collisions) == len(
+                naive_collisions
+            ), f"Collision count mismatch: BVH={len(bvh_collisions)}, Naive={len(naive_collisions)}"
+
+            speedup = naive_time / bvh_time if bvh_time > 0 else float("inf")
+            check_reduction = (
+                (1 - bvh_checks / naive_checks) * 100 if naive_checks > 0 else 0
+            )
+
+            print(f"  Collisions found: {len(bvh_collisions)}")
+            print(f"  BVH build time: {build_time:.2f} ms")
+            print(f"  BVH check time: {bvh_time:.2f} ms ({bvh_checks:,} checks)")
+            print(f"  Naive check time: {naive_time:.2f} ms ({naive_checks:,} checks)")
+            print(f"  Speedup: {speedup:.1f}x")
+            print(f"  Check reduction: {check_reduction:.1f}%")
+        else:
+            print(f"  Collisions found: {len(bvh_collisions)}")
+            print(f"  BVH build time: {build_time:.2f} ms")
+            print(f"  BVH check time: {bvh_time:.2f} ms ({bvh_checks:,} checks)")
+            print(f"  (Naive method skipped for performance)")
+
+    print("\n" + "=" * 60)
+    print("Demo complete!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

session_py-0.1.3/examples/nurbsurface.py

@@ -0,0 +1,153 @@
+from session_py import NurbsSurface, Point
+from compas_viewer import Viewer
+from compas.datastructures import Mesh
+from compas.geometry import Point as CompasPoint, Polyline
+
+# Create a NURBS surface (3D, order 4, 5x5 control points)
+srf = NurbsSurface(3, False, 4, 4, 5, 5)
+
+# Setup knot vectors
+srf.make_clamped_uniform_knot_vector(0, 1.0)
+srf.make_clamped_uniform_knot_vector(1, 1.0)
+
+# Set control points (hardcoded 5x5 grid)
+srf.set_cv(0, 0, Point(0.0, 0.0, 2.5*-1))
+srf.set_cv(0, 1, Point(0.0, 1.0, 0.0))
+srf.set_cv(0, 2, Point(0.0, 2.0, 0.0))
+srf.set_cv(0, 3, Point(0.0, 3.0, 0.0))
+srf.set_cv(0, 4, Point(0.0, 4.0, 2.5*-1))
+
+srf.set_cv(1, 0, Point(1.0, 0.0, 0.0))
+srf.set_cv(1, 1, Point(1.0, 1.0, 0.0))
+srf.set_cv(1, 2, Point(1.0, 2.0, 5.0))
+srf.set_cv(1, 3, Point(1.0, 3.0, 0.0))
+srf.set_cv(1, 4, Point(1.0, 4.0, 0.0))
+
+srf.set_cv(2, 0, Point(2.0, 0.0, 0.0))
+srf.set_cv(2, 1, Point(2.0, 1.0, 0.0))
+srf.set_cv(2, 2, Point(2.0, 2.0, 0.0))
+srf.set_cv(2, 3, Point(2.0, 3.0, 0.0))
+srf.set_cv(2, 4, Point(2.0, 4.0, 0.0))
+
+srf.set_cv(3, 0, Point(3.0, 0.0, 0.0))
+srf.set_cv(3, 1, Point(3.0, 1.0, 0.0))
+srf.set_cv(3, 2, Point(3.0, 2.0, 0.0))
+srf.set_cv(3, 3, Point(3.0, 3.0, 0.0))
+srf.set_cv(3, 4, Point(3.0, 4.0, 0.0))
+
+srf.set_cv(4, 0, Point(4.0, 0.0, 2.5*-1))
+srf.set_cv(4, 1, Point(4.0, 1.0, 0.0))
+srf.set_cv(4, 2, Point(4.0, 2.0, 0.0))
+srf.set_cv(4, 3, Point(4.0, 3.0, 0.0))
+srf.set_cv(4, 4, Point(4.0, 4.0, 2.5*-1))
+
+print("NURBS Surface Grid Evaluation\n")
+
+# Evaluate surface at subdivided grid points
+grid_size = 10  # Increase for finer mesh
+u_min, u_max = srf.domain(0)
+v_min, v_max = srf.domain(1)
+
+# Store evaluated points in 2D grid
+points_grid = []
+for i in range(grid_size):
+    row = []
+    for j in range(grid_size):
+        # Calculate parameters
+        u = u_min + (u_max - u_min) * i / (grid_size - 1)
+        v = v_min + (v_max - v_min) * j / (grid_size - 1)
+        
+        # Evaluate point
+        pt = srf.point_at(u, v)
+        row.append(CompasPoint(pt.x, pt.y, pt.z))
+    points_grid.append(row)
+
+print(f"Evaluated {grid_size}x{grid_size} = {grid_size*grid_size} points")
+
+# Create COMPAS Mesh
+mesh = Mesh()
+
+# Add vertices and store their keys in a 2D array
+vertex_keys = []
+for i in range(grid_size):
+    row_keys = []
+    for j in range(grid_size):
+        pt = points_grid[i][j]
+        key = mesh.add_vertex(x=pt.x, y=pt.y, z=pt.z)
+        row_keys.append(key)
+    vertex_keys.append(row_keys)
+
+print(f"Added {mesh.number_of_vertices()} vertices")
+
+# Create quad faces
+face_count = 0
+for i in range(grid_size - 1):
+    for j in range(grid_size - 1):
+        # Create quad face from 4 adjacent vertices
+        v0 = vertex_keys[i][j]
+        v1 = vertex_keys[i+1][j]
+        v2 = vertex_keys[i+1][j+1]
+        v3 = vertex_keys[i][j+1]
+        mesh.add_face([v0, v1, v2, v3])
+        face_count += 1
+
+print(f"Added {face_count} quad faces")
+print(f"Mesh: {mesh.number_of_vertices()} vertices, {mesh.number_of_faces()} faces, {mesh.number_of_edges()} edges")
+
+# Extract isocurves and convert to polylines
+print("\nExtracting Isocurves...")
+iso_polylines = []
+num_iso_curves = 5  # Number of isocurves in each direction
+curve_divisions = 10  # Points per curve
+
+# Extract iso-u curves (v varies, u constant)
+print(f"Extracting {num_iso_curves} iso-u curves...")
+for i in range(num_iso_curves):
+    u_param = u_min + (u_max - u_min) * i / (num_iso_curves - 1)
+    iso_curve = srf.iso_curve(0, u_param)
+    
+    if iso_curve:
+        curve_points = []
+        t_min, t_max = iso_curve.domain()
+        
+        for j in range(curve_divisions):
+            t = t_min + (t_max - t_min) * j / (curve_divisions - 1)
+            pt = iso_curve.point_at(t)
+            curve_points.append(CompasPoint(pt.x, pt.y, pt.z))
+        
+        polyline = Polyline(curve_points)
+        iso_polylines.append(polyline)
+        print(f"  Iso-u at u={u_param:.2f}: {len(curve_points)} points")
+
+# Extract iso-v curves (u varies, v constant)
+print(f"Extracting {num_iso_curves} iso-v curves...")
+for i in range(num_iso_curves):
+    v_param = v_min + (v_max - v_min) * i / (num_iso_curves - 1)
+    iso_curve = srf.iso_curve(1, v_param)
+    
+    if iso_curve:
+        curve_points = []
+        t_min, t_max = iso_curve.domain()
+        
+        for j in range(curve_divisions):
+            t = t_min + (t_max - t_min) * j / (curve_divisions - 1)
+            pt = iso_curve.point_at(t)
+            curve_points.append(CompasPoint(pt.x, pt.y, pt.z))
+        
+        polyline = Polyline(curve_points)
+        iso_polylines.append(polyline)
+        print(f"  Iso-v at v={v_param:.2f}: {len(curve_points)} points")
+
+print(f"\nTotal isocurve polylines: {len(iso_polylines)}")
+
+# Visualize with COMPAS Viewer
+viewer = Viewer()
+viewer.scene.add(mesh, show_vertices=False, show_edges=True, show_faces=True, opacity=0.7)
+
+# Add isocurve polylines with different color
+for polyline in iso_polylines:
+    viewer.scene.add(polyline, linewidth=2, linecolor=(1, 0, 0))  # Red isocurves
+
+viewer.show()
+
+print("\n✅ Done!")