composeui 0.1.0__py3-none-any.whl

composeui/images/composeui.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
+  <!-- the default icon of an app (`MainView.app_icon`), and the documentation's favicon:
+       ComposeUI's icon without its fan-out lines and view square, which blur when small -->
+  <defs>
+    <linearGradient id="composeui-bg" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#3446a8"/>
+      <stop offset="1" stop-color="#1d1a4f"/>
+    </linearGradient>
+  </defs>
+  <rect width="64" height="64" rx="14" fill="url(#composeui-bg)"/>
+  <path d="M33.5 19.9 A14 14 0 1 0 33.5 44.1" fill="none" stroke="#fff" stroke-width="8" stroke-linecap="round"/>
+  <circle cx="44.2" cy="14.3" r="4.6" fill="#2fd4c4"/>
+  <circle cx="51.5" cy="32.0" r="4.6" fill="#ffc857"/>
+  <circle cx="44.2" cy="49.7" r="4.6" fill="#ff8fc7"/>
+</svg>

composeui/locales/fr.json

@@ -0,0 +1,73 @@
+{
+  "File": "Fichier",
+  "New": "Nouveau",
+  "Open": "Ouvrir",
+  "Save": "Enregistrer",
+  "Save As": "Enregistrer sous",
+  "Exit": "Quitter",
+  "OK": "OK",
+  "Cancel": "Annuler",
+  "Help": "Aide",
+  "Can't open {name}: {error}.": "Impossible d'ouvrir {name} : {error}.",
+  "Language": "Langue",
+  "Save Image": "Enregistrer l'image",
+  "{header}: \"{text}\" isn't a valid value": "{header} : « {text} » n'est pas une valeur valide",
+  "Search": "Rechercher",
+  "+ Filter": "+ Filtre",
+  "Column": "Colonne",
+  "Value": "Valeur",
+  "Add": "Ajouter",
+  "Clear": "Effacer",
+  "{shown} of {total}": "{shown} sur {total}",
+  "No rows match the filters": "Aucune ligne ne correspond aux filtres",
+  "Remove the filter on {header}": "Retirer le filtre sur {header}",
+  "Type a value to filter by": "Saisissez une valeur pour filtrer",
+  "\"{text}\" isn't a number": "« {text} » n'est pas un nombre",
+  "\"{text}\" isn't a date, as 2024-01-31": "« {text} » n'est pas une date, comme 2024-01-31",
+  "\"{text}\" isn't true or false": "« {text} » n'est ni true ni false",
+  "The range's start is after its end": "Le début de l'intervalle est après sa fin",
+  ">=20, 18..24": ">=20, 18..24",
+  ">=2024-01-31": ">=2024-01-31",
+  "true or false": "true ou false",
+  "\"{text}\" isn't a valid regular expression": "« {text} » n'est pas une expression régulière valide",
+  "Edit the filter on {header}": "Modifier le filtre sur {header}",
+  "{header}: {filter}": "{header} : {filter}",
+  "contains, =exact, start*, !not": "contient, =exact, début*, !sauf",
+  "a regular expression, as Room [1-3]": "une expression régulière, comme Pièce [1-3]",
+  "{header} matches {filter}": "{header} correspond à {filter}",
+  "Regular expression": "Expression régulière",
+  "Sidebar": "Panneau latéral",
+  "MM/dd/yyyy": "dd/MM/yyyy",
+  "January": "janvier",
+  "February": "février",
+  "March": "mars",
+  "April": "avril",
+  "May": "mai",
+  "June": "juin",
+  "July": "juillet",
+  "August": "août",
+  "September": "septembre",
+  "October": "octobre",
+  "November": "novembre",
+  "December": "décembre",
+  "Mo": "lu",
+  "Tu": "ma",
+  "We": "me",
+  "Th": "je",
+  "Fr": "ve",
+  "Sa": "sa",
+  "Su": "di",
+  "Pick a date": "Choisir une date",
+  "Previous month": "Mois précédent",
+  "Next month": "Mois suivant",
+  "Resize the panes": "Redimensionner les volets",
+  "Done": "Terminé",
+  "Warning": "Avertissement",
+  "Error": "Erreur",
+  "Choose a file": "Choisir un fichier",
+  "Reload": "Recharger",
+  "No rows": "Aucune ligne",
+  "Export CSV": "Exporter en CSV",
+  "Exported {count} rows to {name}.": "{count} lignes exportées dans {name}.",
+  "Can't export to {name}: {error}.": "Impossible d'exporter dans {name} : {error}."
+}

composeui/mypy.py

