2022-10-10 18:39:40 +02:00
|
|
|
from datetime import datetime, time, timedelta
|
2022-09-05 18:41:04 +02:00
|
|
|
from operator import itemgetter
|
2023-02-26 00:11:49 +01:00
|
|
|
from typing import Dict
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2022-07-22 13:27:16 +02:00
|
|
|
from libretime_api_client.v2 import ApiClient
|
2022-10-10 18:39:40 +02:00
|
|
|
from libretime_shared.datetime import time_in_milliseconds, time_in_seconds
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2022-09-06 14:09:04 +02:00
|
|
|
from ..liquidsoap.models import StreamPreferences
|
2023-02-26 00:11:49 +01:00
|
|
|
from .events import (
|
|
|
|
ActionEvent,
|
|
|
|
AnyEvent,
|
|
|
|
EventKind,
|
|
|
|
Events,
|
|
|
|
FileEvent,
|
|
|
|
WebStreamEvent,
|
|
|
|
datetime_to_event_key,
|
2023-03-04 21:50:12 +01:00
|
|
|
event_isoparse,
|
2023-02-26 00:11:49 +01:00
|
|
|
)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
|
|
|
|
2023-03-01 20:27:27 +01:00
|
|
|
def insert_event(events: Events, event_key: str, event: AnyEvent) -> None:
|
2022-09-05 18:41:04 +02:00
|
|
|
key = event_key
|
|
|
|
|
|
|
|
# Search for an empty slot
|
|
|
|
index = 0
|
|
|
|
while key in events:
|
|
|
|
# Ignore duplicate event
|
|
|
|
if event == events[key]:
|
|
|
|
return
|
|
|
|
|
|
|
|
key = f"{event_key}_{index}"
|
|
|
|
index += 1
|
|
|
|
|
|
|
|
events[key] = event
|
|
|
|
|
|
|
|
|
2023-02-19 18:29:05 +01:00
|
|
|
def get_schedule(api_client: ApiClient) -> Events:
|
2022-09-06 14:09:04 +02:00
|
|
|
stream_preferences = StreamPreferences(**api_client.get_stream_preferences().json())
|
|
|
|
|
2022-06-24 16:42:46 +02:00
|
|
|
current_time = datetime.utcnow()
|
|
|
|
end_time = current_time + timedelta(days=1)
|
|
|
|
|
|
|
|
current_time_str = current_time.isoformat(timespec="seconds")
|
|
|
|
end_time_str = end_time.isoformat(timespec="seconds")
|
|
|
|
|
2022-07-22 15:41:38 +02:00
|
|
|
schedule = api_client.list_schedule(
|
2022-06-24 16:42:46 +02:00
|
|
|
params={
|
2022-07-17 22:27:57 +02:00
|
|
|
"ends_after": f"{current_time_str}Z",
|
|
|
|
"ends_before": f"{end_time_str}Z",
|
|
|
|
"overbooked": False,
|
|
|
|
"position_status__gt": 0,
|
2022-06-24 16:42:46 +02:00
|
|
|
}
|
2022-07-22 15:41:38 +02:00
|
|
|
).json()
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2023-02-19 18:16:07 +01:00
|
|
|
events: Dict[str, AnyEvent] = {}
|
2022-09-05 18:41:04 +02:00
|
|
|
for item in sorted(schedule, key=itemgetter("starts_at")):
|
2023-03-04 21:50:12 +01:00
|
|
|
item["starts_at"] = event_isoparse(item["starts_at"])
|
|
|
|
item["ends_at"] = event_isoparse(item["ends_at"])
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2022-07-27 09:54:57 +02:00
|
|
|
show_instance = api_client.get_show_instance(item["instance"]).json()
|
|
|
|
show = api_client.get_show(show_instance["show"]).json()
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2022-09-06 14:09:04 +02:00
|
|
|
if show["live_enabled"]:
|
2023-03-04 21:50:12 +01:00
|
|
|
show_instance["starts_at"] = event_isoparse(show_instance["starts_at"])
|
|
|
|
show_instance["ends_at"] = event_isoparse(show_instance["ends_at"])
|
2024-02-08 20:29:10 +01:00
|
|
|
generate_live_events(events, show_instance, stream_preferences)
|
2022-09-06 14:09:04 +02:00
|
|
|
|
2022-06-24 16:42:46 +02:00
|
|
|
if item["file"]:
|
2022-07-27 09:54:57 +02:00
|
|
|
file = api_client.get_file(item["file"]).json()
|
2024-02-08 20:29:10 +01:00
|
|
|
generate_file_events(events, item, file, show, stream_preferences)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
|
|
|
elif item["stream"]:
|
2022-07-27 09:54:57 +02:00
|
|
|
webstream = api_client.get_webstream(item["stream"]).json()
|
2022-09-05 18:41:04 +02:00
|
|
|
generate_webstream_events(events, item, webstream, show)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2023-02-19 18:29:05 +01:00
|
|
|
return dict(sorted(events.items()))
|
2022-06-24 16:42:46 +02:00
|
|
|
|
|
|
|
|
2022-09-06 14:09:04 +02:00
|
|
|
def generate_live_events(
|
2023-02-19 18:16:07 +01:00
|
|
|
events: Events,
|
2022-09-06 14:09:04 +02:00
|
|
|
show_instance: dict,
|
2024-02-08 20:29:10 +01:00
|
|
|
stream_preferences: StreamPreferences,
|
2022-09-06 14:09:04 +02:00
|
|
|
):
|
2024-02-08 20:29:10 +01:00
|
|
|
transition = timedelta(seconds=stream_preferences.input_fade_transition)
|
2022-09-06 14:09:04 +02:00
|
|
|
|
2023-03-04 21:50:12 +01:00
|
|
|
switch_off = show_instance["ends_at"] - transition
|
|
|
|
kick_out = show_instance["ends_at"]
|
|
|
|
switch_off_event_key = datetime_to_event_key(switch_off)
|
|
|
|
kick_out_event_key = datetime_to_event_key(kick_out)
|
2022-09-06 14:09:04 +02:00
|
|
|
|
|
|
|
# If enabled, fade the input source out
|
2023-03-04 21:50:12 +01:00
|
|
|
if switch_off != kick_out:
|
|
|
|
switch_off_event = ActionEvent(
|
|
|
|
type=EventKind.ACTION,
|
|
|
|
event_type="switch_off",
|
|
|
|
start=switch_off,
|
|
|
|
end=switch_off,
|
|
|
|
)
|
2022-09-06 14:09:04 +02:00
|
|
|
insert_event(events, switch_off_event_key, switch_off_event)
|
|
|
|
|
|
|
|
# Then kick the source out
|
2023-03-04 21:50:12 +01:00
|
|
|
kick_out_event = ActionEvent(
|
|
|
|
type=EventKind.ACTION,
|
|
|
|
event_type="kick_out",
|
|
|
|
start=kick_out,
|
|
|
|
end=kick_out,
|
|
|
|
)
|
2022-09-06 14:09:04 +02:00
|
|
|
insert_event(events, kick_out_event_key, kick_out_event)
|
|
|
|
|
|
|
|
|
2022-06-24 16:42:46 +02:00
|
|
|
def generate_file_events(
|
2023-02-19 18:16:07 +01:00
|
|
|
events: Events,
|
2022-06-24 16:42:46 +02:00
|
|
|
schedule: dict,
|
|
|
|
file: dict,
|
|
|
|
show: dict,
|
2024-02-08 20:29:10 +01:00
|
|
|
stream_preferences: StreamPreferences,
|
2022-09-05 18:41:04 +02:00
|
|
|
):
|
2022-06-24 16:42:46 +02:00
|
|
|
"""
|
|
|
|
Generate events for a scheduled file.
|
|
|
|
"""
|
2023-03-04 21:50:12 +01:00
|
|
|
event = FileEvent(
|
|
|
|
type=EventKind.FILE,
|
|
|
|
row_id=schedule["id"],
|
|
|
|
start=schedule["starts_at"],
|
|
|
|
end=schedule["ends_at"],
|
|
|
|
uri=file["url"],
|
|
|
|
id=file["id"],
|
2022-06-24 16:42:46 +02:00
|
|
|
# Show data
|
2023-03-04 21:50:12 +01:00
|
|
|
show_name=show["name"],
|
2022-06-24 16:42:46 +02:00
|
|
|
# Extra data
|
2023-03-04 21:50:12 +01:00
|
|
|
fade_in=time_in_milliseconds(time.fromisoformat(schedule["fade_in"])),
|
|
|
|
fade_out=time_in_milliseconds(time.fromisoformat(schedule["fade_out"])),
|
|
|
|
cue_in=time_in_seconds(time.fromisoformat(schedule["cue_in"])),
|
|
|
|
cue_out=time_in_seconds(time.fromisoformat(schedule["cue_out"])),
|
|
|
|
# File data
|
|
|
|
track_title=file.get("track_title"),
|
|
|
|
artist_name=file.get("artist_name"),
|
|
|
|
mime=file["mime"],
|
|
|
|
replay_gain=file["replay_gain"],
|
|
|
|
filesize=file["size"],
|
|
|
|
)
|
2024-02-08 20:29:10 +01:00
|
|
|
|
|
|
|
if event.replay_gain is None:
|
|
|
|
event.replay_gain = 0.0
|
|
|
|
|
|
|
|
if stream_preferences.replay_gain_enabled:
|
|
|
|
event.replay_gain += stream_preferences.replay_gain_offset
|
|
|
|
else:
|
|
|
|
event.replay_gain = None
|
|
|
|
|
2023-03-04 21:50:12 +01:00
|
|
|
insert_event(events, event.start_key, event)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
|
|
|
|
|
|
|
def generate_webstream_events(
|
2023-02-19 18:16:07 +01:00
|
|
|
events: Events,
|
2022-06-24 16:42:46 +02:00
|
|
|
schedule: dict,
|
|
|
|
webstream: dict,
|
|
|
|
show: dict,
|
2022-09-05 18:41:04 +02:00
|
|
|
):
|
2022-06-24 16:42:46 +02:00
|
|
|
"""
|
|
|
|
Generate events for a scheduled webstream.
|
|
|
|
"""
|
2022-07-17 22:27:57 +02:00
|
|
|
schedule_start_event_key = datetime_to_event_key(schedule["starts_at"])
|
|
|
|
schedule_end_event_key = datetime_to_event_key(schedule["ends_at"])
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2023-03-04 21:50:12 +01:00
|
|
|
stream_buffer_start_event = WebStreamEvent(
|
|
|
|
type=EventKind.WEB_STREAM_BUFFER_START,
|
|
|
|
row_id=schedule["id"],
|
|
|
|
start=schedule["starts_at"] - timedelta(seconds=5),
|
|
|
|
end=schedule["starts_at"] - timedelta(seconds=5),
|
|
|
|
uri=webstream["url"],
|
|
|
|
id=webstream["id"],
|
|
|
|
# Show data
|
|
|
|
show_name=show["name"],
|
|
|
|
)
|
2022-09-05 18:41:04 +02:00
|
|
|
insert_event(events, schedule_start_event_key, stream_buffer_start_event)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2023-03-04 21:50:12 +01:00
|
|
|
stream_output_start_event = WebStreamEvent(
|
|
|
|
type=EventKind.WEB_STREAM_OUTPUT_START,
|
|
|
|
row_id=schedule["id"],
|
|
|
|
start=schedule["starts_at"],
|
|
|
|
end=schedule["ends_at"],
|
|
|
|
uri=webstream["url"],
|
|
|
|
id=webstream["id"],
|
2022-06-24 16:42:46 +02:00
|
|
|
# Show data
|
2023-03-04 21:50:12 +01:00
|
|
|
show_name=show["name"],
|
|
|
|
)
|
2022-09-05 18:41:04 +02:00
|
|
|
insert_event(events, schedule_start_event_key, stream_output_start_event)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2022-07-17 22:27:57 +02:00
|
|
|
# NOTE: stream_*_end were previously triggered 1 second before
|
|
|
|
# the schedule end.
|
2023-03-04 21:50:12 +01:00
|
|
|
stream_buffer_end_event = WebStreamEvent(
|
|
|
|
type=EventKind.WEB_STREAM_BUFFER_END,
|
|
|
|
row_id=schedule["id"],
|
|
|
|
start=schedule["ends_at"],
|
|
|
|
end=schedule["ends_at"],
|
|
|
|
uri=webstream["url"],
|
|
|
|
id=webstream["id"],
|
|
|
|
# Show data
|
|
|
|
show_name=show["name"],
|
|
|
|
)
|
2022-09-05 18:41:04 +02:00
|
|
|
insert_event(events, schedule_end_event_key, stream_buffer_end_event)
|
2022-06-24 16:42:46 +02:00
|
|
|
|
2023-03-04 21:50:12 +01:00
|
|
|
stream_output_end_event = WebStreamEvent(
|
|
|
|
type=EventKind.WEB_STREAM_OUTPUT_END,
|
|
|
|
row_id=schedule["id"],
|
|
|
|
start=schedule["ends_at"],
|
|
|
|
end=schedule["ends_at"],
|
|
|
|
uri=webstream["url"],
|
|
|
|
id=webstream["id"],
|
|
|
|
# Show data
|
|
|
|
show_name=show["name"],
|
|
|
|
)
|
2022-09-05 18:41:04 +02:00
|
|
|
insert_event(events, schedule_end_event_key, stream_output_end_event)
|