Merge branch 'master' of github.com:fork-tongue/collagraph into finegrained-reactivity

Author: berendkleinhaneveld

README.md

@@ -81,11 +81,10 @@ uv run collagraph examples/pyside/counter.cgx
 
 For more examples, please take a look at the [examples folder](examples).
 
-Currently there are three renderers:
+Currently there are two renderers:
 
 * [PysideRenderer](collagraph/renderers/pyside_renderer.py): for rendering PySide6 applications
 * [PygfxRenderer](collagraph/renderers/pygfx_renderer.py): for rendering 3D graphic scenes with [Pygfx](https://github.com/pygfx/pygfx)
-* [DomRenderer](collagraph/renderers/dom_renderer.py): for rendering to browser DOM through [PyScript](https://pyscript.net) (or rather [Pyodide](https://pyodide.org/en/stable/))
 
 It is possible to create a custom Renderer using the [Renderer](collagraph/renderers/__init__.py) interface, to render to other UI frameworks, for instance wxPython.
 

collagraph/__main__.py

@@ -16,8 +16,6 @@ def available_renderers():
         "PySideRenderer": "pyside",
         "PygfxRenderer": "pygfx",
         "DictRenderer": "dict",
-        # TODO: add support for DomRenderer
-        # "DomRenderer": "dom",
     }.items():
         try:
             importlib.import_module("collagraph", renderer_type)

collagraph/renderers/__init__.py

@@ -70,13 +70,6 @@ def remove_event_listener(self, el: Any, event_type: str, value: Callable):
 
 from .dict_renderer import DictRenderer
 
-try:
-    import js
-except ImportError:  # pragma: no cover
-    pass
-else:
-    from .dom_renderer import DomRenderer
-
 try:
     import pygfx
 except ImportError:  # pragma: no cover

collagraph/renderers/dom_renderer.py

@@ -28,7 +28,7 @@ def insert(self, el, anchor=None):
 def remove(self, el):
     if hasattr(el, "model_index"):
         # Only support removal of rows for now
-        row, column = getattr(el, "model_index")
+        row, _column = getattr(el, "model_index")
         if model := el.model():
             index = model.indexFromItem(el)
             row = index.row()

collagraph/renderers/pyside/objects/standarditem.py

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from functools import lru_cache
+from functools import lru_cache, partial
 from typing import Any, Callable
 from warnings import warn
 
@@ -404,6 +404,11 @@ def add_event_listener(self, el: Any, event_type: str, value: Callable):
                 # a QObject?) results in a SystemError. Lambdas though _can_ function
                 # as a slot, so when creating a slot of the value fails, retry with
                 # a simple lambda.
+                if isinstance(value, partial):
+                    # In the case that value is a partial object, Pyside 6.9.2 spits
+                    # out a warning 'PytestUnraisableExceptionWarning'. Wrapping the
+                    # partial in a lambda seems to do the trick
+                    raise SystemError
                 slot = QtCore.Slot()(value)
             except SystemError:
                 # TODO: with some inspection we might be able to figure out the

collagraph/renderers/pyside_renderer.py

@@ -39,7 +39,7 @@ def find_spec(
             # In our case we can just return the existing spec.
             return target.__spec__
 
-        package, _, module_name = name.rpartition(".")
+        _package, _, module_name = name.rpartition(".")
         sfc_file_name = f"{module_name}.{compiler.SUFFIX}"
         directories = sys.path if path is None else path
         for directory in directories:

collagraph/sfc/importer.py

@@ -16,7 +16,7 @@
     renderer.register_element("WgpuCanvas", WgpuCanvas)
     gui = cg.Collagraph(renderer=renderer)
 
-    state = reactive({"count": 500})
+    state = reactive({"count": 1000})
 
     # Define Qt structure and map state to the structure
     # Pass in the app as a container. Can actually be any truthy object

examples/pygfx/combined-example.py

@@ -0,0 +1,78 @@
+import random
+
+import pygfx as gfx
+
+from collagraph import h
+
+sphere_geom = gfx.sphere_geometry(radius=0.5)
+materials = {
+    "default": gfx.MeshPhongMaterial(color=[1, 1, 1], pick_write=True),
+    "selected": gfx.MeshPhongMaterial(color=[1, 0, 0], pick_write=True),
+    "hovered": gfx.MeshPhongMaterial(color=[1, 0.6, 0], pick_write=True),
+    "other": gfx.MeshPhongMaterial(color=[1, 0, 0.5], pick_write=True),
+}
+
+
+def rand_point():
+    return (
+        random.randint(-20, 20),
+        random.randint(-20, 20),
+        random.randint(-20, 20),
+    )
+
+
+def point(index, selected, hovered, set_selected, set_hovered):
+    material = (
+        "selected"
+        if index == selected
+        else "hovered"
+        if index == hovered
+        else "default"
+    )
+    return h(
+        "Mesh",
+        {
+            "geometry": sphere_geom,
+            "material": materials[material],
+            "local.position": positions[index],
+            "key": index,
+            "on_click": lambda event: set_selected(index),
+            "on_pointer_move": lambda event: set_hovered(index),
+        },
+    )
+
+
+positions = []
+
+
+def PointCloud(props):
+    global positions
+
+    def set_hovered(index):
+        props["hovered"] = index
+
+    def set_selected(index):
+        if props.get("selected", -1) == index:
+            props["selected"] = -1
+        else:
+            props["selected"] = index
+
+    selected = props.get("selected", -1)
+    hovered = props.get("hovered", -1)
+    number_of_points = props.get("count", 50)
+
+    if len(positions) > number_of_points:
+        positions = positions[:number_of_points]
+    elif len(positions) < number_of_points:
+        positions.extend(
+            [rand_point() for _ in range(number_of_points - len(positions))]
+        )
+
+    return h(
+        "Group",
+        {},
+        *[
+            point(i, selected, hovered, set_selected, set_hovered)
+            for i in range(number_of_points)
+        ],
+    )

examples/pygfx/point_cloud.py

@@ -0,0 +1,53 @@
+import pygfx as gfx
+from point_cloud import PointCloud, materials, sphere_geom
+from wgpu.gui.auto import WgpuCanvas, run
+
+import collagraph as cg
+from collagraph import h
+
+if __name__ == "__main__":
+    canvas = WgpuCanvas(size=(600, 400))
+    renderer = gfx.renderers.WgpuRenderer(canvas)
+
+    camera = gfx.PerspectiveCamera(60, 16 / 9)
+    camera.local.z = 15
+    camera.show_pos((0, 0, 0))
+
+    controls = gfx.OrbitController(camera)
+    controls.register_events(renderer)
+
+    gui = cg.Collagraph(renderer=cg.PygfxRenderer())
+
+    element = h(
+        "Group",
+        {
+            "name": "Landmarks",
+        },
+        h("AmbientLight"),
+        h("PointLight", {"local.position": (0, 70, 70), "cast_shadow": True}),
+        h(
+            PointCloud,
+            # When increasing this number, it will take longer
+            # and longer for pygfx to create the render pipeline
+            # (compiling shaders and such), so be careful...
+            {"count": 500},
+        ),
+        h(
+            "Mesh",
+            {
+                "name": "Hip",
+                "local.position": (2, 2, 2),
+                "geometry": sphere_geom,
+                "material": materials["other"],
+            },
+        ),
+    )
+
+    container = gfx.Scene()
+
+    def animate():
+        renderer.render(container, camera)
+
+    gui.render(element, container, callback=lambda: canvas.request_draw(animate))
+    canvas.request_draw(animate)
+    run()