@@ -0,0 +1,46 @@
+"""Mypy integration for CSV row classes and field factories."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from mypy.nodes import AssignmentStmt, CallExpr, MemberExpr, RefExpr, TypeInfo
+from mypy.plugin import Plugin
+from mypy.plugins.attrs import attr_attrib_makers, attr_class_maker_callback, attr_define_makers
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from mypy.plugin import ClassDefContext
+
+
+_DEFINE_ROW = "composeui.core.sqlitemodel.define_csv_row"
+
+
+def _define_csv_row(ctx: ClassDefContext) -> bool:
+    # Mypy's attrs plugin expects converter references to have a resolved node.
+    # Built-in method descriptors (e.g. str.strip) need their owning type's symbol.
+    for statement in ctx.cls.defs.body:
+        if not isinstance(statement, AssignmentStmt) or not isinstance(statement.rvalue, CallExpr):
+            continue
+        for name, expression in zip(statement.rvalue.arg_names, statement.rvalue.args):
+            if name != "converter" or not isinstance(expression, MemberExpr):
+                continue
+            owner = expression.expr
+            if isinstance(owner, RefExpr) and isinstance(owner.node, TypeInfo):
+                symbol = owner.node.get(expression.name)
+                if symbol is not None:
+                    expression.node = symbol.node
+    return attr_class_maker_callback(ctx, auto_attribs_default=None, slots_default=True)
+
+
+class _CSVPlugin(Plugin):
+    def get_class_decorator_hook_2(self, fullname: str) -> Callable[[ClassDefContext], bool] | None:
+        return _define_csv_row if fullname == _DEFINE_ROW else None
+
+
+def plugin(_version: str) -> type[Plugin]:
+    """Register the CSV field factory and row decorator with mypy's attrs plugin."""
+    attr_attrib_makers.add("composeui.core.sqlitemodel.csv_field")
+    attr_define_makers.add(_DEFINE_ROW)
+    return _CSVPlugin

composeui/qtcore/maprenderer.py

@@ -0,0 +1,115 @@
+"""The map renderer, loaded only when an application uses a map."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import Protocol
+
+from composeui.core.renderer import ViewLike
+from composeui.core.view import MapPoint, MapView
+from composeui.qtcore.qtrenderer import QtWidgetRenderer
+from composeui.qtcore.widgets.qmap import QMap
+
+if TYPE_CHECKING:
+    from composeui.core.signal import Signal, SignalNoArgs
+
+
+class MapViewLike(ViewLike, Protocol):
+    title: str
+    center: MapPoint | None
+    zoom: float | None
+    points: list[MapPoint]
+    height: int
+    tiles: bool
+    user_agent: str
+    clicked: Signal[float, float]
+    viewport_changed: SignalNoArgs
+
+
+class QtMapRenderer(QtWidgetRenderer[MapViewLike, QMap]):
+    def __init__(self, view: MapViewLike) -> None:
+        super().__init__(view)
+        self._refresh_dispatcher.update(
+            {
+                "title": self._refresh_title,
+                "center": self._refresh_center,
+                "zoom": self._refresh_zoom,
+                "points": self._refresh_points,
+                "height": self._refresh_height,
+                "tiles": self._refresh_tiles,
+                "user_agent": self._refresh_user_agent,
+            }
+        )
+
+    def render(self) -> None:
+        if self._rendered_object is None:
+            widget = self._rendered_object = QMap(self._view.user_agent, tiles=self._view.tiles)
+            widget.viewport_moved.connect(self._viewport_moved)
+            widget.point_clicked.connect(self._view.clicked.emit)
+            widget.map.resized.connect(self._resize)
+            self.refresh()
+
+    @staticmethod
+    def _refresh_title(_view: MapViewLike, widget: QMap, value: str) -> None:
+        widget.title.setText(value)
+        widget.title.setVisible(bool(value))
+        widget.map.setAccessibleName(value)
+
+    @staticmethod
+    def _refresh_center(view: MapViewLike, widget: QMap, value: MapPoint | None) -> None:
+        QtMapRenderer._fit(widget, view.points, value, view.zoom)
+
+    @staticmethod
+    def _refresh_zoom(view: MapViewLike, widget: QMap, value: float | None) -> None:
+        QtMapRenderer._fit(widget, view.points, view.center, value)
+
+    @staticmethod
+    def _refresh_points(view: MapViewLike, widget: QMap, value: list[MapPoint]) -> None:
+        widget.root.setProperty("points", [[p.latitude, p.longitude] for p in value])
+        QtMapRenderer._fit(widget, value, view.center, view.zoom)
+
+    @staticmethod
+    def _fit(
+        widget: QMap, points: list[MapPoint], center: MapPoint | None, zoom: float | None
+    ) -> None:
+        position, span_x, span_y = MapView.point_bounds(points, center)
+        widget.root.setProperty("latitude", position.latitude)
+        widget.root.setProperty("longitude", position.longitude)
+        widget.root.setProperty(
+            "zoom",
+            zoom
+            if zoom is not None
+            else MapView.fitted_zoom(span_x, span_y, widget.map.width(), widget.map.height()),
+        )
+
+    def _resize(self) -> None:
+        widget = self._rendered_object
+        assert widget is not None
+        view = self._view
+        self._fit(widget, view.points, view.center, view.zoom)
+
+    @staticmethod
+    def _refresh_height(_view: MapViewLike, widget: QMap, value: int) -> None:
+        widget.map.setFixedHeight(value)
+
+    def _configure(self, view: MapViewLike, widget: QMap, user_agent: str, *, tiles: bool) -> None:
+        widget.configure(user_agent, tiles=tiles)
+        self._refresh_center(view, widget, view.center)
+        self._refresh_zoom(view, widget, view.zoom)
+        self._refresh_points(view, widget, view.points)
+
+    def _refresh_tiles(self, view: MapViewLike, widget: QMap, value: bool) -> None:
+        self._configure(view, widget, view.user_agent, tiles=value)
+
+    def _refresh_user_agent(self, view: MapViewLike, widget: QMap, value: str) -> None:
+        self._configure(view, widget, value, tiles=view.tiles)
+
+    def _viewport_moved(self, latitude: float, longitude: float, zoom: float) -> None:
+        with self.stop_refresh():
+            self._view.center = MapPoint(
+                latitude=latitude,
+                longitude=longitude,
+            )
+            self._view.zoom = zoom
+        self._view.viewport_changed.emit()

composeui/qtcore/qtapplication.py

@@ -0,0 +1,222 @@
+"""The application classes of the Qt backend."""
+
+from __future__ import annotations
+
+import logging
+import signal
+import sys
+from typing import TYPE_CHECKING, NamedTuple, TypeVar
+
+from qtpy.QtCore import QThread, QTimer
+from qtpy.QtWidgets import QApplication, QMainWindow, QWidget
+
+from composeui.core.application import Application, ModelApplication
+from composeui.core.reload import (
+    acknowledge_changes,
+    can_reload_in_place,
+    is_reloaded,
+    keep_rerun,
+    load_reloaded_state,
+    rerun_program,
+    run_reloading,
+    save_reloaded_state,
+    take_changes,
+)
+from composeui.core.view import RendererType
+from composeui.qtcore.qtrenderer import QtMainRenderer
+
+if TYPE_CHECKING:
+    import argparse
+    from collections.abc import Callable
+    from pathlib import Path
+
+    from composeui.core.model import Model
+    from composeui.core.view import MainView, View
+
+
+LOGGER = logging.getLogger("COMPOSEUI")
+
+#: milliseconds between two looks, in a reloaded app, at whether files changed
+_CHANGES_CHECK_INTERVAL = 200
+
+MainViewT = TypeVar("MainViewT", bound="MainView")
+ModelT = TypeVar("ModelT", bound="Model")
+
+
+class _Run(NamedTuple):
+    """An app ready to show its main view, its command line parsed."""
+
+    args: argparse.Namespace
+    main_view: MainView
+    model: Model | None
+    render: Callable[[RendererType], None]
+
+
+def _add_reload_argument(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--reload",
+        help="Run the app again when a Python file under the current directory changes.",
+        action="store_true",
+    )
+
+
+def _exec(run: _Run) -> int:
+    """Show the main view until its window is closed, or run it again on every change."""
+    if run.args.reload and not is_reloaded():
+        # never shown here: closed first, as the child processes build and open their own
+        if run.model is not None:
+            run.model.close()
+        # the app runs in a child process, which a new one replaces when it can't run the
+        # changed code itself
+        return run_reloading()
+    app = QApplication(sys.argv)
+    signal.signal(signal.SIGINT, signal.SIG_DFL)  # kill the program when Ctr+c
+    if not is_reloaded():
+        run.render(RendererType.QT)
+        try:
+            return app.exec()
+        finally:
+            if run.model is not None:
+                run.model.close()
+    reloads = _Reloads(run)
+    try:
+        return app.exec()
+    finally:
+        reloads.close()
+
+
+class _Reloads:
+    """The window of a reloaded app, which shows the app the changed code builds."""
+
+    def __init__(self, run: _Run) -> None:
+        self._run = run
+        #: the files changed, taken, whose code the app runs once it can
+        self._changed: list[Path] | None = None
+        load_reloaded_state(run.main_view, run.model)
+        run.render(RendererType.QT)
+        self._timer = QTimer()
+        self._timer.timeout.connect(self._follow_changes)
+        self._timer.start(_CHANGES_CHECK_INTERVAL)
+
+    def close(self) -> None:
+        """Close the model of the app shown last."""
+        if self._run.model is not None:
+            self._run.model.close()
+
+    def _follow_changes(self) -> None:
+        if self._changed is None:
+            self._changed = take_changes()
+        # The timer also fires in a nested event loop, e.g. a file dialog's that a callback
+        # opened: the callback goes on with the app once it returns. Not a check of the
+        # modal dialog, which its loop outlives for a last event once it's closed.
+        if self._changed is None or QThread.currentThread().loopLevel() > 1:
+            return
+        changed, self._changed = self._changed, None
+        save_reloaded_state(self._run.main_view, self._run.model)
+        if not can_reload_in_place(changed):
+            # the supervisor runs the program in a new process, which opens the state saved
+            self._timer.stop()
+            QApplication.quit()
+            return
+        try:
+            run = rerun_program()
+        except Exception:
+            LOGGER.exception("The changed code fails: the window keeps the previous code")
+            acknowledge_changes()
+            return
+        try:
+            self._show(run)
+        except Exception:
+            # the window may be half replaced: a new process shows the state saved
+            LOGGER.exception("The changed app can't show: it runs again in a new process")
+            if run.model is not None and run.model is not self._run.model:
+                run.model.close()
+            self._timer.stop()
+            QApplication.quit()
+            return
+        acknowledge_changes()
+
+    def _show(self, run: _Run) -> None:
+        """Show `run`'s main view in the window, in place of the previous one."""
+        previous = self._run
+        renderer = previous.main_view.renderer
+        window = renderer.qt_object if isinstance(renderer, QtMainRenderer) else None
+        assert window is not None
+        load_reloaded_state(run.main_view, run.model)
+        previous.main_view.jobs.drop()
+        _forget_widgets(previous.main_view, window)
+        run.main_view.renderer = QtMainRenderer(run.main_view, window)
+        run.render(RendererType.QT)
+        self._run = run
+        if previous.model is not None and previous.model is not run.model:
+            previous.model.close()
+
+
+def _forget_widgets(view: View, window: QMainWindow) -> None:
+    """Detach `view` and its children from their widgets, which the window drops.
+
+    So a late change of a view, e.g. a status bar clearing its message, reaches no widget;
+    the windows of its own, e.g. a dialog's, close.
+    """
+    for child in view.children_views:
+        _forget_widgets(child, window)
+    widget = getattr(view.renderer, "qt_object", None)
+    if isinstance(widget, QWidget) and widget.isWindow() and widget is not window:
+        widget.close()
+        widget.deleteLater()
+    # not through the view's `on_setattr`: it would show the change on the renderer
+    object.__setattr__(view, "renderer", None)
+
+
+class QtApplication(Application[MainViewT]):
+    """The Qt app: it shows the main view in a window."""
+
+    def __init__(self, *, build_main_view: Callable[[], MainViewT]) -> None:
+        super().__init__(build_main_view=build_main_view)
+        _add_reload_argument(self._parser)
+
+    def run(self) -> None:
+        super().run()
+        assert self._args is not None
+        run = _Run(self._args, self.main_view, None, self.render)
+        keep_rerun(run)
+        sys.exit(_exec(run))
+
+
+class QtModelApplication(ModelApplication[MainViewT, ModelT]):
+    """The Qt app with a model, which it closes once the window is closed."""
+
+    def __init__(
+        self,
+        *,
+        build_main_view: Callable[[], MainViewT],
+        build_model: Callable[[], ModelT],
+        setup_model: Callable[[MainViewT, ModelT], None] | None = None,
+    ) -> None:
+        try:
+            super().__init__(
+                build_main_view=build_main_view, build_model=build_model, setup_model=setup_model
+            )
+        except BaseException:
+            # built first: e.g. a reload of a program whose `setup_model` now fails
+            model: Model | None = getattr(self, "_model", None)
+            if model is not None:
+                model.close()
+            raise
+        _add_reload_argument(self._parser)
+
+    def run(self) -> None:
+        try:
+            super().run()
+        except BaseException:
+            self.model.close()
+            raise
+        assert self._args is not None
+        run = _Run(self._args, self.main_view, self.model, self.render)
+        keep_rerun(run)
+        sys.exit(_exec(run))
+
+
+#: the backend's applications, for `composeui.core.application.run`
+APPLICATION = QtApplication
+MODEL_APPLICATION = QtModelApplication