def lambda_handler(event, context):
"""Takes in an event from Api.ai, through Api Gateway.
Returns a dict with keys "speech", "displayText", and "Source".
Source is always the "BART API" """
dict() = {
"speech": get_station_name() + "from" + get_direction(),
"displayText": get_station_name() + "from" + get_direction(),
"Source": "BART API"
}
return dict()
def lambda_handler(event, context):
"""Takes in an event from Api.ai, through Api Gateway.
Returns a dict with keys "speech", "displayText", and "Source".
Source is always the "BART API" """
station_name = get_station_name(event)
spoken_station_name = station_info(station_name)["spoken_name"]
written_station_name = station_info(station_name)["written_name"]
direction = get_direction(event)[0].lower()
"""Sets the parameters of the request to the bart api."""
param = {}
param["cmd"] = "etd"
param["orig"] = station_info(station_name)["abbr"]
param["key"] = os.environ["BART_API_KEY"]
param["dir"] = direction
param["json"] = "y"
response = requests.get(BART_URL, params = param)
response_json = response.json()
minutes = get_departure_info(response_json)["minutes"]
minutes_next = get_departure_info(response_json)["minutes next"]
destination = get_departure_info(response_json)["destination"]
spoken_text = get_spoken_or_written_string(spoken_station_name, direction, minutes, destination, minutes_next, True)
written_text = get_spoken_or_written_string(written_station_name, direction, minutes, destination, minutes_next, False)
return {"speech" : spoken_text, "display API" : written_text, "source" : "BART API"}
def main(
station: ('URI to radio station (direct link, not playlist)', 'option', 's') = "",
console: ('Start as console application', 'flag', 'c') = False
):
"""
The main function to start the application. App can be started in three modes:
* Qt application with system tray icon, default, no options
* Console process, with -c option
"""
# Determine radio station
# TODO: If no station specified, play last one or a random one
uri = station
if not uri:
uri = StateStorage.get_last_station()
if uri:
print("Connecting to last station selected: %s" % utils.get_station_name(uri))
if not uri:
station = utils.get_random_station(config.stations)
uri = station['uri']
if uri:
print("Station randomly selected: %s" % station['name'])
if not uri:
raise ValueError('Specify radio station URI as start argument or add one in config.py file!')
# Start as console app, if requested
if console:
app = App(sys.argv)
app.show_tray_icon = False
app.run(uri)
else:
app = App(sys.argv)
app.run(uri)
def list_stations():
__addon__ = xbmcaddon.Addon()
# Show a dialog
pDialog = xbmcgui.DialogProgress()
pDialog.create(config.NAME, 'Fetching station list...')
try:
stations = comm.get_stations()
if not stations:
d = xbmcgui.Dialog()
msg = utils.dialog_message(
"No stations found. This is usually because no matches are currently being played. Please try again later."
)
d.ok(*msg)
return
utils.log("Found %s stations" % len(stations))
ok = True
for s in stations:
station_name = utils.get_station_name(s['id'])
thumb = os.path.join(__addon__.getAddonInfo('path'), "resources",
"img", "%s.jpg" % s['id'])
listitem = xbmcgui.ListItem(station_name)
labels = {"title": station_name, "genre": "Sport"}
listitem.setInfo(type='music', infoLabels=labels)
listitem.setThumbnailImage(thumb)
params = utils.make_url({
"id": s['id'],
"name": station_name,
"url": s['streamURL']
})
url = "%s?%s" % (sys.argv[0], params)
# Add the item to the list
ok = xbmcplugin.addDirectoryItem(handle=int(sys.argv[1]),
url=url,
listitem=listitem,
isFolder=True,
totalItems=len(stations))
xbmcplugin.endOfDirectory(handle=int(sys.argv[1]), succeeded=ok)
except:
# user cancelled dialog or an error occurred
d = xbmcgui.Dialog()
msg = utils.dialog_error("Unable to fetch station list")
d.ok(*msg)
utils.log_error()
import sys
import database
import utils
def get_station_name():
hardware_parameters = database.get_hardware_parameters()
mac_address = utils.get_mac_address('-')
idx = hardware_parameters['macAddress'].index(mac_address)
station_name = hardware_parameters['stationName'][idx]
return station_name
if __name__ == '__main__':
import sys
import utils
station_name = utils.get_station_name()
msg = station_name
msg += '\n'
sys.stdout.write(msg)
sys.stdout.flush()
initial_startup = True
upload_successful = False
files_uploaded = 0
captures_failed = 0
camera_parameters = None
if dump_station_parameters_database:
station_parameters = database.get_station_parameters(verbose=True)
hourly_parameters = database.get_hourly_parameters(verbose=True)
hardware_parameters = database.get_hardware_parameters(verbose=True)
sys.exit()
if flash_camera_settings:
station_parameters = database.get_station_parameters(verbose=False)
station_parameters['stationName'] = utils.get_station_name()
if station_parameters['cameraType'].lower() == 'rpi':
parameters = database.get_rpi_camera_parameters(station_parameters,
verbose=True)
elif station_parameters['cameraType'].lower() == 'gphoto2':
parameters = database.get_gphoto2_camera_parameters(station_parameters,
verbose=True)
camera_parameters = camera.initialize(station_parameters, verbose=True)
camera.close(station_parameters, camera_parameters, verbose=True)
sys.exit()
while True:
# Pick up the latest parameters from the databases
if verbose:
msg = 'Picking up the latest parameters from the '
msg += 'configuration databases ...'