Use constants for HTTP headers (#10313)

* Use constants for HTTP headers

* Fix ordering

* Move 'no-cache' to platform

homeassistant/components/binary_sensor/aurora.py

@@ -7,25 +7,32 @@
 from datetime import timedelta
 import logging
 
+from aiohttp.hdrs import USER_AGENT
 import requests
 import voluptuous as vol
 
-from homeassistant.components.binary_sensor \
-    import (BinarySensorDevice, PLATFORM_SCHEMA)
-from homeassistant.const import (CONF_NAME)
+from homeassistant.components.binary_sensor import (
+    PLATFORM_SCHEMA, BinarySensorDevice)
+from homeassistant.const import CONF_NAME, ATTR_ATTRIBUTION
 import homeassistant.helpers.config_validation as cv
 from homeassistant.util import Throttle
 
-CONF_THRESHOLD = "forecast_threshold"
-
 _LOGGER = logging.getLogger(__name__)
 
+CONF_ATTRIBUTION = "Data provided by the National Oceanic and Atmospheric" \
+                   "Administration"
+CONF_THRESHOLD = 'forecast_threshold'
+
+DEFAULT_DEVICE_CLASS = 'visible'
 DEFAULT_NAME = 'Aurora Visibility'
-DEFAULT_DEVICE_CLASS = "visible"
 DEFAULT_THRESHOLD = 75
 
+HA_USER_AGENT = "Home Assistant Aurora Tracker v.0.1.0"
+
 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=5)
 
+URL = "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
     vol.Optional(CONF_THRESHOLD, default=DEFAULT_THRESHOLD): cv.positive_int,
