[flatpak] improvement: removed some unneeded API calls when listing updates (cli/tray)

CHANGELOG.md

@@ -18,6 +18,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - removing the "%U" parameter before launching applications to prevent error messages
   - minor code refactoring
 
+- Flatpak
+  - cli/tray: removed some unneeded API calls when listing updates [#234](https://github.com/vinifmor/bauh/issues/234)
+
 - UI
   - upgrade summary dialog size
   - displaying tips for some custom actions (on mouse hover)

bauh/gems/flatpak/controller.py

@@ -27,7 +27,7 @@ from bauh.gems.flatpak import flatpak, SUGGESTIONS_FILE, CONFIG_FILE, UPDATES_IG
 from bauh.gems.flatpak.config import FlatpakConfigManager
 from bauh.gems.flatpak.constants import FLATHUB_API_URL
 from bauh.gems.flatpak.model import FlatpakApplication
-from bauh.gems.flatpak.worker import FlatpakAsyncDataLoader, FlatpakUpdateLoader
+from bauh.gems.flatpak.worker import FlatpakAsyncDataLoader
 
 DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.000Z'
 RE_INSTALL_REFS = re.compile(r'\d+\)\s+(.+)')
@@ -50,28 +50,34 @@ class FlatpakManager(SoftwareManager):
     def get_managed_types(self) -> Set["type"]:
         return {FlatpakApplication}
 
-    def _map_to_model(self, app_json: dict, installed: bool, disk_loader: DiskCacheLoader, internet: bool = True) -> FlatpakApplication:
+    def _map_to_model(self, app_json: dict, installed: bool, disk_loader: Optional[DiskCacheLoader], internet: bool = True) -> Tuple[FlatpakApplication, Optional[FlatpakAsyncDataLoader]]:
 
         app = FlatpakApplication(**app_json, i18n=self.i18n)
         app.installed = installed
         api_data = self.api_cache.get(app_json['id'])
 
+        if app.runtime and app.latest_version is None:
+            app.latest_version = app.version
+
         expired_data = api_data and api_data.get('expires_at') and api_data['expires_at'] <= datetime.utcnow()
 
+        data_loader: Optional[FlatpakAsyncDataLoader] = None
+
         if not api_data or expired_data:
             if not app.runtime:
                 if disk_loader:
                     disk_loader.fill(app)  # preloading cached disk data
 
                 if internet:
-                    FlatpakAsyncDataLoader(app=app, api_cache=self.api_cache, manager=self,
+                    data_loader = FlatpakAsyncDataLoader(app=app, api_cache=self.api_cache, manager=self,
-                                           context=self.context, category_cache=self.category_cache).start()
+                                                         context=self.context, category_cache=self.category_cache)
+                    data_loader.start()
 
         else:
             app.fill_cached_data(api_data)
             app.status = PackageStatus.READY
 
-        return app
+        return app, data_loader
 
     def _get_search_remote(self) -> str:
         remotes = flatpak.list_remotes()
@@ -109,7 +115,7 @@ class FlatpakManager(SoftwareManager):
             if len(apps_found) > len(already_read):
                 for app_found in apps_found:
                     if app_found['id'] not in already_read:
-                        res.new.append(self._map_to_model(app_found, False, disk_loader))
+                        res.new.append(self._map_to_model(app_found, False, disk_loader)[0])
 
         res.total = len(res.installed) + len(res.new)
         return res
@@ -117,7 +123,8 @@ class FlatpakManager(SoftwareManager):
     def _add_updates(self, version: Version, output: list):
         output.append(flatpak.list_updates_as_str(version))
 
-    def read_installed(self, disk_loader: Optional[DiskCacheLoader], limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None, internet_available: bool = None) -> SearchResult:
+    def read_installed(self, disk_loader: Optional[DiskCacheLoader], limit: int = -1, only_apps: bool = False, pkg_types: Set[Type[SoftwarePackage]] = None,
+                       internet_available: bool = None, wait_async_data: bool = False) -> SearchResult:
         version = flatpak.get_version()
 
         updates = []
@@ -136,14 +143,18 @@ class FlatpakManager(SoftwareManager):
             update_map = updates[0]
 
         models = {}
+        data_loaders: Optional[List[FlatpakAsyncDataLoader]] = [] if wait_async_data else None
 
         if installed:
             for app_json in installed:
-                model = self._map_to_model(app_json=app_json, installed=True,
+                model, loader = self._map_to_model(app_json=app_json, installed=True,
-                                           disk_loader=disk_loader, internet=internet_available)
+                                                   disk_loader=disk_loader, internet=internet_available)
                 model.update = False
                 models[model.get_update_id(version)] = model
 
+                if loader and data_loaders is not None:
+                    data_loaders.append(loader)
+
         if update_map:
             for update_id in update_map['full']:
                 model_with_update = models.get(update_id)
@@ -188,6 +199,10 @@ class FlatpakManager(SoftwareManager):
                     if model.get_update_ignore_key() in ignored:
                         model.updates_ignored = True
 
+        if data_loaders:
+            for loader in data_loaders:
+                loader.join()
+
         return SearchResult([*models.values()], None, len(models))
 
     def downgrade(self, pkg: FlatpakApplication, root_password: Optional[str], watcher: ProcessWatcher) -> bool:
@@ -475,7 +490,7 @@ class FlatpakManager(SoftwareManager):
                     current_key = '{}:{}:{}'.format(p['id'], p['name'], p['branch'])
                     if current_key != pkg_key and (not installed_by_level or current_key not in installed_by_level):
                         new_installed.append(self._map_to_model(app_json=p, installed=True,
-                                                                disk_loader=disk_loader, internet=net_available))
+                                                                disk_loader=disk_loader, internet=net_available)[0])
 
             return TransactionResult(success=installed, installed=new_installed, removed=[])
         else:
