appstream-python 0.6.3__py3-none-any.whl → 0.8__py3-none-any.whl

appstream_python/Component.py

@@ -1,8 +1,10 @@
+from .Shared import TranslateableTag, TranslateableList, Description
 from typing import Any, Optional, Literal, TypedDict, Union
+from .Release import ReleaseList
 from ._helper import assert_func
 from .StandardConstants import *
 from lxml import etree
-import datetime
+import dataclasses
 import io
 import os
 
@@ -35,358 +37,6 @@ class InternetRelationDict(TypedDict):
     bandwidth_mbitps: Optional[int]
 
 
-class TranslateableTag:
-    "Represents a translatable tag"
-
-    def __init__(self) -> None:
-        self._text = ""
-        self._translations: dict[str, str] = {}
-
-    def get_default_text(self) -> str:
-        """Returns the untranslated text"""
-        return self._text
-
-    def set_default_text(self, text: str) -> None:
-        """Sets the untranslated text"""
-        self._text = text
-
-    def get_translated_text(self, lang: str) -> Optional[str]:
-        """Returns the translated text"""
-        return self._translations.get(lang, None)
-
-    def get_translated_text_default(self, lang: str) -> Optional[str]:
-        """Returns the translated text. Returns the default text, if the translation does not exists"""
-        return self._translations.get(lang, self._text)
-
-    def set_translated_text(self, lang: str, text: str) -> None:
-        """Sets the translated text"""
-        self._translations[lang] = text
-
-    def get_available_languages(self) -> list[str]:
-        """Returns a list with all languages of the tag"""
-        return list(self._translations.keys())
-
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
-        """Load a list of Tags"""
-        for i in tag_list:
-            if i.get("{http://www.w3.org/XML/1998/namespace}lang") is None:
-                if i.text is not None:
-                    self._text = i.text.strip()
-                else:
-                    self._text = ""
-            else:
-                if i.text is not None:
-                    self._translations[i.get(_XML_LANG)] = i.text.strip()
-                else:
-                    self._translations[i.get(_XML_LANG)] = ""
-
-    def write_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
-        """Writes a Tag"""
-        default_tag = etree.SubElement(parent_tag, tag_name)
-        default_tag.text = self._text
-
-        for key, value in self._translations.items():
-            translation_tag = etree.SubElement(parent_tag, tag_name)
-            translation_tag.set("{http://www.w3.org/XML/1998/namespace}lang", key)
-            translation_tag.text = value
-
-    def clear(self) -> None:
-        """Resets all data"""
-        self._text = ""
-        self._translations.clear()
-
-    def __repr__(self) -> str:
-        return f"<TranslateableTag default='{self._text}'>"
-
-
-class TranslateableList:
-    "Represents a translatable list"
-
-    def __init__(self) -> None:
-        self._translated_data: dict[str, dict[str, str]] = {}
-        self._translated_lists: dict[str, list[str]] = {}
-
-    def get_default_list(self) -> list[str]:
-        "Returns a list with the default items"
-        return list(self._translated_data.keys())
-
-    def get_translated_list(self, lang: str) -> list[str]:
-        "Returns the translated list for the given language"
-        if lang in self._translated_lists:
-            return self._translated_lists[lang]
-
-        return_list: list[str] = []
-        for untranslated_text, translations in self._translated_data.items():
-            return_list.append(translations.get(lang, untranslated_text))
-        return return_list
-
-    def load_tag(self, tag: etree.Element) -> None:
-        "Loads an Tag. Only for internal use."
-        if tag.get("{http://www.w3.org/XML/1998/namespace}lang") is None:
-            current_text = ""
-            for i in tag.getchildren():
-                if i.get(_XML_LANG) is None:
-                    try:
-                        current_text = i.text.strip()
-                        self._translated_data[current_text] = {}
-                    except AttributeError:
-                        pass
-                else:
-                    if current_text in self._translated_data:
-                        self._translated_data[current_text][i.get(_XML_LANG)] = i.text.strip()
-        else:
-            if tag.get("{http://www.w3.org/XML/1998/namespace}lang") not in self._translated_lists:
-                self._translated_lists[tag.get("{http://www.w3.org/XML/1998/namespace}lang")] = []
-            for i in tag.getchildren():
-                self._translated_lists[tag.get("{http://www.w3.org/XML/1998/namespace}lang")].append(i.text.strip())
-
-    def write_all_tag(self, parent_tag: etree.Element, tag_name: str) -> None:
-        "Writes the XML tags. Onnly for internal use."
-        for untranslated_text, translations in self._translated_data.items():
-            default_tag = etree.SubElement(parent_tag, tag_name)
-            default_tag.text = untranslated_text
-            for lang, translated_text in translations.items():
-                translated_tag = etree.SubElement(parent_tag, tag_name)
-                translated_tag.set(_XML_LANG, lang)
-                translated_tag.text = translated_text
-
-    def write_untranslated_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
-        "Writes the untranslated XML tags. Onnly for internal use."
-        for untranslated_text in self._translated_data.keys():
-            default_tag = etree.SubElement(parent_tag, tag_name)
-            default_tag.text = untranslated_text
-
-    def write_translated_tags(self, parent_tag: etree.Element, tag_name: str, lang: str) -> None:
-        "Writes the translated XML tags. Onnly for internal use."
-        for untranslated_text, translations in self._translated_data.items():
-            child_tag = etree.SubElement(parent_tag, tag_name)
-            child_tag.text = translations.get(lang, untranslated_text)
-
-    def clear(self) -> None:
-        """Resets all data"""
-        self._translated_data.clear()
-
-
-class DescriptionItem:
-    "The Interface for a Description Item"
-
-    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
-        "Retutns the Type of the Item"
-        return "none"
-
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
-        "Loads teh XML tags into the Elemnt. Only for internal use."
-        raise NotImplementedError
-
-    def get_tags(self, parent_tag: etree.Element) -> None:
-        "Get the XML Tag from the Element. Only for internal use."
-        raise NotImplementedError()
-
-    def get_translated_tag(self, lang: Optional[str]) -> etree.Element:
-        "Loads the tag for a given language"
-        raise NotImplementedError()
-
-    def to_plain_text(self, lang: Optional[str] = None) -> str:
-        "Returns the content as plain text"
-        raise NotImplementedError()
-
-
-class DescriptionParagraph(DescriptionItem):
-    "Represents a paragraph <p> in the Description"
-
-    def __init__(self) -> None:
-        self.content = TranslateableTag()
-        """The Text of the Paragraph"""
-
-    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
-        "Retutns the Type of the Item"
-        return "paragraph"
-
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
-        "Loads teh XML tags into the Elemnt. Only for internal use."
-        self.content.load_tags(tag_list)
-
-    def get_tags(self, parent_tag: etree.Element) -> None:
-        "Get the XML Tag from the Element. Only for internal use."
-        self.content.write_tags(parent_tag, "p")
-
-    def get_translated_tag(self, lang: Optional[str]) -> etree.Element:
-        "Loads the tag for a given language"
-        paragraph_tag = etree.Element("p")
-        if lang is None:
-            paragraph_tag.text = self.content.get_default_text()
-        else:
-            paragraph_tag.text = self.content.get_translated_text_default(lang)
-        return paragraph_tag
-
-    def to_plain_text(self, lang: Optional[str] = None) -> str:
-        "Returns the content as plain text"
-        return self.content.get_translated_text_default(lang).strip()
-
-
-class DescriptionList(DescriptionItem):
-    "Represents a list <ul>/<ol> in the Description"
-
-    def __init__(self, list_type: str) -> None:
-        self._list_type = list_type
-
-        self.content: TranslateableList = TranslateableList()
-        "The list"
-
-    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
-        "Retutns the Type of the Item"
-        if self._list_type == "ul":
-            return "unordered-list"
-        else:
-            return "ordered-list"
-
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
-        "Loads the XML tags into the Elemnt. Only for internal use."
-        self.content.load_tag(tag_list)
-
-    def get_tags(self, parent_tag: etree.Element) -> None:
-        "Get the XML Tag from the Element. Only for internal use."
-        list_tag = etree.SubElement(parent_tag, self._list_type)
-        self.content.write_all_tag(list_tag, "li")
-
-    def get_translated_tag(self, lang: Optional[str] = None) -> etree.Element:
-        "Loads the tag for a given language"
-        list_tag = etree.Element(self._list_type)
-        if lang is None:
-            self.content.write_untranslated_tags(list_tag, "li")
-        else:
-            self.content.write_translated_tags(list_tag, "li", lang)
-        return list_tag
-
-    def to_plain_text(self, lang: Optional[str] = None) -> str:
-        "Returns the content as plain text"
-        tag_list = self.content.get_translated_list(lang)
-
-        return_text = ""
-        if self.get_type() == "unordered-list":
-            for tag_text in tag_list:
-                return_text += f"• {tag_text}\n"
-        elif self.get_type() == "ordered-list":
-            for count, tag_text in enumerate(tag_list):
-                return_text += f"{count + 1}. {tag_text}\n"
-
-        return return_text.strip()
-
-
-class Description:
-    "Represents a <description> tag"
-
-    def __init__(self) -> None:
-        self.items: list[DescriptionItem] = []
-        """All Description Items"""
-
-    def load_tags(self, tag: etree.Element) -> None:
-        "Load a XML tag. Onyl for internal use."
-        paragraph_list: list[etree.Element] = []
-        for i in tag.getchildren():
-            if i.tag == "p":
-                if i.get("{http://www.w3.org/XML/1998/namespace}lang") is not None:
-                    paragraph_list.append(i)
-                else:
-                    if len(paragraph_list) != 0:
-                        paragraph_item = DescriptionParagraph()
-                        paragraph_item.load_tags(paragraph_list)
-                        self.items.append(paragraph_item)
-                    paragraph_list.clear()
-                    paragraph_list.append(i)
-            elif i.tag in ("ul", "ol"):
-                if len(paragraph_list) != 0:
-                    paragraph_item = DescriptionParagraph()
-                    paragraph_item.load_tags(paragraph_list)
-                    self.items.append(paragraph_item)
-                    paragraph_list.clear()
-
-                list_item = DescriptionList(i.tag)
-                list_item.load_tags(i)
-                self.items.append(list_item)
-
-        if len(paragraph_list) != 0:
-            paragraph_item = DescriptionParagraph()
-            paragraph_item.load_tags(paragraph_list)
-            self.items.append(paragraph_item)
-
-    def get_tags(self, parent_tag: etree.Element) -> None:
-        "Writes a Description tag. Only for internal use."
-        description_tag = etree.SubElement(parent_tag, "description")
-        for i in self.items:
-            i.get_tags(description_tag)
-
-    def to_html(self, lang: Optional[str] = None) -> str:
-        "Get the HTML code of the description in the given language"
-        description_tag = etree.Element("description")
-
-        for i in self.items:
-            description_tag.append(i.get_translated_tag(lang))
-
-        text = etree.tostring(description_tag, pretty_print=True, encoding="utf-8").decode("utf-8")
-
-        # Remove the description tag
-        text = text.replace("<description>", "")
-        text = text.replace("</description>", "")
-        text = text.replace("<description/>", "")
-
-        # Remove the 2 spaces at the start of each line, after we removed the description tag
-        return_text = ""
-        for line in text.splitlines():
-            return_text += line.removeprefix("  ") + "\n"
-
-        return return_text.strip()
-
-    def to_plain_text(self, lang: Optional[str] = None) -> str:
-        """
-        Converts the Description into Plain Text
-
-        :param lang: The language
-        :return: The Description
-        """
-        text = ""
-
-        for i in self.items:
-            text += f"{i.to_plain_text(lang)}\n\n"
-
-        text = text.removesuffix("\n\n")
-
-        return text.strip()
-
-
-class Release:
-    "Represents a <release> tag"
-
-    def __init__(self) -> None:
-        self.version: str = ""
-        "The version"
-
-        self.date: Optional[datetime.date]
-        "The date"
-
-        self.description = Description()
-        "The description"
-
-    def load_tag(self, tag: etree.Element) -> None:
-        "Loads a release tag"
-
-        self.version = tag.get("version") or ""
-
-        try:
-            self.date = datetime.date.fromisoformat(tag.get("date"))
-        except Exception:
-            pass
-
-        try:
-            self.date = datetime.date.fromtimestamp(int(tag.get("timestamp")))
-        except Exception:
-            pass
-
-        description_tag = tag.find("description")
-        if description_tag is not None:
-            self.description.load_tags(description_tag)
-
-
 class Image:
     "Represents a <image> tag"
 
