collagraph 0.9.2__tar.gz → 0.9.4__tar.gz

{collagraph-0.9.2 → collagraph-0.9.4}/.github/workflows/ci.yml

@@ -65,6 +65,22 @@ jobs:
         env:
           QT_QPA_PLATFORM: offscreen
 
+  pyinstaller:
+    name: Test PyInstaller hooks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+      - name: Install dependencies
+        run: uv sync
+      - name: Test PyInstaller hooks
+        run: bash tests/pyinstaller/test_pyinstaller.sh
+
   build:
     name: Build and test wheel
     runs-on: ubuntu-latest
@@ -91,7 +107,7 @@ jobs:
   publish:
     name: Publish to Github and Pypi
     runs-on: ubuntu-latest
-    needs: [lint, test, build]
+    needs: [lint, test, build, pyinstaller]
     if: success() && startsWith(github.ref, 'refs/tags/v')
     environment:
       name: pypi

{collagraph-0.9.2 → collagraph-0.9.4}/.gitignore

@@ -4,5 +4,6 @@ __pycache__
 .coverage
 dist
 build
+*.spec
 uv.lock
 .venv

{collagraph-0.9.2 → collagraph-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: collagraph
-Version: 0.9.2
+Version: 0.9.4
 Summary: Reactive user interfaces
 Author-email: Berend Klein Haneveld <berendkleinhaneveld@gmail.com>, Korijn van Golen <korijn@gmail.com>
 License-Expression: MIT

collagraph-0.9.4/collagraph/__pyinstaller/hook-collagraph.py

@@ -0,0 +1,126 @@
+import ast
+import atexit
+from pathlib import Path
+
+from PyInstaller.lib.modulegraph.modulegraph import DependencyInfo, MissingModule
+
+from collagraph.sfc.compiler import construct_ast, get_script_ast
+from collagraph.sfc.parser import CGXParser
+
+# Keep track of generated files so they can be cleaned up
+_generated_files: list[Path] = []
+
+
+def _cleanup_generated_files():
+    for path in _generated_files:
+        path.unlink(missing_ok=True)
+
+
+atexit.register(_cleanup_generated_files)
+
+
+def hook(hook_api):
+    collagraph_uses = hook_api.analysis.graph.get_code_using("collagraph")
+
+    hidden_imports = set()
+    cgx_modules = set()
+
+    for package, code in collagraph_uses.items():
+        source_dir = Path(code.co_filename).parent
+
+        # Collect CGX files and their imports from the source directory
+        cgx_files = list(source_dir.glob("**/*.cgx"))
+        hidden_imports |= collect_hidden_imports(cgx_files)
+
+        # Pre-compile each CGX file to Python source so that
+        # PyInstaller can bundle them as regular Python modules,
+        # removing the need to bundle .cgx files and compile them
+        # at runtime
+        for cgx_path in cgx_files:
+            module_name = cgx_path.stem
+            tree, _name = construct_ast(cgx_path)
+            python_source = ast.unparse(tree)
+
+            # Write compiled module next to the CGX file so
+            # PyInstaller can discover it on its existing search path
+            py_path = cgx_path.with_suffix(".py")
+            if not py_path.exists():
+                py_path.write_text(python_source, encoding="utf-8")
+                _generated_files.append(py_path)
+            cgx_modules.add(module_name)
+
+    # Filter out imports that correspond to CGX modules, since
+    # they are now available as pre-compiled Python modules
+    hidden_imports -= cgx_modules
+
+    graph = hook_api.analysis.graph
+
+    # Remove any MissingModule nodes for CGX modules that were
+    # already marked as missing during initial analysis (before
+    # the compiled .py files existed).
+    # removeNode() calls hide_node() which moves the node to
+    # hidden_nodes. Graph.add_node() silently ignores nodes in
+    # hidden_nodes, so we must also delete from hidden_nodes to
+    # allow import_hook to re-add the module as a SourceModule.
+    for name in cgx_modules:
+        node = graph.find_node(name)
+        if isinstance(node, MissingModule):
+            graph.removeNode(node)
+            if name in graph.graph.hidden_nodes:
+                del graph.graph.hidden_nodes[name]
+
+    # Import CGX modules via the module graph and create edges
+    # to the collagraph node so they are included in the bundle.
+    collagraph_node = graph.find_node("collagraph")
+    for name in cgx_modules:
+        try:
+            nodes = graph.import_hook(name, collagraph_node)
+            for node in nodes:
+                graph._updateReference(
+                    collagraph_node,
+                    node,
+                    edge_data=DependencyInfo(
+                        conditional=False,
+                        fromlist=False,
+                        function=False,
+                        tryexcept=False,
+                    ),
+                )
+        except ImportError:
+            pass
+
+    # Add remaining hidden imports (non-CGX Python modules)
+    hook_api.add_imports(*hidden_imports)
+
+
+def collect_hidden_imports(cgx_files):
+    hidden_imports = set()
+    for path in cgx_files:
+        template = path.read_text(encoding="utf-8")
+        # Parse the file component into a tree of Node instances
+        parser = CGXParser()
+        parser.feed(template)
+
+        # Get the AST from the script tag
+        script_tree = get_script_ast(parser, path)
+
+        # Find a list of imported module names
+        imported_names = ImportsCollector()
+        imported_names.visit(script_tree)
+
+        hidden_imports |= imported_names.names
+
+    return hidden_imports
+
+
+class ImportsCollector(ast.NodeVisitor):
+    def __init__(self):
+        self.names = set()
+
+    def visit_ImportFrom(self, node):
+        if node.module:
+            self.names.add(node.module)
+
+    def visit_Import(self, node):
+        for alias in node.names:
+            self.names.add(alias.name)

{collagraph-0.9.2 → collagraph-0.9.4}/collagraph/fragment.py

@@ -581,11 +581,20 @@ class ListFragment(Fragment):
 
                 # Keys that are no longer present - unmount them
                 removed_keys = old_key_set - new_key_set
+                removed_fragments = set()
                 for key in removed_keys:
                     fragment = self.key_to_fragment.pop(key)
-                    # Remove from children list
-                    self.children.remove(fragment)
                     fragment.unmount()
+                    removed_fragments.add(fragment)
+
+                # Create a filtered snapshot of the old children order
+                # (excluding removed fragments) for position comparisons
+                old_children = [f for f in self.children if f not in removed_fragments]
+
+                # Build a map from fragment to its old position
+                old_fragment_positions = {
+                    frag: i for i, frag in enumerate(old_children)
+                }
 
                 # Build new children array in the correct order
                 new_children = []
@@ -605,9 +614,33 @@ class ListFragment(Fragment):
                         self.key_to_fragment[key] = fragment
                         new_children.append(fragment)
 
-                # Now we need to reorder/mount the DOM elements to match new_children
-                # We process from the end to the beginning to avoid interference
-                # from previous moves
+                # Map reused fragments to their old positions, skip new ones
+                old_positions = []
+                reused_indices = []
+                for i, fragment in enumerate(new_children):
+                    if fragment in old_fragment_positions:
+                        old_positions.append(old_fragment_positions[fragment])
+                        reused_indices.append(i)
+
+                # Find LIS - these fragments are already in correct order
+                # Example: [A, B, C] -> [C, A, B]
+                # Old positions: {A:0, B:1, C:2}
+                # Map to old positions: [2, 0, 1]
+                # LIS: [0, 1] (A, B already in order)
+                # Only move C
+                lis_indices = longest_increasing_subsequence(old_positions)
+                # Convert LIS result to set of new_children indices
+                dont_move = {reused_indices[i] for i in lis_indices}
+
+                # Reconciliation strategy: Process new_children from end to
+                # start using anchors. Three different orderings in play:
+                # - old_children: The OLD order (filtered snapshot)
+                # - new_children: The desired NEW order
+                # - DOM state: Updated incrementally as we process each fragment
+                #
+                # We process backwards (end to beginning) so that anchors
+                # (elements to the right) are already in their final
+                # positions when we use them as insertion points.
                 for i in range(len(new_children) - 1, -1, -1):
                     fragment = new_children[i]
 
@@ -625,40 +658,14 @@ class ListFragment(Fragment):
                     if not fragment._mounted:
                         # Mount new fragment at the correct position
                         fragment.mount(target, anchor=anchor)
-                    else:
-                        # Fragment is already mounted, move it in the DOM if needed
-                        if fragment.element:
-                            # Check if it's already in the correct position
-                            # Get the actual next sibling in the current DOM
-                            current_next = self._get_next_sibling(
-                                fragment.element, target
-                            )
-
-                            # Only move if not already in correct position
-                            if current_next != anchor:
-                                # Remove from current position
-                                # (but keep element reference)
-                                # and insert at new position
-                                self.renderer.remove(fragment.element, target)
-                                self.renderer.insert(
-                                    fragment.element, parent=target, anchor=anchor
-                                )
-
-                # Update children list
-                self.children = new_children
-
-            def _get_next_sibling(element, parent):
-                """Get the next sibling element in the parent's children list"""
-                try:
-                    idx = parent.children.index(element)
-                    if idx + 1 < len(parent.children):
-                        return parent.children[idx + 1]
-                    return None
-                except (ValueError, AttributeError):
-                    return None
+                    elif i not in dont_move:
+                        # Fragment needs to be moved (not in LIS)
+                        # Move the fragment and all its DOM children
+                        move_fragment_dom(fragment, self.renderer, target, anchor)
 
-            # Bind the helper function to self
-            self._get_next_sibling = _get_next_sibling
+                # Update children list to match new_children
+                # This removes any unmounted fragments and ensures correct order
+                self.children = new_children
 
             # Watch for changes
             self._watchers["list"] = watch_effect(update_children_keyed)
@@ -1098,3 +1105,79 @@ class DynamicFragment(Fragment):
     def _remove(self):
         if self._active_fragment:
             self._active_fragment._remove()
+
+
+def move_fragment_dom(
+    fragment: Fragment, renderer: Renderer, target: Any, anchor: Any | None
+) -> None:
+    """
+    Recursively move all DOM elements in a fragment tree to a new position.
+
+    For fragments with a direct element, moves that element.
+    For fragments without (e.g. ComponentFragment), recursively moves children.
+    """
+    if fragment.element:
+        # Fragment has a single element - move it
+        renderer.remove(fragment.element, target)
+        renderer.insert(fragment.element, parent=target, anchor=anchor)
+    else:
+        # Fragment without direct element - move all child DOM elements
+        for child in fragment.children:
+            if child._mounted:
+                move_fragment_dom(child, renderer, target, anchor)
+
+
+def longest_increasing_subsequence(nums: list[int]) -> list[int]:
+    """
+    Find the longest increasing subsequence in a list of numbers.
+    Returns the indices of elements in the LIS.
+
+    Used to optimize keyed list reconciliation by finding which elements
+    are already in the correct relative order and don't need to move.
+
+    Example:
+        nums = [2, 0, 1]
+        returns [1, 2]  # indices of values 0, 1 (the LIS)
+    """
+    if not nums:
+        return []
+
+    n = len(nums)
+    # tails[i] = smallest tail element for LIS of length i+1
+    tails = []
+    # predecessor[i] = index of previous element in LIS ending at i
+    predecessor = [-1] * n
+    # tail_indices[i] = index in nums of tails[i]
+    tail_indices = []
+
+    for i, num in enumerate(nums):
+        # Binary search for the position to insert num
+        left, right = 0, len(tails)
+        while left < right:
+            mid = (left + right) // 2
+            if tails[mid] < num:
+                left = mid + 1
+            else:
+                right = mid
+
+        # Update predecessor
+        if left > 0:
+            predecessor[i] = tail_indices[left - 1]
+
+        # Update or append to tails
+        if left < len(tails):
+            tails[left] = num
+            tail_indices[left] = i
+        else:
+            tails.append(num)
+            tail_indices.append(i)
+
+    # Reconstruct the LIS indices
+    result = []
+    current = tail_indices[-1]
+    while current != -1:
+        result.append(current)
+        current = predecessor[current]
+
+    result.reverse()
+    return result

{collagraph-0.9.2 → collagraph-0.9.4}/collagraph/renderers/pyside/objects/treewidgetitem.py

@@ -4,6 +4,34 @@ from ... import PySideRenderer
 from .qobject import set_attribute as qobject_set_attribute
 
 
+def _snapshot_item_state(
+    item: QTreeWidgetItem,
+) -> list[tuple[QTreeWidgetItem, bool, bool]]:
+    """Record ``(isExpanded, isSelected)`` for ``item`` and all descendants.
+
+    Qt resets both bits across a ``removeChild``, so callers snapshot
+    here before removing and restore after re-inserting (the path
+    keyed-v-for reordering takes).
+    """
+    snapshot: list[tuple[QTreeWidgetItem, bool, bool]] = []
+
+    def walk(it: QTreeWidgetItem) -> None:
+        snapshot.append((it, it.isExpanded(), it.isSelected()))
+        for i in range(it.childCount()):
+            walk(it.child(i))
+
+    walk(item)
+    return snapshot
+
+
+def _restore_item_state(
+    snapshot: list[tuple[QTreeWidgetItem, bool, bool]],
+) -> None:
+    for it, expanded, selected in snapshot:
+        it.setExpanded(expanded)
+        it.setSelected(selected)
+
+
 @PySideRenderer.register_insert(QTreeWidgetItem)
 def insert(self, el: QTreeWidgetItem, anchor=None):
     if not isinstance(el, QTreeWidgetItem):
@@ -17,13 +45,26 @@ def insert(self, el: QTreeWidgetItem, anchor=None):
         if anchor is not None:
             index = self.indexOfChild(anchor)
             if self.treeWidget():
+                # ``el`` may already be in the tree (legacy code paths
+                # call insert without removing first); snapshot so we
+                # can preserve its expansion/selection across removeChild.
+                state = _snapshot_item_state(el)
                 self.removeChild(el)
-            self.insertChild(index, el)
+                self.insertChild(index, el)
+                _restore_item_state(state)
+            else:
+                self.insertChild(index, el)
         else:
             self.addChild(el)
 
-        # After mounting, process some attributes that can only
-        # be adjusted when the item is mounted in the tree structure
+        # Restore state snapshotted at remove-time (keyed reorder via a
+        # separate remove/insert pair, see remove() below).
+        if hasattr(el, "_state_snapshot"):
+            _restore_item_state(el._state_snapshot)
+            del el._state_snapshot
+
+        # After mounting, process some attributes that can only be
+        # adjusted when the item is mounted in the tree structure.
         if hasattr(el, "_expanded"):
             el.setExpanded(el._expanded)
             delattr(el, "_expanded")
@@ -43,6 +84,11 @@ def remove(self, el: QTreeWidgetItem):
         tree_widget.blockSignals(True)
 
     try:
+        # Stash UI state so a paired insert() (keyed reorder) can put
+        # the subtree back the way it was. The stash is consumed by
+        # the next insert of ``el``; if the item is being removed for
+        # good the attribute is garbage-collected with it.
+        el._state_snapshot = _snapshot_item_state(el)
         self.removeChild(el)
     finally:
         if tree_widget:

{collagraph-0.9.2 → collagraph-0.9.4}/collagraph/sfc/importer.py

@@ -66,5 +66,8 @@ class CGXPathFinder(MetaPathFinder):
                 return spec
 
 
-# Add cgx path finder at the end of the list of finders
-sys.meta_path.append(CGXPathFinder())
+# Add cgx path finder at the end of the list of finders.
+# Skip when running as a frozen PyInstaller bundle, since CGX files
+# are pre-compiled to Python modules by the PyInstaller hook.
+if not getattr(sys, "frozen", False):
+    sys.meta_path.append(CGXPathFinder())