setup.py

fpakman/core/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

fpakman/core/controller.py

@@ -0,0 +1,22 @@
+from typing import List
+
+from fpakman.core.model import FlatpakManager
+
+
+class FlatpakController:
+
+    def __init__(self, model: FlatpakManager):
+        self.model = model
+
+    def refresh(self) -> List[dict]:
+        return self.model.read_installed()
+
+    def update(self, package_refs: List[str]) -> List[dict]:
+        return self.model.update_apps(package_refs)
+
+    def check_installed(self) -> bool:
+        version = self.model.get_version()
+        return False if version is None else version
+
+    def get_version(self) -> str:
+        return self.model.get_version()

fpakman/core/flatpak.py

@@ -0,0 +1,76 @@
+import re
+from typing import List
+
+from fpakman.core import system
+
+
+def app_str_to_json(line: str, version: str) -> dict:
+
+    app_array = line.split('\t')
+
+    if version >= '1.3.0':
+        app = {'name': app_array[0],
+               'id': app_array[1],
+               'version': app_array[2],
+               'branch': app_array[3]}
+    elif '1.0' <= version < '1.1':
+        app = {'ref': app_array[0], 'options': app_array[1]}
+
+        ref_data = app['ref'].split('/')
+        app['id'] = ref_data[0]
+        app['arch'] = ref_data[1]
+        app['branch'] = ref_data[2]
+        app['name'] = ref_data[0].split('.')[-1]
+        app['version'] = None
+    elif '1.2' <= version < '1.3':
+        app = {'name': app_array[0][1].split('.')[-1],
+               'id': app_array[1],
+               'version': app_array[2],
+               'branch': app_array[3],
+               'arch': app_array[4],
+               'origin': app_array[5]}
+    else:
+        raise Exception('Unsupported version')
+
+    info = re.findall('\w+:\s.+', get_app_info(app['id']))
+    fields_to_get = ['origin', 'arch', 'ref']
+
+    for field in info:
+        field_val = field.split(':')
+        field_name = field_val[0].lower()
+
+        if field_name in fields_to_get:
+            app[field_name] = field_val[1].strip()
+
+        if field_name == 'ref':
+            app['runtime'] = app['ref'].startswith('runtime/')
+
+    return app
+
+
+def get_version():
+    res = system.run_cmd('flatpak --version')
+    return res.split(' ')[1].strip() if res else None
+
+
+def get_app_info(app_id: str):
+    return system.run_cmd('flatpak info ' + app_id)
+
+
+def list_installed() -> List[dict]:
+    apps_str = system.run_cmd('flatpak list')
+
+    if apps_str:
+        version = get_version()
+        app_lines = apps_str.split('\n')
+        return [app_str_to_json(line, version) for line in app_lines if line]
+
+    return []
+
+
+def update(ref: str):
+    return bool(system.run_cmd('flatpak update -y ' + ref))
+
+
+def list_updates_as_str():
+    return system.run_cmd('flatpak update', ignore_return_code=True)

fpakman/core/model.py

@@ -0,0 +1,92 @@
+from threading import Lock, Thread
+from typing import List
+
+import requests
+from PyQt5.QtCore import QUrl
+from PyQt5.QtGui import QPixmap, QIcon
+from PyQt5.QtNetwork import QNetworkAccessManager, QNetworkRequest
+
+from fpakman.core import flatpak
+
+__FLATHUB_URL__ = 'https://flathub.org'
+__FLATHUB_API_URL__ = __FLATHUB_URL__ + '/api/v1'
+
+
+class FlatpakManager:
+
+    def __init__(self):
+        self.apps = []
+        self.apps_db = {}
+        self.http_session = requests.Session()
+        self.lock_db_read = Lock()
+
+    def load_database_async(self):
+        Thread(target=self.load_database, daemon=True).start()
+
+    def load_database(self):
+
+        self.lock_db_read.acquire()
+
+        try:
+            res = self.http_session.get(__FLATHUB_API_URL__ + '/apps')
+
+            if res.status_code == 200:
+                for app in res.json():
+                    self.apps_db[app['flatpakAppId']] = app
+        finally:
+            self.lock_db_read.release()
+
+    def get_version(self):
+        return flatpak.get_version()
+
+    def read_installed(self) -> List[dict]:
+
+        installed = flatpak.list_installed()
+
+        if installed:
+            installed.sort(key=lambda p: p['name'].lower())
+
+            available_updates = flatpak.list_updates_as_str()
+
+            for app in installed:
+
+                if not self.apps_db:
+                    self.load_database()
+
+                if self.apps_db:
+                    app_data = self.apps_db.get(app['id'], None)
+                else:
+                    app_data = None
+
+                if not app_data:
+                    app['latest_version'] = None
+                    app['icon'] = None
+                else:
+                    app['latest_version'] = app_data['currentReleaseVersion']
+                    app['icon'] = app_data['iconMobileUrl']
+
+                    if app['icon'].startswith('/'):
+                        app['icon'] = __FLATHUB_URL__ + app['icon']
+
+                app['update'] = app['id'] in available_updates
+
+        self.apps = installed
+        return [*self.apps]
+
+    def update_apps(self, refs: List[str]) -> List[dict]:
+
+        if self.apps:
+
+            for ref in refs:
+                package_found = [app for app in self.apps if app['ref'] == ref]
+
+                if package_found:
+                    package_found = package_found[0]
+                    updated = flatpak.update(ref)
+
+                    if updated:
+                        package_found['update'] = not updated
+
+            return [*self.apps]
+
+        return []

fpakman/core/resource.py

@@ -0,0 +1,10 @@
+import os
+
+
+def get_path(resource_path):
+    app_dir = get_app_dir()
+    return app_dir + '/resources/' + resource_path
+
+
+def get_app_dir():
+    return os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

fpakman/core/system.py

@@ -0,0 +1,6 @@
+import subprocess
+
+
+def run_cmd(cmd: str, expected_code: int = 0, ignore_return_code: bool = False) -> str:
+    res = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE)
+    return res.stdout.decode() if ignore_return_code or res.returncode == expected_code else None

fpakman/core/util.py

@@ -0,0 +1,35 @@
+import locale
+
+from fpakman.core import resource
+import glob
+
+
+def get_locale_keys():
+
+    current_locale = locale.getdefaultlocale()
+    locale_path = None
+    if current_locale:
+        current_locale = current_locale[0]
+
+        locale_dir = '{}/resources/locale'.format(resource.get_app_dir())
+
+        for locale_file in glob.glob(locale_dir + '/*'):
+            name = locale_file.split('/')[-1]
+
+            if current_locale == name or current_locale.startswith(name + '_'):
+                locale_path = locale_file
+                break
+
+    if not locale_path:
+        locale_path = '{}/resources/locale/en'.format(resource.get_app_dir())
+
+    with open(locale_path, 'r') as f:
+        locale_keys = f.readlines()
+
+    locale_obj = {}
+    for line in locale_keys:
+        if line:
+            keyval = line.strip().split('=')
+            locale_obj[keyval[0].strip()] = keyval[1].strip()
+
+    return locale_obj