@@ -43,10 +50,7 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
 
     try:
         aurora_data = AuroraData(
-            hass.config.latitude,
-            hass.config.longitude,
-            threshold
-        )
+            hass.config.latitude, hass.config.longitude, threshold)
         aurora_data.update()
     except requests.exceptions.HTTPError as error:
         _LOGGER.error(
@@ -85,9 +89,9 @@ def device_state_attributes(self):
         attrs = {}
 
         if self.aurora_data:
-            attrs["visibility_level"] = self.aurora_data.visibility_level
-            attrs["message"] = self.aurora_data.is_visible_text
-
+            attrs['visibility_level'] = self.aurora_data.visibility_level
+            attrs['message'] = self.aurora_data.is_visible_text
+            attrs[ATTR_ATTRIBUTION] = CONF_ATTRIBUTION
         return attrs
 
     def update(self):
@@ -104,10 +108,7 @@ def __init__(self, latitude, longitude, threshold):
         self.longitude = longitude
         self.number_of_latitude_intervals = 513
         self.number_of_longitude_intervals = 1024
-        self.api_url = \
-            "http://services.swpc.noaa.gov/text/aurora-nowcast-map.txt"
-        self.headers = {"User-Agent": "Home Assistant Aurora Tracker v.0.1.0"}
-
+        self.headers = {USER_AGENT: HA_USER_AGENT}
         self.threshold = int(threshold)
         self.is_visible = None
         self.is_visible_text = None
@@ -132,14 +133,14 @@ def update(self):
 
     def get_aurora_forecast(self):
         """Get forecast data and parse for given long/lat."""
-        raw_data = requests.get(self.api_url, headers=self.headers).text
+        raw_data = requests.get(URL, headers=self.headers, timeout=5).text
         forecast_table = [
             row.strip(" ").split("   ")
             for row in raw_data.split("\n")
             if not row.startswith("#")
         ]
 
-        # convert lat and long for data points in table
+        # Convert lat and long for data points in table
         converted_latitude = round((self.latitude / 180)
                                    * self.number_of_latitude_intervals)
         converted_longitude = round((self.longitude / 360)

homeassistant/components/bloomsky.py

@@ -4,16 +4,17 @@
 For more details about this component, please refer to the documentation at
 https://home-assistant.io/components/bloomsky/
 """
-import logging
 from datetime import timedelta
+import logging
 
+from aiohttp.hdrs import AUTHORIZATION
 import requests
 import voluptuous as vol
 
 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import discovery
-from homeassistant.util import Throttle
 import homeassistant.helpers.config_validation as cv
+from homeassistant.util import Throttle
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -68,7 +69,7 @@ def refresh_devices(self):
         """Use the API to retrieve a list of devices."""
         _LOGGER.debug("Fetching BloomSky update")
         response = requests.get(
-            self.API_URL, headers={"Authorization": self._api_key}, timeout=10)
+            self.API_URL, headers={AUTHORIZATION: self._api_key}, timeout=10)
         if response.status_code == 401:
             raise RuntimeError("Invalid API_KEY")
         elif response.status_code != 200:

homeassistant/components/device_tracker/swisscom.py

@@ -6,13 +6,14 @@
 """
 import logging
 
+from aiohttp.hdrs import CONTENT_TYPE
 import requests
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
 from homeassistant.const import CONF_HOST
+import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -77,7 +78,7 @@ def _update_info(self):
     def get_swisscom_data(self):
         """Retrieve data from Swisscom and return parsed result."""
         url = 'http://{}/ws'.format(self.host)
-        headers = {'Content-Type': 'application/x-sah-ws-4-call+json'}
+        headers = {CONTENT_TYPE: 'application/x-sah-ws-4-call+json'}
         data = """
         {"service":"Devices", "method":"get",
         "parameters":{"expression":"lan and not self"}}"""

homeassistant/components/device_tracker/tplink.py

@@ -5,21 +5,27 @@
 https://home-assistant.io/components/device_tracker.tplink/
 """
 import base64
+from datetime import datetime
 import hashlib
 import logging
 import re
-from datetime import datetime
 
+from aiohttp.hdrs import (
+    ACCEPT, COOKIE, PRAGMA, REFERER, CONNECTION, KEEP_ALIVE, USER_AGENT,
+    CONTENT_TYPE, CACHE_CONTROL, ACCEPT_ENCODING, ACCEPT_LANGUAGE)
 import requests
 import voluptuous as vol
 
-import homeassistant.helpers.config_validation as cv
 from homeassistant.components.device_tracker import (
     DOMAIN, PLATFORM_SCHEMA, DeviceScanner)
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.const import (
+    CONF_HOST, CONF_PASSWORD, CONF_USERNAME, HTTP_HEADER_X_REQUESTED_WITH)
+import homeassistant.helpers.config_validation as cv
 
 _LOGGER = logging.getLogger(__name__)
 
+HTTP_HEADER_NO_CACHE = 'no-cache'
+
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
     vol.Required(CONF_HOST): cv.string,
     vol.Required(CONF_PASSWORD): cv.string,
@@ -78,7 +84,7 @@ def _update_info(self):
         referer = 'http://{}'.format(self.host)
         page = requests.get(
             url, auth=(self.username, self.password),
-            headers={'referer': referer}, timeout=4)
+            headers={REFERER: referer}, timeout=4)
 
         result = self.parse_macs.findall(page.text)
 
@@ -123,7 +129,7 @@ def _update_info(self):
             .format(b64_encoded_username_password)
 
         response = requests.post(
-            url, headers={'referer': referer, 'cookie': cookie},
+            url, headers={REFERER: referer, COOKIE: cookie},
             timeout=4)
 
         try:
@@ -174,11 +180,11 @@ def _get_auth_tokens(self):
             .format(self.host)
         referer = 'http://{}/webpages/login.html'.format(self.host)
 
-        # If possible implement rsa encryption of password here.
+        # If possible implement RSA encryption of password here.
         response = requests.post(
             url, params={'operation': 'login', 'username': self.username,
                          'password': self.password},
-            headers={'referer': referer}, timeout=4)
+            headers={REFERER: referer}, timeout=4)
 
         try:
             self.stok = response.json().get('data').get('stok')
@@ -207,11 +213,9 @@ def _update_info(self):
                'form=statistics').format(self.host, self.stok)
         referer = 'http://{}/webpages/index.html'.format(self.host)
 
-        response = requests.post(url,
-                                 params={'operation': 'load'},
-                                 headers={'referer': referer},
-                                 cookies={'sysauth': self.sysauth},
-                                 timeout=5)
+        response = requests.post(
+            url, params={'operation': 'load'}, headers={REFERER: referer},
+            cookies={'sysauth': self.sysauth}, timeout=5)
 
         try:
             json_response = response.json()
@@ -248,10 +252,9 @@ def _log_out(self):
                'form=logout').format(self.host, self.stok)
         referer = 'http://{}/webpages/index.html'.format(self.host)
 
-        requests.post(url,
-                      params={'operation': 'write'},
-                      headers={'referer': referer},
-                      cookies={'sysauth': self.sysauth})
+        requests.post(
+            url, params={'operation': 'write'}, headers={REFERER: referer},
+            cookies={'sysauth': self.sysauth})
         self.stok = ''
         self.sysauth = ''
 
@@ -292,7 +295,7 @@ def _get_auth_tokens(self):
         # Create the authorization cookie.
         cookie = 'Authorization=Basic {}'.format(self.credentials)
 
-        response = requests.get(url, headers={'cookie': cookie})
+        response = requests.get(url, headers={COOKIE: cookie})
 
         try:
             result = re.search(r'window.parent.location.href = '
@@ -326,8 +329,8 @@ def _update_info(self):
             cookie = 'Authorization=Basic {}'.format(self.credentials)
 
             page = requests.get(url, headers={
-                'cookie': cookie,
-                'referer': referer
+                COOKIE: cookie,
+                REFERER: referer,
             })
             mac_results.extend(self.parse_macs.findall(page.text))
 
@@ -361,50 +364,49 @@ def _update_info(self):
         base_url = 'http://{}'.format(self.host)
 
         header = {
-            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
-                          " rv:53.0) Gecko/20100101 Firefox/53.0",
-            "Accept": "application/json, text/javascript, */*; q=0.01",
-            "Accept-Language": "Accept-Language: en-US,en;q=0.5",
-            "Accept-Encoding": "gzip, deflate",
-            "Content-Type": "application/x-www-form-urlencoded; "
-                            "charset=UTF-8",
-            "X-Requested-With": "XMLHttpRequest",
-            "Referer": "http://" + self.host + "/",
-            "Connection": "keep-alive",
-            "Pragma": "no-cache",
-            "Cache-Control": "no-cache"
+            USER_AGENT:
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.12;"
+                " rv:53.0) Gecko/20100101 Firefox/53.0",
+            ACCEPT: "application/json, text/javascript, */*; q=0.01",
+            ACCEPT_LANGUAGE: "Accept-Language: en-US,en;q=0.5",
+            ACCEPT_ENCODING: "gzip, deflate",
+            CONTENT_TYPE: "application/x-www-form-urlencoded; charset=UTF-8",
+            HTTP_HEADER_X_REQUESTED_WITH: "XMLHttpRequest",
+            REFERER: "http://{}/".format(self.host),
+            CONNECTION: KEEP_ALIVE,
+            PRAGMA: HTTP_HEADER_NO_CACHE,
+            CACHE_CONTROL: HTTP_HEADER_NO_CACHE,
         }
 
         password_md5 = hashlib.md5(
             self.password.encode('utf')).hexdigest().upper()
 
-        # create a session to handle cookie easier
+        # Create a session to handle cookie easier
         session = requests.session()
         session.get(base_url, headers=header)
 
         login_data = {"username": self.username, "password": password_md5}
         session.post(base_url, login_data, headers=header)
 
-        # a timestamp is required to be sent as get parameter
+        # A timestamp is required to be sent as get parameter
         timestamp = int(datetime.now().timestamp() * 1e3)
 
         client_list_url = '{}/data/monitor.client.client.json'.format(
             base_url)
 
         get_params = {
             'operation': 'load',
-            '_': timestamp
+            '_': timestamp,
         }
 
-        response = session.get(client_list_url,
-                               headers=header,
-                               params=get_params)
+        response = session.get(
+            client_list_url, headers=header, params=get_params)
         session.close()
         try:
             list_of_devices = response.json()
         except ValueError:
             _LOGGER.error("AP didn't respond with JSON. "
-                          "Check if credentials are correct.")
+                          "Check if credentials are correct")
             return False
 
         if list_of_devices: