aiohttp and async, remove server_name

Author: maykar

README.md

@@ -33,7 +33,7 @@ Read through these two resources before posting issues to GitHub or the forums.
 | ssl | false | no | Set to true if you use SSL to access Plex.
 | max | 5 | no | Max number of items to show in sensor.
 | download_images | true | no | Setting this to false will turn off downloading of images, but will require certain Plex settings to work. See below.
-| img_dir | '/custom-lovelace/upcoming-media-card/images/plex/' | no | This option allows you to choose a custom directory to store images in if you enable download_images.
+| img_dir | '/upcoming-media-card-images/plex/' | no | This option allows you to choose a custom directory to store images in if you enable download_images. Directory must start and end with a `/`.
 | ssl_cert | false | no | If you provide your own SSL certificate in Plex's network settings set this to true.
 | section_types | movie, show | no | Allows you to specify which section types to consider [movie, show].
 | image_resolution | 200 | no | Allows you to change the resolution of the generated images (in px), useful to display higher quality images as a background somewhere.

custom_components/plex_recently_added/sensor.py

@@ -10,18 +10,36 @@
 import os.path
 import logging
 import json
-import requests
+import aiohttp
+import asyncio
+import async_timeout
 import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 from datetime import datetime
 from homeassistant.components.sensor import PLATFORM_SCHEMA
 from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT, CONF_SSL
 from homeassistant.helpers.entity import Entity
 
-__version__ = '0.3.1'
-
 _LOGGER = logging.getLogger(__name__)
 
+
+async def fetch(session, url, self, ssl, content):
+    with async_timeout.timeout(10):
+        async with session.get(
+            url, ssl=ssl, headers={
+                "Accept": "application/json", "X-Plex-Token": self.token}
+        ) as response:
+            if content:
+                return await response.content.read()
+            else:
+                return await response.text()
+
+
+async def request(url, self, content=False, ssl=False):
+    async with aiohttp.ClientSession() as session:
+        return await fetch(session, url, self, ssl, content)
+
+
 CONF_DL_IMAGES = 'download_images'
 DEFAULT_NAME = 'Plex Recently Added'
 CONF_SERVER = 'server_name'
@@ -43,10 +61,10 @@
     vol.Optional(CONF_HOST, default='localhost'): cv.string,
     vol.Optional(CONF_PORT, default=32400): cv.port,
     vol.Optional(CONF_SECTION_TYPES,
-                default=['movie', 'show']): vol.All(cv.ensure_list, [cv.string]),
+                 default=['movie', 'show']): vol.All(cv.ensure_list, [cv.string]),
     vol.Optional(CONF_RESOLUTION, default=200): cv.positive_int,
-    vol.Optional(CONF_IMG_CACHE, 
-                default='/upcoming-media-card-images/plex/'): cv.string
+    vol.Optional(CONF_IMG_CACHE,
+                 default='/upcoming-media-card-images/plex/'): cv.string
 })
 
 
@@ -77,8 +95,9 @@ def __init__(self, hass, conf, name):
         self.sections = conf.get(CONF_SECTION_TYPES)
         self.resolution = conf.get(CONF_RESOLUTION)
         if self.server_name:
-            self.server_ip, self.local_ip, self.port = get_server_ip(
-                self.server_name, self.token)
+            _LOGGER.warning(
+                "Plex Recently Added: The server_name option has been removed. Use host and port options instead.")
+            return
         else:
             self.server_ip = conf.get(CONF_HOST)
             self.local_ip = conf.get(CONF_HOST)
@@ -97,10 +116,14 @@ def name(self):
 
     @property
     def state(self):
+        if self.server_name:
+            return "server_name is no longer an option, use host and port."
         return self._state
 
     @property
     def device_state_attributes(self):
+        if self.server_name:
+            return
         import math
         attributes = {}
         if self.change_detected:
@@ -181,23 +204,20 @@ def device_state_attributes(self):
                     else:
                         card_item['fanart'] = ''
                 else:
