Add call to "pageterms" to gather alias, label and description of a page

tests/mock_data.py

@@ -586,4 +586,41 @@ def wikipedia_api_request(page, params):
             }
         }
     },
+    'en:action=query&prop=pageterms&titles=Test1&': {
+        "batchcomplete": "",
+        "query": {
+            "pages": {
+                "1": {
+                    "pageid": 1,
+                    "ns": 0,
+                    "title": "Test1",
+                    "terms": {
+                        "alias": [
+                            "Test 1",
+                            "Test one",
+                            "Test ONE"
+                        ],
+                        "label": [
+                            "Test 1"
+                        ],
+                        "description": [
+                            "test"
+                        ]
+                    }
+                }
+            }
+        }
+    },
+    'en:action=query&prop=pageterms&titles=Non_Existent&': {
+        "batchcomplete": "",
+        "query": {
+            "pages": {
+                "-1": {
+                    "ns": 0,
+                    "title": "Non Existent",
+                    "missing": ""
+                }
+            }
+        }
+    },
 }

tests/page_terms_test.py

@@ -0,0 +1,34 @@
+import unittest
+
+import wikipediaapi
+from tests.mock_data import wikipedia_api_request
+
+
+class TestPageTerm(unittest.TestCase):
+    def setUp(self):
+        self.wiki = wikipediaapi.Wikipedia("en")
+        self.wiki._query = wikipedia_api_request
+
+    def test_alias_good_parsing(self):
+        page = self.wiki.page('Test1')
+        self.assertEqual(page.alias, ["Test 1", "Test one", "Test ONE"])
+
+    def test_description_good_parsing(self):
+        page = self.wiki.page('Test1')
+        self.assertEqual(page.desc, ['test'])
+
+    def test_label_good_parsing(self):
+        page = self.wiki.page('Test1')
+        self.assertEqual(page.label, ['Test 1'])
+
+    def test_label_nonexistent_page(self):
+        page = self.wiki.page('Non_Existent')
+        self.assertEqual(page.label, [])
+
+    def test_alias_nonexistent_page(self):
+        page = self.wiki.page('Non_Existent')
+        self.assertEqual(page.alias, [])
+
+    def test_description_nonexistent_page(self):
+        page = self.wiki.page('Non_Existent')
+        self.assertEqual(page.desc, [])

wikipediaapi/__init__.py

@@ -7,13 +7,13 @@
 """
 
 __version__ = (0, 5, 4)
+
 import logging
 import re
-from enum import IntEnum
-from typing import Union
-
 import requests
+from enum import IntEnum
 from typing import Dict, Any, List, Optional
+from typing import Union
 from urllib import parse
 
 log = logging.getLogger(__name__)
@@ -563,6 +563,40 @@ def categorymembers(
 
         return self._build_categorymembers(v, page)
 
+    def pageterms(self,
+                  page: 'WikipediaPage',
+                  **kwargs,
+                  ):
+        """
+        https://www.mediawiki.org/w/api.php?action=query&prop=pageterms
+        https://www.wikidata.org/wiki/Help:Aliases
+
+        :param page: :class:`WikipediaPage`
+        :param kwargs: parameters used in API call
+        :return: Alias,label and description of given page
+        """
+        params = {
+            'action': 'query',
+            'prop': 'pageterms',
+            'titles': page.title,
+        }
+        used_params = kwargs
+        used_params.update(params)
+
+        raw = self._query(
+            page,
+            used_params
+        )
+        self._common_attributes(raw['query'], page)
+        pages = raw['query']['pages']
+        for k, v in pages.items():
+            if k == '-1':
+                page._attributes['pageid'] = -1
+                return page._pageterms
+            else:
+                return self._build_pageterms(v, page)
+        return page._pageterms
+
     def _query(
             self,
             page: 'WikipediaPage',
@@ -768,6 +802,16 @@ def _build_categorymembers(
 
         return page._categorymembers
 
+    def _build_pageterms(
+            self,
+            extract,
+            page
+    ) -> PagesDict:
+
+        self._common_attributes(extract, page)
+        page._pageterms = extract.get('terms', [])
+        return page._pageterms
+
     def _common_attributes(
             self,
             extract,
@@ -909,7 +953,10 @@ class WikipediaPage(object):
         "canonicalurl": ["info"],
         "readable": ["info"],
         "preload": ["info"],
-        "displaytitle": ["info"]
+        "displaytitle": ["info"],
+        "alias": ["pageterms"],
+        "label": ["pageterms"],
+        "description": ["pageterms"]
     }
 
     def __init__(
@@ -929,6 +976,7 @@ def __init__(
         self._backlinks = {}  # type: PagesDict
         self._categories = {}  # type: PagesDict
         self._categorymembers = {}  # type: PagesDict
+        self._pageterms = {}  # type : PagesDict
 
         self._called = {
             'extracts': False,
@@ -938,6 +986,7 @@ def __init__(
             'backlinks': False,
             'categories': False,
             'categorymembers': False,
+            'pageterms': False,
         }
 
         self._attributes = {
@@ -1144,6 +1193,39 @@ def categorymembers(self) -> PagesDict:
             self._fetch('categorymembers')
         return self._categorymembers
 
+    @property
+    def alias(self) -> List[str]:
+        """
+        Returns the list alias of the current page.
+
+        :return: alias
+        """
+        if not self._called['pageterms']:
+            self._fetch('pageterms')
+        return self._pageterms.get('alias', [])
+
+    @property
+    def label(self) -> List[str]:
+        """
+        Returns the list of label of the current page.
+
+        :return: label
+        """
+        if not self._called['pageterms']:
+            self._fetch('pageterms')
+        return self._pageterms.get('label', [])
+
+    @property
+    def desc(self) -> List[str]:
+        """
+        Returns the list of descriptive word of the current page.
+
+        :return: description
+        """
+        if not self._called['pageterms']:
+            self._fetch('pageterms')
+        return self._pageterms.get('description', [])
+
     def _fetch(self, call) -> 'WikipediaPage':
         getattr(self.wiki, call)(self)
         self._called[call] = True