@@ -499,27 +514,15 @@ class FlatpakManager(SoftwareManager):
 
     def list_updates(self, internet_available: bool) -> List[PackageUpdate]:
         updates = []
-        installed = self.read_installed(None, internet_available=internet_available).installed
+        installed = self.read_installed(None, internet_available=internet_available, wait_async_data=True).installed
 
-        to_update = [p for p in installed if p.update and not p.is_update_ignored()]
+        if installed:
-
+            for p in installed:
-        if to_update:
+                if isinstance(p, FlatpakApplication) and p.update and not p.is_update_ignored():
-            loaders = []
+                    updates.append(PackageUpdate(pkg_id=f'{p.id}:{p.branch}:{p.installation}',
-
+                                                 pkg_type='Flatpak',
-            for app in to_update:
+                                                 name=p.name,
-                if app.is_application():
+                                                 version=p.latest_version))
-                    loader = FlatpakUpdateLoader(app=app, http_client=self.context.http_client)
-                    loader.start()
-                    loaders.append(loader)
-
-            for loader in loaders:
-                loader.join()
-
-            for app in to_update:
-                updates.append(PackageUpdate(pkg_id='{}:{}:{}'.format(app.id, app.branch, app.installation),
-                                             pkg_type='Flatpak',
-                                             name=app.name,
-                                             version=app.version))
 
         return updates
 
@@ -560,7 +563,7 @@ class FlatpakManager(SoftwareManager):
                             app_json = flatpak.search(cli_version, appid, remote_level, app_id=True)
 
                             if app_json:
-                                model = PackageSuggestion(self._map_to_model(app_json[0], False, None), priority)
+                                model = PackageSuggestion(self._map_to_model(app_json[0], False, None)[0], priority)
                                 self.suggestions_cache.add(appid, model)
                                 res.append(model)
                     else:

bauh/gems/flatpak/worker.py

@@ -6,7 +6,6 @@ from bauh.api.abstract.cache import MemoryCache
 from bauh.api.abstract.context import ApplicationContext
 from bauh.api.abstract.controller import SoftwareManager
 from bauh.api.abstract.model import PackageStatus
-from bauh.api.http import HttpClient
 from bauh.gems.flatpak.constants import FLATHUB_API_URL, FLATHUB_URL
 from bauh.gems.flatpak.model import FlatpakApplication
 
@@ -14,7 +13,7 @@ from bauh.gems.flatpak.model import FlatpakApplication
 class FlatpakAsyncDataLoader(Thread):
 
     def __init__(self, app: FlatpakApplication, manager: SoftwareManager, context: ApplicationContext, api_cache: MemoryCache, category_cache: MemoryCache):
-        super(FlatpakAsyncDataLoader, self).__init__(daemon=True)
+        super(FlatpakAsyncDataLoader, self).__init__()
         self.app = app
         self.manager = manager
         self.http_client = context.http_client
@@ -96,21 +95,3 @@ class FlatpakAsyncDataLoader(Thread):
 
             if self.persist:
                 self.manager.cache_to_disk(pkg=self.app, icon_bytes=None, only_icon=False)
-
-
-class FlatpakUpdateLoader(Thread):
-
-    def __init__(self, app: FlatpakApplication, http_client: HttpClient):
-        super(FlatpakUpdateLoader, self).__init__(daemon=True)
-        self.app = app
-        self.http_client = http_client
-
-    def run(self):
-        try:
-            data = self.http_client.get_json('{}/apps/{}'.format(FLATHUB_API_URL, self.app.id))
-
-            if data and data.get('currentReleaseVersion'):
-                self.app.version = data['currentReleaseVersion']
-                self.app.latest_version = self.app.version
-        except:
-            traceback.print_exc()