QHeaderView going out of viewport

Question

I'm having couple of issues while trying to make a QHeaderView for my QTableView.

1. I want QHeaderView to be resizable by the user (Qt.ResizeMode.Interactive) while being able to stretch its sections proportionately when the window or QTableView is being resized. I found this problem online, and managed to mostly solve it but there is still some stuttering when the resizing begins and I think there should be a better solution than mine. Currently it's done by using QTimer to stop sections from going out of the viewport. Timer is being updated every millisecond. If the update interval is bigger, sections would go out of viewport and magically teleport back when the timer is updated, so once per millisecond in my case. There's still some stuttering visible if the user is dragging sections out of the viewport by dragging their mouse faster, not so visible when the mouse is slower, but visible none the less.
2. Every section should be resizable and movable, besides the first two. The first two sections should be immovable and fixed. I managed to make them fixed and they don't seem to have an effect on resizing of the sections, but I have no idea how to make them immovable while all the other sections are movable.
3. Sections should have text eliding, which I managed to make an item delegate for, but setting it on QHeaderView seems to do absolutely nothing (paint() method doesn't even get called). It's probably because item delegate isn't affecting sections, if so, how can I make a delegate that does affect them?

Here's my current code (it's a bit of a mess, but hopefully you'll get the idea):

import sys
import weakref
from typing import Any, Optional

from PyQt6 import QtWidgets, QtCore, QtGui
from PyQt6.QtCore import pyqtSlot, Qt
from PyQt6.QtGui import QFontMetrics
from PyQt6.QtWidgets import QHeaderView, QStyledItemDelegate, QStyleOptionViewItem


class MyItemDelegate(QStyledItemDelegate):
    def __init__(self, parent=None):
        super().__init__(parent)

    def paint(self, painter: QtGui.QPainter, option: QStyleOptionViewItem, index: QtCore.QModelIndex) -> None:
        text = index.data(Qt.ItemDataRole.DisplayRole)
        # print(text)
        if text:
            elided_text = QFontMetrics(option.font).elidedText(str(text), Qt.TextElideMode.ElideRight, option.rect.width())
            painter.drawText(option.rect, Qt.AlignmentFlag.AlignLeft, elided_text)


class HeaderView(QtWidgets.QHeaderView):
    def __init__(self,
                 orientation: QtCore.Qt.Orientation = Qt.Orientation.Horizontal,
                 parent: Optional[QtWidgets.QWidget] = None):
        super(HeaderView, self).__init__(orientation, parent)
        item_delegate = MyItemDelegate(self)
        self.setItemDelegate(item_delegate)

        self.setMinimumSectionSize(5)
        self.setStretchLastSection(True)
        self.setCascadingSectionResizes(True)
        self.setSectionsMovable(True)

        self.fixed_section_indexes = (0, 1)

        timer = QtCore.QTimer(self)
        timer.setSingleShot(True)
        timer.setTimerType(Qt.TimerType.PreciseTimer)
        timer.timeout.connect(self._update_sizes)

        resize_mode_timer = QtCore.QTimer(self)
        resize_mode_timer.setTimerType(Qt.TimerType.PreciseTimer)
        resize_mode_timer.setSingleShot(True)
        resize_mode_timer.timeout.connect(lambda: self.setSectionResizeMode(QHeaderView.ResizeMode.Interactive))

        self._resize_mode_timer = weakref.proxy(resize_mode_timer)
        self._timer = weakref.proxy(timer)
        self.sectionResized.connect(self._handle_resize)

        self.setTextElideMode(Qt.TextElideMode.ElideLeft)
        self.setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)

        self.proportions = []

        self.mouse_pressed = False

    def mouseReleaseEvent(self, e: QtGui.QMouseEvent) -> None:
        self.mouse_pressed = False
        super().mouseReleaseEvent(e)
        self.proportions = [self.sectionSize(i) / self.width() for i in range(self.count())]
        # print(self.mouse_pressed)

    def init_sizes(self):
        each = self.width() // self.count()
        for i in range(self.count()):
            self.resizeSection(self.logicalIndex(i), each)

    @pyqtSlot(int, int, int)
    def _handle_resize(self, logicalIndex: int, oldSize: int, newSize: int):
        self._timer.start(1)

    def resizeEvent(self, event: QtGui.QResizeEvent):
        super().resizeEvent(event)
        width = self.width()
        # sizes = [self.sectionSize(self.logicalIndex(i)) for i in range(self.count())]
        width_without_fixed = width - sum([self.sectionSize(i) for i in self.fixed_section_indexes])

        for i in range(self.count()):
            if not self.proportions:
                break

            if i not in self.fixed_section_indexes:
                self.resizeSection(i, int(self.proportions[i] * width_without_fixed))

        self._timer.start(1)

    @pyqtSlot()
    def _update_sizes(self):
        width = self.width()
        sizes = [self.sectionSize(self.logicalIndex(i)) for i in range(self.count())]
        # width_without_fixed = width - sum([self.sectionSize(i) for i in self.fixed_section_indexes])
        index = len(sizes) - 1
        i = 0
        while index >= 0 and sum(sizes) > width:
            i += 1
            if i > 100:
                break
            if sizes[index] > 5 and index not in self.fixed_section_indexes:  # minimum width (5)
                new_width = width - (sum(sizes) - sizes[index])
                if new_width < 5:
                    new_width = 5
                sizes[index] = new_width
            index -= 1
        for j, value in enumerate(sizes):
            self.resizeSection(self.logicalIndex(j), value)
        if not self.proportions:
            self.proportions = [self.sectionSize(i) / width for i in range(self.count())]


class Model(QtCore.QAbstractTableModel):
    def __init__(self, parent: Optional[QtWidgets.QWidget] = None) -> None:
        super(Model, self).__init__(parent)
        self.__headers = ["Column A", "Column B", "Column C", "Column D", "Column E", "Column F", "Column G"]
        self.__data = []
        for i in range(10):
            row = [0, 1, 2, 3, 42222222222, 5, 6, 74444444]
            self.__data.append(row)

    def rowCount(self, index: Optional[QtCore.QModelIndex] = None) -> int:
        return len(self.__data)

    def columnCount(self, index: Optional[QtCore.QModelIndex] = None) -> int:
        return len(self.__headers)

    def headerData(self, section: int, orientation: QtCore.Qt.Orientation,
                   role: QtCore.Qt.ItemDataRole = Qt.ItemDataRole.DisplayRole) -> Any:
        if role == Qt.ItemDataRole.DisplayRole:
            if orientation == Qt.Orientation.Horizontal:
                return self.__headers[section]
            return f"{section}"
        return None

    def data(self, index: QtCore.QModelIndex,
             role: QtCore.Qt.ItemDataRole = Qt.ItemDataRole.DisplayRole) -> Any:
        if role in [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole]:
            return self.__data[index.row()][index.column()]
        return None


if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    view = QtWidgets.QTableView()
    view.resize(600, 600)
    header = HeaderView()
    view.setHorizontalHeader(header)
    model = Model()
    view.setModel(model)
    header.init_sizes()
    view.horizontalHeader().resizeSection(0, 30)
    view.horizontalHeader().setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
    view.horizontalHeader().resizeSection(1, 30)
    view.horizontalHeader().setSectionResizeMode(1, QHeaderView.ResizeMode.Fixed)
    view.show()
    app.exec()