269 lines
9.8 KiB
Python
269 lines
9.8 KiB
Python
"""
|
|
Support for GTFS (Google/General Transport Format Schema).
|
|
|
|
For more details about this platform, please refer to the documentation at
|
|
https://home-assistant.io/components/sensor.gtfs/
|
|
"""
|
|
import os
|
|
import logging
|
|
import datetime
|
|
import threading
|
|
|
|
from homeassistant.helpers.entity import Entity
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
REQUIREMENTS = ["https://github.com/robbiet480/pygtfs/archive/"
|
|
"00546724e4bbcb3053110d844ca44e2246267dd8.zip#"
|
|
"pygtfs==0.1.3"]
|
|
|
|
ICON = "mdi:train"
|
|
|
|
TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
|
|
|
|
# pylint: disable=too-many-locals
|
|
|
|
|
|
def get_next_departure(sched, start_station_id, end_station_id):
|
|
"""Get the next departure for the given sched."""
|
|
origin_station = sched.stops_by_id(start_station_id)[0]
|
|
destination_station = sched.stops_by_id(end_station_id)[0]
|
|
|
|
now = datetime.datetime.now()
|
|
day_name = now.strftime("%A").lower()
|
|
now_str = now.strftime("%H:%M:%S")
|
|
|
|
from sqlalchemy.sql import text
|
|
|
|
sql_query = text("""
|
|
SELECT trip.trip_id, trip.route_id,
|
|
time(origin_stop_time.departure_time),
|
|
time(destination_stop_time.arrival_time),
|
|
time(origin_stop_time.arrival_time),
|
|
time(origin_stop_time.departure_time),
|
|
origin_stop_time.drop_off_type,
|
|
origin_stop_time.pickup_type,
|
|
origin_stop_time.shape_dist_traveled,
|
|
origin_stop_time.stop_headsign,
|
|
origin_stop_time.stop_sequence,
|
|
time(destination_stop_time.arrival_time),
|
|
time(destination_stop_time.departure_time),
|
|
destination_stop_time.drop_off_type,
|
|
destination_stop_time.pickup_type,
|
|
destination_stop_time.shape_dist_traveled,
|
|
destination_stop_time.stop_headsign,
|
|
destination_stop_time.stop_sequence
|
|
FROM trips trip
|
|
INNER JOIN calendar calendar
|
|
ON trip.service_id = calendar.service_id
|
|
INNER JOIN stop_times origin_stop_time
|
|
ON trip.trip_id = origin_stop_time.trip_id
|
|
INNER JOIN stops start_station
|
|
ON origin_stop_time.stop_id = start_station.stop_id
|
|
INNER JOIN stop_times destination_stop_time
|
|
ON trip.trip_id = destination_stop_time.trip_id
|
|
INNER JOIN stops end_station
|
|
ON destination_stop_time.stop_id = end_station.stop_id
|
|
WHERE calendar.{day_name} = 1
|
|
AND time(origin_stop_time.departure_time) > time(:now_str)
|
|
AND start_station.stop_id = :origin_station_id
|
|
AND end_station.stop_id = :end_station_id
|
|
AND origin_stop_time.stop_sequence < destination_stop_time.stop_sequence
|
|
ORDER BY origin_stop_time.departure_time LIMIT 1;
|
|
""".format(day_name=day_name))
|
|
result = sched.engine.execute(sql_query, now_str=now_str,
|
|
origin_station_id=origin_station.id,
|
|
end_station_id=destination_station.id)
|
|
item = {}
|
|
for row in result:
|
|
item = row
|
|
|
|
today = datetime.datetime.today().strftime("%Y-%m-%d")
|
|
departure_time_string = "{} {}".format(today, item[2])
|
|
arrival_time_string = "{} {}".format(today, item[3])
|
|
departure_time = datetime.datetime.strptime(departure_time_string,
|
|
TIME_FORMAT)
|
|
arrival_time = datetime.datetime.strptime(arrival_time_string,
|
|
TIME_FORMAT)
|
|
|
|
seconds_until = (departure_time-datetime.datetime.now()).total_seconds()
|
|
minutes_until = int(seconds_until / 60)
|
|
|
|
route = sched.routes_by_id(item[1])[0]
|
|
|
|
origin_stoptime_arrival_time = "{} {}".format(today, item[4])
|
|
|
|
origin_stoptime_departure_time = "{} {}".format(today, item[5])
|
|
|
|
dest_stoptime_arrival_time = "{} {}".format(today, item[11])
|
|
|
|
dest_stoptime_depart_time = "{} {}".format(today, item[12])
|
|
|
|
origin_stop_time_dict = {
|
|
"Arrival Time": origin_stoptime_arrival_time,
|
|
"Departure Time": origin_stoptime_departure_time,
|
|
"Drop Off Type": item[6], "Pickup Type": item[7],
|
|
"Shape Dist Traveled": item[8], "Headsign": item[9],
|
|
"Sequence": item[10]
|
|
}
|
|
|
|
destination_stop_time_dict = {
|
|
"Arrival Time": dest_stoptime_arrival_time,
|
|
"Departure Time": dest_stoptime_depart_time,
|
|
"Drop Off Type": item[13], "Pickup Type": item[14],
|
|
"Shape Dist Traveled": item[15], "Headsign": item[16],
|
|
"Sequence": item[17]
|
|
}
|
|
|
|
return {
|
|
"trip_id": item[0],
|
|
"trip": sched.trips_by_id(item[0])[0],
|
|
"route": route,
|
|
"agency": sched.agencies_by_id(route.agency_id)[0],
|
|
"origin_station": origin_station,
|
|
"departure_time": departure_time,
|
|
"destination_station": destination_station,
|
|
"arrival_time": arrival_time,
|
|
"seconds_until_departure": seconds_until,
|
|
"minutes_until_departure": minutes_until,
|
|
"origin_stop_time": origin_stop_time_dict,
|
|
"destination_stop_time": destination_stop_time_dict
|
|
}
|
|
|
|
|
|
def setup_platform(hass, config, add_devices, discovery_info=None):
|
|
"""Get the GTFS sensor."""
|
|
if config.get("origin") is None:
|
|
_LOGGER.error("Origin must be set in the GTFS configuration!")
|
|
return False
|
|
|
|
if config.get("destination") is None:
|
|
_LOGGER.error("Destination must be set in the GTFS configuration!")
|
|
return False
|
|
|
|
if config.get("data") is None:
|
|
_LOGGER.error("Data must be set in the GTFS configuration!")
|
|
return False
|
|
|
|
gtfs_dir = hass.config.path("gtfs")
|
|
|
|
if not os.path.exists(gtfs_dir):
|
|
os.makedirs(gtfs_dir)
|
|
|
|
if not os.path.exists(os.path.join(gtfs_dir, config["data"])):
|
|
_LOGGER.error("The given GTFS data file/folder was not found!")
|
|
return False
|
|
|
|
import pygtfs
|
|
|
|
split_file_name = os.path.splitext(config["data"])
|
|
|
|
sqlite_file = "{}.sqlite".format(split_file_name[0])
|
|
joined_path = os.path.join(gtfs_dir, sqlite_file)
|
|
gtfs = pygtfs.Schedule(joined_path)
|
|
|
|
# pylint: disable=no-member
|
|
if len(gtfs.feeds) < 1:
|
|
pygtfs.append_feed(gtfs, os.path.join(gtfs_dir,
|
|
config["data"]))
|
|
|
|
dev = []
|
|
dev.append(GTFSDepartureSensor(gtfs, config["origin"],
|
|
config["destination"]))
|
|
add_devices(dev)
|
|
|
|
# pylint: disable=too-many-instance-attributes,too-few-public-methods
|
|
|
|
|
|
class GTFSDepartureSensor(Entity):
|
|
"""Implementation of an GTFS departures sensor."""
|
|
|
|
def __init__(self, pygtfs, origin, destination):
|
|
"""Initialize the sensor."""
|
|
self._pygtfs = pygtfs
|
|
self.origin = origin
|
|
self.destination = destination
|
|
self._name = "GTFS Sensor"
|
|
self._unit_of_measurement = "min"
|
|
self._state = 0
|
|
self._attributes = {}
|
|
self.lock = threading.Lock()
|
|
self.update()
|
|
|
|
@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 unit_of_measurement(self):
|
|
"""Return the unit of measurement of this entity, if any."""
|
|
return self._unit_of_measurement
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the state attributes."""
|
|
return self._attributes
|
|
|
|
@property
|
|
def icon(self):
|
|
"""Icon to use in the frontend, if any."""
|
|
return ICON
|
|
|
|
def update(self):
|
|
"""Get the latest data from GTFS and update the states."""
|
|
with self.lock:
|
|
self._departure = get_next_departure(self._pygtfs, self.origin,
|
|
self.destination)
|
|
self._state = self._departure["minutes_until_departure"]
|
|
|
|
origin_station = self._departure["origin_station"]
|
|
destination_station = self._departure["destination_station"]
|
|
origin_stop_time = self._departure["origin_stop_time"]
|
|
destination_stop_time = self._departure["destination_stop_time"]
|
|
agency = self._departure["agency"]
|
|
route = self._departure["route"]
|
|
trip = self._departure["trip"]
|
|
|
|
name = "{} {} to {} next departure"
|
|
self._name = name.format(agency.agency_name,
|
|
origin_station.stop_id,
|
|
destination_station.stop_id)
|
|
|
|
# Build attributes
|
|
|
|
self._attributes = {}
|
|
|
|
def dict_for_table(resource):
|
|
"""Return a dict for the SQLAlchemy resource given."""
|
|
return dict((col, getattr(resource, col))
|
|
for col in resource.__table__.columns.keys())
|
|
|
|
def append_keys(resource, prefix=None):
|
|
"""Properly format key val pairs to append to attributes."""
|
|
for key, val in resource.items():
|
|
if val == "" or val is None or key == "feed_id":
|
|
continue
|
|
pretty_key = key.replace("_", " ")
|
|
pretty_key = pretty_key.title()
|
|
pretty_key = pretty_key.replace("Id", "ID")
|
|
pretty_key = pretty_key.replace("Url", "URL")
|
|
if prefix is not None and \
|
|
pretty_key.startswith(prefix) is False:
|
|
pretty_key = "{} {}".format(prefix, pretty_key)
|
|
self._attributes[pretty_key] = val
|
|
|
|
append_keys(dict_for_table(agency), "Agency")
|
|
append_keys(dict_for_table(route), "Route")
|
|
append_keys(dict_for_table(trip), "Trip")
|
|
append_keys(dict_for_table(origin_station), "Origin Station")
|
|
append_keys(dict_for_table(destination_station),
|
|
"Destination Station")
|
|
append_keys(origin_stop_time, "Origin Stop")
|
|
append_keys(destination_stop_time, "Destination Stop")
|