include return types in one-line docstring for @Property

Author: elfkuzco

libzim/libzim.pyx

@@ -496,11 +496,7 @@ cdef class _Creator:
 
     @property
     def filename(self) -> pathlib.Path:
-        """Path of the ZIM Archive.
-
-        Returns:
-            (pathlib.Path): Archive\'s ZIM file path.
-        """
+        """pathlib.Path: Path of the ZIM Archive."""
         return self._filename
 
 class ContentProvider:
@@ -841,34 +837,22 @@ cdef class Entry:
 
     @property
     def title(self) -> str:
-        """The title of the entry.
-
-        Returns:
-            (str): The UTF-8 decoded title of the entry.
-        """
+        """The UTF-8 decoded title of the entry."""
         return self.c_entry.getTitle().decode('UTF-8')
 
     @property
     def path(self) -> str:
-        """The path of the entry.
-
-        Returns:
-            (str): The UTF-8 decoded path of the entry.
-        """
+        """str: The UTF-8 decoded path of the entry."""
         return self.c_entry.getPath().decode("UTF-8", "strict")
 
     @property
     def _index(self) -> pyint:
-        """Internal index in Archive"""
+        """int: Internal index in Archive"""
         return self.c_entry.getIndex()
 
     @property
     def is_redirect(self) -> pybool:
-        """Whether entry is a redirect.
-
-        Returns:
-            (bool): True if the Entry is a redirect, otherwise False.
-        """
+        """bool: Whether entry is a redirect."""
         return self.c_entry.isRedirect()
 
     def get_redirect_entry(self) -> Entry:
@@ -920,55 +904,36 @@ cdef class Item:
 
     @property
     def title(self) -> str:
-        """The title of the Item.
-
-        Returns:
-            (str): The UTF-8 decoded title of the item.
-        """
+        """str: The UTF-8 decoded title of the item."""
         return self.c_item.getTitle().decode('UTF-8')
 
     @property
     def path(self) -> str:
-        """The path of the Item.
-
-        Returns:
-            (str): The UTF-8 decoded path of the item.
+        """str: The UTF-8 decoded path of the item.
         """
         return self.c_item.getPath().decode("UTF-8", "strict")
 
     @property
     def content(self) -> memoryview:
-        """The data associated to the item.
-
-        Returns:
-            (memoryview): A memory view of the item's data.
-        """
+        """memoryview: The data associated to the item."""
         if not self._haveBlob:
             self._blob = ReadingBlob.from_blob(move(self.c_item.getData(<int> 0)))
             self._haveBlob = True
         return memoryview(self._blob)
 
     @property
     def mimetype(self) -> str:
-        """The mimetype of the item.
-
-        Returns:
-            (str): The mimetype of the item.
-        """
+        """str: The mimetype of the item."""
         return self.c_item.getMimetype().decode('UTF-8')
 
     @property
     def _index(self) -> pyint:
-        """Internal index in Archive"""
+        """int: Internal index in Archive"""
         return self.c_item.getIndex()
 
     @property
     def size(self) -> pyint:
-        """The size of the item.
-
-        Returns:
-            (int): The size (in bytes) of the item.
-        """
+        """int: The size (in bytes) of the item."""
         return self.c_item.getSize()
 
     def __repr__(self) -> str:
@@ -1006,20 +971,12 @@ cdef class Archive:
 
     @property
     def filename(self) -> pathlib.Path:
-        """Path (not just file name) of the ZIM Archive.
-
-        Returns:
-            (pathlib.Path): Archive\'s ZIM file path.
-        """
+        """pathlib.Path:  Archive's ZIM file path."""
         return self._filename
 
     @property
     def filesize(self) -> pyint:
-        """Total size of ZIM file (or sum of files if split).
-
-        Returns:
-            (int): The total size of ZIM file (or sum of files if split).
-        """
+        """int: Total size of ZIM file (or sum of files if split)."""
         return self.c_archive.getFilesize()
 
     def has_entry_by_path(self, path: str) -> pybool:
@@ -1091,11 +1048,7 @@ cdef class Archive:
 
     @property
     def metadata_keys(self) -> List[str]:
-        """List of Metadata keys present in this archive.
-
-        Returns:
-           (list[str]): The list of metada in this archive.
-        """
+        """list[str]: List of Metadata keys present in this archive."""
         return [key.decode("UTF-8", "strict") for key in self.c_archive.getMetadataKeys()]
 
     def get_metadata_item(self, name: str) -> Item:
@@ -1135,86 +1088,51 @@ cdef class Archive:
 
     @property
     def has_main_entry(self) -> pybool:
-        """Whether Archive has a main entry set.
-
-        Returns:
-            (bool): True if the archive has a main entry, otherwise False.
-        """
+        """bool: Whether Archive has a main entry set."""
         return self.c_archive.hasMainEntry()
 
     @property
     def main_entry(self) -> Entry:
