qcanvas 1.0.12.dev2__py3-none-any.whl → 1.1.0__py3-none-any.whl

qcanvas/run.py

@@ -1,3 +1,27 @@
+# nuitka-project: --enable-plugin=pyside6
+# nuitka-project: --windows-icon-from-ico=./deploy/windows/qcanvas.ico
+# nuitka-project: --windows-console-mode=attach
+# nuitka-project: --linux-icon=deploy/appimage/qcanvas.svg
+# nuitka-project: --standalone
+# nuitka-project: --include-module=yt_dlp
+
+# Anti-bloat
+
+##########################################################
+# nuitka-project: --include-package=aiosqlite
+# nuitka-project: --nofollow-import-to=aiosqlite.tests.*
+##########################################################
+# nuitka-project: --nofollow-import-to=rich
+##########################################################
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.mssql
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.postgresql
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.oracle
+# nuitka-project: --nofollow-import-to=sqlalchemy.dialects.mysql
+##########################################################
+# nuitka-project: --nofollow-import-to=rich
+##########################################################
+# nuitka-project: --nofollow-import-to=yt_dlp.extractor.lazy_extractors
+
 import logging
 from logging import INFO, WARNING
 

qcanvas/ui/course_viewer/content_tree.py

@@ -45,8 +45,8 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
         *,
         header_text: str | Sequence[str],
         indentation: int = 20,
-        max_width: int,
-        min_width: int,
+        max_width: Optional[int] = None,
+        min_width: Optional[int] = None,
     ) -> None:
         if not isinstance(header_text, str) and isinstance(header_text, Sequence):
             self.setHeaderLabels(header_text)
@@ -54,8 +54,12 @@ class ContentTree(MemoryTreeWidget, Generic[T]):
             self.setHeaderLabel(header_text)
 
         self.setIndentation(indentation)
-        self.setMaximumWidth(max_width)
-        self.setMinimumWidth(min_width)
+
+        if max_width is not None:
+            self.setMaximumWidth(max_width)
+
+        if min_width is not None:
+            self.setMinimumWidth(min_width)
 
     def reload(self, data: T, *, sync_receipt: SyncReceipt) -> None:
         self._reloading = True

qcanvas/ui/course_viewer/course_viewer.py

@@ -47,18 +47,12 @@ class CourseViewer(QWidget):
             downloader=downloader,
             sync_receipt=sync_receipt,
         )
-        # self._files_tab = FileTab.create_from_receipt(
-        #     course=course,
-        #     downloader=downloader,
-        #     sync_receipt=sync_receipt,
-        # )
 
         self._tabs = QTabWidget()
         self._tabs.addTab(self._pages_tab, "Pages")
         self._tabs.addTab(self._assignments_tab, "Assignments")
         self._tabs.addTab(self._mail_tab, "Mail")
         self._tabs.addTab(QLabel("Not implemented"), "Files")
-        # self._tabs.addTab(self._files_tab, "Files")
         # self._tabs.addTab(QLabel("Not implemented"), "Panopto")  # The meme lives on!
 
         self.setLayout(layout(QVBoxLayout, self._course_label, self._tabs))
@@ -84,10 +78,6 @@ class CourseViewer(QWidget):
         updates = sync_receipt.updates_by_course.get(self._course_id, None)
 
         if updates is not None:
-            # if len(updates.updated_resources) > 0:
-            #     raise Exception("Looks like you forgot to update the other numbers??????"")
-            #     self._highlight_tab(0)
-
             if len(updates.updated_pages) > 0:
                 self._highlight_tab(0)
 

qcanvas/ui/course_viewer/tabs/resource_rich_browser.py

@@ -50,12 +50,6 @@ class ResourceRichBrowser(QTextBrowser):
             self._downloader.download_finished.connect(self._download_updated)
             self._downloader.download_failed.connect(self._download_updated)
 
-        # _dark_listener.theme_changed.connect(self._theme_changed)
-
-    # @Slot()
-    # def _theme_changed(self, theme: str) -> None:
-    #     print(theme)
-
     def show_blank(self, completely_blank: bool = False) -> None:
         if completely_blank:
             self.clear()
