text: """Sensor for Spot Crime."""
  
  from collections import defaultdict
  from datetime import timedelta
  import logging
  
  import spotcrime
  import voluptuous as vol
  
  from homeassistant.components.sensor import PLATFORM_SCHEMA
  from homeassistant.const import (
      ATTR_ATTRIBUTION,
      ATTR_LATITUDE,
      ATTR_LONGITUDE,
      CONF_API_KEY,
      CONF_EXCLUDE,
      CONF_INCLUDE,
      CONF_LATITUDE,
      CONF_LONGITUDE,
      CONF_NAME,
      CONF_RADIUS,
  )
  import homeassistant.helpers.config_validation as cv
  from homeassistant.helpers.entity import Entity
  from homeassistant.util import slugify
  
  _LOGGER = logging.getLogger(__name__)
  
  CONF_DAYS = "days"
  DEFAULT_DAYS = 1
  NAME = "spotcrime"
  
  EVENT_INCIDENT = f"{NAME}_incident"
  
  SCAN_INTERVAL = timedelta(minutes=30)
  
  PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
      {
          vol.Required(CONF_NAME): cv.string,
          vol.Required(CONF_RADIUS): vol.Coerce(float),
          vol.Required(CONF_API_KEY): cv.string,
          vol.Inclusive(CONF_LATITUDE, "coordinates"): cv.latitude,
          vol.Inclusive(CONF_LONGITUDE, "coordinates"): cv.longitude,
          vol.Optional(CONF_DAYS, default=DEFAULT_DAYS): cv.positive_int,
          vol.Optional(CONF_INCLUDE): vol.All(cv.ensure_list, [cv.string]),
          vol.Optional(CONF_EXCLUDE): vol.All(cv.ensure_list, [cv.string]),
      }
  )
  
  
  def setup_platform(hass, config, add_entities, discovery_info=None):
      """Set up the Crime Reports platform."""
      latitude = config.get(CONF_LATITUDE, hass.config.latitude)
      longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
      name = config[CONF_NAME]
      radius = config[CONF_RADIUS]
      api_key = config[CONF_API_KEY]
      days = config.get(CONF_DAYS)
      include = config.get(CONF_INCLUDE)
      exclude = config.get(CONF_EXCLUDE)
  
      add_entities(
          [
              SpotCrimeSensor(
                  name, latitude, longitude, radius, include, exclude, api_key, days
              )
          ],
          True,
      )
  
  
  class SpotCrimeSensor(Entity):
      """Representation of a Spot Crime Sensor."""
  
      def __init__(
          self, name, latitude, longitude, radius, include, exclude, api_key, days
      ):
          """Initialize the Spot Crime sensor."""
  
          self._name = name
          self._include = include
          self._exclude = exclude
          self.api_key = api_key
          self.days = days
          self._spotcrime = spotcrime.SpotCrime(
              (latitude, longitude),
              radius,
              self._include,
              self._exclude,
              self.api_key,
              self.days,
          )
          self._attributes = None
          self._state = None
          self._previous_incidents = set()
          self._attributes = {ATTR_ATTRIBUTION: spotcrime.ATTRIBUTION}
  
      @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 device_state_attributes(self):
          """Return the state attributes."""
          return self._attributes
  
      def _incident_event(self, incident):
          data = {
              "type": incident.get("type"),
              "timestamp": incident.get("timestamp"),
              "address": incident.get("location"),
          }
          if incident.get("coordinates"):
              data.update(
                  {
                      ATTR_LATITUDE: incident.get("lat"),
                      ATTR_LONGITUDE: incident.get("lon"),
                  }
              )
          self.hass.bus.fire(EVENT_INCIDENT, data)
  
      def update(self):
          """Update device state."""
          incident_counts = defaultdict(int)
          incidents = self._spotcrime.get_incidents()
          if len(incidents) < len(self._previous_incidents):
              self._previous_incidents = set()
          for incident in incidents:
              incident_type = slugify(incident.get("type"))
              incident_counts[incident_type] += 1
              if (
                  self._previous_incidents
                  and incident.get("id") not in self._previous_incidents
              ):
                  self._incident_event(incident)
              self._previous_incidents.add(incident.get("id"))
          self._attributes.update(incident_counts)
          self._state = len(incidents)
  