-        """Get the main entry of the Archive.
-
-        Returns:
-            (Entry): The main entry.
-        """
+        """Entry: The main entry of the Archive."""
         return Entry.from_entry(move(self.c_archive.getMainEntry()))
 
     @property
     def uuid(self) -> UUID:
-        """The uuid of the archive.
-
-        Returns:
-            (uuid.UUID): The uuid of hte archive.
-        """
+        """uuid.UUID: The uuid of the archive."""
         return UUID(self.c_archive.getUuid().hex())
 
     @property
     def has_new_namespace_scheme(self) -> pybool:
-        """Whether Archive is using new “namespaceless” namespace scheme
-
-        Returns:
-            (bool): True if the archive uses the new namespace scheme, otherwise False.
-        """
+        """bool: Whether Archive is using new “namespaceless” namespace scheme."""
         return self.c_archive.hasNewNamespaceScheme()
 
     @property
     def is_multipart(self) -> pybool:
-        """Whether Archive is multipart (split over multiple files).
-
-        Returns:
-            (bool): True if the archive is split in different files, otherwise False.
-        """
+        """bool: Whether Archive is multipart (split over multiple files)."""
         return self.c_archive.isMultiPart()
 
     @property
     def has_fulltext_index(self) -> pybool:
-        """Whether Archive includes a full-text index.
-
-        Returns:
-            (bool): True if the archive has a title index.
-        """
+        """bool: Whether Archive includes a full-text index."""
         return self.c_archive.hasFulltextIndex()
 
     @property
     def has_title_index(self) -> pybool:
-        """Whether Archive includes a title index.
-
-        Returns:
-            (bool): True if the archive has a title index, otherwise False.
-        """
+        """bool: Whether Archive includes a title index."""
         return self.c_archive.hasTitleIndex()
 
     @property
     def has_checksum(self) -> str:
-        """Whether Archive includes a checksum of its content.
+        """bool: Whether Archive includes a checksum of its content.
 
         The checksum is not the checksum of the file. It is an internal
         checksum stored in the zim file.
-
-        Returns:
-            (bool): True if the archive has a checksum, otherwise False.
         """
         return self.c_archive.hasChecksum()
 
     @property
     def checksum(self) -> str:
-        """Archive's checksum.
-
-        Returns:
-            (str): The checksum stored in the archive.
-        """
+        """str: The checksum stored in the archive."""
         return self.c_archive.getChecksum().decode("UTF-8", "strict")
 
     def check(self) -> pybool:
@@ -1227,31 +1145,25 @@ cdef class Archive:
 
     @property
     def entry_count(self) -> pyint:
-        """Number of user entries in Archive.
+        """int: Number of user entries in Archive.
 
         If Archive doesn't support “user entries”
         then this returns `all_entry_count`.
-
-        Returns:
-            (int): The number of user entries in the archive.
         """
         return self.c_archive.getEntryCount()
 
     @property
     def all_entry_count(self) -> pyint:
-        """Number of entries in Archive.
+        """int: Number of entries in Archive.
 
         Total number of entries in the archive, including internal entries
         created by libzim itself, metadata, indexes, etc.
-
-        Returns:
-            (int): The number of all entries in the archive.
         """
         return self.c_archive.getAllEntryCount()
 
     @property
     def article_count(self) -> pyint:
-        """Number of “articles” in the Archive.
+        """int: Number of “articles” in the Archive.
 
         If Archive has_new_namespace_scheme then this is the
         number of Entry with “FRONT_ARTICLE” Hint.
@@ -1261,20 +1173,12 @@ cdef class Archive:
         Note: a few ZIM created during transition might have new scheme but no
         listing, resulting in this returning all entries.
 
-        Returns:
-            (int): The number of articles in the archive.
         """
         return self.c_archive.getArticleCount()
 
     @property
     def media_count(self) -> pyint:
-        """Number of media in the Archive.
-
-        This definition of "media" is based on the mimetype.
-
-        Returns:
-            (int): The number of median in the archive.
-        """
+        """int: Number of media in the Archive."""
         return self.c_archive.getMediaCount()
 
     def get_illustration_sizes(self) -> Set[pyint]:

mkdocs.yml

@@ -125,3 +125,5 @@ plugins:
             # docstring style and options
             docstring_style: google
             docstring_section_style: list
+            docstring_options:
+              returns_type_in_property_summary: true

pyproject.toml

@@ -81,6 +81,7 @@ docs = [
   "mkdocs-gen-files==0.5.0",
   "mkdocs-literate-nav==0.6.1",
   "mkdocs-include-markdown-plugin==7.1.2",
+  "griffe==1.5.6",
 ]
 dev = [
   "pre-commit==4.0.1",