@@ -102,16 +96,31 @@ class ResourceRichBrowser(QTextBrowser):
                     )
                     continue
 
-                file_link_tag = self._create_resource_link_tag(doc, resource_id)
+                file_link_tag = self._create_resource_link_tag(
+                    doc, resource_id, resource_link.name == "img"
+                )
                 resource_link.replace_with(file_link_tag)
             except NoExtractorError:
                 pass
 
         return str(doc)
 
-    def _create_resource_link_tag(self, doc: BeautifulSoup, resource_id: str) -> Tag:
+    def _create_resource_link_tag(
+        self, doc: BeautifulSoup, resource_id: str, is_image: bool
+    ) -> Tag:
         resource = self._current_content_resources[resource_id]
 
+        # todo not sure if this is a good idea or not
+        # if is_image and resource.download_state == db.ResourceDownloadState.DOWNLOADED:
+        #     location = self._downloader.resource_download_location(resource)
+        #
+        #     file_link_tag = doc.new_tag(
+        #         "img",
+        #         attrs={
+        #             "source": location.absolute(),
+        #         },
+        #     )
+        # else:
         file_link_tag = doc.new_tag(
             "a",
             attrs={

qcanvas/ui/main_ui/qcanvas_window.py

@@ -23,7 +23,7 @@ from qcanvas.ui.main_ui.options.quick_sync_option import QuickSyncOption
 from qcanvas.ui.main_ui.options.sync_on_start_option import SyncOnStartOption
 from qcanvas.ui.main_ui.options.theme_selection_menu import ThemeSelectionMenu
 from qcanvas.ui.main_ui.status_bar_progress_display import StatusBarProgressDisplay
-from qcanvas.util import paths, settings, auto_downloader
+from qcanvas.util import auto_downloader, paths, settings
 from qcanvas.util.qurl_util import file_url
 from qcanvas.util.ui_tools import create_qaction
 

qcanvas/ui/setup/setup_checker.py

@@ -1,13 +1,13 @@
 import logging
 
 import qcanvas.util.settings as settings
-from qcanvas.util import is_url
+from qcanvas.util.url_checker import is_url
 
 _logger = logging.getLogger(__name__)
 
 
 def needs_setup() -> bool:
-    if not is_url(settings.client.panopto_url):
+    if not settings.client.panopto_disabled and not is_url(settings.client.panopto_url):
         return True
     elif not is_url(settings.client.canvas_url):
         return True

qcanvas/ui/setup/setup_dialog.py

@@ -1,18 +1,19 @@
 import logging
 from threading import Semaphore
+from typing import Optional
 
 from qasync import asyncSlot
 from qcanvas_api_clients.canvas import CanvasClient, CanvasClientConfig
 from qcanvas_api_clients.panopto import PanoptoClient, PanoptoClientConfig
 from qcanvas_api_clients.util.request_exceptions import ConfigInvalidError
-from qtpy.QtCore import QUrl, Signal, Slot
+from qtpy.QtCore import Qt, QUrl, Signal, Slot
 from qtpy.QtGui import QDesktopServices, QIcon
 from qtpy.QtWidgets import *
 
 import qcanvas.util.settings as settings
 from qcanvas import icons
-from qcanvas.util import is_url
-from qcanvas.util.layouts import grid_layout_widget, layout
+from qcanvas.util.layouts import GridItem, grid_layout_widget, layout
+from qcanvas.util.url_checker import is_url
 
 _logger = logging.getLogger(__name__)
 
@@ -21,6 +22,68 @@ _tutorial_url = (
 )
 
 
+class _InputRow:
+    def __init__(
+        self,
+        *,
+        label: str,
+        initial_value: str,
+        placeholder_text: Optional[str] = None,
+        is_password: bool = False,
+    ):
+        self._label = QLabel(label)
+        self._input = QLineEdit(initial_value)
+
+        if placeholder_text is not None:
+            self._input.setPlaceholderText(placeholder_text)
+
+        if is_password:
+            self._input.setEchoMode(QLineEdit.EchoMode.Password)
+
+    def set_error(self, message: Optional[str]) -> None:
+        self._input.setStyleSheet("QLineEdit { border: 1px solid red }")
+        self._input.setToolTip(message)
+
+    def clear_error(self) -> None:
+        self._input.setStyleSheet(None)
+        self._input.setToolTip(None)
+
+    def grid_row(self) -> list[QWidget]:
+        return [self._label, self._input]
+
+    def disable(self) -> None:
+        self._input.setEnabled(False)
+
+    @property
+    def enabled(self) -> bool:
+        return self._input.isEnabled()
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self._input.setEnabled(value)
+
+    @property
+    def text(self) -> str:
+        return self._input.text().strip()
+
+    @property
+    def url_text(self) -> str:
+        url = self.text
+
+        if not url.startswith("http"):
+            return "https://" + url
+        else:
+            return url
+
+    @property
+    def is_valid_url(self) -> bool:
+        return is_url(self.url_text)
+
+    @property
+    def is_empty(self) -> bool:
+        return len(self.text) == 0
+
+
 class SetupDialog(QDialog):
     closed = Signal()
 
@@ -33,38 +96,58 @@ class SetupDialog(QDialog):
         self.setWindowIcon(QIcon(icons.main_icon))
 
         self._semaphore = Semaphore()
-        self._canvas_url_box = QLineEdit(settings.client.canvas_url)
-        self._canvas_url_box.setPlaceholderText("https://instance.canvas.com")
-        self._canvas_api_key_box = QLineEdit(settings.client.canvas_api_key)
-        self._canvas_api_key_box.setEchoMode(QLineEdit.EchoMode.Password)
-        self._panopto_url_box = QLineEdit(settings.client.panopto_url)
-        self._panopto_url_box.setPlaceholderText("https://instance.panopto.com")
+
+        self._canvas_url_box = _InputRow(
+            label="Canvas URL",
+            initial_value=settings.client.canvas_url,
+            placeholder_text="https://instance.canvas.com",
+        )
+        self._panopto_url_box = _InputRow(
+            label="Panopto URL",
+            initial_value=settings.client.panopto_url,
+            placeholder_text="https://instance.panopto.com",
+        )
+        self._canvas_api_key_box = _InputRow(
+            label="Canvas API Key",
+            initial_value=settings.client.canvas_api_key,
+            is_password=True,
+        )
+        self._disable_panopto_checkbox = QCheckBox("Continue without Panopto")
+        self._disable_panopto_checkbox.checkStateChanged.connect(
+            self._disable_panopto_check_changed
+        )
         self._button_box = self._setup_button_box()
-        self._button_box.accepted.connect(self._accepted)
-        self._button_box.helpRequested.connect(self._help_requested)
         self._waiting_indicator = self._setup_progress_bar()
-        self._status_bar = QStatusBar()
 
         self.setLayout(
             layout(
                 QVBoxLayout,
                 grid_layout_widget(
                     [
-                        [QLabel("Canvas URL"), self._canvas_url_box],
-                        [QLabel("Canvas API Key"), self._canvas_api_key_box],
-                        [QLabel("Panopto URL"), self._panopto_url_box],
+                        self._canvas_url_box.grid_row(),
+                        self._canvas_api_key_box.grid_row(),
+                        self._panopto_url_box.grid_row(),
+                        [
+                            GridItem(
+                                self._disable_panopto_checkbox,
+                                col_span=2,
+                                alignment=Qt.AlignmentFlag.AlignRight,
+                            )
+                        ],
                     ]
                 ),
                 self._waiting_indicator,
                 self._button_box,
-                self._status_bar,
             )
         )
 
     def _setup_button_box(self) -> QDialogButtonBox:
         box = QDialogButtonBox()
         box.addButton(QDialogButtonBox.StandardButton.Ok)
-        box.addButton("Get a Canvas API key", QDialogButtonBox.ButtonRole.HelpRole)
+        box.addButton("Get a Canvas API Key", QDialogButtonBox.ButtonRole.HelpRole)
+
+        box.accepted.connect(self._verify_settings)
+        box.helpRequested.connect(self._help_requested)
         return box
 
     def _setup_progress_bar(self) -> QProgressBar:
@@ -81,32 +164,33 @@ class SetupDialog(QDialog):
         widget.setSizePolicy(size_policy)
 
     @asyncSlot()
-    async def _accepted(self) -> None:
+    async def _verify_settings(self) -> None:
         if self._semaphore.acquire(False):
             try:
                 self._clear_errors()
 
-                if not self._all_inputs_valid():
-                    self._status_bar.showMessage("Invalid input!", 5000)
+                if not self._check_all_inputs():
                     return
 
                 self._waiting_indicator.setVisible(True)
-                self._status_bar.showMessage("Checking configuration...")
 
                 canvas_config = CanvasClientConfig(
-                    api_token=self._canvas_api_key_box.text().strip(),
-                    canvas_url=self._get_url(self._canvas_url_box),
+                    api_token=self._canvas_api_key_box.text,
+                    canvas_url=self._canvas_url_box.url_text,
                 )
 
                 if not await self._check_canvas_config(canvas_config):
                     return
 
-                if not await self._check_panopto_config(canvas_config):
-                    self._show_panopto_help()
-                    return
+                if self._panopto_enabled:
+                    if not await self._check_panopto_config(canvas_config):
+                        self._show_panopto_help()
+                        return
             except Exception as e:
-                self._status_bar.showMessage(f"An error occurred: {e}", 5000)
                 _logger.warning("Checking config failed", exc_info=e)
+
+                error_box = QErrorMessage(self)
+                error_box.showMessage(f"Checking config failed: {e}")
             finally:
                 self._waiting_indicator.setVisible(False)
                 self._semaphore.release()
@@ -117,59 +201,40 @@ class SetupDialog(QDialog):
             _logger.debug("Validation already in progress")
 
     def _clear_errors(self) -> None:
-        for line_edit in [
-            self._canvas_url_box,
-            self._panopto_url_box,
-            self._canvas_api_key_box,
-        ]:
-            self._status_bar.clearMessage()
-            line_edit.setStyleSheet(None)
-            line_edit.setToolTip(None)
-
-    def _all_inputs_valid(self) -> bool:
+        self._canvas_url_box.clear_error()
+        self._panopto_url_box.clear_error()
+        self._canvas_api_key_box.clear_error()
+
+    def _check_all_inputs(self) -> bool:
         all_valid = True
 
-        if not is_url(self._get_url(self._canvas_url_box)):
+        if not self._canvas_url_box.is_valid_url:
             all_valid = False
-            self._show_error(self._canvas_url_box, "Canvas URL is invalid")
-        if len(self._canvas_api_key_box.text().strip()) == 0:
+            self._canvas_url_box.set_error("Canvas URL is invalid")
+
+        if self._canvas_api_key_box.is_empty:
             all_valid = False
-            self._show_error(self._canvas_api_key_box, "Canvas API key is empty")
-        if not is_url(self._get_url(self._panopto_url_box)):
+            self._canvas_api_key_box.set_error("Canvas API key is empty")
+
+        if self._panopto_enabled and not self._panopto_url_box.is_valid_url:
             all_valid = False
-            self._show_error(self._panopto_url_box, "Panopto URL is invalid")
+            self._panopto_url_box.set_error("Panopto URL is invalid")
 
         return all_valid
 
-    def _get_url(self, line_edit: QLineEdit) -> str:
-        url = line_edit.text().strip()
-
-        if not url.startswith("http"):
-            return "https://" + url
-        else:
-            return url
-
     async def _check_canvas_config(self, canvas_config: CanvasClientConfig) -> bool:
         try:
             await CanvasClient.verify_config(canvas_config)
             return True
         except ConfigInvalidError:
-            self._show_error(self._canvas_api_key_box, "Canvas API key is invalid")
+            self._canvas_api_key_box.set_error("Canvas API key is invalid")
             return False
 
-    def _show_error(self, line_edit: QLineEdit, text: str) -> None:
-        line_edit.setToolTip(text)
-        self._waiting_indicator.hide()
-        self._highlight_line_edit(line_edit)
-
-    def _highlight_line_edit(self, line_edit: QLineEdit) -> None:
-        line_edit.setStyleSheet("QLineEdit { border: 1px solid red }")
-
     async def _check_panopto_config(self, canvas_config: CanvasClientConfig) -> bool:
         client = CanvasClient(canvas_config)
         try:
             await PanoptoClient.verify_config(
-                PanoptoClientConfig(panopto_url=self._get_url(self._panopto_url_box)),
+                PanoptoClientConfig(panopto_url=self._panopto_url_box.url_text),
                 client,
             )
             return True
@@ -194,15 +259,21 @@ class SetupDialog(QDialog):
 
     @Slot()
     def _open_panopto_login(self) -> None:
-        url = QUrl(self._get_url(self._panopto_url_box))
+        url = QUrl(self._panopto_url_box.url_text)
         url.setPath("/Panopto/Pages/Auth/Login.aspx")
         url.setQuery("instance=Canvas&AllowBounce=true")
         QDesktopServices.openUrl(url)
 
     def _save_and_close(self) -> None:
-        settings.client.canvas_url = self._get_url(self._canvas_url_box)
-        settings.client.panopto_url = self._get_url(self._panopto_url_box)
-        settings.client.canvas_api_key = self._canvas_api_key_box.text().strip()
+        settings.client.canvas_url = self._canvas_url_box.url_text
+
+        if self._panopto_enabled:
+            settings.client.panopto_url = self._panopto_url_box.url_text
+        else:
+            settings.client.panopto_disabled = True
+
+        settings.client.canvas_api_key = self._canvas_api_key_box.text
+
         self.closed.emit()
         self.close()
 
@@ -223,3 +294,11 @@ class SetupDialog(QDialog):
     @Slot()
     def _open_tutorial(self) -> None:
         QDesktopServices.openUrl(QUrl(_tutorial_url))
+
+    @Slot(Qt.CheckState)
+    def _disable_panopto_check_changed(self, state: Qt.CheckState) -> None:
+        self._panopto_url_box.enabled = state == Qt.CheckState.Unchecked
+
+    @property
+    def _panopto_enabled(self) -> bool:
+        return self._disable_panopto_checkbox.checkState() == Qt.CheckState.Unchecked

qcanvas/util/__init__.py

@@ -1,2 +0,0 @@
-# todo remove this
-from .url_checker import is_url

qcanvas/util/auto_downloader.py

@@ -4,8 +4,7 @@ import logging
 import qcanvas_backend.database.types as db
 from qcanvas_backend.net.resources.download.resource_manager import ResourceManager
 from qcanvas_backend.net.sync.sync_receipt import SyncReceipt
-from qtpy.QtWidgets import QMessageBox
-from qtpy.QtWidgets import QWidget
+from qtpy.QtWidgets import QMessageBox, QWidget
 
 from qcanvas.util import settings
 

qcanvas/util/paths.py

@@ -1,30 +1,27 @@
 import logging
 import os
-import platform
-import sys
 from pathlib import Path
 
 import cachetools
 import platformdirs
 from qtpy.QtCore import QSettings
 
+from qcanvas.util.runtime import *
+
 _logger = logging.getLogger(__name__)
 
-_is_running_portable = Path(".portable").exists()
-_is_running_on_windows = platform.system() == "Windows"
-_is_running_on_linux = platform.system() == "Linux"
-_is_running_as_pyinstaller = getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")
-_is_running_as_flatpak = os.environ.get("container", "") == "flatpak"
+
+def ui_storage() -> Path:
+    return root() / ".UI"
+
+
+def data_storage() -> Path:
+    return root()
 
 
 def client_settings() -> QSettings:
-    if _is_running_portable:
+    if is_running_portable:
         return QSettings("QCanvas.ini", QSettings.Format.IniFormat)
-    elif _is_running_as_pyinstaller and _is_running_on_windows:
-        return QSettings(
-            str(platformdirs.user_documents_path() / "QCanvasTeam" / "QCanvas.ini"),
-            QSettings.Format.IniFormat,
-        )
     else:
         return QSettings("QCanvasTeam", "QCanvas")
 
@@ -33,20 +30,12 @@ def client_settings() -> QSettings:
 def root() -> Path:
     root_path = Path()
 
-    if not _is_running_portable:
-        if _is_running_as_flatpak:
-            root_path = Path(os.environ["XDG_DATA_HOME"])
-        elif _is_running_as_pyinstaller:
-            root_path = platformdirs.user_data_path("QCanvasReborn", "QCanvasTeam")
+    if is_running_as_flatpak:
+        # Flatpak does not support portable mode
+        root_path = Path(os.environ["XDG_DATA_HOME"])
+    elif not is_running_portable and is_running_as_compiled:
+        root_path = platformdirs.user_data_path("QCanvasReborn", "QCanvasTeam")
 
     print("Root path", root_path.absolute())
     _logger.debug("Root path %s", root_path.absolute())
     return root_path
-
-
-def ui_storage() -> Path:
-    return root() / ".UI"
-
-
-def data_storage() -> Path:
-    return root()

qcanvas/util/runtime.py

@@ -0,0 +1,20 @@
+import os
+import platform
+import sys
+from pathlib import Path
+
+is_running_portable = Path(".portable").exists()
+is_running_on_windows = platform.system() == "Windows"
+is_running_on_linux = platform.system() == "Linux"
+_is_nuitka = "__compiled__" in globals()
+_is_pyinstaller = getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")
+is_running_as_compiled = _is_nuitka or _is_pyinstaller
+is_running_as_flatpak = os.environ.get("container", "") == "flatpak"
+
+__all__ = [
+    "is_running_portable",
+    "is_running_as_flatpak",
+    "is_running_on_linux",
+    "is_running_as_compiled",
+    "is_running_on_windows",
+]

qcanvas/util/settings/_client_settings.py

@@ -15,6 +15,7 @@ class _ClientSettings:
     canvas_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
     canvas_api_key: MappedSetting[Optional[str]] = MappedSetting(default=None)
     panopto_url: MappedSetting[Optional[str]] = MappedSetting(default=None)
+    panopto_disabled = BoolSetting(default=False)
     quick_sync_enabled = BoolSetting(default=False)
     sync_on_start = BoolSetting(default=False)
     download_new_resources = BoolSetting(default=False)
@@ -27,5 +28,13 @@ class _ClientSettings:
         )
 
     @property
-    def panopto_config(self) -> PanoptoClientConfig:
-        return PanoptoClientConfig(panopto_url=self.panopto_url)
+    def panopto_config(self) -> Optional[PanoptoClientConfig]:
+        """
+        Generates a panopto client config. If panopto is disabled, it returns None.
+        """
+
+        if self.panopto_disabled:
+            _logger.debug("Panopto is disabled")
+            return None
+        else:
+            return PanoptoClientConfig(panopto_url=self.panopto_url)

qcanvas/util/themes.py

@@ -1,6 +1,7 @@
 import logging
 
 import qdarktheme
+from qtpy.QtWidgets import QApplication, QStyleFactory
 
 _logger = logging.getLogger(__name__)
 
@@ -18,6 +19,8 @@ def apply(theme: str) -> None:
     theme = ensure_theme_is_valid(theme)
 
     if theme != "native":
+        QApplication.setStyle(QStyleFactory.create("Fusion"))
+
         qdarktheme.setup_theme(
             theme,
             custom_colors={"primary": "e02424"},

{qcanvas-1.0.12.dev2.dist-info → qcanvas-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qcanvas
-Version: 1.0.12.dev2
+Version: 1.1.0
 Summary: QCanvas is a desktop client for Canvas LMS.
 Author: QCanvas
 Author-email: QCanvas@noreply.codeberg.org
@@ -14,8 +14,8 @@ Requires-Dist: lightdb (>=2.0,<3.0)
 Requires-Dist: platformdirs (>=4.2.2,<5.0.0)
 Requires-Dist: pyqtdarktheme-fork (>=2.3.2,<3.0.0)
 Requires-Dist: qasync (>=0.27.1,<0.28.0)
-Requires-Dist: qcanvas-api-clients (>=0.2.2,<0.3.0)
-Requires-Dist: qcanvas-backend (==0.1.10)
+Requires-Dist: qcanvas-api-clients (>=0.3.0,<0.4.0)
+Requires-Dist: qcanvas-backend (>=0.2.0,<0.3.0)
 Requires-Dist: qtpy (>=2.4.1,<3.0.0)
 Requires-Dist: sqlalchemy (>=2.0.31,<3.0.0)
 Requires-Dist: validators (>=0.33.0,<0.34.0)