Merge pull request #5 from Kronopt/develop

Kronopt · web-flow · commit 03c3d85c32ce · 2020-08-13T23:08:03.000+01:00
Develop
diff --git a/.pylintrc b/.pylintrc
@@ -138,7 +138,8 @@ disable=print-statement,
         xreadlines-attribute,
         deprecated-sys-function,
         exception-escape,
-        comprehension-escape
+        comprehension-escape,
+        wrong-import-position
 
 # Enable the message, report, category or checker with the given id(s). You can
 # either give multiple identifier separated by comma (,) or put this option
diff --git a/docs/history.md b/docs/history.md
@@ -1,5 +1,8 @@
 # History
 
+### 0.2.2 (13-08-2020)
+* Fixed failing to import xkcd_wrapper if either only requests or aiohttp were installed
+
 ### 0.2.1 (11-08-2020)
 * Separate dependencies
     (you can now use the async implementation without having to install the sync dependencies and vice versa)
diff --git a/docs/usage.md b/docs/usage.md
@@ -39,7 +39,8 @@ comic.explanation   # xkcd explanation wiki url
 
 ### Async implementation
 
-The `AsyncClient`can be used in much the same way as `Client`. After importing `xkcd_wrapper`, instantiate the `AsyncClient`:
+The `AsyncClient`can be used in much the same way as `Client`. After importing `xkcd_wrapper`,
+instantiate the `AsyncClient`:
 ```python
 async_client = xkcd_wrapper.AsyncClient() 
 ```
diff --git a/xkcd_wrapper/__init__.py b/xkcd_wrapper/__init__.py
@@ -27,10 +27,28 @@
 __author__ = 'Pedro HC David, https://github.com/Kronopt'
 __credits__ = ['Pedro HC David']
 __license__ = 'GPLv3'
-__version__ = '0.2.1'
+__version__ = '0.2.2'
 
 
-from .client import Client
-from .async_client import AsyncClient
+REQUESTS_INSTALLED = True
+AIOHTTP_INSTALLED = True
+
+try:
+    from .client import Client
+except ModuleNotFoundError:
+    REQUESTS_INSTALLED = False
+
+try:
+    from .async_client import AsyncClient
+except ModuleNotFoundError:
+    AIOHTTP_INSTALLED = False
+
+if not any([REQUESTS_INSTALLED, AIOHTTP_INSTALLED]):
+    raise ModuleNotFoundError(
+        'Neither \'requests\' nor \'aiohttp\' are installed. '
+        'xkcd-wrapper needs at least one of those dependencies to work. '
+        'Use the correct pip command to install the necessary dependencies '
+        '(please refer to the xkcd-wrapper documentation).')
+
 from .comic import Comic
 from . import exceptions
diff --git a/xkcd_wrapper/async_client.py b/xkcd_wrapper/async_client.py
@@ -7,12 +7,12 @@
 
 import random
 import aiohttp
-from .client import Client
+from .base_client import BaseClient
 from .comic import Comic
 from . import exceptions
 
 
-class AsyncClient(Client):
+class AsyncClient(BaseClient):
     """
     AsyncClient asynchronously communicates with the xkcd API, parses its response and generates
     Comic objects
@@ -92,6 +92,9 @@ async def get_latest(self):
         """
         return await self.get(0)  # comic_id of 0 requests latest comic
 
+    # get_latest alias
+    latest = get_latest
+
     async def get_random(self):
         """
         Asynchronously retrieves a random xkcd comic
@@ -118,6 +121,9 @@ async def get_random(self):
         parsed_response = self._parse_response(await self._request_comic(random_id))
         return Comic(parsed_response)
 
+    # get_random alias
+    random = get_random
+
     async def _request_comic(self, comic_id):
         """
         Handles asynchronous http requests
diff --git a/xkcd_wrapper/base_client.py b/xkcd_wrapper/base_client.py
@@ -0,0 +1,119 @@
+#!python
+# coding: utf-8
+
+"""
+xkcd-wrapper BaseClient
+"""
+
+import json
+from . import exceptions
+
+
+class BaseClient:
+    """
+    BaseClient contains the methods common to both Client and AsyncClient
+    This class alone doesn't communicate with the xkcd API
+    """
+
+    def __init__(self):
+        """
+        BaseClient init
+        """
+        self._base_url = 'https://xkcd.com/{}{}'
+        self._api = 'info.0.json'
+        self._explanation_wiki_url = 'https://www.explainxkcd.com/wiki/index.php/'
+
+    def base_url(self):
+        """
+        xkcd base API url
+
+        Returns
+        -------
+        str
+            xkcd base API url
+        """
+        return self._base_url.format('', '')
+
+    def latest_comic_url(self):
+        """
+        xkcd API url for latest comic
+
+        Returns
+        -------
+        str
+            xkcd API url for latest comic
+        """
+        return self._base_url.format(self._api, '')
+
+    def comic_id_url(self, comic_id):
+        """
+        xkcd API url for comic with id = comic_id
+
+        Parameters
+        ----------
+        comic_id : int
+            xkcd comic id
+
+        Returns
+        -------
+        str
+            xkcd API url for comic with id = comic_id
+        """
+        return self._base_url.format(str(comic_id) + '/', self._api)
+
+    def _parse_response(self, response):
+        """
+        Parses xkcd API response
+
+        Parameters
+        ----------
+        response : str
+            xkcd API json response as str
+
+        Returns
+        -------
+        dict
+            relevant fields, extracted from xkcd API response, plus some extra ones
+
+        Raises
+        ------
+        xkcd_wrapper.exceptions.BadResponseField
+            If response contained a field that could not be converted to int (after json decode)
+        """
+        # relation between xkcd-wrapper fields and xkcd API fields
+        fields_relationship = {
+            'id': 'num',
+            'day': 'day',
+            'month': 'month',
+            'year': 'year',
+            'title': 'safe_title',
+            'description': 'alt',
+            'transcript': 'transcript',
+            'image': 'img',
+        }
+
+        json_response = json.loads(response)
+
+        # all values default to None to avoid errors if the xkcd API returns missing data
+        parsed = dict()
+
+        for wrapper_value, api_value in fields_relationship.items():
+            # if int conversion raises ValueError, something came wrong from the API
+            if wrapper_value in ('id', 'day', 'month', 'year'):  # int
+                try:
+                    parsed[wrapper_value] = int(
+                        json_response[api_value]) if api_value in json_response else None
+                except ValueError as err:
+                    raise exceptions.BadResponseField(wrapper_value, api_value, err)
+
+            # everything converts to str, so no error here
+            else:  # str
+                parsed[wrapper_value] = str(
+                    json_response[api_value]) if api_value in json_response else None
+
+        parsed['link'] = self._base_url.format(
+            parsed['id'], '') if parsed['id'] is not None else None
+        parsed['explanation'] = '{}{}'.format(self._explanation_wiki_url,
+                                              parsed['id']) if parsed['id'] is not None else None
+
+        return parsed
diff --git a/xkcd_wrapper/client.py b/xkcd_wrapper/client.py
@@ -5,14 +5,14 @@
 xkcd-wrapper Client
 """
 
-import json
 import random
 import requests
+from .base_client import BaseClient
 from .comic import Comic
 from . import exceptions
 
 
-class Client:
+class Client(BaseClient):
     """
     Client communicates with the xkcd API, parses its response and generates Comic objects
 
@@ -39,52 +39,6 @@ class Client:
         When calling get(id), get_latest() and random() if an http error or a timeout occurs
     """
 
-    def __init__(self):
-        """
-        Client init
-        """
-        self._base_url = 'https://xkcd.com/{}{}'
-        self._api = 'info.0.json'
-        self._explanation_wiki_url = 'https://www.explainxkcd.com/wiki/index.php/'
-
-    def base_url(self):
-        """
-        xkcd base API url
-
-        Returns
-        -------
-        str
-            xkcd base API url
-        """
-        return self._base_url.format('', '')
-
-    def latest_comic_url(self):
-        """
-        xkcd API url for  latest comic
-
-        Returns
-        -------
-        str
-            xkcd API url for  latest comic
-        """
-        return self._base_url.format(self._api, '')
-
-    def comic_id_url(self, comic_id):
-        """
-        xkcd API url for comic with id = comic_id
-
-        Parameters
-        ----------
-        comic_id : int
-            xkcd comic id
-
-        Returns
-        -------
-        str
-            xkcd API url for comic with id = comic_id
-        """
-        return self._base_url.format(str(comic_id) + '/', self._api)
-
     def get(self, comic_id):
         """
         Retrieve an xkcd comic by id
@@ -203,62 +157,5 @@ def _request_comic(self, comic_id):
             raise exceptions.HttpError(xkcd_response.status_code, xkcd_response.reason)
         return xkcd_response.text
 
-    def _parse_response(self, response):
-        """
-        Parses xkcd API response
-
-        Parameters
-        ----------
-        response : str
-            xkcd API json response as str
-
-        Returns
-        -------
-        dict
-            relevant fields, extracted from xkcd API response, plus some extra ones
-
-        Raises
-        ------
-        xkcd_wrapper.exceptions.BadResponseField
-            If response contained a field that could not be converted to int (after json decode)
-        """
-        # relation between xkcd-wrapper fields and xkcd API fields
-        fields_relationship = {
-            'id': 'num',
-            'day': 'day',
-            'month': 'month',
-            'year': 'year',
-            'title': 'safe_title',
-            'description': 'alt',
-            'transcript': 'transcript',
-            'image': 'img',
-        }
-
-        json_response = json.loads(response)
-
-        # all values default to None to avoid errors when the API returns missing data
-        parsed = dict()
-
-        for wrapper_value, api_value in fields_relationship.items():
-            # if int conversion raises ValueError, something came wrong from the API
-            if wrapper_value in ('id', 'day', 'month', 'year'):  # int
-                try:
-                    parsed[wrapper_value] = int(
-                        json_response[api_value]) if api_value in json_response else None
-                except ValueError as err:
-                    raise exceptions.BadResponseField(wrapper_value, api_value, err)
-
-            # everything converts to str, so no error here
-            else:  # str
-                parsed[wrapper_value] = str(
-                    json_response[api_value]) if api_value in json_response else None
-
-        parsed['link'] = self._base_url.format(
-            parsed['id'], '') if parsed['id'] is not None else None
-        parsed['explanation'] = '{}{}'.format(self._explanation_wiki_url,
-                                              parsed['id']) if parsed['id'] is not None else None
-
-        return parsed
-
     def __repr__(self):
         return 'xkcd_wrapper.Client()'
