pacebar 0.1.0__py3-none-any.whl

pacebar/__init__.py

@@ -0,0 +1,3 @@
+"""PaceBar — a floating pacing timer for timeboxed stages."""
+
+__version__ = "0.1.0"

pacebar/__main__.py

@@ -0,0 +1,20 @@
+"""Entry point: `python -m pacebar` / the `pacebar` script / the exe."""
+
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from .app import App
+from .constants import APP_DISPLAY_NAME
+
+
+def main() -> int:
+    qt_application = QApplication(sys.argv)
+    qt_application.setApplicationName(APP_DISPLAY_NAME)
+    app = App()
+    app.show()
+    return qt_application.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pacebar/app.py

@@ -0,0 +1,24 @@
+"""Application controller: wires the editor to a run, persists the run on start."""
+
+from PySide6.QtWidgets import QApplication
+
+from .editor import EditorWindow
+from .overlay import RunController
+from .persistence import save_sections
+
+
+class App:
+    def __init__(self):
+        self.editor = EditorWindow()
+        self.editor.start_requested.connect(self._start_run)
+        self.run: RunController | None = None
+
+    def show(self):
+        self.editor.show()
+
+    def _start_run(self, sections, lateness_seconds, yellow_percent, yellow_seconds):
+        # Persist the schedule (order + minutes + names only) as the run begins.
+        save_sections(sections)
+        self.editor.hide()
+        self.run = RunController(sections, lateness_seconds, yellow_percent, yellow_seconds)
+        self.run.finished.connect(QApplication.instance().quit)

pacebar/constants.py

@@ -0,0 +1,29 @@
+"""Constants shared across modules.
+
+Purely cosmetic, single-use dimensions live next to the code that uses them;
+this file holds values that are shared or worth tuning in one place.
+"""
+
+# Identity and storage
+APP_DISPLAY_NAME = "PaceBar"
+LAST_RUN_FILENAME = "pacebar_last_run.json"
+
+# Section / editor limits and defaults
+MIN_SECTION_MINUTES = 1
+MAX_SECTION_MINUTES = 999
+MAX_LATENESS_MINUTES = 999
+MAX_SECTION_NAME_LENGTH = 30
+MAX_YELLOW_PERCENT = 100
+MAX_YELLOW_SECONDS = 3600
+DEFAULT_YELLOW_PERCENT = 10
+DEFAULT_YELLOW_SECONDS = 30
+
+# Overlay rendering
+RENDER_INTERVAL_MS = 100  # ~10 Hz; the smallest shown unit is one second
+OVERLAY_FONT_POINT_INCREASE = 2
+OVERLAY_HEIGHT_FACTOR = 1.6
+
+# Pastel status colors for the strip and minimized square
+PASTEL_GREEN = "#cfe8cf"
+PASTEL_YELLOW = "#f6efb4"
+PASTEL_RED = "#f2c4c4"

pacebar/editor/__init__.py

@@ -0,0 +1,5 @@
+"""The setup window where the user defines the meeting's sections."""
+
+from .window import EditorWindow
+
+__all__ = ["EditorWindow"]

pacebar/editor/fields.py

@@ -0,0 +1,91 @@
+"""Input widgets for a section row: the minutes spin box and the name field."""
+
+from PySide6.QtCore import QEvent, Qt, QTimer, Signal
+from PySide6.QtWidgets import QLineEdit, QSpinBox
+
+from ..constants import (
+    MAX_SECTION_MINUTES,
+    MAX_SECTION_NAME_LENGTH,
+    MIN_SECTION_MINUTES,
+    PASTEL_RED,
+)
+
+_TAB_KEYS = (Qt.Key_Tab, Qt.Key_Backtab)
+_ENTER_KEYS = (Qt.Key_Return, Qt.Key_Enter)
+_MINUTES_FIELD_WIDTH = 95
+_NAME_OVERFLOW_BLINK_MS = 120
+
+
+class MinutesSpinBox(QSpinBox):
+    """Whole-minutes spin box that keeps Tab and Enter inside the current row."""
+
+    tab_pressed = Signal()
+    enter_pressed = Signal()
+
+    def __init__(self, value: int = MIN_SECTION_MINUTES):
+        super().__init__()
+        self.setRange(MIN_SECTION_MINUTES, MAX_SECTION_MINUTES)
+        self.setValue(max(MIN_SECTION_MINUTES, value))
+        self.setSuffix(" min")
+        self.setFixedWidth(_MINUTES_FIELD_WIDTH)
+
+    def event(self, event):
+        # Tab is consumed by the focus framework before keyPressEvent, so we
+        # intercept it here in event() instead.
+        if event.type() == QEvent.KeyPress:
+            if event.key() in _TAB_KEYS:
+                self.tab_pressed.emit()
+                return True
+            if event.key() in _ENTER_KEYS:
+                self.enter_pressed.emit()
+                return True
+        return super().event(event)
+
+
+class NameLineEdit(QLineEdit):
+    """Section name field: caps at MAX_SECTION_NAME_LENGTH and blinks when full."""
+
+    tab_pressed = Signal()
+    enter_pressed = Signal()
+    up_pressed = Signal()
+    down_pressed = Signal()
+
+    def __init__(self, text: str = ""):
+        super().__init__(text)
+        self.setMaxLength(MAX_SECTION_NAME_LENGTH)
+        self.setPlaceholderText("Section name")
+        self._default_style = self.styleSheet()
+
+    def event(self, event):
+        if event.type() == QEvent.KeyPress:
+            key = event.key()
+            if key in _TAB_KEYS:
+                self.tab_pressed.emit()
+                return True
+            if key in _ENTER_KEYS:
+                self.enter_pressed.emit()
+                return True
+            # Up/Down jump between rows (the spin box keeps arrows for its value).
+            if key == Qt.Key_Up:
+                self.up_pressed.emit()
+                return True
+            if key == Qt.Key_Down:
+                self.down_pressed.emit()
+                return True
+            if self._is_overflow_keystroke(event):
+                self._blink()
+                return True
+        return super().event(event)
+
+    def _is_overflow_keystroke(self, event) -> bool:
+        text = event.text()
+        return bool(
+            text
+            and text.isprintable()
+            and len(self.text()) >= MAX_SECTION_NAME_LENGTH
+            and not self.hasSelectedText()
+        )
+
+    def _blink(self):
+        self.setStyleSheet(f"background:{PASTEL_RED};")
+        QTimer.singleShot(_NAME_OVERFLOW_BLINK_MS, lambda: self.setStyleSheet(self._default_style))

