limit py scan on flatpak to speed up start

Author: mkiol

desktop/qml/SettingsAdvancedPage.qml

@@ -257,26 +257,42 @@ ColumnLayout {
         text: qsTranslate("SettingsPage", "Libraries")
     }
 
-    CheckBox {
-        checked: _settings.py_feature_scan
-        text: qsTranslate("SettingsPage", "Use Python libriaries")
-        onCheckedChanged: {
-            _settings.py_feature_scan = checked
-        }
-
-        ToolTip.delay: Qt.styleHints.mousePressAndHoldInterval
-        ToolTip.visible: hovered
-        ToolTip.text: qsTranslate("SettingsPage", "Check the presence of the required Python libraries.") + " " +
-                      qsTranslate("SettingsPage", "Disable this option if you observe problems when launching the application.")
-        hoverEnabled: true
+    ComboBoxForm {
+        id: pyScanModeCombo
 
+        label.text: qsTranslate("SettingsPage", "Detection of Python libraries")
+        toolTip: qsTranslate("SettingsPage", "Determine how and whether Python libraries are detected when the application is launched.")
+        comboBox {
+            currentIndex: {
+                if (_settings.py_scan_mode === Settings.PyScanOn) return 0
+                if (_settings.py_scan_mode === Settings.PyScanOffAllEnabled) return 1
+                if (_settings.py_scan_mode === Settings.PyScanOffAllDisabled) return 2
+                return _settings.is_xcb() ? 1 : 2
+            }
+            model: [
+                qsTranslate("SettingsPage", "On"),
+                qsTranslate("SettingsPage", "Off (Assume all are available)"),
+                qsTranslate("SettingsPage", "Off (Assume none are available)"),
+            ]
+            onActivated: {
+                if (index === 0) {
+                    _settings.py_scan_mode = Settings.PyScanOn
+                } else if (index === 1) {
+                    _settings.py_scan_mode = Settings.PyScanOffAllEnabled
+                } else if (index === 2) {
+                    _settings.py_scan_mode = Settings.PyScanOffAllDisabled
+                } else {
+                    _settings.py_scan_mode = Settings.PyScanOn;
+                }
+            }
+        }
     }
 
     TextFieldForm {
         id: pyTextField
 
         indends: 1
-        visible: _settings.py_feature_scan
+        visible: _settings.py_scan_mode === Settings.PyScanOn || _settings.py_scan_mode === Settings.PyScanOffAllEnabled
         label.text: qsTranslate("SettingsPage", "Location of Python libraries (version: %1)").arg(app.py_version.length === 0 ? "0.0.0" : app.py_version)
         toolTip: qsTranslate("SettingsPage", "Python libraries directory (%1).").arg("<i>PYTHONPATH</i>") + " " +
                  qsTranslate("SettingsPage", "Leave blank to use the default value.") + " " +

src/py_executor.cpp

@@ -106,12 +106,25 @@ void py_executor::loop() {
     try {
         m_py_interpreter.emplace();
 
-        if (settings::instance()->py_feature_scan()) {
-            libs_availability = py_tools::libs_availability();
-        } else {
-            LOGW("py scan is off");
-            libs_availability = py_tools::libs_availability_t{};
-        }
+#ifdef USE_PY
+        libs_availability = py_tools::libs_availability(
+            [scan_type = settings::instance()->py_scan_mode()] {
+                switch (scan_type) {
+                    case settings::py_scan_mode_t::PyScanOn:
+                        LOGD("py scan mode: on");
+                        return py_tools::libs_scan_type_t::on;
+                    case settings::py_scan_mode_t::PyScanOffAllEnabled:
+                        LOGD("py scan mode: off-all-enabled");
+                        return py_tools::libs_scan_type_t::off_all_enabled;
+                    case settings::py_scan_mode_t::PyScanOffAllDisabled:
+                        LOGD("py scan mode: off-all-disabled");
+                        return py_tools::libs_scan_type_t::off_all_disabled;
+                }
+                LOGF("invalid py scan mode");
+            }());
+#else
+        libs_availability = py_tools::libs_availability_t{};
+#endif
 
         while (!m_shutting_down) {
             std::unique_lock<std::mutex> lock{m_mutex};

src/py_tools.cpp

@@ -61,11 +61,43 @@ std::ostream& operator<<(std::ostream& os,
 }
 
 namespace py_tools {
-libs_availability_t libs_availability() {
+libs_availability_t libs_availability(libs_scan_type_t scan_type) {
     // run only in py thread
 
     libs_availability_t availability{};
 
+    switch (scan_type) {
+        case libs_scan_type_t::on:
+            break;
+        case libs_scan_type_t::off_all_enabled:
+            if (cpu_tools::cpuinfo().feature_flags &
+                cpu_tools::feature_flags_t::avx) {
+                availability.coqui_tts = true;
+                availability.whisperspeech_tts = true;
+                availability.parler_tts = true;
+                availability.f5_tts = true;
+                availability.kokoro_tts = true;
+                availability.kokoro_ja = true;
+                availability.kokoro_zh = true;
+            }
+            availability.faster_whisper = true;
+            availability.mimic3_tts = true;
+            availability.transformers = true;
+            availability.unikud = true;
+            availability.gruut_de = true;
+            availability.gruut_es = true;
+            availability.gruut_fa = true;
+            availability.gruut_fr = true;
+            availability.gruut_it = true;
+            availability.gruut_nl = true;
+            availability.gruut_ru = true;
+            availability.gruut_sw = true;
+            availability.mecab = true;
+            break;
+        case libs_scan_type_t::off_all_disabled:
+            return availability;
+    }
+
 #ifdef USE_PY
     namespace py = pybind11;
     using namespace pybind11::literals;
@@ -103,7 +135,25 @@ libs_availability_t libs_availability() {
         } catch (const std::exception& err) {
             LOGD("torch cuda check py error: " << err.what());
         }
+    }
+
+    try {
+        LOGD("checking: ctranslate2-cuda");
+        auto ct2 = py::module_::import("ctranslate2");
+        LOGD("ctranslate2 version: "
+             << ct2.attr("__version__").cast<std::string>());
+        availability.ctranslate2_cuda =
+            py::len(ct2.attr("get_supported_compute_types")("cuda")) > 0;
+    } catch (const std::exception& err) {
+        LOGD("ctranslate2-cuda check py error: " << err.what());
+    }
 
+    if (scan_type == libs_scan_type_t::off_all_enabled ||
+        scan_type == libs_scan_type_t::off_all_disabled) {
+        return availability;
+    }
+
+    if (cpu_tools::cpuinfo().feature_flags & cpu_tools::feature_flags_t::avx) {
         try {
             LOGD("checking: coqui tts");
             py::module_::import("TTS");
@@ -170,17 +220,6 @@ libs_availability_t libs_availability() {
             LOGD("faster-whisper check py error: " << err.what());
         }
 
-        try {
-            LOGD("checking: ctranslate2-cuda");
-            auto ct2 = py::module_::import("ctranslate2");
-            LOGD("ctranslate2 version: "
-                 << ct2.attr("__version__").cast<std::string>());
-            availability.ctranslate2_cuda =
-                py::len(ct2.attr("get_supported_compute_types")("cuda")) > 0;
-        } catch (const std::exception& err) {
-            LOGD("ctranslate2-cuda check py error: " << err.what());
-        }
-
         try {
             LOGD("checking: transformers");
             py::module_::import("transformers");

src/py_tools.hpp

@@ -11,6 +11,7 @@
 #include <iostream>
 
 namespace py_tools {
+enum class libs_scan_type_t { on, off_all_disabled, off_all_enabled };
 inline static const auto python_site_path = "python/site-packages";
 
 struct py_version_t {
@@ -46,7 +47,7 @@ struct libs_availability_t {
     bool mecab = false;
 };
 
-libs_availability_t libs_availability();
+libs_availability_t libs_availability(libs_scan_type_t scan_type);
 bool init_module();
 }  // namespace py_tools
 

src/settings.cpp

@@ -27,6 +27,7 @@
 #include <thread>
 
 #include "config.h"
+#include "cpu_tools.hpp"
 #include "gpu_tools.hpp"
 #include "logger.hpp"
 #include "module_tools.hpp"
@@ -2104,14 +2105,21 @@ void settings::set_tts_tag_mode(tts_tag_mode_t value) {
     }
 }
 
-bool settings::py_feature_scan() const {
-    return value(QStringLiteral("service/py_feature_scan"), true).toBool();
+settings::py_scan_mode_t settings::py_scan_mode() const {
+    return static_cast<py_scan_mode_t>(
+        value(QStringLiteral("service/py_scan_mode"),
+              static_cast<int>(is_flatpak() && cpu_tools::arch() ==
+                                                   cpu_tools::arch_t::x86_64
+                                   ? py_scan_mode_t::PyScanOffAllEnabled
+                                   : py_scan_mode_t::PyScanOn))
+            .toInt());
 }
 
-void settings::set_py_feature_scan(bool value) {
-    if (value != py_feature_scan()) {
-        setValue(QStringLiteral("service/py_feature_scan"), value);
-        emit py_feature_scan_changed();
+void settings::set_py_scan_mode(py_scan_mode_t value) {
+    if (value != py_scan_mode()) {
+        setValue(QStringLiteral("service/py_scan_mode"),
+                 static_cast<int>(value));
+        emit py_scan_mode_changed();
 
         set_restart_required(true);
     }
@@ -2218,7 +2226,7 @@ void settings::disable_hw_scan() {
 }
 
 void settings::disable_py_scan() {
-    set_py_feature_scan(false);
+    set_py_scan_mode(py_scan_mode_t::PyScanOffAllDisabled);
     set_restart_required(false);
 }
 

src/settings.h

@@ -351,8 +351,8 @@ class settings : public QSettings, public singleton<settings> {
                    set_default_mnt_out_lang NOTIFY default_mnt_out_lang_changed)
     Q_PROPERTY(QString audio_input_device READ audio_input_device WRITE
                    set_audio_input_device NOTIFY audio_input_device_changed)
-    Q_PROPERTY(bool py_feature_scan READ py_feature_scan WRITE
-                   set_py_feature_scan NOTIFY py_feature_scan_changed)
+    Q_PROPERTY(py_scan_mode_t py_scan_mode READ py_scan_mode WRITE
+                   set_py_scan_mode NOTIFY py_scan_mode_changed)
     Q_PROPERTY(
         cache_audio_format_t cache_audio_format READ cache_audio_format WRITE
             set_cache_audio_format NOTIFY cache_audio_format_changed)
@@ -646,6 +646,13 @@ class settings : public QSettings, public singleton<settings> {
     };
     Q_ENUM(voice_profile_type_t)
 
+    enum class py_scan_mode_t {
+        PyScanOn = 0,
+        PyScanOffAllDisabled = 1,
+        PyScanOffAllEnabled = 2
+    };
+    Q_ENUM(py_scan_mode_t)
+
     struct voice_profile_prompt_t {
         QString name;
         QString desc;
@@ -907,8 +914,8 @@ class settings : public QSettings, public singleton<settings> {
     void set_enabled_models(const QStringList &value);
     QString audio_input_device() const;
     void set_audio_input_device(const QString &value);
-    bool py_feature_scan() const;
-    void set_py_feature_scan(bool value);
+    py_scan_mode_t py_scan_mode() const;
+    void set_py_scan_mode(py_scan_mode_t value);
     int num_threads() const;
     void set_num_threads(int value);
     QString py_path() const;
@@ -1053,7 +1060,7 @@ class settings : public QSettings, public singleton<settings> {
     void default_mnt_lang_changed();
     void default_mnt_out_lang_changed();
     void audio_input_device_changed();
-    void py_feature_scan_changed();
+    void py_scan_mode_changed();
     void cache_audio_format_changed();
     void cache_policy_changed();
     void num_threads_changed();