From 69f1b97f2c7fc507b0385c35750ff5a790eb9489 Mon Sep 17 00:00:00 2001
From: LRvdLinden <77990847+LRvdLinden@users.noreply.github.com>
Date: Fri, 14 May 2021 14:15:45 +0200
Subject: [PATCH] Add files via upload

---
 .../__pycache__/sensor.cpython-38.pyc         | Bin 0 -> 8219 bytes
 .../google_geocode/manifest.json              |   8 +
 .../google_geocode/sensor.py                  | 318 ++++++++++++++++++
 3 files changed, 326 insertions(+)
 create mode 100644 config/custom_components/google_geocode/__pycache__/sensor.cpython-38.pyc
 create mode 100644 config/custom_components/google_geocode/manifest.json
 create mode 100644 config/custom_components/google_geocode/sensor.py

diff --git a/config/custom_components/google_geocode/__pycache__/sensor.cpython-38.pyc b/config/custom_components/google_geocode/__pycache__/sensor.cpython-38.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4e6e5d945da5206e9cbd4bd886e41fc88b1617d
GIT binary patch
literal 8219
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
F{{az<hw=ab

literal 0
HcmV?d00001

diff --git a/config/custom_components/google_geocode/manifest.json b/config/custom_components/google_geocode/manifest.json
new file mode 100644
index 0000000..199ad61
--- /dev/null
+++ b/config/custom_components/google_geocode/manifest.json
@@ -0,0 +1,8 @@
+{
+  "domain": "google_geocode",
+  "name": "Google Geocode",
+  "documentation": "https://github.com/michaelmcarthur/GoogleGeocode-HASS",
+  "dependencies": [],
+  "codeowners": [],
+  "requirements": []
+}
diff --git a/config/custom_components/google_geocode/sensor.py b/config/custom_components/google_geocode/sensor.py
new file mode 100644
index 0000000..ef9eb07
--- /dev/null
+++ b/config/custom_components/google_geocode/sensor.py
@@ -0,0 +1,318 @@
+"""
+Support for Google Geocode sensors.
+
+For more details about this platform, please refer to the documentation at
+https://github.com/michaelmcarthur/GoogleGeocode-HASS
+"""
+from datetime import datetime
+from datetime import timedelta 
+import logging
+import json
+import requests
+from requests import get
+
+import voluptuous as vol
+
+from homeassistant.components.sensor import PLATFORM_SCHEMA
+from homeassistant.const import (
+    CONF_API_KEY, CONF_NAME, CONF_SCAN_INTERVAL, ATTR_ATTRIBUTION, ATTR_LATITUDE, ATTR_LONGITUDE)
+import homeassistant.helpers.location as location
+from homeassistant.util import Throttle
+from homeassistant.helpers.entity import Entity
+import homeassistant.helpers.config_validation as cv
+
+_LOGGER = logging.getLogger(__name__)
+
+CONF_ORIGIN = 'origin'
+CONF_OPTIONS = 'options'
+CONF_DISPLAY_ZONE = 'display_zone'
+CONF_ATTRIBUTION = "Data provided by maps.google.com"
+CONF_GRAVATAR = 'gravatar'
+
+ATTR_STREET_NUMBER = 'Street Number'
+ATTR_STREET = 'Street'
+ATTR_CITY = 'City'
+ATTR_POSTAL_TOWN = 'Postal Town'
+ATTR_POSTAL_CODE = 'Postal Code'
+ATTR_REGION = 'State'
+ATTR_COUNTRY = 'Country'
+ATTR_COUNTY = 'County'
+ATTR_FORMATTED_ADDRESS = 'Formatted Address'
+
+DEFAULT_NAME = 'Google Geocode'
+DEFAULT_OPTION = 'street, city'
+DEFAULT_DISPLAY_ZONE = 'display'
+DEFAULT_KEY = 'no key'
+current = '0,0'
+zone_check = 'a'
+SCAN_INTERVAL = timedelta(seconds=60)
+
+PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
+    vol.Required(CONF_ORIGIN): cv.string,
+    vol.Optional(CONF_API_KEY, default=DEFAULT_KEY): cv.string,
+    vol.Optional(CONF_OPTIONS, default=DEFAULT_OPTION): cv.string,
+    vol.Optional(CONF_DISPLAY_ZONE, default=DEFAULT_DISPLAY_ZONE): cv.string,
+    vol.Optional(CONF_GRAVATAR, default=None): vol.Any(None, cv.string),
+    vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
+    vol.Optional(CONF_SCAN_INTERVAL, default=SCAN_INTERVAL):
+        cv.time_period,
+})
+
+TRACKABLE_DOMAINS = ['device_tracker', 'sensor', 'person']
+
+def setup_platform(hass, config, add_devices, discovery_info=None):
+    """Setup the sensor platform."""
+    name = config.get(CONF_NAME)
+    api_key = config.get(CONF_API_KEY)
+    origin = config.get(CONF_ORIGIN)
+    options = config.get(CONF_OPTIONS)
+    display_zone = config.get(CONF_DISPLAY_ZONE)
+    gravatar = config.get(CONF_GRAVATAR) 
+
+    add_devices([GoogleGeocode(hass, origin, name, api_key, options, display_zone, gravatar)])
+
+
+class GoogleGeocode(Entity):
+    """Representation of a Google Geocode Sensor."""
+
+    def __init__(self, hass, origin, name, api_key, options, display_zone, gravatar):
+        """Initialize the sensor."""
+        self._hass = hass
+        self._name = name
+        self._api_key = api_key
+        self._options = options.lower()
+        self._display_zone = display_zone.lower()
+        self._state = "Awaiting Update"
+        self._gravatar = gravatar
+
+        self._street_number = None
+        self._street = None
+        self._city = None
+        self._postal_town = None
+        self._postal_code = None
+        self._city = None
+        self._region = None
+        self._country = None
+        self._county = None
+        self._formatted_address = None
+        self._zone_check_current = None
+
+        # Check if origin is a trackable entity
+        if origin.split('.', 1)[0] in TRACKABLE_DOMAINS:
+            self._origin_entity_id = origin
+        else:
+            self._origin = origin
+
+        if gravatar is not None:
+            self._picture = self._get_gravatar_for_email(gravatar)
+        else:
+            self._picture = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self._state
+
+    @property
+    def entity_picture(self):
+        """Return the picture of the device."""
+        return self._picture
+        
+    @property
+    def device_state_attributes(self):
+        """Return the state attributes."""
+        return{
+            ATTR_STREET_NUMBER: self._street_number,
+            ATTR_STREET: self._street,
+            ATTR_CITY: self._city,
+            ATTR_POSTAL_TOWN: self._postal_town,
+            ATTR_POSTAL_CODE: self._postal_code,
+            ATTR_REGION: self._region,
+            ATTR_COUNTRY: self._country,
+            ATTR_COUNTY: self._county,
+            ATTR_ATTRIBUTION: CONF_ATTRIBUTION,
+            ATTR_FORMATTED_ADDRESS: self._formatted_address,
+        }
+
+    @Throttle(SCAN_INTERVAL)
+    def update(self):
+        """Get the latest data and updates the states."""
+
+        if hasattr(self, '_origin_entity_id'):
+            self._origin = self._get_location_from_entity(
+                self._origin_entity_id
+            )
+
+        """Update if location has changed."""
+
+        global current
+        global zone_check_count
+        global zone_check
+        global user_display
+        zone_check = self.hass.states.get(self._origin_entity_id).state
+        zone_check_count = 2
+
+        if zone_check == self._zone_check_current:
+            zone_check_count = 1
+        if zone_check == 'not_home':
+            zone_check_count = 2
+        if zone_check_count == 1:
+            pass
+        elif self._origin == None:
+            pass
+        elif current == self._origin:
+            pass
+        else:
+            _LOGGER.info("google request sent")
+            self._zone_check_current = self.hass.states.get(self._origin_entity_id).state
+            zone_check_count = 2
+            lat = self._origin
+            current = lat
+            self._reset_attributes()
+            if self._api_key == 'no key':
+                url = "https://maps.google.com/maps/api/geocode/json?latlng=" + lat
+            else:
+                url = "https://maps.googleapis.com/maps/api/geocode/json?latlng=" + lat + "&key=" + self._api_key
+            response = get(url)
+            json_input = response.text
+            decoded = json.loads(json_input)
+            street_number = ''
+            street = 'Unnamed Road'
+            alt_street = 'Unnamed Road'
+            city = ''
+            postal_town = ''
+            formatted_address = ''
+            state = ''
+            county = ''
+            country = ''
+
+
+            
+            for result in decoded["results"]:
+                for component in result["address_components"]:
+                    if 'street_number' in component["types"]:
+                        street_number = component["long_name"]
+                        self._street_number = street_number
+                    if 'route' in component["types"]:
+                        street = component["long_name"]
+                        self._street = street
+                    if 'sublocality_level_1' in component["types"]:
+                        alt_street = component["long_name"]
+                    if 'postal_town' in component["types"]:
+                        postal_town = component["long_name"]
+                        self._postal_town = postal_town
+                    if 'locality' in component["types"]:
+                        city = component["long_name"]
+                        self._city = city
+                    if 'administrative_area_level_1' in component["types"]:
+                        state = component["long_name"]
+                        self._region = state
+                    if 'administrative_area_level_2' in component["types"]:
+                        county = component["long_name"]
+                        self._county = county
+                    if 'country' in component["types"]:
+                        country = component["long_name"]
+                        self._country = country
+                    if 'postal_code' in component["types"]:
+                        postal_code = component["long_name"]
+                        self._postal_code = postal_code
+
+            try:
+                if 'formatted_address' in decoded['results'][0]:
+                    formatted_address = decoded['results'][0]['formatted_address']
+                    self._formatted_address = formatted_address
+            except IndexError:
+                pass
+
+            if 'error_message' in decoded:
+                self._state = decoded['error_message']
+                _LOGGER.error("You have exceeded your daily requests or entered a incorrect key please create or check the api key.")
+            elif self._display_zone == 'hide' or zone_check == "not_home":
+                if street == 'Unnamed Road':
+                    street = alt_street
+                    self._street = alt_street
+                if city == '':
+                    city = postal_town
+                    if city == '':
+                        city = county
+
+                display_options = self._options
+                user_display = []
+
+                if "street_number" in display_options:
+                    user_display.append(street_number)
+                if "street" in display_options:
+                    user_display.append(street)
+                if "city" in display_options:
+                    self._append_to_user_display(city)
+                if "county" in display_options:
+                    self._append_to_user_display(county)
+                if "state" in display_options:
+                    self._append_to_user_display(state)
+                if "postal_code" in display_options:
+                    self._append_to_user_display(postal_code)
+                if "country" in display_options:
+                    self._append_to_user_display(country)
+                if "formatted_address" in display_options:
+                    self._append_to_user_display(formatted_address)
+                        
+                user_display = ', '.join(  x for x in user_display )
+                
+                if user_display == '':
+                    user_display = street
+                self._state = user_display
+            else:
+                self._state = zone_check[0].upper() + zone_check[1:]
+
+    def _get_location_from_entity(self, entity_id):
+        """Get the origin from the entity state or attributes."""
+        entity = self._hass.states.get(entity_id)
+
+        if entity is None:
+            _LOGGER.error("Unable to find entity %s", entity_id)
+            return None
+
+        # Check if the entity has origin attributes
+        if location.has_location(entity):
+            return self._get_location_from_attributes(entity)
+
+        # When everything fails just return nothing
+        return None
+
+    def _reset_attributes(self):
+        """Resets attributes."""
+        self._street = None
+        self._street_number = None
+        self._city = None
+        self._postal_town = None
+        self._postal_code = None
+        self._region = None
+        self._country = None
+        self._county = None
+        self._formatted_address = None
+
+    def _append_to_user_display(self, append_check):
+        """Appends attribute to state if false."""
+        if append_check == "":
+            pass
+        else:
+            user_display.append(append_check)
+
+    @staticmethod
+    def _get_location_from_attributes(entity):
+        """Get the lat/long string from an entities attributes."""
+        attr = entity.attributes
+        return "%s,%s" % (attr.get(ATTR_LATITUDE), attr.get(ATTR_LONGITUDE))
+        
+    def _get_gravatar_for_email(self, email: str):
+        """Return an 80px Gravatar for the given email address.
+        Async friendly.
+        """
+        import hashlib
+        url = 'https://www.gravatar.com/avatar/{}.jpg?s=80&d=wavatar'
+        return url.format(hashlib.md5(email.encode('utf-8').lower()).hexdigest())