@@ -541,6 +191,44 @@ class DisplayLength:
             return False
 
 
+@dataclasses.dataclass
+class Developer:
+    "Represents a <developer> tag"
+
+    id: Optional[str] = None
+    name: TranslateableTag = dataclasses.field(default_factory=lambda: TranslateableTag())
+
+    def load_tag(self, tag: etree.Element) -> None:
+        "Loads the data from a XML tag"
+        self.id = tag.get("id")
+
+        self.name.load_tags(tag.findall("name"))
+
+    def get_tag(self) -> etree.Element:
+        """
+        Returns the XML Tag
+
+        :return: The Tag
+        """
+        tag = etree.Element("developer")
+
+        if self.id is not None:
+            tag.set("id", self.id)
+
+        self.name.write_tags(tag, "name")
+
+        return tag
+
+    def clear(self) -> None:
+        """Resets all data"""
+        self.id = None
+        self.name.clear()
+
+    def is_empty(self) -> bool:
+        "Checks if the developer tag is empty"
+        return self.id is None and self.name.get_default_text() == ""
+
+
 class AppstreamComponent:
     "Represents AppStream Component"
 
@@ -554,8 +242,8 @@ class AppstreamComponent:
         self.name: TranslateableTag = TranslateableTag()
         "The component name"
 
-        self.developer_name: TranslateableTag = TranslateableTag()
-        "The developer name"
+        self.developer: Developer = Developer()
+        "The developer"
 
         self.summary: TranslateableTag = TranslateableTag()
         "The component summary"
@@ -572,6 +260,9 @@ class AppstreamComponent:
         self.urls: dict[URL_TYPES_LITERAL, str] = {}
         "The URLs"
 
+        self.launchables: dict[LAUNCHABLE_TYPES, str] = {}
+        "The launchables"
+
         self.oars: dict[OARS_ATTRIBUTE_TYPES_LITERAL, OARS_VALUE_TYPES_LITERAL] = {}
         "The content rating"
 
@@ -581,7 +272,7 @@ class AppstreamComponent:
         self.provides: dict[PROVIDES_TYPES_LITERAL, list[str]] = {}
         "The provides. The content of the depracted mimetype tag goes intp provides['mimetype']"
 
-        self.releases: list[Release] = []
+        self.releases: ReleaseList = ReleaseList()
         "The releases"
 
         self.screenshots: list[Screenshot] = []
@@ -632,17 +323,18 @@ class AppstreamComponent:
         self.id = ""
         self.type = "desktop"
         self.name.clear()
-        self.developer_name.clear()
+        self.developer.clear()
         self.summary.clear()
         self.description.items.clear()
         self.metadata_license = ""
         self.project_license = ""
         self.categories.clear()
         self.urls.clear()
+        self.launchables.clear()
         self.oars.clear()
         self.provides.clear()
-        self.releases.clear()
-        self.screenshots.clear
+        self.releases = ReleaseList()
+        self.screenshots.clear()
         self.project_group = None
         self.translation.clear()
         self.languages.clear()
@@ -704,7 +396,11 @@ class AppstreamComponent:
 
         self.name.load_tags(tag.findall("name"))
 
-        self.developer_name.load_tags(tag.findall("developer_name"))
+        # For backward compatibility
+        self.developer.name.load_tags(tag.findall("developer_name"))
+
+        if (developer_tag := tag.find("developer")) is not None:
+            self.developer.load_tag(developer_tag)
 
         self.summary.load_tags(tag.findall("summary"))
 
@@ -729,17 +425,16 @@ class AppstreamComponent:
             if i.get("type") in URL_TYPES:
                 self.urls[i.get("type")] = i.text.strip()
 
+        for i in tag.findall("launchable"):
+            if i.get("type") in LAUNCHABLE_TYPES:
+                self.launchables[i.get("type")] = i.text.strip()
+
         oars_tag = tag.find("content_rating")
         if oars_tag is not None:
             for i in oars_tag.findall("content_attribute"):
                 if i.get("id") in OARS_ATTRIBUTE_TYPES and i.text.strip() in OARS_VALUE_TYPES:
                     self.oars[i.get("id")] = i.text.strip()
 
-        categories_tag = tag.find("categories")
-        if categories_tag is not None:
-            for i in categories_tag.findall("category"):
-                self.categories.append(i.text.strip())
-
         provides_tag = tag.find("provides")
         if provides_tag is not None:
             for i in provides_tag.getchildren():
@@ -754,10 +449,7 @@ class AppstreamComponent:
 
         releases_tag = tag.find("releases")
         if releases_tag is not None:
-            for i in releases_tag.findall("release"):
-                release_object = Release()
-                release_object.load_tag(i)
-                self.releases.append(release_object)
+            self.releases = ReleaseList.from_tag(releases_tag)
 
         screenshots_tag = tag.find("screenshots")
         if screenshots_tag is not None:
@@ -905,7 +597,8 @@ class AppstreamComponent:
 
         self.name.write_tags(tag, "name")
 
-        self.developer_name.write_tags(tag, "developer_name")
+        if not self.developer.is_empty():
+            tag.append(self.developer.get_tag())
 
         self.summary.write_tags(tag, "summary")
 
@@ -923,6 +616,12 @@ class AppstreamComponent:
                 url_tag.set("type", key)
                 url_tag.text = value
 
+        for key, value in self.launchables.items():
+            if key in LAUNCHABLE_TYPES:
+                url_tag = etree.SubElement(tag, "launchable")
+                url_tag.set("type", key)
+                url_tag.text = value
+
         oars_tag = etree.SubElement(tag, "content_rating")
         oars_tag.set("type", "oars-1.1")
         for key, value in self.oars.items():
@@ -949,6 +648,9 @@ class AppstreamComponent:
         if len(provides_tag.getchildren()) == 0:
             tag.remove(provides_tag)
 
+        if len(self.releases) != 0:
+            tag.append(self.releases.get_tag())
+
         if self.project_group:
             project_group_tag = etree.SubElement(tag, "project_group")
             project_group_tag.text = self.project_group

appstream_python/Release.py

@@ -0,0 +1,187 @@
+from dataclasses import dataclass
+from typing import Type, Literal
+from ._helper import assert_func
+from .Shared import Description
+from lxml import etree
+import collections
+import datetime
+import requests
+import copy
+import os
+
+
+ReleaseType = Literal["stable", "development"]
+ReleaseListType = Literal["embedded", "external"]
+UrgencyType = Literal["unknown", "low", "medium", "high", "critical"]
+
+
+@dataclass
+class Release:
+    "Represents a <release> tag"
+
+    version: str = ""
+    type: ReleaseType = "stable"
+    urgency: UrgencyType = "unknown"
+    date: datetime.date | None = None
+    description = Description()
+    date_eol: datetime.date | None = None
+
+    def __post_init__(self) -> None:
+        self.description = copy.deepcopy(self.description)
+
+    def get_tag(self) -> etree.Element:
+        """
+        Returns the XML Tag
+
+        :return: The Tag
+        """
+        tag = etree.Element("release")
+        tag.set("type", self.type)
+        tag.set("version", self.version)
+
+        if self.urgency != "unknown":
+            tag.set("urgency", self.urgency)
+
+        if self.date is not None:
+            tag.set("date", self.date.isoformat())
+
+        if self.date_eol is not None:
+            tag.set("date_eol", self.date_eol.isoformat())
+
+        self.description.get_tags(tag)
+
+        return tag
+
+    @classmethod
+    def from_tag(cls: Type["Release"], tag: etree._Element) -> "Release":
+        "Loads a release tag"
+        release = cls()
+
+        release.version = tag.get("version", "")
+        release.type = tag.get("type", "stable")
+        release.urgency = tag.get("urgency", "unknown")
+
+        try:
+            release.date = datetime.datetime.fromisoformat(tag.get("date")).date()
+        except Exception:
+            pass
+
+        try:
+            release.date = datetime.date.fromtimestamp(int(tag.get("timestamp")))
+        except Exception:
+            pass
+
+        try:
+            release.date_eol = datetime.datetime.fromisoformat(tag.get("date_eol")).date()
+        except Exception:
+            pass
+
+        description_tag = tag.find("description")
+        if description_tag is not None:
+            release.description.load_tags(description_tag)
+
+        return release
+
+
+class ReleaseList(collections.UserList[Release]):
+    "Represents a list of releases"
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.type: ReleaseListType = "embedded"
+        "The type"
+
+        self.url: str = ""
+        "The URL if external"
+
+    def load_external_releases(self) -> None:
+        "Loads the external releases from the Internet"
+        if self.type != "external":
+            return
+
+        r = requests.get(self.url)
+
+        tag = etree.fromstring(r.content)
+
+        for single_release in tag.findall("release"):
+            self.append(Release.from_tag(single_release))
+
+    def get_tag(self) -> etree.Element:
+        """
+        Returns the XML Tag
+
+        :return: The Tag
+        """
+        tag = etree.Element("releases")
+
+        if self.type != "external":
+            for release in self.data:
+                tag.append(release.get_tag())
+        else:
+            tag.set("type", self.type)
+
+        if self.url != "":
+            tag.set("url", self.url)
+
+        return tag
+
+    def get_xml_string(self) -> str:
+        """
+        Returns the XML data of the ReleaseList as string
+
+        :return: The XMl as string
+        """
+        return etree.tostring(self.get_tag(), pretty_print=True, encoding=str).strip()
+
+    def save_file(self, path: str | os.PathLike) -> None:
+        """Saves the Component as XML file"""
+        with open(path, "wb") as f:
+            f.write(etree.tostring(self.get_tag(), pretty_print=True, xml_declaration=True, encoding="utf-8"))
+
+    @classmethod
+    def from_tag(cls: Type["ReleaseList"], tag: etree._Element, fetch_external: bool = False) -> "ReleaseList":
+        "Creates the list from an XMl tag"
+        release_list = cls()
+
+        release_list.type = tag.get("type", "embedded")
+        release_list.url = tag.get("url", "")
+
+        for single_release in tag.findall("release"):
+            release_list.append(Release.from_tag(single_release))
+
+        if fetch_external:
+            release_list.load_external_releases()
+
+        return release_list
+
+    @classmethod
+    def from_string(cls: Type["ReleaseList"], text: str) -> "ReleaseList":
+        "Loads the Releases from a string"
+        return cls.from_tag(etree.fromstring(text.encode("utf-8")))
+
+    @classmethod
+    def from_file(cls: Type["ReleaseList"], path: str | os.PathLike) -> "ReleaseList":
+        "Loads the Releases from a file"
+        with open(path, "r", encoding="utf-8") as f:
+            return cls.from_string(f.read())
+
+    @classmethod
+    def from_url(cls: Type["ReleaseList"], url: str) -> "ReleaseList":
+        "Loads the Releases from a URL"
+        return cls.from_tag(etree.fromstring(requests.get(url).content))
+
+    def __repr__(self) -> str:
+        return f"ReleaseList(type='{self.type}', url='{self.url}', data={self.data})"
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, ReleaseList):
+            return False
+
+        try:
+            assert_func(self.url == obj.url)
+            assert_func(self.type == obj.type)
+            assert_func(self.data == obj.data)
+            return True
+        except AssertionError:
+            return False

appstream_python/Shared.py