pacebar/editor/row.py

@@ -0,0 +1,83 @@
+"""A single editable section row."""
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtWidgets import QHBoxLayout, QPushButton, QToolButton, QVBoxLayout, QWidget
+
+from ..timing import Section
+from .fields import MinutesSpinBox, NameLineEdit
+
+_MOVE_BUTTON_WIDTH = 26
+_MOVE_BUTTON_HEIGHT = 13
+_ROW_BUTTON_WIDTH = 30
+
+
+class RowWidget(QWidget):
+    """One section row: minutes, name, reorder, add and delete controls."""
+
+    add_after_requested = Signal(object)
+    delete_requested = Signal(object)
+    move_up_requested = Signal(object)
+    move_down_requested = Signal(object)
+    focus_up_requested = Signal(object)
+    focus_down_requested = Signal(object)
+
+    def __init__(self, minutes: int = 1, name: str = ""):
+        super().__init__()
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(6)
+
+        self.minutes = MinutesSpinBox(minutes)
+        self.name = NameLineEdit(name)
+
+        self.move_up_button = QToolButton()
+        self.move_up_button.setText("▲")
+        self.move_down_button = QToolButton()
+        self.move_down_button.setText("▼")
+        move_box = self._build_move_box()
+
+        self.add_button = QPushButton("+")
+        self.delete_button = QPushButton("✕")
+        for button in (self.add_button, self.delete_button):
+            button.setFixedWidth(_ROW_BUTTON_WIDTH)
+            button.setFocusPolicy(Qt.NoFocus)
+
+        layout.addWidget(self.minutes)
+        layout.addWidget(self.name, 1)
+        layout.addWidget(move_box)
+        layout.addWidget(self.add_button)
+        layout.addWidget(self.delete_button)
+
+        self._connect_signals()
+
+    def _build_move_box(self) -> QWidget:
+        """A visually-joined up/down control."""
+        box = QWidget()
+        box_layout = QVBoxLayout(box)
+        box_layout.setContentsMargins(0, 0, 0, 0)
+        box_layout.setSpacing(0)
+        for button in (self.move_up_button, self.move_down_button):
+            button.setAutoRaise(True)
+            button.setFocusPolicy(Qt.NoFocus)
+            button.setFixedSize(_MOVE_BUTTON_WIDTH, _MOVE_BUTTON_HEIGHT)
+            box_layout.addWidget(button)
+        return box
+
+    def _connect_signals(self):
+        # Tab / Shift+Tab cycle only between the two fields of this row.
+        self.minutes.tab_pressed.connect(self.name.setFocus)
+        self.name.tab_pressed.connect(self.minutes.setFocus)
+        # Enter in either field appends a new row.
+        self.minutes.enter_pressed.connect(lambda: self.add_after_requested.emit(self))
+        self.name.enter_pressed.connect(lambda: self.add_after_requested.emit(self))
+        # Up/Down in the name field move between existing rows.
+        self.name.up_pressed.connect(lambda: self.focus_up_requested.emit(self))
+        self.name.down_pressed.connect(lambda: self.focus_down_requested.emit(self))
+
+        self.move_up_button.clicked.connect(lambda: self.move_up_requested.emit(self))
+        self.move_down_button.clicked.connect(lambda: self.move_down_requested.emit(self))
+        self.add_button.clicked.connect(lambda: self.add_after_requested.emit(self))
+        self.delete_button.clicked.connect(lambda: self.delete_requested.emit(self))
+
+    def section(self) -> Section:
+        return Section(self.minutes.value(), self.name.text().strip())

pacebar/editor/window.py

