appstream-python 0.8__tar.gz → 0.9.0__tar.gz

{appstream-python-0.8 → appstream_python-0.9.0}/LICENSE

@@ -1,6 +1,6 @@
 BSD 2-Clause License
 
-Copyright (c) 2022, JakobDev
+Copyright (c) 2022-2026, JakobDev
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

{appstream-python-0.8/appstream_python.egg-info → appstream_python-0.9.0}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: appstream-python
-Version: 0.8
+Version: 0.9.0
 Summary: A library for dealing with Freedesktop Appstream data
 Author-email: JakobDev <jakobdev@gmx.de>
-License: BSD-2-Clause
+License-Expression: BSD-2-Clause
 Project-URL: Documentation, https://appstream-python.readthedocs.io
 Project-URL: Issues, https://codeberg.org/JakobDev/appstream-python/issues
 Project-URL: Source, https://codeberg.org/JakobDev/appstream-python
@@ -12,20 +12,22 @@ Keywords: JakobDev,AppStream,Freedesktop,Linux
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Environment :: Other Environment
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: POSIX :: BSD
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests
 Requires-Dist: lxml
+Requires-Dist: requests
+Dynamic: license-file
 
 # appstream-python
 

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python/Collection.py

@@ -5,20 +5,32 @@ import gzip
 
 class AppstreamCollection:
     "Represents a Collection of multiple AppStream files"
+
     def __init__(self) -> None:
         self._components: dict[str, AppstreamComponent] = {}
         self._categories: dict[str, list[str]] = {}
 
-    def _add_appstream_tag(self, tag: etree.Element) -> None:
+    def _add_appstream_tag(self, tag: etree._Element) -> None:
         component_data = AppstreamComponent()
         component_data.parse_component_tag(tag)
+        self.add_component(component_data)
 
-        self._components[component_data.id] = component_data
+    def add_component(self, component: AppstreamComponent) -> None:
+        "Adds a AppstreamComponent to the collection"
+        self._components[component.id] = component
 
-        for i in component_data.categories:
+        for i in component.categories:
             if i not in self._categories:
                 self._categories[i] = []
-            self._categories[i].append(component_data.id)
+            self._categories[i].append(component.id)
+
+    def load_uncompressed_appstream_collection(self, path: str) -> None:
+        "Loads a uncompressed collection"
+        with open(path, "rb") as f:
+            root = etree.fromstring(f.read())
+
+        for i in root.findall("component"):
+            self._add_appstream_tag(i)
 
     def load_compressed_appstream_collection(self, path: str) -> None:
         "Loads a GZIP compressed collection"
@@ -43,7 +55,7 @@ class AppstreamCollection:
         """Returns a list with all available component id's"""
         return list(self._components.keys())
 
-    def get_component(self, component_id: str) -> AppstreamComponent:
+    def get_component(self, component_id: str) -> AppstreamComponent | None:
         """Returns the component with the given id"""
         return self._components.get(component_id, None)
 
@@ -58,7 +70,7 @@ class AppstreamCollection:
 
         return category_list
 
-    def get_collection_tag(self) -> etree.Element:
+    def get_collection_tag(self) -> etree._Element:
         "Gets the XML from the Collection"
         components_tag = etree.Element("components")
 
@@ -72,5 +84,10 @@ class AppstreamCollection:
         with open(path, "w", encoding="utf-8") as f:
             f.write(etree.tostring(self.get_collection_tag(), pretty_print=True, xml_declaration=True, encoding="utf-8").decode("utf-8"))
 
+    def write_compressed_file(self, path: str) -> None:
+        "Writes a Uncompressed collection file"
+        with gzip.open(path, "wb") as f:
+            f.write(etree.tostring(self.get_collection_tag(), pretty_print=True, xml_declaration=True, encoding="utf-8"))
+
     def __len__(self) -> int:
         return len(self._components)

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python/Component.py

@@ -1,11 +1,10 @@
 from .Shared import TranslateableTag, TranslateableList, Description
-from typing import Any, Optional, Literal, TypedDict, Union
+from typing import Any, IO, Optional, Self, TypedDict, Union, cast
 from .Release import ReleaseList
 from ._helper import assert_func
 from .StandardConstants import *
 from lxml import etree
 import dataclasses
-import io
 import os
 
 
