Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

In PyQt I have a view with rows in it from a model (which in turn is from a SQLite…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Kimikimi-k2-0711-preview’s answer.
  1. User

    In PyQt I have a view with rows in it from a model (which in turn is from a SQLite database). I would like to get some of those rows, change the colour of them and display them in the view. Is there a Class that would help me in this? I am thinking I could get the rows from the original view, create another view with the rows and modify the rows as I'd like. Then a final need is to display both the modified-row view and original-row view as a single composed view. That way I can add/remvoe rows from the modified-row model and have that change effected in the composed view, all without actually affecting the original-row view/mode/underlying-data.

  2. Mistral Assistant

    PyQt: Customizing Row Colors and Combining Views

    In PyQt, you can achieve what you're describing using a combination of proxy models and custom delegates. Here's how to approach this:

    Solution Components

    1. Proxy Model: To filter/modify data without affecting the original model
    2. Custom Delegate: To change the appearance of specific rows
    3. Composite View: To display both original and modified views together

    Implementation Approach

    1. Using QSortFilterProxyModel

    from PyQt5.QtCore import Qt, QSortFilterProxyModel
    from PyQt5.QtGui import QColor
    
    class HighlightProxyModel(QSortFilterProxyModel):
        def __init__(self, highlight_rows, highlight_color=QColor(255, 200, 200), parent=None):
            super().__init__(parent)
            self.highlight_rows = highlight_rows
            self.highlight_color = highlight_color
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.BackgroundRole and index.row() in self.highlight_rows:
                return self.highlight_color
            return super().data(index, role)
    

    2. Creating a Composite View

    You can use a QSplitter or QStackedWidget to display both views side by side:

    from PyQt5.QtWidgets import QSplitter, QTreeView
    
    # Create your original view
    original_view = QTreeView()
    original_view.setModel(original_model)
    
    # Create proxy model for modified rows
    proxy_model = HighlightProxyModel(highlight_rows=[1, 3, 5])  # rows to highlight
    proxy_model.setSourceModel(original_model)
    
    # Create modified view
    modified_view = QTreeView()
    modified_view.setModel(proxy_model)
    
    # Create composite view
    splitter = QSplitter()
    splitter.addWidget(original_view)
    splitter.addWidget(modified_view)
    

    3. Alternative: Single View with Different Styling

    If you want a single view with different styling:

    from PyQt5.QtWidgets import QStyledItemDelegate
    
    class HighlightDelegate(QStyledItemDelegate):
        def __init__(self, highlight_rows, highlight_color=QColor(255, 200, 200), parent=None):
            super().__init__(parent)
            self.highlight_rows = highlight_rows
            self.highlight_color = highlight_color
    
        def initStyleOption(self, option, index):
            super().initStyleOption(option, index)
            if index.row() in self.highlight_rows:
                option.backgroundBrush = self.highlight_color
    
    # Usage:
    view = QTreeView()
    view.setModel(original_model)
    delegate = HighlightDelegate(highlight_rows=[1, 3, 5])
    view.setItemDelegate(delegate)
    

    Complete Example

    Here's a more complete example:

    from PyQt5.QtWidgets import (QApplication, QMainWindow, QTreeView,
                                QSplitter, QVBoxLayout, QWidget)
    from PyQt5.QtCore import Qt, QAbstractItemModel, QModelIndex
    from PyQt5.QtGui import QColor
    
    class SimpleModel(QAbstractItemModel):
        def __init__(self, data, parent=None):
            super().__init__(parent)
            self._data = data
    
        def rowCount(self, parent=QModelIndex()):
            return len(self._data)
    
        def columnCount(self, parent=QModelIndex()):
            return 1
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.DisplayRole:
                return self._data[index.row()][0]
            return None
    
        def index(self, row, column, parent=QModelIndex()):
            return self.createIndex(row, column)
    
        def parent(self, index):
            return QModelIndex()
    
    class HighlightProxyModel(QSortFilterProxyModel):
        def __init__(self, highlight_rows, highlight_color=QColor(255, 200, 200), parent=None):
            super().__init__(parent)
            self.highlight_rows = highlight_rows
            self.highlight_color = highlight_color
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.BackgroundRole and index.row() in self.highlight_rows:
                return self.highlight_color
            return super().data(index, role)
    
    class MainWindow(QMainWindow):
        def __init__(self):
            super().__init__()
    
            # Sample data
            data = [("Item {}".format(i),) for i in range(20)]
    
            # Original model
            self.original_model = SimpleModel(data)
    
            # Create views
            self.original_view = QTreeView()
            self.original_view.setModel(self.original_model)
    
            # Proxy model for modified view
            self.proxy_model = HighlightProxyModel(highlight_rows=[1, 3, 5, 7])
            self.proxy_model.setSourceModel(self.original_model)
    
            self.modified_view = QTreeView()
            self.modified_view.setModel(self.proxy_model)
    
            # Create composite layout
            splitter = QSplitter()
            splitter.addWidget(self.original_view)
            splitter.addWidget(self.modified_view)
    
            central_widget = QWidget()
            layout = QVBoxLayout(central_widget)
            layout.addWidget(splitter)
            self.setCentralWidget(central_widget)
    
    if __name__ == "__main__":
        import sys
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    

    This approach gives you:

    • Two synchronized views showing the same data
    • The ability to highlight specific rows in one view
    • The original data remains unchanged
    • Changes to the proxy model (like filtering) won't affect the original model

    You can extend this further by adding functionality to dynamically add/remove rows from the highlighted set.

  3. User

    I like the idea of using a delegate to colour specific rows and/or using QConcatenateTablesProxyModel to form that needed single-view. One other question I have is what if I want to add new rows from another totally seperate view/model without them being added to the original-row model BUT with them being added to the composed-view. The previous question concerned affect specific rows that already existed in the original view, this question concerns the addition of not-seen before rows to that view (but not affecting the orignal-view model).

  4. Mistral Assistant

    Adding New Rows to a Composite View Without Affecting the Original Model

    To achieve this, you'll need to create a composite model that combines:

    1. The original model (read-only)
    2. A separate model for new rows
    3. A way to display them together in a single view

    Here's how to implement this in PyQt:

    Solution Approach

    1. Create a Composite Model

    We'll subclass QConcatenateTablesProxyModel or create a custom proxy model that can handle both the original model and a separate model for new rows.

    from PyQt5.QtCore import QAbstractProxyModel, QModelIndex, Qt, QPersistentModelIndex
    from PyQt5.QtGui import QColor
    
    class CompositeModel(QAbstractProxyModel):
        def __init__(self, original_model, new_rows_model, parent=None):
            super().__init__(parent)
            self._original_model = original_model
            self._new_rows_model = new_rows_model
    
            # Connect signals
            self._original_model.dataChanged.connect(self._on_data_changed)
            self._original_model.rowsInserted.connect(self._on_rows_inserted)
            self._original_model.rowsRemoved.connect(self._on_rows_removed)
            self._original_model.modelReset.connect(self._on_model_reset)
    
            self._new_rows_model.dataChanged.connect(self._on_data_changed)
            self._new_rows_model.rowsInserted.connect(self._on_rows_inserted)
            self._new_rows_model.rowsRemoved.connect(self._on_rows_removed)
            self._new_rows_model.modelReset.connect(self._on_model_reset)
    
        def _on_data_changed(self, top_left, bottom_right, roles):
            self.dataChanged.emit(self.mapFromSource(top_left), self.mapFromSource(bottom_right), roles)
    
        def _on_rows_inserted(self, parent, start, end):
            self.beginInsertRows(self.mapFromSource(parent), start, end)
            self.endInsertRows()
    
        def _on_rows_removed(self, parent, start, end):
            self.beginRemoveRows(self.mapFromSource(parent), start, end)
            self.endRemoveRows()
    
        def _on_model_reset(self):
            self.beginResetModel()
            self.endResetModel()
    
        def rowCount(self, parent=QModelIndex()):
            if parent.isValid():
                return 0
            return self._original_model.rowCount() + self._new_rows_model.rowCount()
    
        def columnCount(self, parent=QModelIndex()):
            return max(self._original_model.columnCount(), self._new_rows_model.columnCount())
    
        def data(self, index, role=Qt.DisplayRole):
            if not index.isValid():
                return None
    
            if index.row() < self._original_model.rowCount():
                source_index = self._original_model.index(index.row(), index.column())
                return self._original_model.data(source_index, role)
            else:
                new_row = index.row() - self._original_model.rowCount()
                source_index = self._new_rows_model.index(new_row, index.column())
                return self._new_rows_model.data(source_index, role)
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal:
                return self._original_model.headerData(section, orientation, role)
            return None
    
        def index(self, row, column, parent=QModelIndex()):
            if parent.isValid() or row < 0 or column < 0:
                return QModelIndex()
    
            if row < self._original_model.rowCount():
                return self.createIndex(row, column)
            else:
                new_row = row - self._original_model.rowCount()
                if new_row < self._new_rows_model.rowCount():
                    return self.createIndex(row, column)
            return QModelIndex()
    
        def parent(self, index):
            return QModelIndex()
    
        def mapFromSource(self, source_index):
            if not source_index.isValid():
                return QModelIndex()
    
            if source_index.model() == self._original_model:
                return self.index(source_index.row(), source_index.column())
            elif source_index.model() == self._new_rows_model:
                return self.index(source_index.row() + self._original_model.rowCount(),
                                 source_index.column())
            return QModelIndex()
    
        def mapToSource(self, proxy_index):
            if not proxy_index.isValid():
                return QModelIndex()
    
            if proxy_index.row() < self._original_model.rowCount():
                return self._original_model.index(proxy_index.row(), proxy_index.column())
            else:
                new_row = proxy_index.row() - self._original_model.rowCount()
                return self._new_rows_model.index(new_row, proxy_index.column())
    
        def flags(self, index):
            if not index.isValid():
                return Qt.NoItemFlags
    
            if index.row() < self._original_model.rowCount():
                return self._original_model.flags(self.mapToSource(index)) & ~Qt.ItemIsEditable
            else:
                return self._new_rows_model.flags(self.mapToSource(index))
    

    2. Using the Composite Model with a Delegate

    from PyQt5.QtWidgets import QApplication, QMainWindow, QTreeView, QVBoxLayout, QWidget, QPushButton
    from PyQt5.QtCore import QAbstractTableModel, Qt
    from PyQt5.QtGui import QColor
    
    class OriginalModel(QAbstractTableModel):
        def __init__(self, data, parent=None):
            super().__init__(parent)
            self._data = data
    
        def rowCount(self, parent=QModelIndex()):
            return len(self._data)
    
        def columnCount(self, parent=QModelIndex()):
            return 1
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.DisplayRole:
                return self._data[index.row()][0]
            return None
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal and role == Qt.DisplayRole:
                return "Original Data"
            return None
    
    class NewRowsModel(QAbstractTableModel):
        def __init__(self, parent=None):
            super().__init__(parent)
            self._data = []
    
        def rowCount(self, parent=QModelIndex()):
            return len(self._data)
    
        def columnCount(self, parent=QModelIndex()):
            return 1
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.DisplayRole:
                return self._data[index.row()][0]
            elif role == Qt.BackgroundRole:
                return QColor(200, 255, 200)  # Light green for new rows
            return None
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal and role == Qt.DisplayRole:
                return "New Rows"
            return None
    
        def insertRow(self, row, data, parent=QModelIndex()):
            self.beginInsertRows(parent, row, row)
            self._data.insert(row, [data])
            self.endInsertRows()
            return True
    
    class HighlightDelegate(QStyledItemDelegate):
        def __init__(self, parent=None):
            super().__init__(parent)
    
        def initStyleOption(self, option, index):
            super().initStyleOption(option, index)
            # Custom styling can be added here if needed
            pass
    
    class MainWindow(QMainWindow):
        def __init__(self):
            super().__init__()
    
            # Sample data
            original_data = [("Original Item {}".format(i),) for i in range(5)]
    
            # Models
            self.original_model = OriginalModel(original_data)
            self.new_rows_model = NewRowsModel()
    
            # Composite model
            self.composite_model = CompositeModel(self.original_model, self.new_rows_model)
    
            # View
            self.view = QTreeView()
            self.view.setModel(self.composite_model)
            self.view.setItemDelegate(HighlightDelegate())
    
            # Button to add new rows
            self.add_button = QPushButton("Add New Row")
            self.add_button.clicked.connect(self.add_new_row)
    
            # Layout
            central_widget = QWidget()
            layout = QVBoxLayout(central_widget)
            layout.addWidget(self.view)
            layout.addWidget(self.add_button)
            self.setCentralWidget(central_widget)
    
        def add_new_row(self):
            # Get the next row number
            row_count = self.new_rows_model.rowCount()
            # Add a new row to the new rows model
            self.new_rows_model.insertRow(row_count, f"New Item {row_count + 1}")
    
    if __name__ == "__main__":
        import sys
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    

    Key Features of This Solution

    1. Composite Model: Combines both the original model and a separate model for new rows
    2. Isolation: New rows are added to the separate model, not affecting the original model
    3. Visual Distinction: New rows can be styled differently (e.g., with a light green background)
    4. Single View: All data is displayed in one unified view
    5. Read-Only Original Data: The original model's data is displayed as read-only

    Extending the Solution

    You can further enhance this by:

    1. Adding a way to remove new rows
    2. Implementing drag-and-drop between the original and new sections
    3. Adding more sophisticated styling for different types of rows
    4. Implementing sorting/filtering capabilities

    This approach gives you a clean separation between the original data and new additions while presenting them in a single unified view.

  5. User

    Can I add new columns with a delegate? Without affecting the underlying model data? I want specific rows of a specific View of the Composite View to have different values in this new column. Can a model have multiple proxies filtering/manipulating the view? Can a view have multiple delegates manipulating the rows?

  6. Mistral Assistant

    Adding Virtual Columns with Delegates and Multiple Proxies/Delegates in PyQt

    You're asking several important questions about PyQt's model-view architecture. Let me address each one systematically.

    1. Adding Virtual Columns with a Delegate

    Yes, you can add virtual columns without affecting the underlying model, but there are some important considerations:

    Approach 1: Using a Proxy Model

    The most robust way is to use a proxy model that adds virtual columns:

    from PyQt5.QtCore import QIdentityProxyModel, QModelIndex, Qt
    
    class VirtualColumnProxyModel(QIdentityProxyModel):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.virtual_columns = 1  # Number of virtual columns to add
    
        def columnCount(self, parent=QModelIndex()):
            return super().columnCount(parent) + self.virtual_columns
    
        def data(self, index, role=Qt.DisplayRole):
            if not index.isValid():
                return None
    
            # For virtual columns (last columns)
            if index.column() >= super().columnCount(index.parent()):
                if role == Qt.DisplayRole:
                    # Return custom data for virtual column
                    return f"Virtual {index.row()}"
                elif role == Qt.BackgroundRole:
                    # Custom styling for virtual column
                    return QColor(220, 230, 240)
                return None
    
            # For original columns
            return super().data(index, role)
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal:
                if section >= super().columnCount():
                    if role == Qt.DisplayRole:
                        return f"Virtual Col {section - super().columnCount() + 1}"
                    return None
            return super().headerData(section, orientation, role)
    

    Approach 2: Using a Custom Delegate (More Limited)

    While delegates can't truly add columns (since column count comes from the model), you can create the visual appearance of additional columns:

    from PyQt5.QtWidgets import QStyledItemDelegate, QStyleOptionViewItem
    from PyQt5.QtCore import QRect
    
    class VirtualColumnDelegate(QStyledItemDelegate):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.virtual_column_width = 100
    
        def paint(self, painter, option, index):
            # First paint the original content
            super().paint(painter, option, index)
    
            # Then paint our virtual column
            virtual_option = QStyleOptionViewItem(option)
            virtual_rect = QRect(option.rect.right() + 1, option.rect.top(),
                                self.virtual_column_width, option.rect.height())
            virtual_option.rect = virtual_rect
            virtual_option.text = f"Virtual {index.row()}"
    
            # Draw the virtual column
            self.initStyleOption(virtual_option, index)
            painter.save()
            painter.setPen(QColor(200, 200, 200))
            painter.drawRect(virtual_rect)
            painter.drawText(virtual_rect, Qt.AlignCenter, virtual_option.text)
            painter.restore()
    
        def sizeHint(self, option, index):
            size = super().sizeHint(option, index)
            size.setWidth(size.width() + self.virtual_column_width)
            return size
    

    2. Multiple Proxies Filtering/Manipulating the View

    Yes, you can chain multiple proxy models together to create complex transformations:

    # Original model
    original_model = YourModel()
    
    # First proxy (filtering)
    filter_proxy = QSortFilterProxyModel()
    filter_proxy.setSourceModel(original_model)
    filter_proxy.setFilterKeyColumn(0)
    filter_proxy.setFilterFixedString("Important")
    
    # Second proxy (adding virtual columns)
    virtual_column_proxy = VirtualColumnProxyModel()
    virtual_column_proxy.setSourceModel(filter_proxy)
    
    # Third proxy (highlighting)
    highlight_proxy = HighlightProxyModel(highlight_rows=[1, 3, 5])
    highlight_proxy.setSourceModel(virtual_column_proxy)
    
    # Set the final proxy to the view
    view.setModel(highlight_proxy)
    

    3. Multiple Delegates for Different Rows

    Yes, you can use multiple delegates for different rows, but you need to manage them through a single delegate that acts as a dispatcher:

    class MultiDelegate(QStyledItemDelegate):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.delegates = {}  # {row: delegate} mapping
    
        def setDelegateForRow(self, row, delegate):
            self.delegates[row] = delegate
    
        def paint(self, painter, option, index):
            delegate = self.delegates.get(index.row(), self)
            delegate.paint(painter, option, index)
    
        def sizeHint(self, option, index):
            delegate = self.delegates.get(index.row(), self)
            return delegate.sizeHint(option, index)
    
        def createEditor(self, parent, option, index):
            delegate = self.delegates.get(index.row(), self)
            return delegate.createEditor(parent, option, index)
    
        def setEditorData(self, editor, index):
            delegate = self.delegates.get(index.row(), self)
            delegate.setEditorData(editor, index)
    
        def setModelData(self, editor, model, index):
            delegate = self.delegates.get(index.row(), self)
            delegate.setModelData(editor, model, index)
    

    Complete Example Combining All Concepts

    Here's a complete example that demonstrates all these concepts together:

    from PyQt5.QtWidgets import (QApplication, QMainWindow, QTreeView, QVBoxLayout,
                                QWidget, QStyledItemDelegate, QStyleOptionViewItem)
    from PyQt5.QtCore import (Qt, QAbstractTableModel, QModelIndex, QIdentityProxyModel,
                             QSortFilterProxyModel)
    from PyQt5.QtGui import QColor, QPainter, QBrush
    
    class OriginalModel(QAbstractTableModel):
        def __init__(self, data, parent=None):
            super().__init__(parent)
            self._data = data
    
        def rowCount(self, parent=QModelIndex()):
            return len(self._data)
    
        def columnCount(self, parent=QModelIndex()):
            return 2  # Original columns
    
        def data(self, index, role=Qt.DisplayRole):
            if role == Qt.DisplayRole:
                return self._data[index.row()][index.column()]
            return None
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal and role == Qt.DisplayRole:
                return ["Name", "Value"][section]
            return None
    
    class VirtualColumnProxyModel(QIdentityProxyModel):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.virtual_columns = 1
    
        def columnCount(self, parent=QModelIndex()):
            return super().columnCount(parent) + self.virtual_columns
    
        def data(self, index, role=Qt.DisplayRole):
            if not index.isValid():
                return None
    
            if index.column() >= super().columnCount(index.parent()):
                if role == Qt.DisplayRole:
                    return f"Virtual {index.row()}"
                elif role == Qt.BackgroundRole:
                    return QColor(220, 230, 240)
                return None
    
            return super().data(index, role)
    
        def headerData(self, section, orientation, role=Qt.DisplayRole):
            if orientation == Qt.Horizontal:
                if section >= super().columnCount():
                    if role == Qt.DisplayRole:
                        return "Virtual Data"
                    return None
            return super().headerData(section, orientation, role)
    
    class HighlightDelegate(QStyledItemDelegate):
        def __init__(self, highlight_rows, parent=None):
            super().__init__(parent)
            self.highlight_rows = highlight_rows
    
        def initStyleOption(self, option, index):
            super().initStyleOption(option, index)
            if index.row() in self.highlight_rows:
                option.backgroundBrush = QBrush(QColor(255, 230, 200))
    
    class SpecialRowDelegate(QStyledItemDelegate):
        def paint(self, painter, option, index):
            option.backgroundBrush = QBrush(QColor(200, 230, 255))
            super().paint(painter, option, index)
    
    class MultiDelegate(QStyledItemDelegate):
        def __init__(self, parent=None):
            super().__init__(parent)
            self.delegates = {}  # {row: delegate} mapping
    
        def setDelegateForRow(self, row, delegate):
            self.delegates[row] = delegate
    
        def paint(self, painter, option, index):
            delegate = self.delegates.get(index.row(), self)
            delegate.paint(painter, option, index)
    
        def sizeHint(self, option, index):
            delegate = self.delegates.get(index.row(), self)
            return delegate.sizeHint(option, index)
    
    class MainWindow(QMainWindow):
        def __init__(self):
            super().__init__()
    
            # Sample data
            data = [["Item {}".format(i), i * 10] for i in range(20)]
    
            # Original model
            original_model = OriginalModel(data)
    
            # First proxy - filtering
            filter_proxy = QSortFilterProxyModel()
            filter_proxy.setSourceModel(original_model)
            filter_proxy.setFilterKeyColumn(0)
            filter_proxy.setFilterFixedString("Item")  # Show all items in this example
    
            # Second proxy - adding virtual columns
            virtual_proxy = VirtualColumnProxyModel()
            virtual_proxy.setSourceModel(filter_proxy)
    
            # View setup
            self.view = QTreeView()
            self.view.setModel(virtual_proxy)
    
            # Multi-delegate setup
            multi_delegate = MultiDelegate()
    
            # Set special delegate for specific rows
            highlight_delegate = HighlightDelegate(highlight_rows=[1, 3, 5, 7])
            special_delegate = SpecialRowDelegate()
    
            for row in [1, 3, 5, 7]:
                multi_delegate.setDelegateForRow(row, highlight_delegate)
            for row in [2, 6, 8]:
                multi_delegate.setDelegateForRow(row, special_delegate)
    
            self.view.setItemDelegate(multi_delegate)
    
            # Layout
            central_widget = QWidget()
            layout = QVBoxLayout(central_widget)
            layout.addWidget(self.view)
            self.setCentralWidget(central_widget)
    
    if __name__ == "__main__":
        import sys
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    

    Key Takeaways

    1. Virtual Columns: Best implemented with a proxy model that adds to the column count
    2. Multiple Proxies: You can chain proxy models to create complex transformations
    3. Multiple Delegates: Use a dispatcher delegate to apply different delegates to different rows
    4. Non-Destructive: All these techniques work without modifying the original model data

    This architecture gives you maximum flexibility to:

    • Add visual columns that don't exist in the original data
    • Apply different styling to different rows
    • Chain multiple transformations
    • Keep the original data pristine while presenting rich visual representations

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.