@@ -0,0 +1,178 @@
+"""The setup window: a toolbar plus one editable row per section."""
+
+from PySide6.QtCore import Signal
+from PySide6.QtWidgets import (
+    QFrame,
+    QHBoxLayout,
+    QLabel,
+    QPushButton,
+    QScrollArea,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..constants import (
+    APP_DISPLAY_NAME,
+    DEFAULT_YELLOW_PERCENT,
+    DEFAULT_YELLOW_SECONDS,
+    MAX_LATENESS_MINUTES,
+    MAX_YELLOW_PERCENT,
+    MAX_YELLOW_SECONDS,
+)
+from ..persistence import load_sections
+from .row import RowWidget
+
+_WINDOW_DEFAULT_SIZE = (560, 440)
+_SECONDS_PER_MINUTE = 60
+
+
+class EditorWindow(QWidget):
+    """Top-level setup window."""
+
+    # sections, lateness_seconds, yellow_percent, yellow_seconds
+    start_requested = Signal(object, int, int, int)
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle(APP_DISPLAY_NAME)
+        self.rows: list[RowWidget] = []
+
+        root_layout = QVBoxLayout(self)
+        root_layout.addLayout(self._build_toolbar())
+        root_layout.addWidget(self._build_rows_area(), 1)
+
+        self._load_initial_rows()
+        self.resize(*_WINDOW_DEFAULT_SIZE)
+
+    # --- construction ---------------------------------------------------
+
+    def _build_toolbar(self) -> QHBoxLayout:
+        toolbar = QHBoxLayout()
+
+        self.start_button = QPushButton("▶ Start")
+        self.start_button.clicked.connect(self._on_start)
+        self.lateness = QSpinBox()
+        self.lateness.setRange(0, MAX_LATENESS_MINUTES)
+        self.lateness.setSuffix(" min late")
+        self.reset_button = QPushButton("⟳ Reset")
+        self.reset_button.clicked.connect(self.reset)
+
+        toolbar.addWidget(self.start_button)
+        toolbar.addWidget(self.lateness)
+        toolbar.addWidget(self.reset_button)
+        toolbar.addStretch(1)
+
+        toolbar.addWidget(QLabel("Yellow at"))
+        self.yellow_percent = QSpinBox()
+        self.yellow_percent.setRange(0, MAX_YELLOW_PERCENT)
+        self.yellow_percent.setValue(DEFAULT_YELLOW_PERCENT)
+        self.yellow_percent.setSuffix(" %")
+        self.yellow_seconds = QSpinBox()
+        self.yellow_seconds.setRange(0, MAX_YELLOW_SECONDS)
+        self.yellow_seconds.setValue(DEFAULT_YELLOW_SECONDS)
+        self.yellow_seconds.setSuffix(" s")
+        toolbar.addWidget(self.yellow_percent)
+        toolbar.addWidget(QLabel("or"))
+        toolbar.addWidget(self.yellow_seconds)
+        return toolbar
+
+    def _build_rows_area(self) -> QScrollArea:
+        self.rows_container = QWidget()
+        self.rows_layout = QVBoxLayout(self.rows_container)
+        self.rows_layout.setContentsMargins(0, 0, 0, 0)
+        self.rows_layout.setSpacing(4)
+        self.rows_layout.addStretch(1)
+
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+        scroll_area.setWidget(self.rows_container)
+        scroll_area.setFrameShape(QFrame.NoFrame)
+        return scroll_area
+
+    # --- row management -------------------------------------------------
+
+    def _make_row(self, minutes: int, name: str) -> RowWidget:
+        row = RowWidget(minutes, name)
+        row.add_after_requested.connect(self._add_after)
+        row.delete_requested.connect(self._delete)
+        row.move_up_requested.connect(self._move_up)
+        row.move_down_requested.connect(self._move_down)
+        row.focus_up_requested.connect(self._focus_up)
+        row.focus_down_requested.connect(self._focus_down)
+        return row
+
+    def _insert_row(self, index: int, minutes: int = 1, name: str = "") -> RowWidget:
+        row = self._make_row(minutes, name)
+        self.rows.insert(index, row)
+        self.rows_layout.insertWidget(index, row)  # trailing stretch stays last
+        return row
+
+    def _add_after(self, row: RowWidget):
+        index = self.rows.index(row) + 1
+        new_row = self._insert_row(index)
+        new_row.minutes.setFocus()
+
+    def _delete(self, row: RowWidget):
+        self.rows.remove(row)
+        row.setParent(None)
+        row.deleteLater()
+        if not self.rows:
+            self._insert_row(0)
+
+    def _move_up(self, row: RowWidget):
+        index = self.rows.index(row)
+        if index > 0:
+            self._swap(index, index - 1)
+
+    def _move_down(self, row: RowWidget):
+        index = self.rows.index(row)
+        if index < len(self.rows) - 1:
+            self._swap(index, index + 1)
+
+    def _swap(self, first: int, second: int):
+        self.rows[first], self.rows[second] = self.rows[second], self.rows[first]
+        for row in self.rows:
+            self.rows_layout.removeWidget(row)
+        for position, row in enumerate(self.rows):
+            self.rows_layout.insertWidget(position, row)
+
+    def _focus_up(self, row: RowWidget):
+        index = self.rows.index(row)
+        if index > 0:
+            self.rows[index - 1].name.setFocus()
+
+    def _focus_down(self, row: RowWidget):
+        index = self.rows.index(row)
+        if index < len(self.rows) - 1:
+            self.rows[index + 1].name.setFocus()
+
+    def _load_initial_rows(self):
+        saved_sections = load_sections()
+        if saved_sections:
+            for section in saved_sections:
+                self._insert_row(len(self.rows), section.minutes, section.name)
+        else:
+            self._insert_row(0)
+
+    # --- actions --------------------------------------------------------
+
+    def reset(self):
+        for row in list(self.rows):
+            row.setParent(None)
+            row.deleteLater()
+        self.rows.clear()
+        self._insert_row(0)
+
+    def _on_start(self):
+        sections = [row.section() for row in self.rows]
+        sections = [section for section in sections if section.name]
+        if not sections:
+            return
+        lateness_seconds = self.lateness.value() * _SECONDS_PER_MINUTE
+        self.start_requested.emit(
+            sections,
+            lateness_seconds,
+            self.yellow_percent.value(),
+            self.yellow_seconds.value(),
+        )

pacebar/formatting.py

@@ -0,0 +1,14 @@
+"""Display formatting helpers."""
+
+
+def format_duration(total_seconds: float, show_hours: bool) -> str:
+    """Format seconds as [-]HH:MM:SS, hiding the hours group when not needed."""
+    is_negative = total_seconds < 0
+    whole_seconds = int(abs(total_seconds))
+    hours, remainder = divmod(whole_seconds, 3600)
+    minutes, seconds = divmod(remainder, 60)
+    if show_hours:
+        body = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+    else:
+        body = f"{minutes:02d}:{seconds:02d}"
+    return ("-" if is_negative else "") + body

pacebar/overlay/__init__.py

@@ -0,0 +1,5 @@
+"""The running overlay: the floating strip, the minimized square and hotkeys."""
+
+from .controller import RunController
+
+__all__ = ["RunController"]

pacebar/overlay/bar.py

@@ -0,0 +1,80 @@
+"""The flat top strip shown while a meeting runs."""
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QFont
+from PySide6.QtWidgets import QHBoxLayout, QLabel, QPushButton, QWidget
+
+_FRAMELESS_TOPMOST = Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint | Qt.Tool
+
+
+class OverlayBar(QWidget):
+    """The flat top strip. Every variable-width part is pinned so width is stable."""
+
+    back_clicked = Signal()
+    next_clicked = Signal()
+    minimize_clicked = Signal()
+    cancel_clicked = Signal()
+
+    def __init__(
+        self,
+        font: QFont,
+        height: int,
+        timer_width: int,
+        name_width: int,
+        next_width: int,
+    ):
+        super().__init__(None, _FRAMELESS_TOPMOST)
+        self.setAttribute(Qt.WA_StyledBackground, True)
+        self.setFixedHeight(height)
+
+        layout = QHBoxLayout(self)
+        layout.setContentsMargins(8, 0, 8, 0)
+        layout.setSpacing(10)
+
+        self.back_button = self._make_flat_button("◀", font)
+        self.timer_label = QLabel()
+        self.timer_label.setFont(font)
+        self.timer_label.setFixedWidth(timer_width)
+        self.current_label = QLabel()
+        self.current_label.setFont(font)
+        self.current_label.setFixedWidth(name_width)
+        self.next_button = self._make_flat_button("", font)
+        self.next_button.setFixedWidth(next_width)
+        self.minimize_button = self._make_flat_button("▢", font)
+        self.cancel_button = self._make_flat_button("✕", font)
+
+        layout.addWidget(self.back_button)
+        layout.addWidget(self.timer_label)
+        layout.addWidget(self.current_label)
+        layout.addWidget(self.next_button)
+        layout.addWidget(self.minimize_button)
+        layout.addWidget(self.cancel_button)
+
+        self.back_button.clicked.connect(self.back_clicked)
+        self.next_button.clicked.connect(self.next_clicked)
+        self.minimize_button.clicked.connect(self.minimize_clicked)
+        self.cancel_button.clicked.connect(self.cancel_clicked)
+
+    def _make_flat_button(self, text: str, font: QFont) -> QPushButton:
+        button = QPushButton(text)
+        button.setFont(font)
+        button.setFlat(True)
+        button.setCursor(Qt.PointingHandCursor)
+        button.setFocusPolicy(Qt.NoFocus)
+        button.setStyleSheet(
+            "QPushButton{border:none;background:transparent;padding:0 4px;text-align:left;}"
+            "QPushButton:hover{background:rgba(0,0,0,0.08);}"
+        )
+        return button
+
+    def set_color(self, color: str):
+        self.setStyleSheet(f"OverlayBar{{background:{color};}}")
+
+    def set_timer_text(self, text: str):
+        self.timer_label.setText(text)
+
+    def set_current(self, name: str):
+        self.current_label.setText(name)
+
+    def set_next(self, label: str):
+        self.next_button.setText(label)

pacebar/overlay/controller.py

@@ -0,0 +1,154 @@
+"""Run controller: owns the timer model, both windows, render loop and hotkeys."""
+
+from PySide6.QtCore import QObject, QPoint, QTimer, Signal
+from PySide6.QtGui import QCursor, QFontMetrics, QGuiApplication
+from PySide6.QtWidgets import QApplication
+
+from ..constants import (
+    OVERLAY_FONT_POINT_INCREASE,
+    OVERLAY_HEIGHT_FACTOR,
+    PASTEL_GREEN,
+    PASTEL_RED,
+    PASTEL_YELLOW,
+    RENDER_INTERVAL_MS,
+)
+from ..formatting import format_duration
+from ..timing import GREEN, RED, YELLOW, TimerModel
+from .bar import OverlayBar
+from .hotkeys import HotkeyBridge, start_global_hotkeys
+from .square import MiniSquare
+
+_STATUS_COLORS = {GREEN: PASTEL_GREEN, YELLOW: PASTEL_YELLOW, RED: PASTEL_RED}
+
+_SECONDS_PER_HOUR = 3600
+_TIMER_WIDTH_PADDING = 6
+_NAME_WIDTH_PADDING = 6
+_NEXT_WIDTH_PADDING = 10
+_SQUARE_TOP_MARGIN = 10
+
+
+class RunController(QObject):
+    """Owns the timer model, both windows, the render loop and global hotkeys."""
+
+    finished = Signal()
+
+    def __init__(self, sections, lateness_seconds, yellow_percent, yellow_seconds):
+        super().__init__()
+        self.model = TimerModel(sections, lateness_seconds)
+        self.yellow_percent = yellow_percent
+        self.yellow_seconds = yellow_seconds
+
+        font = QApplication.font()
+        if font.pointSize() > 0:
+            font.setPointSize(font.pointSize() + OVERLAY_FONT_POINT_INCREASE)
+        metrics = QFontMetrics(font)
+        bar_height = int(metrics.height() * OVERLAY_HEIGHT_FACTOR)
+
+        self.show_hours = max(s.seconds for s in sections) >= _SECONDS_PER_HOUR
+        timer_width, name_width, next_width = self._measure_widths(metrics, sections)
+
+        self.bar = OverlayBar(font, bar_height, timer_width, name_width, next_width)
+        self.bar.adjustSize()
+        self.bar.setFixedWidth(self.bar.width())
+        self.square = MiniSquare(bar_height)
+        self._square_shown = False
+        self._square_home = QPoint()
+
+        self._connect_windows()
+
+        self._render_timer = QTimer(self)
+        self._render_timer.timeout.connect(self.tick)
+        self._render_timer.start(RENDER_INTERVAL_MS)
+
+        self._place_bar()
+        self.bar.show()
+        self.tick()
+
+        self._hotkey_bridge = HotkeyBridge()
+        self._hotkey_bridge.next_requested.connect(self.on_next_button)
+        self._hotkey_bridge.back_requested.connect(self.on_back)
+        self._hotkey_listener = start_global_hotkeys(self._hotkey_bridge)
+
+    # --- setup ----------------------------------------------------------
+
+    def _measure_widths(self, metrics: QFontMetrics, sections):
+        """Size every variable-width part to its worst case for this run."""
+        worst_seconds = max(s.seconds for s in sections)
+        worst_timer_text = "-" + format_duration(worst_seconds, self.show_hours)
+        timer_width = metrics.horizontalAdvance(worst_timer_text) + _TIMER_WIDTH_PADDING
+
+        longest_name = max((s.name for s in sections), key=len, default="")
+        name_width = metrics.horizontalAdvance(longest_name) + _NAME_WIDTH_PADDING
+
+        next_labels = ["→ " + s.name for s in sections] + ["→ End"]
+        widest_next = max(metrics.horizontalAdvance(label) for label in next_labels)
+        next_width = widest_next + _NEXT_WIDTH_PADDING
+        return timer_width, name_width, next_width
+
+    def _connect_windows(self):
+        self.bar.back_clicked.connect(self.on_back)
+        self.bar.next_clicked.connect(self.on_next_button)
+        self.bar.minimize_clicked.connect(self.minimize)
+        self.bar.cancel_clicked.connect(self.cancel)
+        self.square.clicked.connect(self.restore)
+
+    # --- placement ------------------------------------------------------
+
+    def _place_bar(self):
+        screen = QGuiApplication.screenAt(QCursor.pos()) or QGuiApplication.primaryScreen()
+        geometry = screen.availableGeometry()
+        left = geometry.x() + (geometry.width() - self.bar.width()) // 2
+        self.bar.move(left, geometry.y())
+        square_left = geometry.x() + (geometry.width() - self.square.width()) // 2
+        self._square_home = QPoint(square_left, geometry.y() + _SQUARE_TOP_MARGIN)
+
+    # --- render ---------------------------------------------------------
+
+    def tick(self):
+        remaining = self.model.remaining()
+        self.bar.set_timer_text(format_duration(remaining, self.show_hours))
+        self.bar.set_current(self.model.current.name)
+        upcoming = self.model.next_section
+        self.bar.set_next("→ " + (upcoming.name if upcoming else "End"))
+        status = self.model.color(self.yellow_percent, self.yellow_seconds)
+        color = _STATUS_COLORS[status]
+        self.bar.set_color(color)
+        self.square.set_color(color)
+
+    # --- actions --------------------------------------------------------
+
+    def on_next_button(self):
+        # On the last section the button reads "End" and quits the program.
+        if self.model.is_last:
+            self.cancel()
+        else:
+            self.model.advance()
+            self.tick()
+
+    def on_back(self):
+        if self.model.go_back():
+            self.tick()
+
+    def minimize(self):
+        if not self._square_shown:
+            self.square.move(self._square_home)
+            self._square_shown = True
+        self.bar.hide()
+        self.square.show()
+
+    def restore(self):
+        self.square.hide()
+        self._place_bar()
+        self.bar.show()
+
+    def cancel(self):
+        self._render_timer.stop()
+        self._stop_hotkeys()
+        self.bar.close()
+        self.square.close()
+        self.finished.emit()
+
+    def _stop_hotkeys(self):
+        if self._hotkey_listener is not None:
+            self._hotkey_listener.stop()
+            self._hotkey_listener = None

pacebar/overlay/hotkeys.py

@@ -0,0 +1,112 @@
+"""Global hotkeys.
+
+On Windows we use the native ``RegisterHotKey`` API plugged into Qt's own
+message loop via a native event filter. That is far more robust in a frozen
+``--windowed`` exe than a background low-level keyboard hook (which silently
+receives no events there). On other platforms we fall back to pynput.
+"""
+
+import sys
+
+from PySide6.QtCore import QAbstractNativeEventFilter, QCoreApplication, QObject, Signal
+
+
+class HotkeyBridge(QObject):
+    """Carries hotkey events as Qt signals delivered on the main thread."""
+
+    next_requested = Signal()
+    back_requested = Signal()
+
+
+# Win32 RegisterHotKey modifiers / message / virtual-key codes.
+_MOD_ALT = 0x0001
+_MOD_CONTROL = 0x0002
+_MOD_NOREPEAT = 0x4000
+_WM_HOTKEY = 0x0312
+_VK_A = 0x41
+_VK_D = 0x44
+_HOTKEY_NEXT = 1
+_HOTKEY_BACK = 2
+
+
+class _WindowsHotkeys(QAbstractNativeEventFilter):
+    """Ctrl+Alt+D / Ctrl+Alt+A via native RegisterHotKey + Qt's message pump."""
+
+    def __init__(self, bridge: HotkeyBridge):
+        super().__init__()
+        import ctypes
+        from ctypes import wintypes
+
+        self._wintypes = wintypes
+        self._user32 = ctypes.windll.user32
+        self._user32.RegisterHotKey.argtypes = [
+            wintypes.HWND,
+            ctypes.c_int,
+            wintypes.UINT,
+            wintypes.UINT,
+        ]
+        self._user32.RegisterHotKey.restype = wintypes.BOOL
+        self._user32.UnregisterHotKey.argtypes = [wintypes.HWND, ctypes.c_int]
+        self._user32.UnregisterHotKey.restype = wintypes.BOOL
+
+        self._bridge = bridge
+        self._ids: list[int] = []
+        modifiers = _MOD_CONTROL | _MOD_ALT | _MOD_NOREPEAT
+        for hotkey_id, virtual_key in ((_HOTKEY_NEXT, _VK_D), (_HOTKEY_BACK, _VK_A)):
+            if self._user32.RegisterHotKey(None, hotkey_id, modifiers, virtual_key):
+                self._ids.append(hotkey_id)
+        QCoreApplication.instance().installNativeEventFilter(self)
+
+    def nativeEventFilter(self, event_type, message):
+        if event_type == b"windows_generic_MSG":
+            msg = self._wintypes.MSG.from_address(int(message))
+            if msg.message == _WM_HOTKEY:
+                if msg.wParam == _HOTKEY_NEXT:
+                    self._bridge.next_requested.emit()
+                elif msg.wParam == _HOTKEY_BACK:
+                    self._bridge.back_requested.emit()
+        return False, 0
+
+    def stop(self):
+        app = QCoreApplication.instance()
+        if app is not None:
+            app.removeNativeEventFilter(self)
+        for hotkey_id in self._ids:
+            self._user32.UnregisterHotKey(None, hotkey_id)
+        self._ids = []
+
+
+def start_global_hotkeys(bridge: HotkeyBridge):
+    """Start global hotkeys. Returns a handle with .stop(), or None if unavailable."""
+    if sys.platform == "win32":
+        try:
+            return _WindowsHotkeys(bridge)
+        except Exception:
+            return None
+    return _start_pynput(bridge)
+
+
+def _start_pynput(bridge: HotkeyBridge):
+    """Fallback for non-Windows (X11 etc.). May be blocked under Wayland."""
+    try:
+        from pynput import keyboard
+    except Exception:
+        return None
+
+    def on_next():
+        bridge.next_requested.emit()
+
+    def on_back():
+        bridge.back_requested.emit()
+
+    try:
+        listener = keyboard.GlobalHotKeys(
+            {
+                "<ctrl>+<alt>+d": on_next,
+                "<ctrl>+<alt>+a": on_back,
+            }
+        )
+        listener.start()
+        return listener
+    except Exception:
+        return None

pacebar/overlay/square.py

@@ -0,0 +1,42 @@
+"""The minimized square: a draggable, color-only status indicator."""
+
+from PySide6.QtCore import QPoint, Qt, Signal
+from PySide6.QtWidgets import QWidget
+
+_FRAMELESS_TOPMOST = Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint | Qt.Tool
+_DRAG_THRESHOLD_PX = 4
+
+
+class MiniSquare(QWidget):
+    """Small draggable square that signals status by color; a click restores."""
+
+    clicked = Signal()
+
+    def __init__(self, size: int):
+        super().__init__(None, _FRAMELESS_TOPMOST)
+        self.setAttribute(Qt.WA_StyledBackground, True)
+        self.setFixedSize(size, size)
+        self._press_position = None
+        self._window_origin = QPoint()
+        self._dragged = False
+
+    def set_color(self, color: str):
+        self.setStyleSheet(f"background:{color};")
+
+    def mousePressEvent(self, event):
+        self._press_position = event.globalPosition().toPoint()
+        self._window_origin = self.pos()
+        self._dragged = False
+
+    def mouseMoveEvent(self, event):
+        if self._press_position is None:
+            return
+        offset = event.globalPosition().toPoint() - self._press_position
+        if offset.manhattanLength() > _DRAG_THRESHOLD_PX:
+            self._dragged = True
+        self.move(self._window_origin + offset)
+
+    def mouseReleaseEvent(self, event):
+        if self._press_position is not None and not self._dragged:
+            self.clicked.emit()
+        self._press_position = None

pacebar/paths.py

@@ -0,0 +1,20 @@
+"""Filesystem locations for persisted state."""
+
+import sys
+from pathlib import Path
+
+from .constants import LAST_RUN_FILENAME
+
+
+def state_directory() -> Path:
+    """Folder of the running exe, so each copy keeps its own typical schedule.
+
+    When running from source there is no exe, so fall back to the current dir.
+    """
+    if getattr(sys, "frozen", False):
+        return Path(sys.executable).parent
+    return Path.cwd()
+
+
+def last_run_path() -> Path:
+    return state_directory() / LAST_RUN_FILENAME

pacebar/persistence.py

@@ -0,0 +1,24 @@
+"""Load/save the last run as a deliberately simple JSON file."""
+
+import json
+
+from .paths import last_run_path
+from .timing import Section
+
+
+def save_sections(sections) -> None:
+    """Persist sections in order. No lateness, no thresholds — kept minimal."""
+    data = [{"minutes": int(section.minutes), "name": section.name} for section in sections]
+    last_run_path().write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def load_sections():
+    """Return the saved sections, or [] if the file is missing/unreadable."""
+    path = last_run_path()
+    if not path.exists():
+        return []
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        return [Section(int(item["minutes"]), str(item["name"])) for item in data]
+    except Exception:
+        return []

pacebar/timing.py

@@ -0,0 +1,94 @@
+"""Pure timing model: stages, a global meeting clock and color state."""
+
+from dataclasses import dataclass
+from time import monotonic
+
+GREEN = "green"
+YELLOW = "yellow"
+RED = "red"
+
+
+@dataclass
+class Section:
+    minutes: int
+    name: str
+
+    @property
+    def seconds(self) -> int:
+        return self.minutes * 60
+
+
+class TimerModel:
+    """Drives the countdown using one global clock for the whole meeting.
+
+    Two pieces of state are enough to place every stage on the same timeline:
+
+    * ``_start`` — the monotonic instant the meeting began. It is shifted back by
+      the initial lateness, so elapsed time starts at ``lateness`` and the first
+      stage is already partway down (possibly negative).
+    * ``_accumulated`` — the planned seconds of all *completed* stages.
+
+    The remaining time of the current stage is therefore its planned cumulative
+    end minus the real elapsed time. Switching stages never restarts the clock,
+    so an overrun (or an early switch) carries straight over to the next stage.
+    """
+
+    def __init__(self, sections, lateness_seconds: int = 0):
+        if not sections:
+            raise ValueError("at least one section is required")
+        self.sections = list(sections)
+        self.index = 0
+        self._start = monotonic() - lateness_seconds
+        self._accumulated = 0.0
+
+    @property
+    def current(self) -> Section:
+        return self.sections[self.index]
+
+    @property
+    def is_last(self) -> bool:
+        return self.index >= len(self.sections) - 1
+
+    @property
+    def next_section(self):
+        return None if self.is_last else self.sections[self.index + 1]
+
+    def _elapsed(self) -> float:
+        return monotonic() - self._start
+
+    def remaining(self) -> float:
+        # Planned cumulative end of the current stage, minus real elapsed time.
+        return (self._accumulated + self.current.seconds) - self._elapsed()
+
+    def advance(self) -> bool:
+        """Move to the next stage. Returns False if already on the last one.
+
+        The real clock keeps running: we only bank the current stage's *planned*
+        duration, so any over/under-run rolls into the next stage automatically.
+        """
+        if self.is_last:
+            return False
+        self._accumulated += self.current.seconds
+        self.index += 1
+        return True
+
+    def go_back(self) -> bool:
+        """Roll back one stage — the exact inverse of advance().
+
+        The global clock keeps running, so the previous stage resumes exactly
+        where the timeline puts it: with the time it had left if you switched
+        early, or already overdue if you had overrun it.
+        """
+        if self.index == 0:
+            return False
+        self.index -= 1
+        self._accumulated -= self.current.seconds
+        return True
+
+    def color(self, yellow_percent: float, yellow_seconds: float) -> str:
+        remaining = self.remaining()
+        if remaining < 0:
+            return RED
+        # Yellow kicks in at whichever threshold is larger: percent or seconds.
+        threshold = max(self.current.seconds * yellow_percent / 100.0, yellow_seconds)
+        return YELLOW if remaining <= threshold else GREEN

pacebar-0.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: pacebar
+Version: 0.1.0
+Summary: Floating top-strip pacing timer for timeboxed stages — meetings, talks, workouts, even cooking — with countdown and color signalling.
+Author-email: Roman Voronov <roman.voronov.python.developer@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: countdown,meeting,overlay,pacing,presentation,pyside6,timer
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: pynput>=1.7
+Requires-Dist: pyside6>=6.6
+Provides-Extra: build
+Requires-Dist: pyinstaller>=6.3; extra == 'build'
+Provides-Extra: dev
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# PaceBar
+
+![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB?logo=python&logoColor=white)
+![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux-555)
+![License: MIT](https://img.shields.io/badge/License-MIT-green)
+![Made with Claude Code](https://img.shields.io/badge/Made%20with-Claude%20Code-D97757?logo=anthropic&logoColor=white)
+
+A small desktop tool that keeps you on time through any sequence of timed stages —
+a sales call, a talk, a workout, even a recipe. You enter the stages and how many
+minutes each should take; on **Start** a flat,
+always-on-top strip appears across the top of the screen and counts the current
+section down. The strip is **green** while you are on pace, **pastel yellow** when
+the section is almost over, and **pastel red** once you have run over — so you can
+feel the pacing without staring at numbers.
+
+Written in Python with **PySide6**. Built cross-platform (Windows + Linux);
+**tested and working on Windows 11**, **not yet tested on Linux** (feedback welcome).
+
+## Screenshots
+
+The setup window — one row per section, plus the start / lateness / reset toolbar:
+
+![Setup window](https://raw.githubusercontent.com/Rioran/pacebar/main/docs/images/editor.png)
+
+The running strip (here ~2 minutes left on the current section, next section as a
+button), and the minimized square that signals status by color alone:
+
+![Running strip](https://raw.githubusercontent.com/Rioran/pacebar/main/docs/images/strip.png)
+
+![Minimized square](https://raw.githubusercontent.com/Rioran/pacebar/main/docs/images/minimized.png)
+
+## Requirements
+
+- [uv](https://docs.astral.sh/uv/) (manages the virtual environment and dependencies)
+- Python 3.10+ (uv can install it for you)
+
+## Install
+
+```bash
+pip install pacebar
+pacebar
+```
+
+This pulls in PySide6 automatically and adds a `pacebar` command. (Prefer the
+standalone exe if you don't want a Python environment at all — see below.)
+
+## Run from source
+
+```bash
+uv sync            # create the venv and install dependencies
+uv run pacebar
+```
+
+Or run it in **one click** — double-click the script for your OS:
+
+- **Windows:** `scripts\run.bat`
+- **Linux / macOS:** `scripts/run.sh`
+
+(`uv sync` runs automatically the first time `uv run` is used.)
+
+## Build a standalone executable
+
+One click: double-click `scripts\build.bat` (Windows) or `scripts/build.sh`
+(Linux / macOS). Or run it manually:
+
+```bash
+uv run --extra build pyinstaller --noconfirm --clean pacebar.spec
+```
+
+The build is driven by [`pacebar.spec`](pacebar.spec) (a single
+`--windowed --onefile` build). The result lands in `dist/` (`pacebar.exe` on
+Windows) — one shareable file; it starts a touch slower because it unpacks to a temp
+dir on launch.
+
+PyInstaller does **not** cross-compile: it freezes for the OS you run the build on.
+Build on Windows to get the `.exe`, and on Linux (or WSL) to get a Linux binary — each
+runs only on its own platform. For a platform-independent option, use `pip install`
+above instead.
+
+## Lint & format
+
+```bash
+uv run ruff format .   # format
+uv run ruff check .    # lint
+```
+
+## Publishing to PyPI (maintainer)
+
+```bash
+uv build                          # builds the wheel + sdist into dist/
+uv publish dist/pacebar-*    # upload (needs a PyPI account + API token)
+```
+
+The `pacebar-*` glob is deliberate: it uploads only the wheel and sdist and skips
+`pacebar.exe`, which also lives in `dist/`. Test on TestPyPI first
+(`uv publish --publish-url https://test.pypi.org/legacy/ ...`), and make sure the
+project name is still available on PyPI before the first real upload.
+
+## How to use
+
+**Setup window**
+
+- Each row is one section: **minutes** (whole positive number — arrows or type) and a
+  **name** (max 30 characters; it blinks red if you try to type more).
+- **Tab / Shift+Tab** move between the two fields of the current row only.
+  **Up / Down** (while in the name field) jump to the name field of the row above /
+  below. **Enter** adds a new row. The `+` button also adds one; the ▲/▼ control
+  reorders; `✕` deletes.
+- **Start** is top-left. Next to it is **minutes late** — how late the meeting is
+  actually starting (subtracted from the first section). **Reset** clears everything
+  back to one empty row (no confirmation, by design).
+- **Yellow at … % or … s** controls the warning threshold: the strip turns yellow
+  when the remaining time drops below *whichever is larger* — that percentage of the
+  section, or that many seconds.
+
+**Running strip** (left → right)
+
+- ◀ **Back** — roll back one section. It resumes on the same global timeline: with the
+  time it still had if you switched early, or already overdue if you had overrun it.
+- **Timer** — counts the current section down; format `HH:MM:SS` with the hours group
+  hidden when no section is an hour or longer. Goes negative when you run over.
+- **Current section name.**
+- **→ Next section** — click to advance. On the last section it reads **→ End**;
+  clicking it exits the program.
+- ▢ **Minimize** — collapses to a small square that signals status by color only.
+  Drag it anywhere; click it to restore the full strip.
+- ✕ **Cancel** — quits the program.
+
+**Global hotkeys** (work even when another app is focused), laid out like game
+left/right (D = forward, A = back):
+
+- **Ctrl+Alt+D** — next section (right); on the last section it triggers **End** (exit)
+- **Ctrl+Alt+A** — back (left)
+
+> Chosen to stay clear of common conflicts: plain Alt+A mutes the mic in Zoom and
+> Alt+D jumps to the browser address bar. On non-US layouts Ctrl+Alt equals AltGr,
+> but that only matters while typing into a text field, not during a call.
+
+> The strip is intentionally visible to everyone on a screen share — it keeps the
+> whole call honest about time. There is deliberately **no pause**: business calls
+> have hard stops.
+
+## Saved state
+
+On every Start the schedule (order, minutes, names — no lateness, no thresholds) is
+written to `pacebar_last_run.json`, and it is loaded back the next time you launch. This
+also makes the tool handy for rehearsing a talk.
+
+The file lives **next to the running exe**, so each copy of the app keeps its own
+typical call scenario — drop a copy in a different project folder and it remembers a
+different schedule. (When running from source there is no exe, so it uses the current
+working directory instead.)
+
+## Notes & limitations
+
+- Global hotkeys need the `pynput` package (already a dependency). On Linux they work
+  under **X11**; under **Wayland** they may be blocked — the on-strip buttons always
+  work regardless.
+- Always-on-top is reliable over windowed apps (Zoom/Meet/Teams). A few apps in true
+  fullscreen-exclusive mode can still cover any topmost window.
+- The strip width is fixed for the run from the widest section name and worst-case
+  timer. An extreme overrun (more minutes over than the longest section) can still
+  nudge the timer width.

pacebar-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+pacebar/__init__.py,sha256=r0xu41rhHPYY0C2AniNOI9Qr2pblUpvBXU33vnTgWC0,87
+pacebar/__main__.py,sha256=-utKlA1Seqn8ksP7rW84kJiBSJRGVblq-qfBljFneKI,426
+pacebar/app.py,sha256=UpwYXMWGA2DAqgjAGfKlvwBZ-TQCot_czxxzGDb1YvY,849
+pacebar/constants.py,sha256=Dv9Oyt_Im7pgOBZdHvd_JBDVUQPqKVDyAQeA7cgUDrg,825
+pacebar/formatting.py,sha256=YwyzeSeKitD_IvB1ou1dMFfvFRWN1YOnaj9ih2nJ2KY,541
+pacebar/paths.py,sha256=9Gf0bgE9MoJ_CIY8ynjS2EBM5l0oTSE7R4AVbHACHGo,510
+pacebar/persistence.py,sha256=5cDTwal9CfLS5YqrYXcVFVzto1EsRDAe6q-aWzMYvvU,815
+pacebar/timing.py,sha256=hWi2jj-03drorCawo5F5a4XfuPWJN5i2IZ3ebhwAfbE,3192
+pacebar/editor/__init__.py,sha256=RK7_XFmgOsEmel2IUX_BrGYBJuzoayMqMjxJA5j3pTk,132
+pacebar/editor/fields.py,sha256=C6H_kXYWzKGt4vfRizkhwIx9wSEtiX9eToPVsCfmjoc,3000
+pacebar/editor/row.py,sha256=LLDCrwsgBrl3RqYkAI5ykAtrbtgaQ1tIqSIzpcFYhw8,3312
+pacebar/editor/window.py,sha256=oP86skaVvkyj4qQHIkMAXUuBDuYIsjxCMKNEfSoZkJw,5938
+pacebar/overlay/__init__.py,sha256=FxOeOt4PQr0_0wKfRnTZhpQn-etl9V8xRgZAMqJDHYw,149
+pacebar/overlay/bar.py,sha256=TBGnFjpCjhXugHFtdvp6XkalMCedk6ME_mzlznuWZMQ,2824
+pacebar/overlay/controller.py,sha256=vBVjakK0Sc1VcgPAm40YJb0KCW1mBfqnSuZyu4R2K18,5727
+pacebar/overlay/hotkeys.py,sha256=jmh8GSGhprJGSW8M9279bDoitHaG_0PIWkr22fr_bgw,3511
+pacebar/overlay/square.py,sha256=qte2_OUjPSL4dPfwz3QTKY4rIph5JNKprHiaHMcUH54,1428
+pacebar-0.1.0.dist-info/METADATA,sha256=emd9sCWG0Ka-8BGgt_M-Yn9tC_6Jzvyfc5aRZZJcups,8185
+pacebar-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pacebar-0.1.0.dist-info/entry_points.txt,sha256=CZ06IldTiRbuUWpsdIy45sJZbN-hFxepG2Bo0P-OACQ,50
+pacebar-0.1.0.dist-info/licenses/LICENSE,sha256=ihxuew3kQ8FXvaHuD9-fVOX-IXusEbARDiVIST0Dk54,1070
+pacebar-0.1.0.dist-info/RECORD,,

pacebar-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pacebar-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pacebar = pacebar.__main__:main

pacebar-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roman Voronov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.