@@ -0,0 +1,371 @@
+from typing import Optional, Literal
+from ._helper import assert_func
+from lxml import etree
+
+
+_XML_LANG = "{http://www.w3.org/XML/1998/namespace}lang"
+
+
+class TranslateableTag:
+    "Represents a translatable tag"
+    def __init__(self) -> None:
+        self._text = ""
+        self._translations: dict[str, str] = {}
+
+    def get_default_text(self) -> str:
+        """Returns the untranslated text"""
+        return self._text
+
+    def set_default_text(self, text: str) -> None:
+        """Sets the untranslated text"""
+        self._text = text
+
+    def get_translated_text(self, lang: str) -> Optional[str]:
+        """Returns the translated text"""
+        return self._translations.get(lang, None)
+
+    def get_translated_text_default(self, lang: str) -> Optional[str]:
+        """Returns the translated text. Returns the default text, if the translation does not exists"""
+        return self._translations.get(lang, self._text)
+
+    def set_translated_text(self, lang: str, text: str) -> None:
+        """Sets the translated text"""
+        self._translations[lang] = text
+
+    def get_available_languages(self) -> list[str]:
+        """Returns a list with all languages of the tag"""
+        return list(self._translations.keys())
+
+    def load_tags(self, tag_list: list[etree.Element]) -> None:
+        """Load a list of Tags"""
+        for i in tag_list:
+            if i.get("{http://www.w3.org/XML/1998/namespace}lang") is None:
+                if i.text is not None:
+                    self._text = i.text.strip()
+                else:
+                    self._text = ""
+            else:
+                if i.text is not None:
+                    self._translations[i.get(_XML_LANG)] = i.text.strip()
+                else:
+                    self._translations[i.get(_XML_LANG)] = ""
+
+    def write_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
+        """Writes a Tag"""
+        default_tag = etree.SubElement(parent_tag, tag_name)
+        default_tag.text = self._text
+
+        for key, value in self._translations.items():
+            translation_tag = etree.SubElement(parent_tag, tag_name)
+            translation_tag.set("{http://www.w3.org/XML/1998/namespace}lang", key)
+            translation_tag.text = value
+
+    def clear(self) -> None:
+        """Resets all data"""
+        self._text = ""
+        self._translations.clear()
+
+    def __repr__(self) -> str:
+        return f"<TranslateableTag default='{self._text}'>"
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, TranslateableTag):
+            return False
+
+        try:
+            assert_func(self._translations == obj._translations)
+            return True
+        except AssertionError:
+            return False
+
+
+class TranslateableList:
+    "Represents a translatable list"
+
+    def __init__(self) -> None:
+        self._translated_data: dict[str, dict[str, str]] = {}
+        self._translated_lists: dict[str, list[str]] = {}
+
+    def get_default_list(self) -> list[str]:
+        "Returns a list with the default items"
+        return list(self._translated_data.keys())
+
+    def get_translated_list(self, lang: str) -> list[str]:
+        "Returns the translated list for the given language"
+        if lang in self._translated_lists:
+            return self._translated_lists[lang]
+
+        return_list: list[str] = []
+        for untranslated_text, translations in self._translated_data.items():
+            return_list.append(translations.get(lang, untranslated_text))
+        return return_list
+
+    def load_tag(self, tag: etree.Element) -> None:
+        "Loads an Tag. Only for internal use."
+        if tag.get("{http://www.w3.org/XML/1998/namespace}lang") is None:
+            current_text = ""
+            for i in tag.getchildren():
+                if i.get(_XML_LANG) is None:
+                    try:
+                        current_text = i.text.strip()
+                        self._translated_data[current_text] = {}
+                    except AttributeError:
+                        pass
+                else:
+                    if current_text in self._translated_data:
+                        self._translated_data[current_text][i.get(_XML_LANG)] = i.text.strip()
+        else:
+            if tag.get("{http://www.w3.org/XML/1998/namespace}lang") not in self._translated_lists:
+                self._translated_lists[tag.get("{http://www.w3.org/XML/1998/namespace}lang")] = []
+            for i in tag.getchildren():
+                self._translated_lists[tag.get("{http://www.w3.org/XML/1998/namespace}lang")].append(i.text.strip())
+
+    def write_all_tag(self, parent_tag: etree.Element, tag_name: str) -> None:
+        "Writes the XML tags. Onnly for internal use."
+        for untranslated_text, translations in self._translated_data.items():
+            default_tag = etree.SubElement(parent_tag, tag_name)
+            default_tag.text = untranslated_text
+            for lang, translated_text in translations.items():
+                translated_tag = etree.SubElement(parent_tag, tag_name)
+                translated_tag.set(_XML_LANG, lang)
+                translated_tag.text = translated_text
+
+    def write_untranslated_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
+        "Writes the untranslated XML tags. Onnly for internal use."
+        for untranslated_text in self._translated_data.keys():
+            default_tag = etree.SubElement(parent_tag, tag_name)
+            default_tag.text = untranslated_text
+
+    def write_translated_tags(self, parent_tag: etree.Element, tag_name: str, lang: str) -> None:
+        "Writes the translated XML tags. Onnly for internal use."
+        for untranslated_text, translations in self._translated_data.items():
+            child_tag = etree.SubElement(parent_tag, tag_name)
+            child_tag.text = translations.get(lang, untranslated_text)
+
+    def clear(self) -> None:
+        """Resets all data"""
+        self._translated_data.clear()
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, TranslateableList):
+            return False
+
+        try:
+            assert_func(self._translated_data == obj._translated_data)
+            assert_func(self._translated_lists == obj._translated_lists)
+            return True
+        except AssertionError:
+            return False
+
+
+class DescriptionItem:
+    "The Interface for a Description Item"
+
+    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
+        "Retutns the Type of the Item"
+        return "none"
+
+    def load_tags(self, tag_list: list[etree.Element]) -> None:
+        "Loads teh XML tags into the Elemnt. Only for internal use."
+        raise NotImplementedError
+
+    def get_tags(self, parent_tag: etree.Element) -> None:
+        "Get the XML Tag from the Element. Only for internal use."
+        raise NotImplementedError()
+
+    def get_translated_tag(self, lang: Optional[str]) -> etree.Element:
+        "Loads the tag for a given language"
+        raise NotImplementedError()
+
+    def to_plain_text(self, lang: Optional[str] = None) -> str:
+        "Returns the content as plain text"
+        raise NotImplementedError()
+
+
+class DescriptionParagraph(DescriptionItem):
+    "Represents a paragraph <p> in the Description"
+
+    def __init__(self) -> None:
+        self.content = TranslateableTag()
+        """The Text of the Paragraph"""
+
+    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
+        "Retutns the Type of the Item"
+        return "paragraph"
+
+    def load_tags(self, tag_list: list[etree.Element]) -> None:
+        "Loads teh XML tags into the Elemnt. Only for internal use."
+        self.content.load_tags(tag_list)
+
+    def get_tags(self, parent_tag: etree.Element) -> None:
+        "Get the XML Tag from the Element. Only for internal use."
+        self.content.write_tags(parent_tag, "p")
+
+    def get_translated_tag(self, lang: Optional[str]) -> etree.Element:
+        "Loads the tag for a given language"
+        paragraph_tag = etree.Element("p")
+        if lang is None:
+            paragraph_tag.text = self.content.get_default_text()
+        else:
+            paragraph_tag.text = self.content.get_translated_text_default(lang)
+        return paragraph_tag
+
+    def to_plain_text(self, lang: Optional[str] = None) -> str:
+        "Returns the content as plain text"
+        return self.content.get_translated_text_default(lang).strip()
+
+    def __repr__(self) -> str:
+        return f"<DescriptionParagraph default='{self.content.get_default_text()}'>"
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, DescriptionParagraph):
+            return False
+
+        return self.content == obj.content
+
+
+class DescriptionList(DescriptionItem):
+    "Represents a list <ul>/<ol> in the Description"
+
+    def __init__(self, list_type: str) -> None:
+        self._list_type = list_type
+
+        self.content: TranslateableList = TranslateableList()
+        "The list"
+
+    def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
+        "Returns the Type of the Item"
+        if self._list_type == "ul":
+            return "unordered-list"
+        else:
+            return "ordered-list"
+
+    def load_tags(self, tag_list: list[etree.Element]) -> None:
+        "Loads the XML tags into the Elemnt. Only for internal use."
+        self.content.load_tag(tag_list)
+
+    def get_tags(self, parent_tag: etree.Element) -> None:
+        "Get the XML Tag from the Element. Only for internal use."
+        list_tag = etree.SubElement(parent_tag, self._list_type)
+        self.content.write_all_tag(list_tag, "li")
+
+    def get_translated_tag(self, lang: Optional[str] = None) -> etree.Element:
+        "Loads the tag for a given language"
+        list_tag = etree.Element(self._list_type)
+        if lang is None:
+            self.content.write_untranslated_tags(list_tag, "li")
+        else:
+            self.content.write_translated_tags(list_tag, "li", lang)
+        return list_tag
+
+    def to_plain_text(self, lang: Optional[str] = None) -> str:
+        "Returns the content as plain text"
+        tag_list = self.content.get_translated_list(lang)
+
+        return_text = ""
+        if self.get_type() == "unordered-list":
+            for tag_text in tag_list:
+                return_text += f"• {tag_text}\n"
+        elif self.get_type() == "ordered-list":
+            for count, tag_text in enumerate(tag_list):
+                return_text += f"{count + 1}. {tag_text}\n"
+
+        return return_text.strip()
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, DescriptionList):
+            return False
+
+        try:
+            assert_func(self._list_type == obj._list_type)
+            assert_func(self.content == obj.content)
+            return True
+        except AssertionError:
+            return False
+
+
+class Description:
+    "Represents a <description> tag"
+
+    def __init__(self) -> None:
+        self.items: list[DescriptionItem] = []
+        """All Description Items"""
+
+    def load_tags(self, tag: etree.Element) -> None:
+        "Load a XML tag. Onyl for internal use."
+        paragraph_list: list[etree.Element] = []
+        for i in tag.getchildren():
+            if i.tag == "p":
+                if i.get("{http://www.w3.org/XML/1998/namespace}lang") is not None:
+                    paragraph_list.append(i)
+                else:
+                    if len(paragraph_list) != 0:
+                        paragraph_item = DescriptionParagraph()
+                        paragraph_item.load_tags(paragraph_list)
+                        self.items.append(paragraph_item)
+                    paragraph_list.clear()
+                    paragraph_list.append(i)
+            elif i.tag in ("ul", "ol"):
+                if len(paragraph_list) != 0:
+                    paragraph_item = DescriptionParagraph()
+                    paragraph_item.load_tags(paragraph_list)
+                    self.items.append(paragraph_item)
+                    paragraph_list.clear()
+
+                list_item = DescriptionList(i.tag)
+                list_item.load_tags(i)
+                self.items.append(list_item)
+
+        if len(paragraph_list) != 0:
+            paragraph_item = DescriptionParagraph()
+            paragraph_item.load_tags(paragraph_list)
+            self.items.append(paragraph_item)
+
+    def get_tags(self, parent_tag: etree.Element) -> None:
+        "Writes a Description tag. Only for internal use."
+        description_tag = etree.SubElement(parent_tag, "description")
+        for i in self.items:
+            i.get_tags(description_tag)
+
+    def to_html(self, lang: Optional[str] = None) -> str:
+        "Get the HTML code of the description in the given language"
+        description_tag = etree.Element("description")
+
+        for i in self.items:
+            description_tag.append(i.get_translated_tag(lang))
+
+        text = etree.tostring(description_tag, pretty_print=True, encoding="utf-8").decode("utf-8")
+
+        # Remove the description tag
+        text = text.replace("<description>", "")
+        text = text.replace("</description>", "")
+        text = text.replace("<description/>", "")
+
+        # Remove the 2 spaces at the start of each line, after we removed the description tag
+        return_text = ""
+        for line in text.splitlines():
+            return_text += line.removeprefix("  ") + "\n"
+
+        return return_text.strip()
+
+    def to_plain_text(self, lang: Optional[str] = None) -> str:
+        """
+        Converts the Description into Plain Text
+
+        :param lang: The language
+        :return: The Description
+        """
+        text = ""
+
+        for i in self.items:
+            text += f"{i.to_plain_text(lang)}\n\n"
+
+        text = text.removesuffix("\n\n")
+
+        return text.strip()
+
+    def __eq__(self, obj: object) -> bool:
+        if not isinstance(obj, Description):
+            return False
+
+        return self.items == obj.items