-                    card_item['poster'] = image_url(self.url_elements,
+                    card_item['poster'] = image_url(self,
                                                     False, poster, self.resolution)
-                    card_item['fanart'] = image_url(self.url_elements,
+                    card_item['fanart'] = image_url(self,
                                                     False, fanart, self.resolution)
                 self.card_json.append(card_item)
                 self.change_detected = False
         attributes['data'] = self.card_json
         return attributes
 
-    def update(self):
-        import re
+    async def async_update(self):
         import os
-        plex = requests.Session()
-        if not self.cert:
-            """Default SSL certificate is for plex.tv not our api server"""
-            plex.verify = False
-        headers = {"Accept": "application/json", "X-Plex-Token": self.token}
+        import re
+        if self.server_name:
+            return
         url_base = 'http{0}://{1}:{2}/library/sections'.format(self.ssl,
                                                                self.server_ip,
                                                                self.port)
@@ -208,102 +228,100 @@ def update(self):
         """Find the ID of all libraries in Plex."""
         sections = []
         try:
-            libraries = plex.get(all_libraries, headers=headers, timeout=10)
-            for lib_section in libraries.json()['MediaContainer']['Directory']:
+            libraries = await request(all_libraries, self)
+            libraries = json.loads(libraries)
+            for lib_section in libraries['MediaContainer']['Directory']:
                 if lib_section['type'] in self.sections:
                     sections.append(lib_section['key'])
         except OSError:
             _LOGGER.warning("Host %s is not available", self.server_ip)
             self._state = '%s cannot be reached' % self.server_ip
             return
-        if libraries.status_code == 200:
-            self.api_json = []
-            self._state = 'Online'
-            """Get JSON for each library, combine and sort."""
-            for library in sections:
-                sub_sec = plex.get(recently_added.format(
-                    library, self.max_items * 2), headers=headers, timeout=10)
-                try:
-                    self.api_json += sub_sec.json()['MediaContainer']['Metadata']
-                except:
-                    _LOGGER.warning('No Metadata field for "{}"'.format(sub_sec.json()['MediaContainer']['librarySectionTitle']))
-                    pass
-            self.api_json = sorted(self.api_json, key=lambda i: i['addedAt'],
-                                   reverse=True)[:self.max_items]
-
-            """Update attributes if view count changes"""
-            if view_count(self.api_json) != view_count(self.data):
-                self.change_detected = True
-                self.data = self.api_json
+        self.api_json = []
+        self._state = 'Online'
+        """Get JSON for each library, combine and sort."""
+        for library in sections:
+            sub_sec = await request(recently_added.format(
+                library, self.max_items * 2), self)
+            sub_sec = json.loads(sub_sec)
+            try:
+                self.api_json += sub_sec['MediaContainer']['Metadata']
+            except:
+                _LOGGER.warning('No Metadata field for "{}"'.format(
+                    sub_sec['MediaContainer']['librarySectionTitle']))
+                pass
+        self.api_json = sorted(self.api_json, key=lambda i: i['addedAt'],
+                               reverse=True)[:self.max_items]
 
-            api_ids = media_ids(self.api_json, True)
-            data_ids = media_ids(self.data, True)
-            if self.dl_images:
-                directory = self.conf_dir + 'www' + self._dir
-                if not os.path.exists(directory):
-                    os.makedirs(directory, mode=0o777)
-
-                """Make list of images in dir that use our naming scheme"""
-                dir_re = re.compile(r'[pf]\d+\.jpg')  # p1234.jpg or f1234.jpg
-                dir_images = list(filter(dir_re.search,
-                                         os.listdir(directory)))
-                dir_ids = [file[1:-4] for file in dir_images]
-                dir_ids.sort(key=int)
-
-                """Update if media items have changed or images are missing"""
-                if dir_ids != api_ids or data_ids != api_ids:
-                    self.change_detected = True  # Tell attributes to update
-                    self.data = self.api_json
-                    """Remove images not in list"""
-                    for file in dir_images:
-                        if not any(str(ids) in file for ids in data_ids):
-                            os.remove(directory + file)
-                    """Retrieve image from Plex if it doesn't exist"""
-                    for media in self.data:
-                        if 'type' not in media:
-                            continue
-                        elif media['type'] == 'movie':
-                            poster = media.get('thumb', '')
-                            fanart = media.get('art', '')
-                        elif media['type'] == 'episode':
-                            poster = media.get('grandparentThumb', '')
-                            fanart = media.get('grandparentArt', '')
+        """Update attributes if view count changes"""
+        if view_count(self.api_json) != view_count(self.data):
+            self.change_detected = True
+            self.data = self.api_json
+
+        api_ids = media_ids(self.api_json, True)
+        data_ids = media_ids(self.data, True)
+        if self.dl_images:
+            directory = self.conf_dir + 'www' + self._dir
+            if not os.path.exists(directory):
+                os.makedirs(directory, mode=0o777)
+
+            """Make list of images in dir that use our naming scheme"""
+            dir_re = re.compile(r'[pf]\d+\.jpg')  # p1234.jpg or f1234.jpg
+            dir_images = list(filter(dir_re.search,
+                                     os.listdir(directory)))
+            dir_ids = [file[1:-4] for file in dir_images]
+            dir_ids.sort(key=int)
+
+            """Update if media items have changed or images are missing"""
+            if dir_ids != api_ids or data_ids != api_ids:
+                self.change_detected = True  # Tell attributes to update
+                self.data = self.api_json
+                """Remove images not in list"""
+                for file in dir_images:
+                    if not any(str(ids) in file for ids in data_ids):
+                        os.remove(directory + file)
+                """Retrieve image from Plex if it doesn't exist"""
+                for media in self.data:
+                    if 'type' not in media:
+                        continue
+                    elif media['type'] == 'movie':
+                        poster = media.get('thumb', '')
+                        fanart = media.get('art', '')
+                    elif media['type'] == 'episode':
+                        poster = media.get('grandparentThumb', '')
+                        fanart = media.get('grandparentArt', '')
+                    else:
+                        _LOGGER.error("Media type: %s", media['type'])
+                        continue
+                    poster_jpg = '{}p{}.jpg'.format(directory,
+                                                    media['ratingKey'])
+                    fanart_jpg = '{}f{}.jpg'.format(directory,
+                                                    media['ratingKey'])
+                    if not os.path.isfile(fanart_jpg):
+                        fanart_image = await request(image_url(
+                            self, True, fanart, self.resolution), self, True, True)
+                        if fanart_image:
+                            open(fanart_jpg, 'wb').write(fanart_image)
+                        else:
+                            pass
+                    if not os.path.isfile(poster_jpg):
+                        poster_image = await request(image_url(
+                            self, True, poster, self.resolution), self, True, True)
+                        if poster_image:
+                            open(poster_jpg, 'wb').write(poster_image)
                         else:
-                            _LOGGER.error("Media type: %s", media['type'])
                             continue
-                        poster_jpg = '{}p{}.jpg'.format(directory,
-                                                        media['ratingKey'])
-                        fanart_jpg = '{}f{}.jpg'.format(directory,
-                                                        media['ratingKey'])
-                        if not os.path.isfile(fanart_jpg):
-                            if image_url(self.url_elements, True, fanart):
-                                image = plex.get(image_url(
-                                    self.url_elements, True, fanart, self.resolution),
-                                    headers=headers, timeout=10).content
-                                open(fanart_jpg, 'wb').write(image)
-                            else:
-                                pass
-                        if not os.path.isfile(poster_jpg):
-                            if image_url(self.url_elements, True, poster):
-                                image = plex.get(image_url(
-                                    self.url_elements, True, poster, self.resolution),
-                                    headers=headers, timeout=10).content
-                                open(poster_jpg, 'wb').write(image)
-                            else:
-                                continue
-            else:
-                """Update if media items have changed"""
-                if api_ids != data_ids:
-                    self.change_detected = True  # Tell attributes to update
-                    self.data = self.api_json
         else:
-            self._state = '%s cannot be reached' % self.server_ip
+            """Update if media items have changed"""
+            if api_ids != data_ids:
+                self.change_detected = True  # Tell attributes to update
+                self.data = self.api_json
 
 
-def image_url(url_elements, cert_check, img, resolution=200):
+def image_url(self, cert_check, img, resolution=200):
     """Plex can resize images with a long & partially % encoded url."""
     from urllib.parse import quote
-    ssl, host, local, port, token, self_cert, dl_images = url_elements
+    ssl, host, local, port, token, self_cert, dl_images = self.url_elements
     if not cert_check and not self_cert:
         ssl = ''
     if dl_images:
@@ -313,35 +331,12 @@ def image_url(url_elements, cert_check, img, resolution=200):
                                                                    port,
                                                                    img,
                                                                    token),
-                                                                   safe='')
+                    safe='')
     url = ('http{0}://{1}:{2}/photo/:/transcode?width={5}&height={5}'
            '&minSize=1&url={3}&X-Plex-Token={4}').format(ssl, host, port,
                                                          encoded, token,
                                                          resolution)
-    """Check if image exists"""
-    if not self_cert:
-        r = requests.head(url, verify=False)
-    else:
-        r = requests.head(url)
-    if r.status_code == 200:
-        return url
-    else:
-        return False
-
-
-def get_server_ip(name, token):
-    """With a token and server name we get server's ip, local ip, and port"""
-    import xml.etree.ElementTree as ET
-    from unicodedata import normalize
-    plex_tv = requests.get(
-        'https://plex.tv/api/servers.xml?X-Plex-Token=' + token, timeout=10)
-    plex_xml = ET.fromstring(plex_tv.content)
-    for server in plex_xml.findall('Server'):
-        server_name = server.get('name').casefold()
-        name = name.casefold()
-        if normalize('NFKD', server_name) == normalize('NFKD', name):
-            return (server.get('address'), server.get('localAddresses'),
-                    server.get('port'))
+    return url
 
 
 def days_since(date, tz):