@@ -33,6 +32,7 @@ def _compare_relation_value(operator: RELATION_COMPARISON_OPERATOR_LITERAL, firs
 
 class InternetRelationDict(TypedDict):
     "the type for the content of the Internet attribute"
+
     value: INTERNET_RELATION_VALUE_LITERAL
     bandwidth_mbitps: Optional[int]
 
@@ -44,7 +44,7 @@ class Image:
         self.url: str = ""
         "The image URL"
 
-        self.type: Literal["source", "thumbnail"] = "source"
+        self.type: IMAGE_TYPE_LITERAL = "source"
         "The image type"
 
         self.width: Optional[int] = None
@@ -56,22 +56,25 @@ class Image:
         self.language: Optional[str] = None
         "The language"
 
-    def load_tag(self, tag: etree.Element) -> None:
+    def load_tag(self, tag: etree._Element) -> None:
         "Loads a image tag"
-        self.url = tag.text.strip()
-        self.type = tag.get("type", "source")
+        self.url = (tag.text or "").strip()
+        tag_type = tag.get("type", "source")
+        if tag_type not in IMAGE_TYPE:
+            raise ValueError(f"Invalid image type {tag_type}")
+        self.type = cast(IMAGE_TYPE_LITERAL, tag_type)
 
-        try:
-            self.width = int(tag.get("width"))
-        except (ValueError, TypeError):
-            self.width = None
+        tag_width = tag.get("width")
+        self.width = None
+        if tag_width is not None:
+            self.width = int(tag_width)
 
-        try:
-            self.height = int(tag.get("height"))
-        except (ValueError, TypeError):
-            self.height = None
+        tag_height = tag.get("height")
+        self.height = None
+        if tag_height is not None:
+            self.height = int(tag_height)
 
-        self.language = tag.get("{http://www.w3.org/XML/1998/namespace}lang")
+        self.language = tag.get(_XML_LANG)
 
 
 class Screenshot:
@@ -95,7 +98,7 @@ class Screenshot:
         "Returns the thumbnail images"
         return [image for image in self.images if image.type == "thumbnail"]
 
-    def load_tag(self, tag: etree.Element) -> None:
+    def load_tag(self, tag: etree._Element) -> None:
         "Load a screenshot tag"
         for i in tag.findall("image"):
             img = Image()
@@ -112,7 +115,9 @@ class DisplayLength:
         self.px: int = px
         "The logical pixels"
 
-        self.compare: str = compare
+        if compare not in RELATION_COMPARISON_OPERATOR:
+            raise ValueError(f"Invalid compare {compare}")
+        self.compare: RELATION_COMPARISON_OPERATOR_LITERAL = cast(RELATION_COMPARISON_OPERATOR_LITERAL, compare)
         "Compare"
 
     def compare_px(self, value: int) -> bool:
@@ -124,7 +129,7 @@ class DisplayLength:
         """
         return _compare_relation_value(self.compare, value, self.px)
 
-    def get_tag(self) -> etree.Element:
+    def get_tag(self) -> etree._Element:
         """
         Returns the XML Tag
 
@@ -139,16 +144,22 @@ class DisplayLength:
         return tag
 
     @classmethod
-    def from_tag(cls: "DisplayLength", tag: etree.Element) -> "DisplayLength":
+    def from_tag(cls, tag: etree._Element) -> Self:
         "Creates the Object from an XML Tag"
         display_length = cls()
 
+        if tag.text is None:
+            raise ValueError("Missing text for tag {tag}")
+
         try:
             display_length.px = int(tag.text)
         except ValueError:
             display_length.px = cls.string_to_px(tag.text)
 
-        display_length.compare = tag.get("compare", "ge")
+        tag_compare = tag.get("compare", "ge")
+        if tag_compare not in RELATION_COMPARISON_OPERATOR:
+            raise ValueError(f"Invalid compare {tag_compare}")
+        display_length.compare = cast(RELATION_COMPARISON_OPERATOR_LITERAL, tag_compare)
 
         return display_length
 
@@ -198,13 +209,13 @@ class Developer:
     id: Optional[str] = None
     name: TranslateableTag = dataclasses.field(default_factory=lambda: TranslateableTag())
 
-    def load_tag(self, tag: etree.Element) -> None:
+    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:
+    def get_tag(self) -> etree._Element:
         """
         Returns the XML Tag
 
@@ -260,7 +271,7 @@ class AppstreamComponent:
         self.urls: dict[URL_TYPES_LITERAL, str] = {}
         "The URLs"
 
-        self.launchables: dict[LAUNCHABLE_TYPES, str] = {}
+        self.launchables: dict[LAUNCHABLE_TYPES_LITERAL, str] = {}
         "The launchables"
 
         self.oars: dict[OARS_ATTRIBUTE_TYPES_LITERAL, OARS_VALUE_TYPES_LITERAL] = {}
@@ -290,13 +301,13 @@ class AppstreamComponent:
         self.keywords: TranslateableList = TranslateableList()
         "The Keywords"
 
-        self.controls: dict[CONTROL_TYPES_LITERAL, Optional[Literal["requires", "recommends", "supports"]]] = {}
+        self.controls: dict[CONTROL_TYPES_LITERAL, Optional[RELATION_LITERAL]] = {}
         "The Controls"
 
-        self.display_length: dict[Literal["requires", "recommends", "supports"], list[DisplayLength]] = {}
+        self.display_length: dict[RELATION_LITERAL, list[DisplayLength]] = {}
         "The Display Length"
 
-        self.internet: dict[Literal["requires", "recommends", "supports"], InternetRelationDict] = {}
+        self.internet: dict[RELATION_LITERAL, InternetRelationDict] = {}
 
         self.kudos: list[str] = []
         "The Kudos"
@@ -357,16 +368,23 @@ class AppstreamComponent:
 
     def get_available_languages(self) -> list[str]:
         "Returns a list with all available languages of the Component"
-        lang_list = self.name.get_available_languages() + self.summary.get_available_languages() + self.developer_name.get_available_languages()
+        lang_list = self.name.get_available_languages() + self.summary.get_available_languages() + self.developer.name.get_available_languages()
         return list(set(lang_list))
 
-    def _parse_relation_tag(self, tag: etree.Element) -> None:
+    def _parse_relation_tag(self, tag: etree._Element) -> None:
         "Parses a relation tag"
         relation = tag.tag
+        if relation not in RELATION:
+            raise ValueError(f"Invalid relation {relation}")
+        relation = cast(RELATION_LITERAL, relation)
 
         for control_tag in tag.findall("control"):
-            if control_tag.text.strip() in CONTROL_TYPES:
-                self.controls[control_tag.text.strip()] = relation
+            if control_tag.text is None:
+                raise ValueError("Empty control tag text {control_tag}")
+            control_tag_text = control_tag.text.strip()
+            if control_tag_text not in CONTROL_TYPES:
+                raise ValueError("Invalid control tag {control_tag_text}")
+            self.controls[cast(CONTROL_TYPES_LITERAL, control_tag_text)] = relation
 
         for display_length_tag in tag.findall("display_length"):
             if relation in self.display_length:
@@ -376,23 +394,31 @@ class AppstreamComponent:
 
         internet_tag = tag.find("internet")
         if internet_tag is not None:
-            internet_dict: InternetRelationDict = {"value": internet_tag.text.strip()}
+            internet_tag_text = (internet_tag.text or "").strip()
+            if internet_tag_text not in INTERNET_RELATION_VALUE:
+                raise ValueError(f"Invalid internet relation {internet_tag_text}")
+            internet_dict: InternetRelationDict = {"bandwidth_mbitps": None, "value": cast(INTERNET_RELATION_VALUE_LITERAL, internet_tag_text)}
 
-            try:
-                internet_dict["bandwidth_mbitps"] = int(internet_tag.get("bandwidth_mbitps"))
-            except (ValueError, TypeError):
-                internet_dict["bandwidth_mbitps"] = None
+            internet_bandwidth = internet_tag.get("bandwidth_mbitps")
+            if internet_bandwidth is not None:
+                try:
+                    internet_dict["bandwidth_mbitps"] = int(internet_bandwidth)
+                except ValueError:
+                    internet_dict["bandwidth_mbitps"] = None
 
             self.internet[relation] = internet_dict
 
-    def parse_component_tag(self, tag: etree._ElementTree) -> None:
+    def parse_component_tag(self, tag: etree._Element) -> None:
         "Parses a XML tag"
-        self.id = tag.find("id").text.strip()
+        id = tag.find("id")
+        if id is not None and id.text is not None:
+            self.id = id.text.strip()
 
-        try:
-            self.type = tag.xpath("/component")[0].get("type")
-        except IndexError:
-            self.type = tag.get("type")
+        tag_component = tag.xpath("/component")
+        if isinstance(tag_component, list) and len(tag_component) > 0:
+            self.type = cast(etree._Element, tag_component[0]).get("type", "")
+        else:
+            self.type = tag.get("type", "")
 
         self.name.load_tags(tag.findall("name"))
 
@@ -409,42 +435,65 @@ class AppstreamComponent:
             self.description.load_tags(description_tag)
 
         metadata_license_tag = tag.find("metadata_license")
-        if metadata_license_tag is not None:
+        if metadata_license_tag is not None and metadata_license_tag.text is not None:
             self.metadata_license = metadata_license_tag.text.strip()
 
         project_license_tag = tag.find("project_license")
-        if project_license_tag is not None:
+        if project_license_tag is not None and project_license_tag.text is not None:
             self.project_license = project_license_tag.text.strip()
 
         categories_tag = tag.find("categories")
         if categories_tag is not None:
             for i in categories_tag.findall("category"):
+                if i.text is None:
+                    raise ValueError("Empty text for category tag {i}")
                 self.categories.append(i.text.strip())
 
         for i in tag.findall("url"):
-            if i.get("type") in URL_TYPES:
-                self.urls[i.get("type")] = i.text.strip()
+            if i.text is None:
+                raise ValueError("Empty text for url tag {i}")
+            i_type = i.get("type")
+            if i_type not in URL_TYPES:
+                raise ValueError("Invalid url type {i_type}")
+            self.urls[cast(URL_TYPES_LITERAL, i_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()
+            if i.text is None:
+                raise ValueError("Empty text for launchable tag {i}")
+            i_type = i.get("type")
+            if i_type not in LAUNCHABLE_TYPES:
+                raise ValueError("Invalid launchable type {i_type}")
+            self.launchables[cast(LAUNCHABLE_TYPES_LITERAL, i_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()
+                i_id_attr = i.get("id")
+                if i_id_attr is None:
+                    raise ValueError("Missing id attribute for content_attribute tag {i}")
+                if i.text is None:
+                    raise ValueError("Empty text for content_attribute tag {i}")
+                i_id_val = i.text.strip()
+                if i_id_attr not in OARS_ATTRIBUTE_TYPES:
+                    raise ValueError("Invalid id attribute {i_id_attr}")
+                if i_id_val not in OARS_VALUE_TYPES:
+                    raise ValueError("Invalid id value {i_id_val}")
+                self.oars[cast(OARS_ATTRIBUTE_TYPES_LITERAL, i_id_attr)] = cast(OARS_VALUE_TYPES_LITERAL, i_id_val)
 
         provides_tag = tag.find("provides")
         if provides_tag is not None:
-            for i in provides_tag.getchildren():
+            for i in provides_tag:
+                if i.text is None:
+                    raise ValueError("Empty text for provides tag {i}")
                 if i.tag in PROVIDES_TYPES:
-                    self.provides[i.tag].append(i.text.strip())
+                    self.provides[cast(PROVIDES_TYPES_LITERAL, i.tag)].append(i.text.strip())
 
         # For backwards compatibility. See: https://www.freedesktop.org/software/appstream/docs/chap-Metadata.html#tag-mimetypes
         mimetypes_tag = tag.find("mimetypes")
         if mimetypes_tag is not None:
             for i in mimetypes_tag.findall("mimetype"):
+                if i.text is None:
+                    raise ValueError("Empty text for mimetypes tag {i}")
                 self.provides["mediatype"].append(i.text.strip())
 
         releases_tag = tag.find("releases")
@@ -460,20 +509,27 @@ class AppstreamComponent:
 
         project_group_tag = tag.find("project_group")
         if project_group_tag is not None:
+            if project_group_tag.text is None:
+                raise ValueError("Empty text for project_group tag {project_group_tag}")
             self.project_group = project_group_tag.text.strip()
 
         for i in tag.findall("translation"):
-            trans_dict = {}
-            trans_dict["type"] = i.get("type")
             if i.text is None:
-                trans_dict["value"] = ""
-            else:
-                trans_dict["value"] = i.text.strip()
+                continue
+            trans_dict = {
+                "type": i.get("type", ""),
+                "value": "",
+            }
+            if i.text is None:
+                raise ValueError("Empty text for lang tag {i}")
+            trans_dict["value"] = i.text.strip()
             self.translation.append(trans_dict)
 
         languages_tag = tag.find("languages")
         if languages_tag is not None:
             for i in languages_tag.findall("lang"):
+                if i.text is None:
+                    continue
                 try:
                     self.languages[i.text.strip()] = int(i.get("percentage") or 100)
                 except ValueError:
@@ -497,45 +553,57 @@ class AppstreamComponent:
         kudos_tag = tag.find("kudos")
         if kudos_tag is not None:
             for i in kudos_tag.findall("kudo"):
+                if i.text is None:
+                    raise ValueError("Empty text for kudo tag {i}")
                 self.kudos.append(i.text.strip())
 
         update_contact_tag = tag.find("update_contact")
         if update_contact_tag is not None:
+            if update_contact_tag.text is None:
+                raise ValueError("Empty text for update_contact tag {update_contact_tag}")
             self.update_contact = update_contact_tag.text.strip()
 
         replaces_tag = tag.find("replaces")
         if replaces_tag is not None:
             for i in replaces_tag.findall("id"):
+                if i.text is None:
+                    raise ValueError("Empty text for replaces tag {replaces_tag}")
                 self.replaces.append(i.text)
 
         suggests_tag = tag.find("suggests")
         if suggests_tag is not None:
             for i in suggests_tag.findall("id"):
+                if i.text is None:
+                    raise ValueError("Empty text for suggests tag {suggests_tag}")
                 self.suggests.append(i.text)
 
         custom_tag = tag.find("custom")
         if custom_tag is not None:
             for i in custom_tag.findall("value"):
+                if i.text is None:
+                    raise ValueError("Empty text for custom tag {custom_tag}")
                 if key := i.get("key", "").strip():
                     self.custom[key] = i.text.strip()
 
         for i in tag.findall("extends"):
+            if i.text is None:
+                raise ValueError("Empty text for extends tag {i}")
             self.extends.append(i.text.strip())
 
     @classmethod
-    def from_component_tag(cls: "AppstreamComponent", root: etree._Element) -> "AppstreamComponent":
+    def from_component_tag(cls, root: etree._Element) -> Self:
         "Load an appdata.xml or metainfo.xml file"
         component = cls()
         component.parse_component_tag(root)
         return component
 
-    def load_file(self, path: Union[str, os.PathLike, io.RawIOBase]) -> None:
+    def load_file(self, path: Union[str, os.PathLike, IO[Any]]) -> None:
         """Load an appdata.xml or metainfo.xml file"""
         root = etree.parse(path)
-        self.parse_component_tag(root)
+        self.parse_component_tag(cast(etree._Element, root))
 
     @classmethod
-    def from_file(cls: "AppstreamComponent", path: Union[str, os.PathLike, io.RawIOBase]) -> "AppstreamComponent":
+    def from_file(cls, path: Union[str, os.PathLike, IO[Any]]) -> Self:
         "Load an appdata.xml or metainfo.xml file"
         component = cls()
         component.load_file(path)
@@ -547,7 +615,7 @@ class AppstreamComponent:
         self.parse_component_tag(root)
 
     @classmethod
-    def from_bytes(cls: "AppstreamComponent", data: bytes, encoding: Optional[str] = None) -> "AppstreamComponent":
+    def from_bytes(cls, data: bytes, encoding: Optional[str] = None) -> Self:
         "Load an appdata.xml or metainfo.xml byte string"
         component = cls()
         component.load_bytes(data, encoding)
@@ -558,13 +626,13 @@ class AppstreamComponent:
         self.load_bytes(text.encode("utf-8"), encoding="utf-8")
 
     @classmethod
-    def from_string(cls: "AppstreamComponent", text: str) -> "AppstreamComponent":
+    def from_string(cls, text: str) -> Self:
         "Load an appdata.xml or metainfo.xml string"
         component = cls()
         component.load_string(text)
         return component
 
-    def _get_relation_tag(self, parent_tag: etree.Element, relation: Literal["supports", "recommends", "requires"]) -> None:
+    def _get_relation_tag(self, parent_tag: etree._Element, relation: RELATION_LITERAL) -> None:
         "Craetes a relation tag from the Component."
         relation_tag = etree.SubElement(parent_tag, relation)
 
@@ -584,10 +652,10 @@ class AppstreamComponent:
 
             internet_tag.text = self.internet[relation]["value"]
 
-        if len(relation_tag.getchildren()) == 0:
+        if len(relation_tag) == 0:
             parent_tag.remove(relation_tag)
 
-    def get_component_tag(self) -> etree.Element:
+    def get_component_tag(self) -> etree._Element:
         "Creates a XML tag from the Component"
         tag = etree.Element("component")
         tag.set("type", self.type)
@@ -610,16 +678,16 @@ class AppstreamComponent:
         project_license_tag = etree.SubElement(tag, "project_license")
         project_license_tag.text = self.project_license
 
-        for key, value in self.urls.items():
-            if key in URL_TYPES:
+        for key_url, value in self.urls.items():
+            if key_url in URL_TYPES:
                 url_tag = etree.SubElement(tag, "url")
-                url_tag.set("type", key)
+                url_tag.set("type", key_url)
                 url_tag.text = value
 
-        for key, value in self.launchables.items():
-            if key in LAUNCHABLE_TYPES:
+        for key_launchable, value in self.launchables.items():
+            if key_launchable in LAUNCHABLE_TYPES:
                 url_tag = etree.SubElement(tag, "launchable")
-                url_tag.set("type", key)
+                url_tag.set("type", key_launchable)
                 url_tag.text = value
 
         oars_tag = etree.SubElement(tag, "content_rating")
@@ -637,15 +705,15 @@ class AppstreamComponent:
                 single_categorie_tag.text = i
 
         provides_tag = etree.SubElement(tag, "provides")
-        for key, value in self.provides.items():
-            if key not in PROVIDES_TYPES:
+        for key_provides, value_provides in self.provides.items():
+            if key_provides not in PROVIDES_TYPES:
                 continue
-            for i in value:
-                single_provides_tag = etree.SubElement(provides_tag, key)
+            for i in value_provides:
+                single_provides_tag = etree.SubElement(provides_tag, key_provides)
                 single_provides_tag.text = i
 
         # Don't write empty provides tag
-        if len(provides_tag.getchildren()) == 0:
+        if len(provides_tag) == 0:
             tag.remove(provides_tag)
 
         if len(self.releases) != 0:
@@ -655,17 +723,17 @@ class AppstreamComponent:
             project_group_tag = etree.SubElement(tag, "project_group")
             project_group_tag.text = self.project_group
 
-        for i in self.translation:
+        for i_translation in self.translation:
             translation_tag = etree.SubElement(tag, "translation")
-            translation_tag.set("type", i["type"])
-            translation_tag.text = i["value"]
+            translation_tag.set("type", i_translation["type"])
+            translation_tag.text = i_translation["value"]
 
         if len(self.languages) > 0:
             languages_tag = etree.SubElement(tag, "languages")
-            for key, value in self.languages.items():
+            for key_languages, value_languages in self.languages.items():
                 single_language_tag = etree.SubElement(languages_tag, "lang")
-                single_language_tag.set("percentage", str(value))
-                single_language_tag.text = key
+                single_language_tag.set("percentage", str(value_languages))
+                single_language_tag.text = key_languages
 
         self._get_relation_tag(tag, "supports")
         self._get_relation_tag(tag, "recommends")
@@ -695,9 +763,9 @@ class AppstreamComponent:
 
         if len(self.custom) > 0:
             custom_tag = etree.SubElement(tag, "custom")
-            for key, value in self.custom:
+            for key_custom, value in self.custom.items():
                 value_tag = etree.SubElement(custom_tag, "value")
-                value_tag.set("key", key.strip())
+                value_tag.set("key", key_custom.strip())
                 value_tag.text = value.strip()
 
         for i in self.extends:

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python/Release.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Type, Literal
+from typing import Literal, Self, cast, get_args
 from ._helper import assert_func
 from .Shared import Description
 from lxml import etree
@@ -29,7 +29,7 @@ class Release:
     def __post_init__(self) -> None:
         self.description = copy.deepcopy(self.description)
 
-    def get_tag(self) -> etree.Element:
+    def get_tag(self) -> etree._Element:
         """
         Returns the XML Tag
 
@@ -53,28 +53,40 @@ class Release:
         return tag
 
     @classmethod
-    def from_tag(cls: Type["Release"], tag: etree._Element) -> "Release":
+    def from_tag(cls, tag: etree._Element) -> Self:
         "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
+        tag_type = tag.get("type", "stable")
+        if tag_type not in get_args(ReleaseType):
+            raise ValueError(f"Invalid type {tag_type}")
+        release.type = cast(ReleaseType, tag_type)
+        tag_urgency = tag.get("urgency", "unknown")
+        if tag_urgency not in get_args(UrgencyType):
+            raise ValueError(f"Invalid urgency {tag_urgency}")
+        release.urgency = cast(UrgencyType, tag_urgency)
+
+        tag_date = tag.get("date")
+        if tag_date is not None:
+            try:
+                release.date = datetime.datetime.fromisoformat(tag_date).date()
+            except Exception:
+                pass
+
+        tag_timestamp = tag.get("timestamp")
+        if tag_timestamp is not None:
+            try:
+                release.date = datetime.date.fromtimestamp(int(tag_timestamp))
+            except Exception:
+                pass
+
+        tag_date_eol = tag.get("date_eol")
+        if tag_date_eol is not None:
+            try:
+                release.date_eol = datetime.datetime.fromisoformat(tag_date_eol).date()
+            except Exception:
+                pass
 
         description_tag = tag.find("description")
         if description_tag is not None:
@@ -107,7 +119,7 @@ class ReleaseList(collections.UserList[Release]):
         for single_release in tag.findall("release"):
             self.append(Release.from_tag(single_release))
 
-    def get_tag(self) -> etree.Element:
+    def get_tag(self) -> etree._Element:
         """
         Returns the XML Tag
 
@@ -140,11 +152,14 @@ class ReleaseList(collections.UserList[Release]):
             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":
+    def from_tag(cls, tag: etree._Element, fetch_external: bool = False) -> Self:
         "Creates the list from an XMl tag"
         release_list = cls()
 
-        release_list.type = tag.get("type", "embedded")
+        tag_type = tag.get("type", "embedded")
+        if tag_type not in get_args(ReleaseListType):
+            raise ValueError(f"Invalid type {tag_type}")
+        release_list.type = cast(ReleaseListType, tag_type)
         release_list.url = tag.get("url", "")
 
         for single_release in tag.findall("release"):
@@ -156,18 +171,18 @@ class ReleaseList(collections.UserList[Release]):
         return release_list
 
     @classmethod
-    def from_string(cls: Type["ReleaseList"], text: str) -> "ReleaseList":
+    def from_string(cls, text: str) -> Self:
         "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":
+    def from_file(cls, path: str | os.PathLike) -> Self:
         "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":
+    def from_url(cls, url: str) -> Self:
         "Loads the Releases from a URL"
         return cls.from_tag(etree.fromstring(requests.get(url).content))
 

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python/Shared.py

@@ -8,6 +8,7 @@ _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] = {}
@@ -24,8 +25,10 @@ class TranslateableTag:
         """Returns the translated text"""
         return self._translations.get(lang, None)
 
-    def get_translated_text_default(self, lang: str) -> Optional[str]:
+    def get_translated_text_default(self, lang: Optional[str]) -> Optional[str]:
         """Returns the translated text. Returns the default text, if the translation does not exists"""
+        if lang is None:
+            return self._text
         return self._translations.get(lang, self._text)
 
     def set_translated_text(self, lang: str, text: str) -> None:
@@ -36,28 +39,29 @@ class TranslateableTag:
         """Returns a list with all languages of the tag"""
         return list(self._translations.keys())
 
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
+    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:
+            i_lang = i.get(_XML_LANG)
+            if i_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()
+                    self._translations[i_lang] = i.text.strip()
                 else:
-                    self._translations[i.get(_XML_LANG)] = ""
+                    self._translations[i_lang] = ""
 
-    def write_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
+    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.set(_XML_LANG, key)
             translation_tag.text = value
 
     def clear(self) -> None:
@@ -90,37 +94,43 @@ class TranslateableList:
         "Returns a list with the default items"
         return list(self._translated_data.keys())
 
-    def get_translated_list(self, lang: str) -> list[str]:
+    def get_translated_list(self, lang: Optional[str]) -> list[str]:
         "Returns the translated list for the given language"
-        if lang in self._translated_lists:
+        if lang is not None and 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))
+            translated_text = untranslated_text
+            if lang is not None:
+                translated_text = translations.get(lang, untranslated_text)
+            return_list.append(translated_text)
         return return_list
 
-    def load_tag(self, tag: etree.Element) -> None:
+    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:
+        tag_lang = tag.get(_XML_LANG)
+        if tag_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
+            for i in tag:
+                if i.text is None:
+                    continue
+                i_lang = i.get(_XML_LANG)
+                if i_lang is None:
+                    current_text = i.text.strip()
+                    self._translated_data[current_text] = {}
                 else:
                     if current_text in self._translated_data:
-                        self._translated_data[current_text][i.get(_XML_LANG)] = i.text.strip()
+                        self._translated_data[current_text][i_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:
+            if tag_lang not in self._translated_lists:
+                self._translated_lists[tag_lang] = []
+            for i in tag:
+                if i.text is None:
+                    continue
+                self._translated_lists[tag_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)
@@ -130,13 +140,13 @@ class TranslateableList:
                 translated_tag.set(_XML_LANG, lang)
                 translated_tag.text = translated_text
 
-    def write_untranslated_tags(self, parent_tag: etree.Element, tag_name: str) -> None:
+    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:
+    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)
@@ -163,17 +173,17 @@ class DescriptionItem:
 
     def get_type(self) -> Literal["paragraph", "unordered-list", "ordered-list"]:
         "Retutns the Type of the Item"
-        return "none"
+        raise NotImplementedError
 
-    def load_tags(self, tag_list: list[etree.Element]) -> 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:
+    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:
+    def get_translated_tag(self, lang: Optional[str]) -> etree._Element:
         "Loads the tag for a given language"
         raise NotImplementedError()
 
@@ -193,15 +203,15 @@ class DescriptionParagraph(DescriptionItem):
         "Retutns the Type of the Item"
         return "paragraph"
 
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
+    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:
+    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:
+    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:
@@ -212,7 +222,7 @@ class DescriptionParagraph(DescriptionItem):
 
     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()
+        return (self.content.get_translated_text_default(lang) or "").strip()
 
     def __repr__(self) -> str:
         return f"<DescriptionParagraph default='{self.content.get_default_text()}'>"
@@ -240,16 +250,19 @@ class DescriptionList(DescriptionItem):
         else:
             return "ordered-list"
 
-    def load_tags(self, tag_list: list[etree.Element]) -> None:
+    def load_tags(self, tag_list: etree._Element | list[etree._Element]) -> None:
         "Loads the XML tags into the Elemnt. Only for internal use."
-        self.content.load_tag(tag_list)
+        if not isinstance(tag_list, list):
+            tag_list = [tag_list]
+        for tag in tag_list:
+            self.content.load_tag(tag)
 
-    def get_tags(self, parent_tag: etree.Element) -> None:
+    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:
+    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:
@@ -291,12 +304,12 @@ class Description:
         self.items: list[DescriptionItem] = []
         """All Description Items"""
 
-    def load_tags(self, tag: etree.Element) -> None:
+    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():
+        paragraph_list: list[etree._Element] = []
+        for i in tag:
             if i.tag == "p":
-                if i.get("{http://www.w3.org/XML/1998/namespace}lang") is not None:
+                if i.get(_XML_LANG) is not None:
                     paragraph_list.append(i)
                 else:
                     if len(paragraph_list) != 0:
@@ -321,7 +334,7 @@ class Description:
             paragraph_item.load_tags(paragraph_list)
             self.items.append(paragraph_item)
 
-    def get_tags(self, parent_tag: etree.Element) -> None:
+    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:

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python/StandardConstants.py

@@ -66,6 +66,12 @@ PROVIDES_TYPES_LITERAL = Literal[
     "id"
 ]
 
+RELATION_LITERAL = Literal[
+    "requires",
+    "recommends",
+    "supports"
+]
+
 RELATION_COMPARISON_OPERATOR_LITERAL = Literal[
     "eq",
     "ne",
@@ -88,11 +94,16 @@ CONTROL_TYPES_LITERAL = Literal[
 ]
 
 INTERNET_RELATION_VALUE_LITERAL = Literal[
-    "always"
-    "offline-only"
+    "always",
+    "offline-only",
     "first-run"
 ]
 
+IMAGE_TYPE_LITERAL = Literal[
+    "source",
+    "thumbnail"
+]
+
 URL_TYPES = list(get_args(URL_TYPES_LITERAL))
 "All URL types"
 
@@ -108,11 +119,17 @@ OARS_VALUE_TYPES = list(get_args(OARS_VALUE_TYPES_LITERAL))
 PROVIDES_TYPES = list(get_args(PROVIDES_TYPES_LITERAL))
 "The list with all types for provides"
 
+RELATION = list(get_args(RELATION_LITERAL))
+"The list with all relations"
+
 RELATION_COMPARISON_OPERATOR = list(get_args(RELATION_COMPARISON_OPERATOR_LITERAL))
-"The aviable Operators for the relation compare attribute"
+"The available Operators for the relation compare attribute"
 
 CONTROL_TYPES = list(get_args(CONTROL_TYPES_LITERAL))
 "The list with all possible values for control"
 
 INTERNET_RELATION_VALUE = list(get_args(INTERNET_RELATION_VALUE_LITERAL))
 "The list with all possible values for internet"
+
+IMAGE_TYPE = list(get_args(IMAGE_TYPE_LITERAL))
+"The list with all possible values for image type"

appstream_python-0.9.0/appstream_python/version.txt

@@ -0,0 +1 @@
+0.9.0

{appstream-python-0.8 → appstream_python-0.9.0/appstream_python.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: appstream-python
-Version: 0.8
+Version: 0.9.0
 Summary: A library for dealing with Freedesktop Appstream data
 Author-email: JakobDev <jakobdev@gmx.de>
-License: BSD-2-Clause
+License-Expression: BSD-2-Clause
 Project-URL: Documentation, https://appstream-python.readthedocs.io
 Project-URL: Issues, https://codeberg.org/JakobDev/appstream-python/issues
 Project-URL: Source, https://codeberg.org/JakobDev/appstream-python
@@ -12,20 +12,22 @@ Keywords: JakobDev,AppStream,Freedesktop,Linux
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Environment :: Other Environment
-Classifier: License :: OSI Approved :: BSD License
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: POSIX :: BSD
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: requests
 Requires-Dist: lxml
+Requires-Dist: requests
+Dynamic: license-file
 
 # appstream-python
 

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ appstream_python/Shared.py
 appstream_python/StandardConstants.py
 appstream_python/__init__.py
 appstream_python/_helper.py
+appstream_python/py.typed
 appstream_python/version.txt
 appstream_python.egg-info/PKG-INFO
 appstream_python.egg-info/SOURCES.txt
@@ -16,6 +17,7 @@ appstream_python.egg-info/dependency_links.txt
 appstream_python.egg-info/requires.txt
 appstream_python.egg-info/top_level.txt
 tests/test_appstream_data.py
+tests/test_collection.py
 tests/test_description.py
 tests/test_display_length.py
 tests/test_releases.py

{appstream-python-0.8 → appstream_python-0.9.0}/pyproject.toml

@@ -6,9 +6,9 @@ build-backend = "setuptools.build_meta"
 name = "appstream-python"
 description = "A library for dealing with Freedesktop Appstream data"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 keywords = ["JakobDev", "AppStream", "Freedesktop", "Linux"]
-license = { text = "BSD-2-Clause" }
+license = "BSD-2-Clause"
 authors = [
     { name = "JakobDev", email = "jakobdev@gmx.de" }
 ]
@@ -16,19 +16,20 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Environment :: Other Environment",
-    "License :: OSI Approved :: BSD License",
     "Operating System :: POSIX",
     "Operating System :: POSIX :: BSD",
     "Operating System :: POSIX :: Linux",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python :: 3 :: Only",
     "Programming Language :: Python :: Implementation :: CPython"
 ]
 dependencies = [
-    "requests",
-    "lxml"
+    "lxml",
+    "requests"
 ]
 dynamic = ["version"]
 
@@ -41,6 +42,9 @@ Donation = "https://ko-fi.com/jakobdev"
 [tool.setuptools.dynamic]
 version = { file = "appstream_python/version.txt" }
 
+[tool.mypy]
+modules = ["appstream_python"]
+
 [tool.pytest.ini_options]
 addopts = "-v --basetemp=pytest-temp --durations=10 --cov=appstream_python --cov-report html --cov-report term --cov-report term-missing"
 testpaths = ["tests"]

{appstream-python-0.8 → appstream_python-0.9.0}/tests/test_appstream_data.py

@@ -33,6 +33,8 @@ def assert_component_jdtextedit(component: appstream_python.AppstreamComponent)
     assert component.display_length["recommends"][0].px == 760
     assert component.display_length["recommends"][0].compare == "ge"
 
+    assert component.get_available_languages() == ["de"]
+
 
 def test_from_component_tag() -> None:
     root = etree.parse(JDTEXTEDIT_METAINFO)

appstream_python-0.9.0/tests/test_collection.py

@@ -0,0 +1,92 @@
+import appstream_python
+import pathlib
+
+
+def _create_test_collection() -> appstream_python.AppstreamCollection:
+    collection = appstream_python.AppstreamCollection()
+
+    a_component = appstream_python.AppstreamComponent()
+    a_component.id = "com.example.A"
+    a_component.categories.append("Utility")
+    collection.add_component(a_component)
+
+    b_component = appstream_python.AppstreamComponent()
+    b_component.id = "com.example.B"
+    b_component.categories.append("Utility")
+    b_component.categories.append("Game")
+    collection.add_component(b_component)
+
+    c_component = appstream_python.AppstreamComponent()
+    c_component.id = "com.example.C"
+    c_component.categories.append("Game")
+    c_component.categories.append("System")
+    collection.add_component(c_component)
+
+    return collection
+
+
+def test_collection_load_appstream_file() -> None:
+    collection = appstream_python.AppstreamCollection()
+    collection.load_appstream_file(pathlib.Path(__file__).parent / "data" / "AppStream" / "com.gitlab.JakobDev.jdTextEdit.metainfo.xml")
+    assert collection.get_component("com.gitlab.JakobDev.jdTextEdit").id == "com.gitlab.JakobDev.jdTextEdit"
+    assert len(collection) == 1
+
+
+def test_collection_get_component_list() -> None:
+    component_list = _create_test_collection().get_component_list()
+    assert component_list[0].id == "com.example.A"
+    assert component_list[1].id == "com.example.B"
+    assert component_list[2].id == "com.example.C"
+    assert len(component_list) == 3
+
+
+def test_collection_get_component_id_list() -> None:
+    assert _create_test_collection().get_component_id_list() == ["com.example.A", "com.example.B", "com.example.C"]
+
+
+def test_collection_get_component() -> None:
+    collection = _create_test_collection()
+    assert collection.get_component("com.example.A").id == "com.example.A"
+    assert collection.get_component("com.example.B").id == "com.example.B"
+    assert collection.get_component("com.example.C").id == "com.example.C"
+    assert collection.get_component("com.example.D") is None
+
+
+def test_collection_find_by_category() -> None:
+    collection = _create_test_collection()
+
+    utility_list = collection.find_by_category("Utility")
+    assert utility_list[0].id == "com.example.A"
+    assert utility_list[1].id == "com.example.B"
+    assert len(utility_list) == 2
+
+    game_list = collection.find_by_category("Game")
+    assert game_list[0].id == "com.example.B"
+    assert game_list[1].id == "com.example.C"
+    assert len(game_list) == 2
+
+    system_list = collection.find_by_category("System")
+    assert system_list[0].id == "com.example.C"
+    assert len(system_list) == 1
+
+    assert len(collection.find_by_category("Office")) == 0
+
+
+def test_collection_write_load_uncompressed_collection(tmp_path: pathlib.Path) -> None:
+    old_collection = _create_test_collection()
+    old_collection.write_uncompressed_file(tmp_path / "test.xml")
+
+    new_collection = appstream_python.AppstreamCollection()
+    new_collection.load_uncompressed_appstream_collection(tmp_path / "test.xml")
+
+    assert old_collection.get_component_id_list() == new_collection.get_component_id_list()
+
+
+def test_collection_write_load_compressed_collection(tmp_path: pathlib.Path) -> None:
+    old_collection = _create_test_collection()
+    old_collection.write_compressed_file(tmp_path / "test.xml.gz")
+
+    new_collection = appstream_python.AppstreamCollection()
+    new_collection.load_compressed_appstream_collection(tmp_path / "test.xml.gz")
+
+    assert old_collection.get_component_id_list() == new_collection.get_component_id_list()

appstream-python-0.8/appstream_python/version.txt

@@ -1 +0,0 @@
-0.8

{appstream-python-0.8 → appstream_python-0.9.0}/appstream_python.egg-info/requires.txt

@@ -1,2 +1,2 @@
-requests
 lxml
+requests