appstream_python/StandardConstants.py

@@ -13,6 +13,13 @@ URL_TYPES_LITERAL = Literal[
     "contribute"
 ]
 
+LAUNCHABLE_TYPES_LITERAL = Literal[
+    "desktop-id",
+    "service",
+    "cockpit-manifest",
+    "url"
+]
+
 OARS_ATTRIBUTE_TYPES_LITERAL = Literal[
     "violence-cartoon",
     "violence-fantasy",
@@ -89,6 +96,9 @@ INTERNET_RELATION_VALUE_LITERAL = Literal[
 URL_TYPES = list(get_args(URL_TYPES_LITERAL))
 "All URL types"
 
+LAUNCHABLE_TYPES = list(get_args(LAUNCHABLE_TYPES_LITERAL))
+"All launchable types"
+
 OARS_ATTRIBUTE_TYPES = list(get_args(OARS_ATTRIBUTE_TYPES_LITERAL))
 "All aviable OARS attributes"
 

appstream_python/__init__.py

@@ -1,4 +1,5 @@
 from .Collection import AppstreamCollection
 from .Component import AppstreamComponent
+from .Release import ReleaseList
 
-__all__ = ["AppstreamCollection", "AppstreamComponent", "StandardConstants"]
+__all__ = ["AppstreamCollection", "AppstreamComponent", "ReleaseList", "StandardConstants"]

appstream_python/version.txt

@@ -1 +1 @@
-0.6.3
+0.8

{appstream_python-0.6.3.dist-info → appstream_python-0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: appstream-python
-Version: 0.6.3
+Version: 0.8
 Summary: A library for dealing with Freedesktop Appstream data
 Author-email: JakobDev <jakobdev@gmx.de>
 License: BSD-2-Clause
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: requests
 Requires-Dist: lxml
 
 # appstream-python

appstream_python-0.8.dist-info/RECORD

@@ -0,0 +1,13 @@
+appstream_python/Collection.py,sha256=D5Sx8M4YovOZ2OKkubgY0rxRA2IwhdXJqcFuAhhoIUE,2777
+appstream_python/Component.py,sha256=BgFWQUv0XBsUZYp4WTuONXAmf80XE64Q7QG0x2PcD1U,24219
+appstream_python/Release.py,sha256=sLQbv0T7FLYZYcfGivveVOKFD6rptoCAK0lbYCFYeiE,5409
+appstream_python/Shared.py,sha256=zHeUDicNbuP_jXx3VTSNGuq7XFGUryZg0zMVCgGdXgo,13959
+appstream_python/StandardConstants.py,sha256=-SzBKeXWFgY_6wc3SgptDlj88gOE_ztXBeBM3Xx3ko4,2376
+appstream_python/__init__.py,sha256=eB0PvIoWrH0ZkNq2yY2h9xujdNqJMKmyM01KDpm6Yis,212
+appstream_python/_helper.py,sha256=T1On8-taSPoKgpz9u8briuRO0uurcBL415o8g2Gc678,326
+appstream_python/version.txt,sha256=_fJ28Bg8cXQoI7Bh9zQtWB5W3grxBkgzm1JSSeJu6U8,4
+appstream_python-0.8.dist-info/LICENSE,sha256=KHWQLS2VDTyyF0CMgSrCU2j758vzhIUXA4viB-DWlTI,1318
+appstream_python-0.8.dist-info/METADATA,sha256=6GzziBTwnxogHEFdDf_uxfUhsxG5EgiN-15nUJ7qOw4,1328
+appstream_python-0.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+appstream_python-0.8.dist-info/top_level.txt,sha256=TEnvfaZcEAhAofLtB0lquKH1fwr9C-9dxpGN405dZiQ,17
+appstream_python-0.8.dist-info/RECORD,,

{appstream_python-0.6.3.dist-info → appstream_python-0.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

appstream_python-0.6.3.dist-info/RECORD

@@ -1,11 +0,0 @@
-appstream_python/Collection.py,sha256=D5Sx8M4YovOZ2OKkubgY0rxRA2IwhdXJqcFuAhhoIUE,2777
-appstream_python/Component.py,sha256=QrXSfWktl0Ki77m4jfySooSx6FgVVdfMFm-maJzQaGE,35969
-appstream_python/StandardConstants.py,sha256=xcpEJixO662W_vCuGV8RSByN70_0tXaM-ODHfNPhdwo,2186
-appstream_python/__init__.py,sha256=Bj7IpeFc_-HflTaV8I1LRxe1vIbBp2iZfXEJEtBE8Uw,164
-appstream_python/_helper.py,sha256=T1On8-taSPoKgpz9u8briuRO0uurcBL415o8g2Gc678,326
-appstream_python/version.txt,sha256=yfVuuTSMvINFva6nyiTJ-WDhWYrwVHJ5R2CiaC_weow,6
-appstream_python-0.6.3.dist-info/LICENSE,sha256=KHWQLS2VDTyyF0CMgSrCU2j758vzhIUXA4viB-DWlTI,1318
-appstream_python-0.6.3.dist-info/METADATA,sha256=h2XBYaJ01kE7PLNP80Auh6BltLpTalrzmv48VckNhuw,1306
-appstream_python-0.6.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-appstream_python-0.6.3.dist-info/top_level.txt,sha256=TEnvfaZcEAhAofLtB0lquKH1fwr9C-9dxpGN405dZiQ,17
-appstream_python-0.6.3.dist-info/RECORD,,