<%= Phoenix.Flash.get(@flash, :info) %>
3 |<%= Phoenix.Flash.get(@flash, :error) %>
4 | <%= @inner_content %> 5 |
14 | {#if @is_race and @lap_counter != nil}
15 |
29 | """
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/lib/f1_bot/output/common.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Output.Common do
2 | alias F1Bot.F1Session.Common.Event
3 |
4 | @post_after_race_lap 5
5 |
6 | def should_post_stats(_event = %Event{meta: meta})
7 | when meta != nil do
8 | lap = meta.lap_number || 0
9 | is_race = meta.session_type == "Race"
10 |
11 | lap > @post_after_race_lap or not is_race
12 | end
13 |
14 | def get_driver_name_by_number(_event = %Event{meta: meta}, driver_number) do
15 | case meta[:driver_info][driver_number] do
16 | %{last_name: name} when name != nil -> name
17 | %{short_name: name} when name != nil -> name
18 | %{driver_abbr: name} when name != nil -> name
19 | _ -> "Car #{driver_number}"
20 | end
21 | end
22 |
23 | def get_driver_abbr_by_number(_event = %Event{meta: meta}, driver_number) do
24 | case meta[:driver_info][driver_number] do
25 | %{driver_abbr: abbr} -> abbr
26 | %{last_name: name} when name != nil -> name
27 | %{short_name: name} when name != nil -> name
28 | _ -> "Car #{driver_number}"
29 | end
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/lib/f1_bot/external_api/signalr/ws_client.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.ExternalApi.SignalR.WSClient do
2 | use Fresh, restart: :temporary
3 | require Logger
4 |
5 | alias F1Bot.ExternalApi.SignalR
6 |
7 | @impl Fresh
8 | def handle_connect(_status, _headers, state) do
9 | SignalR.Client.ws_handle_connected()
10 | {:ok, state}
11 | end
12 |
13 | @impl Fresh
14 | def handle_in(message, state) do
15 | # IO.inspect(message, label: "in")
16 | SignalR.Client.ws_handle_message(message)
17 | {:ok, state}
18 | end
19 |
20 | @impl Fresh
21 | def handle_error(error, _state) do
22 | Logger.error("SignalR connection error: #{inspect(error)}")
23 |
24 | {:close, {:error, error}}
25 | end
26 |
27 | @impl Fresh
28 | def handle_disconnect(code, reason, _state) do
29 | Logger.error("SignalR disconnected: #{inspect({code, reason})}")
30 |
31 | {:close, {:error, reason}}
32 | end
33 |
34 | def send(message) do
35 | # IO.inspect(message, label: "out")
36 | Fresh.send(__MODULE__, message)
37 | end
38 |
39 | def name, do: {:local, __MODULE__}
40 | end
41 |
--------------------------------------------------------------------------------
/scripts/check-nomad-deployment.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | set -euo pipefail
4 |
5 | eval_id=$(echo "$1" | grep -ioP "[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}")
6 | deployment_id=$(nomad eval status -json $eval_id | jq -rM '.DeploymentID')
7 |
8 | i=0
9 | while [ $i -ne 120 ]; do
10 | i=$(($i+1))
11 |
12 | echo "-------"
13 | date
14 | nomad deployment status -verbose "$deployment_id"
15 | full_status=$(nomad deployment status -json "$deployment_id")
16 | echo
17 |
18 | status=$(echo "$full_status" | jq -rM '.Status')
19 | description=$(echo "$full_status" | jq -rM '.StatusDescription')
20 |
21 | if [ "$status" = "failed" ]; then
22 | nomad deployment status -verbose "$deployment_id"
23 | echo "Deployment failed"
24 | exit 1
25 | fi
26 |
27 | if [ "$status" = "successful" ]; then
28 | nomad deployment status -verbose "$deployment_id"
29 | echo "Deployment successful"
30 | exit 0
31 | fi
32 |
33 | sleep 5
34 | done
35 |
36 | nomad deployment status -verbose "$deployment_id"
37 | echo "Deployment timed out"
38 | exit 1
--------------------------------------------------------------------------------
/lib/f1_bot/authentication.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Authentication do
2 | import Ecto.Query
3 | alias F1Bot.Repo
4 | alias F1Bot.Authentication.ApiClient
5 |
6 | def create_api_client(name, scopes) do
7 | params = %{
8 | client_name: name,
9 | scopes: scopes
10 | }
11 |
12 | params
13 | |> ApiClient.create_changeset()
14 | |> Repo.insert()
15 | end
16 |
17 | def list_all_api_clients() do
18 | Repo.all(ApiClient)
19 | end
20 |
21 | def find_api_client_by_name(name) do
22 | query =
23 | ApiClient
24 | |> where([c], c.client_name == ^name)
25 |
26 | case Repo.one(query) do
27 | nil -> {:error, :not_found}
28 | client -> {:ok, client}
29 | end
30 | end
31 |
32 | def update_api_client_scopes(data = %ApiClient{}, scopes) do
33 | data
34 | |> ApiClient.update_changeset(%{scopes: scopes})
35 | |> Repo.update()
36 | end
37 |
38 | def delete_api_client_by_name(name) do
39 | query =
40 | ApiClient
41 | |> where([c], c.client_name == ^name)
42 |
43 | {count, _} = Repo.delete_all(query)
44 | count > 0
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/live_timing_handlers/session_status.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.LiveTimingHandlers.SessionStatus do
2 | @moduledoc """
3 | Handler for session status received from live timing API.
4 |
5 | The handler parses the status as an atom and passes it on to the F1 session instance.
6 | """
7 | require Logger
8 | alias F1Bot.F1Session.LiveTimingHandlers
9 |
10 | alias F1Bot.F1Session
11 | alias LiveTimingHandlers.{Packet, ProcessingResult}
12 |
13 | @behaviour LiveTimingHandlers
14 | @scope "SessionStatus"
15 |
16 | @impl F1Bot.F1Session.LiveTimingHandlers
17 | def process_packet(
18 | session,
19 | %Packet{
20 | topic: @scope,
21 | data: %{"Status" => status}
22 | },
23 | _options
24 | ) do
25 | status =
26 | status
27 | |> String.trim()
28 | |> String.downcase()
29 | |> String.to_atom()
30 |
31 | {session, events} = F1Session.push_session_status(session, status)
32 |
33 | result = %ProcessingResult{
34 | session: session,
35 | events: events
36 | }
37 |
38 | {:ok, result}
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/live_timing_handlers/lap_count.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.LiveTimingHandlers.LapCount do
2 | @moduledoc """
3 | Handler for lap count updates received from live timing API.
4 | """
5 | require Logger
6 | alias F1Bot.F1Session.LiveTimingHandlers
7 |
8 | alias F1Bot.F1Session
9 | alias LiveTimingHandlers.{Packet, ProcessingResult}
10 |
11 | @behaviour LiveTimingHandlers
12 | @scope "LapCount"
13 |
14 | @impl F1Bot.F1Session.LiveTimingHandlers
15 | def process_packet(
16 | session,
17 | %Packet{
18 | topic: @scope,
19 | data: data,
20 | timestamp: timestamp
21 | },
22 | _options
23 | ) do
24 | current = data["CurrentLap"]
25 | total = data["TotalLaps"]
26 |
27 | current = if is_integer(current), do: current, else: nil
28 | total = if is_integer(total), do: total, else: nil
29 |
30 | {session, events} = F1Session.push_lap_counter_update(session, current, total, timestamp)
31 |
32 | result = %ProcessingResult{
33 | session: session,
34 | events: events
35 | }
36 |
37 | {:ok, result}
38 | end
39 | end
40 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/components/chart_js.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.Component.ChartJS do
2 | use F1BotWeb, :component
3 | alias Phoenix.LiveView
4 |
5 | prop chart_id, :string, required: true
6 | prop class, :css_class, default: ""
7 |
8 | @impl true
9 | def render(assigns) do
10 | ~F"""
11 |
16 | Lap
17 | {@lap_counter.current || 0}
18 | /
19 | {@lap_counter.total}
20 |
21 | {/if}
22 |
23 | {#if @session_clock != nil}
24 |
25 | {Format.format_session_clock(@session_clock)}
26 |
27 | {/if}
28 |
12 |
15 |
16 | """
17 | end
18 |
19 | def initialize(socket, id, chart_class) do
20 | payload = %{chart_class: chart_class}
21 | LiveView.push_event(socket, "chartjs:#{id}:init", payload)
22 | end
23 |
24 | def insert_data(socket, id, payload) do
25 | payload =
26 | payload
27 | |> Map.put(:op, "insert")
28 |
29 | LiveView.push_event(socket, "chartjs:#{id}:data", payload)
30 | end
31 |
32 | def replace_data(socket, id, payload) do
33 | payload =
34 | payload
35 | |> Map.put(:op, "replace")
36 |
37 | LiveView.push_event(socket, "chartjs:#{id}:data", payload)
38 | end
39 | end
40 |
--------------------------------------------------------------------------------
/assets/css/app.css:
--------------------------------------------------------------------------------
1 | @import "./fonts.css";
2 | @import "tailwindcss/base";
3 | @import "tailwindcss/components";
4 | @import "tailwindcss/utilities";
5 |
6 | /* Import scoped CSS rules for components */
7 | @import "./_components.css";
8 |
9 | .data-update-highlight {
10 | animation: data-update-highlight 2s ease-in-out;
11 | --highlight-bg-color: rgb(255, 251, 0);
12 | --highlight-color: none;
13 | }
14 |
15 | .dark .data-update-highlight {
16 | --highlight-bg-color: hsl(220, 15%, 23%);
17 | --highlight-color: hsl(0, 0%, 100%);
18 | }
19 |
20 | html:not(.dark) {
21 | color-scheme: light;
22 | }
23 |
24 | html.dark {
25 | color-scheme: dark;
26 | }
27 |
28 | @keyframes data-update-highlight {
29 | 0% {
30 | /* opacity: 1; */
31 | background-color: none;
32 | color: none;
33 | }
34 | 25% {
35 | /* opacity: 0.3; */
36 | background-color: var(--highlight-bg-color);
37 | color: var(--highlight-color);
38 | }
39 | 75% {
40 | /* opacity: 0.3; */
41 | background-color: var(--highlight-bg-color);
42 | color: var(--highlight-color);
43 | }
44 | 100% {
45 | /* opacity: 1; */
46 | background-color: none;
47 | color: none;
48 | }
49 | }
--------------------------------------------------------------------------------
/lib/f1_bot_web/live/helpers.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.LiveHelpers do
2 | alias Phoenix.LiveView
3 |
4 | def fetch_delayed_event_payload(event_scope, delay_ms, default_val) do
5 | case F1Bot.DelayedEvents.fetch_latest_event(delay_ms, event_scope) do
6 | {:ok, data} -> data.payload
7 | {:error, :no_data} -> default_val
8 | end
9 | end
10 |
11 | def subscribe_to_own_events(socket, session) do
12 | user_uuid = session["user_uuid"]
13 |
14 | if user_uuid do
15 | F1Bot.PubSub.subscribe("user_events:#{user_uuid}")
16 | end
17 |
18 | socket
19 | |> Phoenix.Component.assign(:user_uuid, user_uuid)
20 | end
21 |
22 | def broadcast_own_event(_user_uuid = nil, _message), do: :ignore
23 |
24 | def broadcast_own_event(user_uuid, message) do
25 | F1Bot.PubSub.broadcast("user_events:#{user_uuid}", message)
26 | end
27 |
28 | def get_check_param(socket, param_name, default_val, check_fn)
29 | when is_binary(param_name) and is_function(check_fn, 1) do
30 | sent_val = LiveView.get_connect_params(socket)[param_name]
31 |
32 | if sent_val != nil and check_fn.(sent_val) do
33 | sent_val
34 | else
35 | default_val
36 | end
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/components/chart_js.hooks.ts:
--------------------------------------------------------------------------------
1 | import { ChartVisualization, createChart } from '@assets/Visualizations';
2 |
3 | export default {
4 | mounted() {
5 | this.props = { id: this.el.id }
6 | console.log("Chart.js mounted", this.el);
7 |
8 | this.handleEvent(`chartjs:${this.props.id}:init`, async ({ chart_class }) => {
9 | console.log(`${this.props.id} Received init event:`, chart_class)
10 |
11 | const existing = this.props.chart as ChartVisualization;
12 |
13 | if (existing) {
14 | console.log('Destroying previous Chart.js instance');
15 | existing.destroy();
16 | }
17 |
18 | this.props.chart = createChart(chart_class, this.el);
19 | });
20 |
21 | // Handles streaming data into the chart, replacing the entire dataset or inserting new data
22 | this.handleEvent(`chartjs:${this.props.id}:data`, async (updatePayload) => {
23 | console.log(`${this.props.id} Received data event:`, updatePayload)
24 |
25 | const chart = this.props.chart as ChartVisualization;
26 |
27 | if (!chart) {
28 | console.warn('Chart not initialized, skipping', this.props)
29 | return;
30 | }
31 |
32 | chart.updateData(updatePayload);
33 | });
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where third-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Ignore package tarball (built via "mix hex.build").
23 | f1_bot-*.tar
24 |
25 | # Ignore assets that are produced by build tools.
26 | /priv/static/assets/
27 |
28 | # Ignore digested assets cache.
29 | /priv/static/cache_manifest.json
30 |
31 | # In case you use Node.js/npm, you want to ignore these.
32 | npm-debug.log
33 | /assets/node_modules/
34 |
35 | # Database files
36 | *.db
37 | *.db-*
38 |
39 | # Temporary files, for example, from tests.
40 | /tmp/
41 |
42 | .elixir_ls
43 | .lexical
44 | .vscode
45 | .env
46 | *.zip
47 |
48 | # Ignore generated js hook files for components
49 | assets/js/_hooks/
50 |
51 | # Ignore generated CSS file for components
52 | assets/css/_components.css
--------------------------------------------------------------------------------
/assets/js/Visualizations/index.ts:
--------------------------------------------------------------------------------
1 | import { Chart } from 'chart.js/auto';
2 | import 'chartjs-adapter-date-fns';
3 | import annotationPlugin from 'chartjs-plugin-annotation';
4 | // import zoomPlugin from 'chartjs-plugin-zoom';
5 |
6 | import { RaceLapTimeChart } from "./RaceLapTimeChart"
7 | import { LapTimeScale } from './LapTimeScale';
8 | import { AnyChartData } from './DataPayloads';
9 | import { FPQualiLapTimeChart } from "./FPQualiLapTimeChart";
10 |
11 | // Chart.register(zoomPlugin);
12 | Chart.register(annotationPlugin);
13 | Chart.register(LapTimeScale);
14 |
15 | interface ChartVisualization {
16 | updateData(data: AnyChartData): void;
17 |
18 | destroy(): void;
19 | }
20 |
21 | interface ConstructableChart {
22 | new(canvas: HTMLCanvasElement): ChartVisualization;
23 | }
24 |
25 | const ChartJsCharts: Record![logo]({~p"/favicon.png"})
10 |
11 | Race Bot for F1
12 | <%= if F1Bot.demo_mode?() do %>
13 | | Demo
14 | <% end %>
15 |
16 |
17 | """
18 | end
19 |
20 | attr :class, :string, default: ""
21 | def other_site_link(assigns) do
22 | {other_site_name, other_site_link} =
23 | if F1Bot.demo_mode?() do
24 | {"Live Site", "https://racing.recursiveprojects.cloud"}
25 | else
26 | {"Demo Site", "https://racing-dev.recursiveprojects.cloud"}
27 | end
28 |
29 | assigns =
30 | assigns
31 | |> assign(:other_site_name, other_site_name)
32 | |> assign(:other_site_link, other_site_link)
33 |
34 | ~H"""
35 |
36 |
12 | {#for driver_info <- @driver_list}
13 |
26 | {/for}
27 |
28 | """
29 | end
30 |
31 | defp selected_classes(driver_info, drivers_of_interest) do
32 | if driver_info.driver_number in drivers_of_interest do
33 | "bg-white dark:bg-[hsl(220,10%,20%)]"
34 | else
35 | "bg-slate-200 dark:bg-[hsl(220,10%,11%)]"
36 | end
37 | end
38 |
39 | defp selected_styles(driver_info, drivers_of_interest) do
40 | team_color = "##{driver_info.team_color}"
41 | if driver_info.driver_number in drivers_of_interest do
42 | "border-left-color: #{team_color}; border-bottom-color: #{team_color};"
43 | else
44 | "border-left-color: #{team_color}; border-bottom-color: transparent;"
45 | end
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/assets/js/Visualizations/FPQualiLapTimeChart.ts:
--------------------------------------------------------------------------------
1 | import { AnnotationOptions } from "chartjs-plugin-annotation";
2 | import { TrackStatusDataPoint } from "./DataPayloads";
3 | import { RaceLapTimeChart } from "./RaceLapTimeChart";
4 |
5 | class FPQualiLapTimeChart extends RaceLapTimeChart {
6 | constructor(canvas: HTMLCanvasElement) {
7 | super(canvas);
8 | }
9 |
10 | protected makeIntervalAnnotation(point: TrackStatusDataPoint): AnnotationOptions {
11 | const options = super.makeIntervalAnnotation(point);
12 | options.xMin = point.ts_from;
13 | options.xMax = point.ts_to;
14 | return options;
15 | }
16 |
17 | protected makeInstantAnnotation(point: TrackStatusDataPoint): AnnotationOptions {
18 | const options = super.makeIntervalAnnotation(point);
19 | options.xMin = point.ts_from;
20 | options.xMax = point.ts_to;
21 | return options;
22 | }
23 |
24 | protected schema() {
25 | const schema = super.schema() as any;
26 | const scales = schema.options.scales;
27 | const plugins = schema.options.plugins;
28 |
29 | schema.options.parsing.xAxisKey = 'ts';
30 | scales.x.title.text = 'Session Time';
31 |
32 | const newXScaleOpts = {
33 | type: 'time',
34 | display: true,
35 | time: {
36 | unit: 'minute',
37 | displayFormats: {
38 | minute: 'H:mm',
39 | },
40 | tooltipFormat: 'H:mm:ss'
41 | }
42 | };
43 |
44 | Object.assign(scales.x, newXScaleOpts);
45 |
46 | delete plugins.tooltip.callbacks.title;
47 | delete scales.x.ticks.stepSize;
48 | delete scales.x.ticks.precision;
49 |
50 | return schema;
51 | }
52 | }
53 |
54 | export { FPQualiLapTimeChart };
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/clock.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.Clock do
2 | use TypedStruct
3 |
4 | alias F1Bot.F1Session.Common.Event
5 |
6 | typedstruct do
7 | field :utc_server_time_sync, DateTime.t()
8 | field :utc_local_time_sync, DateTime.t()
9 | field :session_clock, Timex.Duration.t()
10 | field :is_running, boolean()
11 | end
12 |
13 | def new(server_time, local_time, session_clock, is_running) do
14 | %__MODULE__{
15 | utc_server_time_sync: server_time,
16 | utc_local_time_sync: local_time,
17 | session_clock: session_clock,
18 | is_running: is_running
19 | }
20 | end
21 |
22 | def session_clock_from_server_time(clock, server_time) do
23 | if clock.is_running do
24 | time_since_clock_started = Timex.diff(server_time, clock.utc_server_time_sync, :duration)
25 |
26 | remaining =
27 | clock.session_clock
28 | |> Timex.Duration.sub(time_since_clock_started)
29 |
30 | if Timex.Duration.to_milliseconds(remaining) < 0 do
31 | Timex.Duration.from_seconds(0)
32 | else
33 | remaining
34 | end
35 | else
36 | clock.session_clock
37 | end
38 | end
39 |
40 | def session_clock_from_local_time(clock, local_time) do
41 | local_time_delta = Timex.diff(local_time, clock.utc_local_time_sync, :duration)
42 | server_time = Timex.add(clock.utc_server_time_sync, local_time_delta)
43 |
44 | session_clock_from_server_time(clock, server_time)
45 | end
46 |
47 | def to_event(clock = %__MODULE__{}, local_time) do
48 | session_clock = session_clock_from_local_time(clock, local_time)
49 | Event.new("session_clock:changed", session_clock)
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/test/f1_bot_web/channels/radio_transcript_channel_test.exs:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.RadioTranscriptChannelTest do
2 | use F1BotWeb.ChannelCase
3 |
4 | alias F1BotWeb.ApiSocket
5 | alias F1Bot.Authentication
6 | alias F1Bot.Authentication.ApiClient
7 | @moduletag :channel
8 |
9 | # Timeout for message assertions
10 | @ms_to 1000
11 |
12 | setup do
13 | {:ok, read_only_client} = Authentication.create_api_client("ro_client", [:read_transcripts])
14 | {:ok, unauth_client} = Authentication.create_api_client("unauth", [])
15 |
16 | {:ok, read_only_socket} = connect(ApiSocket, %{token: ApiClient.token(read_only_client)})
17 | {:ok, unauth_socket} = connect(ApiSocket, %{token: ApiClient.token(unauth_client)})
18 |
19 | %{
20 | read_only_client: read_only_client,
21 | read_only_socket: read_only_socket,
22 | unauth_client: unauth_client,
23 | unauth_socket: unauth_socket,
24 | }
25 | end
26 |
27 | describe "radio_transcript channel auth" do
28 | test "read_transcript client can join the channel", %{read_only_socket: read_only} do
29 | result = join(read_only, "radio_transcript:all")
30 | assert match?({:ok, _reply, _socket}, result)
31 | end
32 |
33 | test "other API clients can't join the channel", %{unauth_socket: unauth} do
34 | result = join(unauth, "radio_transcript:all")
35 | assert match?({:error, :unauthorized}, result)
36 | end
37 | end
38 |
39 | describe "status" do
40 | test "status is sent after joining :status subchannel", %{read_only_socket: socket} do
41 | {:ok, _reply, _socket} = subscribe_and_join(socket, "radio_transcript:status")
42 |
43 | assert_push("status", %{online: _, drivers: [_ | _]}, @ms_to)
44 | end
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/channels/transcriber_service_channel.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.TranscriberServiceChannel do
2 | use F1BotWeb, :channel
3 | require Logger
4 |
5 | alias Ecto.Changeset
6 | alias F1Bot.TranscriberService
7 | alias F1Bot.F1Session.Server
8 | alias F1Bot.F1Session.DriverDataRepo.Transcript
9 | alias F1BotWeb.ApiSocket
10 |
11 | @impl true
12 | def join("transcriber_service", _payload, socket) do
13 | if ApiSocket.client_has_scope?(socket, :transcriber_service) do
14 | {:ok, socket}
15 | else
16 | {:error, :unauthorized}
17 | end
18 | end
19 |
20 | @impl true
21 | def handle_in("transcript", payload, socket) do
22 | case Transcript.validate(payload) do
23 | {:ok, transcript} ->
24 | process_transcript(transcript, socket)
25 | {:reply, :ok, socket}
26 |
27 | {:error, changeset = %Changeset{}} ->
28 | Logger.warning("Received invalid transcript: #{inspect(changeset)}")
29 | {:reply, {:error, :invalid_data}, socket}
30 | end
31 | end
32 |
33 | @impl true
34 | def handle_in("update-status", payload, socket) do
35 | case TranscriberService.Status.validate(payload) do
36 | {:ok, status_update} ->
37 | TranscriberService.update_status(status_update)
38 | {:reply, :ok, socket}
39 |
40 | {:error, changeset = %Changeset{}} ->
41 | Logger.warning("Received invalid status update: #{inspect(changeset)}")
42 | {:reply, {:error, :invalid_data}, socket}
43 | end
44 | end
45 |
46 | defp process_transcript(transcript = %Transcript{}, _socket) do
47 | Logger.info("Received transcript: #{inspect(transcript)}")
48 | Server.process_transcript(transcript)
49 | Transcript.broadcast_to_channels(transcript)
50 | end
51 | end
52 |
--------------------------------------------------------------------------------
/lib/f1_bot/plotting.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Plotting do
2 | @moduledoc """
3 | """
4 | alias F1Bot.Plotting
5 |
6 | def plot_lap_times(driver_numbers, options \\ []) do
7 | Plotting.LapTime.plot(driver_numbers, options)
8 | end
9 |
10 | def plot_gap(driver_numbers, options \\ []) do
11 | Plotting.Gap.plot(driver_numbers, options)
12 | end
13 |
14 | def do_gnuplot(file_path, options, datasets) do
15 | case Gnuplot.plot(options, datasets) do
16 | {:ok, _commands} ->
17 | if check_file_ok(file_path) do
18 | {:ok, file_path}
19 | else
20 | cleanup(file_path)
21 | {:error, :file_not_created}
22 | end
23 |
24 | {:error, _, err} ->
25 | cleanup(file_path)
26 | {:error, err}
27 | end
28 | end
29 |
30 | def cleanup(file_path) do
31 | File.rm(file_path)
32 | end
33 |
34 | def check_file_ok(file_path) do
35 | case File.stat(file_path) do
36 | {:ok, %{size: size, type: type}} ->
37 | type == :regular and size > 0
38 |
39 | _ ->
40 | false
41 | end
42 | end
43 |
44 | def verify_datasets_nonempty(datasets) do
45 | all_points = List.flatten(datasets)
46 |
47 | if length(all_points) > 0 do
48 | :ok
49 | else
50 | :error
51 | end
52 | end
53 |
54 | def create_temp_file_path(extension) do
55 | charset = safe_chars()
56 |
57 | rand =
58 | for _ <- 1..20 do
59 | Enum.random(charset)
60 | end
61 | |> to_string()
62 |
63 | file_name = "f1_gnuplot_#{rand}.#{extension}"
64 |
65 | System.tmp_dir()
66 | |> Path.join(file_name)
67 | end
68 |
69 | defp safe_chars() do
70 | [?0..?9, ?a..?z, ?A..?Z]
71 | |> Enum.map_join(&Enum.to_list/1)
72 | |> to_charlist()
73 | end
74 | end
75 |
--------------------------------------------------------------------------------
/lib/f1_bot/analysis/common.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Analysis.Common do
2 | @moduledoc """
3 | Common functions for analysis
4 | """
5 |
6 | alias F1Bot.F1Session
7 | alias F1Bot.F1Session.TrackStatusHistory
8 | alias F1Bot.F1Session.DriverDataRepo.{DriverData, Laps}
9 |
10 | def all_driver_data(session = %F1Session{}) do
11 | case F1Session.driver_list(session) do
12 | {:ok, driver_list} ->
13 | data =
14 | driver_list
15 | |> Stream.map(& &1.driver_number)
16 | |> Stream.map(&{&1, F1Session.driver_session_data(session, &1)})
17 | |> Stream.filter(fn {status, _} -> status == :ok end)
18 | |> Stream.map(fn {_ok, data} -> data end)
19 | |> Enum.into(%{})
20 |
21 | {:ok, data}
22 | end
23 | end
24 |
25 | def fetch_driver_laps(session = %F1Session{}, driver_no) do
26 | case F1Session.driver_session_data(session, driver_no) do
27 | {:ok, %DriverData{laps: laps}} -> {:ok, laps}
28 | {:error, error} -> {:error, error}
29 | end
30 | end
31 |
32 | def fetch_driver_stints(session = %F1Session{}, driver_no) do
33 | case F1Session.driver_session_data(session, driver_no) do
34 | {:ok, %DriverData{stints: stints}} -> {:ok, stints}
35 | {:error, error} -> {:error, error}
36 | end
37 | end
38 |
39 | def fetch_driver_lap(all_driver_data, driver_no, lap_no) do
40 | case all_driver_data[driver_no] do
41 | nil -> {:error, :not_found}
42 | %DriverData{laps: laps} -> Laps.fetch_by_number(laps, lap_no)
43 | end
44 | end
45 |
46 | def neutralized_periods(session = %F1Session{}) do
47 | TrackStatusHistory.find_intervals_with_status(session.track_status_history, [
48 | :red_flag,
49 | :safety_car,
50 | :virtual_safety_car
51 | ])
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM elixir:1.15-slim AS build
2 |
3 | ENV MIX_ENV=prod
4 |
5 | RUN apt-get update && \
6 | apt-get install -y build-essential git npm && \
7 | apt-get clean && rm -f /var/lib/apt/lists/*_*
8 |
9 | WORKDIR /app
10 |
11 | # Fetch dependencies
12 | RUN mix local.hex --force && mix local.rebar --force
13 | COPY mix.exs mix.lock ./
14 | RUN mix deps.get --only "${MIX_ENV}"
15 |
16 | # Copy static configs and compile dependencies
17 | RUN mkdir config
18 | COPY config/config.exs config/${MIX_ENV}.exs config/
19 | RUN mix deps.compile
20 |
21 | # Build assets and code
22 | COPY priv priv
23 | COPY lib lib
24 | COPY assets assets
25 | COPY tsconfig.json package*json ./
26 | RUN mix assets.setup && \
27 | mix assets.deploy && \
28 | mix compile
29 |
30 | # Create release
31 | COPY config/runtime.exs config/
32 | RUN mix release
33 |
34 | # =================================================
35 |
36 | FROM debian:12-slim
37 |
38 | RUN apt-get update -y && \
39 | apt-get install -y libstdc++6 openssl libncurses5 locales && \
40 | apt-get clean && \
41 | rm -f /var/lib/apt/lists/*_*
42 |
43 | ENV MIX_ENV=prod
44 |
45 | RUN sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen
46 | ENV LANG en_US.UTF-8
47 | ENV LANGUAGE en_US:en
48 | ENV LC_ALL en_US.UTF-8
49 |
50 | RUN useradd --create-home --uid 1000 app
51 |
52 | WORKDIR /app
53 | RUN chown app /app
54 |
55 | COPY --from=build --chown=app:root /app/_build/${MIX_ENV}/rel/f1bot /app/
56 | COPY entrypoint.sh scripts LICENSE.md /app/
57 |
58 | # Entrypoint drops privileges to the `app` user
59 | USER root
60 |
61 | # Explicitly invoke `bash` to ensure that the entrypoint script can
62 | # run even without the `execute` bit set.
63 | # This happens when the repo is cloned on a Windows filesystem.
64 | CMD ["/bin/bash", "/app/entrypoint.sh"]
65 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/live/telemetry.sface:
--------------------------------------------------------------------------------
1 |
2 |
44 |
--------------------------------------------------------------------------------
/.env.example:
--------------------------------------------------------------------------------
1 | # In default (dev) environment, with :external_apis_enabled set to false and
2 | # :discord_api_module set to the `Console` variant, the bot isn't going to connect
3 | # to Discord, so you can fill these variables with random/garbage values.
4 |
5 | DISCORD_TOKEN=
6 |
7 | # Comma-separated list
8 | DISCORD_CHANNEL_IDS_MESSAGES=
9 | # Radio transcripts
10 | DISCORD_CHANNEL_IDS_RADIOS=
11 | DISCORD_SERVER_IDS_COMMANDS=
12 |
13 | # Override emojis when self-hosting. Emojis from `assets/discord_emojis` need to be uploaded to your own Discord server.
14 | # To find the emoji ID, you can insert the emoji in Discord message box, then type a backslash directly in front of it.
15 | # After you send the message, the emoji ID should appear in chat.
16 | # DISCORD_EMOJI_ANNOUNCEMENT=<:YOUR_EMOJI_NAME:YOUR_EMOJI_ID>
17 | # DISCORD_EMOJI_QUICK=
18 | # DISCORD_EMOJI_SPEEDOMETER=
19 | # DISCORD_EMOJI_TIMER=
20 | # DISCORD_EMOJI_HARD_TYRE=
21 | # DISCORD_EMOJI_MEDIUM_TYRE=
22 | # DISCORD_EMOJI_SOFT_TYRE=
23 | # DISCORD_EMOJI_TEST_TYRE=
24 | # DISCORD_EMOJI_WET_TYRE=
25 | # DISCORD_EMOJI_INTERMEDIATE_TYRE=
26 | # DISCORD_EMOJI_FLAG_YELLOW=
27 | # DISCORD_EMOJI_FLAG_RED=
28 | # DISCORD_EMOJI_FLAG_CHEQUERED=
29 |
30 | DEMO_MODE_URL=
31 | # The hostname of the Phoenix server, without the protocol.
32 | # If this is wrong, the websocket connections will fail.
33 | PHX_HOST=racing.recursiveprojects.cloud
34 | # Secret used for signing cookies
35 | SECRET_KEY_BASE=use `mix phx.gen.secret` or `openssl rand -hex 64` to generate this
36 |
37 | # Used in docker-compose.yml
38 | # Port to expose on the host, `port` or `IP:port`
39 | DOCKER_BIND_PORT=4000
40 | # Docker volume or host mount point
41 | DOCKER_DATA_VOLUME=data
42 | DOCKER_CONTAINER_NAME=f1bot
43 | # Tag `master` for stable, or `develop` for in-development versions
44 | DOCKER_IMAGE=ghcr.io/recursivegecko/race_bot:master
45 |
--------------------------------------------------------------------------------
/lib/f1_bot/external_api/discord.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.ExternalApi.Discord do
2 | @moduledoc ""
3 | @callback post_message(String.t()) :: :ok | {:error, any()}
4 |
5 | def post_message(message_or_tuple) do
6 | impl = F1Bot.get_env(:discord_api_module, F1Bot.ExternalApi.Discord.Console)
7 | impl.post_message(message_or_tuple)
8 | end
9 |
10 | def get_emoji_or_default(emoji, default) do
11 | case get_emoji_with_env_override(emoji) do
12 | nil -> default
13 | val -> val
14 | end
15 | end
16 |
17 | def get_emoji_with_env_override(emoji) do
18 | emoji_upcase = emoji |> to_string() |> String.upcase()
19 | env_var = "DISCORD_EMOJI_" <> emoji_upcase
20 |
21 | case System.get_env(env_var) do
22 | nil -> default_emoji(emoji)
23 | val -> val
24 | end
25 | end
26 |
27 | def default_emoji(:announcement), do: "<:f1_announcement:918883988867788830>"
28 | def default_emoji(:quick), do: "<:f1_quick:918883439028109313>"
29 | def default_emoji(:speedometer), do: "<:f1_speedometer:918882472551395388>"
30 | def default_emoji(:timer), do: "<:f1_timer:918882914899484672>"
31 | def default_emoji(:hard_tyre), do: "<:f1_tyre_hard:918870511713415278>"
32 | def default_emoji(:medium_tyre), do: "<:f1_tyre_medium:918870511772123186>"
33 | def default_emoji(:soft_tyre), do: "<:f1_tyre_soft:918870511646310440>"
34 | def default_emoji(:test_tyre), do: "<:f1_tyre_test:918870511801487420>"
35 | def default_emoji(:wet_tyre), do: "<:f1_tyre_wet:918870511591763998>"
36 | def default_emoji(:intermediate_tyre), do: "<:f1_tyre_intermediate:918870511625306142>"
37 | def default_emoji(:flag_yellow), do: "<:f1_flag_yellow:918888979808518174>"
38 | def default_emoji(:flag_red), do: "<:f1_flag_red:918888944450547803>"
39 | def default_emoji(:flag_chequered), do: "<:f1_flag_chequered:919209710647935037>"
40 | def default_emoji(_), do: nil
41 | end
42 |
--------------------------------------------------------------------------------
/test/support/data_case.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.DataCase do
2 | @moduledoc """
3 | This module defines the setup for tests requiring
4 | access to the application's data layer.
5 |
6 | You may define functions here to be used as helpers in
7 | your tests.
8 |
9 | Finally, if the test case interacts with the database,
10 | we enable the SQL sandbox, so changes done to the database
11 | are reverted at the end of every test. If you are using
12 | PostgreSQL, you can even run database tests asynchronously
13 | by setting `use F1Bot.DataCase, async: true`, although
14 | this option is not recommended for other databases.
15 | """
16 |
17 | use ExUnit.CaseTemplate
18 |
19 | using do
20 | quote do
21 | alias F1Bot.Repo
22 |
23 | import Ecto
24 | import Ecto.Changeset
25 | import Ecto.Query
26 | import F1Bot.DataCase
27 | end
28 | end
29 |
30 | setup tags do
31 | F1Bot.DataCase.setup_sandbox(tags)
32 | :ok
33 | end
34 |
35 | @doc """
36 | Sets up the sandbox based on the test tags.
37 | """
38 | def setup_sandbox(tags) do
39 | pid = Ecto.Adapters.SQL.Sandbox.start_owner!(F1Bot.Repo, shared: not tags[:async])
40 | on_exit(fn -> Ecto.Adapters.SQL.Sandbox.stop_owner(pid) end)
41 | end
42 |
43 | @doc """
44 | A helper that transforms changeset errors into a map of messages.
45 |
46 | assert {:error, changeset} = Accounts.create_user(%{password: "short"})
47 | assert "password is too short" in errors_on(changeset).password
48 | assert %{password: ["password is too short"]} = errors_on(changeset)
49 |
50 | """
51 | def errors_on(changeset) do
52 | Ecto.Changeset.traverse_errors(changeset, fn {message, opts} ->
53 | Regex.replace(~r"%{(\w+)}", message, fn _, key ->
54 | opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
55 | end)
56 | end)
57 | end
58 | end
59 |
--------------------------------------------------------------------------------
/test/integration/monza_2022_race_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Integration.Monza2022RaceTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias F1Bot.F1Session
5 | alias F1Bot.Replay
6 |
7 | @moduletag :uses_live_timing_data
8 |
9 | setup_all context do
10 | replay_options = %Replay.Options{
11 | exclude_files_regex: ~r/\.z\./
12 | }
13 |
14 | {:ok, %{session: session}} =
15 | "https://livetiming.formula1.com/static/2022/2022-09-11_Italian_Grand_Prix/2022-09-11_Race"
16 | |> Replay.start_replay(replay_options)
17 |
18 | Map.put(context, :session, session)
19 | end
20 |
21 | test "correctly processes starting tyre compound for #1 Max Verstappen", context do
22 | stints = stints_for_driver(context.session, 1)
23 |
24 | compounds = stints |> Enum.map(fn s -> s.compound end)
25 | lap_numbers = stints |> Enum.map(fn s -> s.lap_number end)
26 |
27 | expected_compounds = [:soft, :medium, :soft]
28 | expected_lap_numbers = [1, 26, 49]
29 |
30 | assert compounds == expected_compounds
31 | assert lap_numbers == expected_lap_numbers
32 | end
33 |
34 | test "correctly processes stints for #16 Charles Leclerc", context do
35 | stints = stints_for_driver(context.session, 16)
36 |
37 | compounds = stints |> Enum.map(fn s -> s.compound end)
38 | lap_numbers = stints |> Enum.map(fn s -> s.lap_number end)
39 |
40 | expected_compounds = [:soft, :medium, :soft, :soft]
41 | expected_lap_numbers = [1, 13, 34, 49]
42 |
43 | assert compounds == expected_compounds
44 | assert lap_numbers == expected_lap_numbers
45 | end
46 |
47 | defp stints_for_driver(session, driver_number) do
48 | {:ok, driver_data} = F1Session.driver_session_data(session, driver_number)
49 | driver_data.stints.data |> order_stints()
50 | end
51 |
52 | defp order_stints(stints) do
53 | Enum.sort_by(stints, fn s -> s.number end, :asc)
54 | end
55 | end
56 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/driver_data_repo/events.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.DriverDataRepo.Events do
2 | @moduledoc """
3 | Helper functions to generate events for `F1Bot.F1Session.DriverDataRepo` functions.
4 | """
5 | alias F1Bot.F1Session.Common.Event
6 |
7 | def make_agg_fastest_lap_event(driver_number, type, lap_time, lap_delta) do
8 | make_aggregate_stats_event(:fastest_lap, %{
9 | driver_number: driver_number,
10 | lap_time: lap_time,
11 | lap_delta: lap_delta,
12 | type: type
13 | })
14 | end
15 |
16 | def make_agg_fastest_sector_event(driver_number, type, sector, sector_time, sector_delta) do
17 | make_aggregate_stats_event(:fastest_sector, %{
18 | driver_number: driver_number,
19 | sector: sector,
20 | sector_time: sector_time,
21 | sector_delta: sector_delta,
22 | type: type
23 | })
24 | end
25 |
26 | def make_agg_top_speed_event(driver_number, type, speed, speed_delta) do
27 | make_aggregate_stats_event(:top_speed, %{
28 | driver_number: driver_number,
29 | speed: speed,
30 | speed_delta: speed_delta,
31 | type: type
32 | })
33 | end
34 |
35 | def make_tyre_change_events(
36 | driver,
37 | _result = %{is_correction: is_correction, stint: stint}
38 | ) do
39 | event =
40 | make_event(driver, :tyre_change, %{
41 | is_correction: is_correction,
42 | compound: stint.compound,
43 | age: stint.age
44 | })
45 |
46 | [event]
47 | end
48 |
49 | def make_tyre_change_events(_driver, _result = nil), do: []
50 |
51 | defp make_event(self, type, payload) do
52 | payload =
53 | payload
54 | |> Map.put(:driver_number, self.number)
55 |
56 | Event.new("driver:#{type}", payload)
57 | end
58 |
59 | defp make_aggregate_stats_event(type, payload) do
60 | Event.new("aggregate_stats:#{type}", payload)
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/driver_cache/driver_info.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.DriverCache.DriverInfo do
2 | @moduledoc """
3 | Personal information about a driver.
4 | """
5 | use TypedStruct
6 |
7 | typedstruct do
8 | @typedoc "Information about a driver"
9 |
10 | field(:full_name, String.t())
11 | field(:first_name, String.t())
12 | field(:last_name, String.t())
13 | field(:short_name, String.t())
14 | field(:driver_number, pos_integer())
15 | field(:driver_abbr, String.t())
16 | field(:team_color, String.t())
17 | field(:team_name, String.t())
18 | field(:picture_url, String.t())
19 | field(:chart_order, pos_integer())
20 | field(:chart_team_order, pos_integer())
21 | end
22 |
23 | def parse_from_json(json) do
24 | data =
25 | %{
26 | "FullName" => :full_name,
27 | "FirstName" => :first_name,
28 | "LastName" => :last_name,
29 | "HeadshotUrl" => :picture_url,
30 | "BroadcastName" => :short_name,
31 | "RacingNumber" => :driver_number,
32 | "Tla" => :driver_abbr,
33 | "TeamColour" => :team_color,
34 | "TeamName" => :team_name
35 | }
36 | |> Enum.reduce(%{}, fn {source, target}, final ->
37 | if json[source] != nil do
38 | Map.put(final, target, json[source])
39 | else
40 | final
41 | end
42 | end)
43 |
44 | struct!(__MODULE__, data)
45 | end
46 |
47 | def team_color_int(%__MODULE__{team_color: color_hex}) when is_binary(color_hex) do
48 | case Integer.parse(color_hex, 16) do
49 | {int, _} -> int
50 | _ -> 0
51 | end
52 | end
53 |
54 | def team_color_int(%__MODULE__{}), do: 0
55 |
56 | def has_personal_info?(info = %__MODULE__{}) do
57 | some_name = info.full_name || info.first_name || info.last_name
58 | some_name != nil and info.driver_number != nil and info.driver_abbr != nil
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/live_timing_handlers/extrapolated_clock.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.LiveTimingHandlers.ExtrapolatedClock do
2 | @moduledoc """
3 | Handler for extrapolated clock which keeps track of remaining session time,
4 | useful for qualifying.
5 | """
6 | require Logger
7 | alias F1Bot.F1Session.LiveTimingHandlers
8 |
9 | alias F1Bot.F1Session
10 | alias F1Bot.DataTransform.Parse
11 | alias LiveTimingHandlers.{Packet, ProcessingResult, ProcessingOptions}
12 |
13 | @behaviour LiveTimingHandlers
14 | @scope "ExtrapolatedClock"
15 |
16 | @impl F1Bot.F1Session.LiveTimingHandlers
17 | def process_packet(
18 | session,
19 | %Packet{
20 | topic: @scope,
21 | data: data = %{"Remaining" => remaining, "Utc" => utc}
22 | },
23 | options = %ProcessingOptions{}
24 | ) do
25 | with {:ok, remaining} <- Parse.parse_session_clock(remaining),
26 | {:ok, server_time} <- Timex.parse(utc, "{ISO:Extended}") do
27 | local_time = options.local_time_fn.()
28 | is_running = !!data["Extrapolating"]
29 |
30 | {session, events} =
31 | F1Session.update_clock(session, server_time, local_time, remaining, is_running)
32 |
33 | result = %ProcessingResult{
34 | session: session,
35 | events: events
36 | }
37 |
38 | {:ok, result}
39 | else
40 | {:error, error} ->
41 | Logger.error("Failed to parse extrapolated clock: #{inspect(error)}")
42 |
43 | result = %ProcessingResult{
44 | session: session,
45 | events: []
46 | }
47 |
48 | {:ok, result}
49 | end
50 | end
51 |
52 | @impl F1Bot.F1Session.LiveTimingHandlers
53 | def process_packet(
54 | _session,
55 | %Packet{
56 | topic: @scope,
57 | data: data
58 | },
59 | _options
60 | ) do
61 | {:error, {:invalid_clock_data, data}}
62 | end
63 | end
64 |
--------------------------------------------------------------------------------
/lib/map_utils.ex:
--------------------------------------------------------------------------------
1 | defmodule MapUtils do
2 | @doc """
3 | Patches the old map or struct, ignoring nil values in the new map
4 | """
5 | def patch_ignore_nil(old, new) when is_map(old) and is_map(new) do
6 | {original_struct, old_map, new_map} = prepare_for_merge(old, new)
7 |
8 | merged =
9 | Map.merge(old_map, new_map, fn _k, a, b ->
10 | if b == nil do
11 | a
12 | else
13 | b
14 | end
15 | end)
16 |
17 | if original_struct do
18 | struct!(original_struct, merged)
19 | else
20 | merged
21 | end
22 | end
23 |
24 | @doc """
25 | Patches the old map, only changing fields that were nil
26 | """
27 | def patch_missing(old, new) when is_map(old) and is_map(new) do
28 | {original_struct, old_map, new_map} = prepare_for_merge(old, new)
29 |
30 | merged =
31 | Map.merge(old_map, new_map, fn _k, a, b ->
32 | if a != nil do
33 | a
34 | else
35 | b
36 | end
37 | end)
38 |
39 | if original_struct do
40 | struct!(original_struct, merged)
41 | else
42 | merged
43 | end
44 | end
45 |
46 | defp prepare_for_merge(old, new) when is_map(old) and is_map(new) do
47 | old_map = if is_struct(old), do: Map.from_struct(old), else: old
48 | new_map = if is_struct(new), do: Map.from_struct(new), else: new
49 |
50 | case {old, new} do
51 | {%struct{}, %struct{}} ->
52 | {struct, old_map, new_map}
53 |
54 | {%struct{}, new} when not is_struct(new) ->
55 | {struct, old_map, new_map}
56 |
57 | {old, %_struct{}} when not is_struct(old) ->
58 | {nil, old_map, new_map}
59 |
60 | {old, new} when not (is_struct(old) or is_struct(new)) ->
61 | {nil, old_map, new_map}
62 |
63 | _ ->
64 | raise "Structs must be the same type. Attempted to patch #{inspect(old.__struct__)} with #{inspect(new.__struct__)}"
65 | end
66 | end
67 | end
68 |
--------------------------------------------------------------------------------
/assets/js/Visualizations/DatasetUtils.ts:
--------------------------------------------------------------------------------
1 | const DataSetUtils = {
2 | /**
3 | * Merges two datasets together, removing points that are no longer in the new dataset and adding points that are new.
4 | * The reason this is necessary is because Chart.js would animate the entire dataset rather than the last added point
5 | * if we just replaced it with a new one.
6 | *
7 | * @param existingData Dataset to modify
8 | * @param newData New dataset to merge into existingData
9 | * @param keyFn Function that maps a point in the dataset to its unique identifier (e.g. X axis value)
10 | */
11 | mergeDataset
3 | <.brand />
4 |
5 |
6 |
7 |
8 |
43 |
9 |
21 |
22 |
23 |
10 |
12 |
13 |
14 |
16 |
17 |
18 |
20 |
24 |
42 |
25 | {@session_info.gp_name} - {@session_info.type}
26 |
27 | Open charts
28 |
29 |
30 |
31 |
32 | {#for driver_info <- @driver_list}
33 |
41 |
19 | <%= @inner_content %>
20 |
21 |
22 |
59 |
60 |
61 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/telemetry.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.Telemetry do
2 | use Supervisor
3 | import Telemetry.Metrics
4 |
5 | def start_link(arg) do
6 | Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
7 | end
8 |
9 | @impl true
10 | def init(_arg) do
11 | children = [
12 | # Telemetry poller will execute the given period measurements
13 | # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics
14 | {:telemetry_poller, measurements: periodic_measurements(), period: 10_000}
15 | # Add reporters as children of your supervision tree.
16 | # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()}
17 | ]
18 |
19 | Supervisor.init(children, strategy: :one_for_one)
20 | end
21 |
22 | def metrics do
23 | [
24 | # Phoenix Metrics
25 | summary("phoenix.endpoint.stop.duration",
26 | unit: {:native, :millisecond}
27 | ),
28 | summary("phoenix.router_dispatch.stop.duration",
29 | tags: [:route],
30 | unit: {:native, :millisecond}
31 | ),
32 |
33 | # Database Metrics
34 | summary("f1bot.repo.query.total_time",
35 | unit: {:native, :millisecond},
36 | description: "The sum of the other measurements"
37 | ),
38 | summary("f1bot.repo.query.decode_time",
39 | unit: {:native, :millisecond},
40 | description: "The time spent decoding the data received from the database"
41 | ),
42 | summary("f1bot.repo.query.query_time",
43 | unit: {:native, :millisecond},
44 | description: "The time spent executing the query"
45 | ),
46 | summary("f1bot.repo.query.queue_time",
47 | unit: {:native, :millisecond},
48 | description: "The time spent waiting for a database connection"
49 | ),
50 | summary("f1bot.repo.query.idle_time",
51 | unit: {:native, :millisecond},
52 | description:
53 | "The time the connection spent waiting before being checked out for the query"
54 | ),
55 |
56 | # VM Metrics
57 | summary("vm.memory.total", unit: {:byte, :kilobyte}),
58 | summary("vm.total_run_queue_lengths.total"),
59 | summary("vm.total_run_queue_lengths.cpu"),
60 | summary("vm.total_run_queue_lengths.io")
61 | ]
62 | end
63 |
64 | defp periodic_measurements do
65 | [
66 | # A module, function and arguments to be invoked periodically.
67 | # This function must call :telemetry.execute/3 and a metric must be added above.
68 | # {F1BotWeb, :count_users, []}
69 | ]
70 | end
71 | end
72 |
--------------------------------------------------------------------------------
/config/dev.exs:
--------------------------------------------------------------------------------
1 | import Config
2 |
3 | config :f1_bot,
4 | connect_to_signalr: false,
5 | start_discord: false,
6 | discord_api_module: F1Bot.ExternalApi.Discord.Console,
7 | default_delay_ms: 1_000,
8 | auto_reload_session: false
9 |
10 | config :logger,
11 | level: :info
12 |
13 | # Do not include metadata nor timestamps in development logs
14 | config :logger, :console, format: "[$level] $message\n"
15 |
16 | # Configure your database
17 | config :f1_bot, F1Bot.Repo,
18 | database: Path.expand("../f1bot_dev.db", Path.dirname(__ENV__.file)),
19 | pool_size: 5,
20 | stacktrace: true,
21 | show_sensitive_data_on_connection_error: true
22 |
23 | # For development, we disable any cache and enable
24 | # debugging and code reloading.
25 | #
26 | # The watchers configuration can be used to run external
27 | # watchers to your application. For example, we use it
28 | # with esbuild to bundle .js and .css sources.
29 | config :f1_bot, F1BotWeb.Endpoint,
30 | # Binding to loopback ipv4 address prevents access from other machines.
31 | # Change to `ip: {0, 0, 0, 0}` to allow access from other machines.
32 | url: [host: "localhost"],
33 | http: [ip: {0, 0, 0, 0}, port: 4000],
34 | check_origin: false,
35 | code_reloader: true,
36 | debug_errors: true,
37 | secret_key_base: "U/lrJxiO8Pof0MWxTnEHM+CvYJ4559nfslojhRY3ui9hEcZX5N3bUrpGPRtKLX8b",
38 | watchers: [
39 | # Start the esbuild watcher by calling Esbuild.install_and_run(:default, args)
40 | esbuild: {Esbuild, :install_and_run, [:default, ~w(--sourcemap=inline --watch)]},
41 | tailwind: {Tailwind, :install_and_run, [:default, ~w(--watch)]}
42 | ],
43 | # Watch static and templates for browser reloading.
44 | reloadable_compilers: [:gettext, :elixir, :surface],
45 | live_reload: [
46 | patterns: [
47 | ~r"priv/static/.*(js|css|png|jpeg|jpg|gif|svg)$",
48 | ~r"lib/f1_bot_web/(controllers|live|components)/.*(ex|heex|sface)$"
49 | ]
50 | ]
51 |
52 | config :f1_bot, F1BotWeb.InternalEndpoint,
53 | url: [host: "localhost"],
54 | http: [ip: {127, 0, 0, 1}, port: 4001],
55 | check_origin: false,
56 | debug_errors: true,
57 | secret_key_base: "kIaE5yMJsNdbC2xW+TtE/ImirvCTyyzkOoftsQPWimDQHfZnwXkx/4sWIww9hWt0",
58 | live_view: [signing_salt: "AOtJEjcdsssJpmsFIkNl6ksdtAQuwavZ"]
59 |
60 | # Set a higher stacktrace during development. Avoid configuring such
61 | # in production as building large stacktraces may be expensive.
62 | config :phoenix, :stacktrace_depth, 20
63 |
64 | # Initialize plugs at runtime for faster development compilation
65 | config :phoenix, :plug_init_mode, :runtime
66 |
--------------------------------------------------------------------------------
/lib/mix/tasks/backtest.ex:
--------------------------------------------------------------------------------
1 | # credo:disable-for-this-file Credo.Check.Warning.IoInspect
2 | defmodule Mix.Tasks.Backtest do
3 | @moduledoc """
4 | Downloads archives of previous races and runs an offline backtest which prints all
5 | Discord messages to console.
6 |
7 | Usage:
8 | ```
9 | iex -S mix backtest --url "http://livetiming.formula1.com/static/2022/2022-05-08_Miami_Grand_Prix/2022-05-08_Race"
10 | ```
11 | """
12 |
13 | use Mix.Task
14 | require Config
15 | require Logger
16 |
17 | alias F1Bot.Replay
18 | alias F1Bot.F1Session.LiveTimingHandlers.ProcessingOptions
19 |
20 | @impl Mix.Task
21 | def run(argv) do
22 | configure()
23 |
24 | parsed_args = parse_argv(argv)
25 | url = Keyword.fetch!(parsed_args, :url)
26 |
27 | Logger.info("Downloading & parsing dataset.")
28 |
29 | replay_options = %Replay.Options{
30 | exclude_files_regex: ~r/\.z\./,
31 | # Broadcast events on the PubSub bus, this allows us to quickly review
32 | # the sanity of F1 packet processing logic by inspecting the console output
33 | # for simulated Discord messages.
34 | events_fn: &F1Bot.PubSub.broadcast_events/1,
35 | report_progress: true,
36 | processing_options: %ProcessingOptions{
37 | skip_heavy_events: false
38 | }
39 | }
40 |
41 | # profile_start()
42 | {:ok, %{session: session}} = Replay.start_replay(url, replay_options)
43 | # profile_end()
44 |
45 | F1Bot.F1Session.Server.replace_session(session)
46 |
47 | total_mem_mb = (:erlang.memory(:total) / 1024 / 1024) |> round()
48 | Logger.info("Total memory usage: #{total_mem_mb} MB")
49 | end
50 |
51 | def profile_start() do
52 | :eprof.start_profiling([self()])
53 | end
54 |
55 | def profile_end() do
56 | :eprof.stop_profiling()
57 | :eprof.analyze()
58 | end
59 |
60 | def parse_argv(argv) do
61 | {parsed_args, _, _} =
62 | OptionParser.parse(argv,
63 | strict: [
64 | url: :string
65 | ]
66 | )
67 |
68 | parsed_args
69 | end
70 |
71 | def configure() do
72 | Application.put_env(:gnuplot, :timeout, {3000, :ms})
73 | Application.put_env(:f1_bot, :connect_to_signalr, false)
74 | Application.put_env(:f1_bot, :start_discord, false)
75 | Application.put_env(:f1_bot, :external_apis_enabled, false)
76 | Application.put_env(:f1_bot, :discord_api_module, F1Bot.ExternalApi.Discord.Console)
77 | Logger.configure(level: :info)
78 |
79 | Finch.start_link(name: __MODULE__)
80 | {:ok, _} = Application.ensure_all_started(:f1_bot)
81 | end
82 | end
83 |
--------------------------------------------------------------------------------
/lib/f1_bot/delayed_events.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.DelayedEvents do
2 | require Logger
3 | alias F1Bot.DelayedEvents.Rebroadcaster
4 |
5 | @min_delay 1_000
6 | @max_delay 45_000
7 | @delay_step 1_000
8 | @available_delays @min_delay..@max_delay//@delay_step
9 |
10 | defdelegate fetch_latest_event(delay_ms, event_scope),
11 | to: F1Bot.DelayedEvents.Rebroadcaster
12 |
13 | def default_delay(), do: F1Bot.get_env(:default_delay_ms, 20_000)
14 | def available_delays, do: @available_delays
15 | def min_delay_ms, do: @min_delay
16 | def max_delay_ms, do: @max_delay
17 | def delay_step, do: @delay_step
18 | def is_valid_delay?(delay_ms), do: delay_ms in @available_delays
19 |
20 | def subscribe_with_delay(scopes, delay_ms, send_init_events) do
21 | if delay_ms in @available_delays do
22 | topics =
23 | Enum.map(scopes, fn scope ->
24 | delayed_topic_for_event(scope, delay_ms)
25 | end)
26 |
27 | F1Bot.PubSub.subscribe_all(topics)
28 |
29 | if send_init_events do
30 | send_init_events(scopes, delay_ms, self())
31 | end
32 |
33 | {:ok, topics}
34 | else
35 | {:error, :invalid_delay}
36 | end
37 | end
38 |
39 | @doc """
40 | Send the latest event for each topic pair for topics that follow the
41 | init + delta pattern, e.g. charts where the init event contains the bulky
42 | chart specification and later events only contain new data points to add.
43 | """
44 | def oneshot_init(scopes, delay_ms) do
45 | if delay_ms in @available_delays do
46 | send_init_events(scopes, delay_ms, self())
47 | :ok
48 | else
49 | {:error, :invalid_delay}
50 | end
51 | end
52 |
53 | def delayed_topic_for_event(scope, delay_ms) do
54 | base_topic = F1Bot.PubSub.topic_for_event(scope)
55 | "delayed:#{delay_ms}::#{base_topic}"
56 | end
57 |
58 | def clear_all_caches() do
59 | Logger.warning("Clearing all delayed events caches")
60 |
61 | for delay_ms <- @available_delays do
62 | Rebroadcaster.clear_cache(delay_ms)
63 | end
64 | end
65 |
66 | def push_to_all(_events = []), do: {:ok, :empty}
67 |
68 | def push_to_all(events) do
69 | for delay_ms <- @available_delays,
70 | via = Rebroadcaster.server_via(delay_ms) do
71 | send(via, {:events, events})
72 | end
73 | end
74 |
75 | defp send_init_events(scopes, delay_ms, pid) do
76 | for scope <- scopes do
77 | case fetch_latest_event(delay_ms, scope) do
78 | {:ok, event} -> send(pid, event)
79 | {:error, :no_data} -> :skip
80 | end
81 | end
82 | end
83 | end
84 |
--------------------------------------------------------------------------------
/test/integration/saudi_2022_quali_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Integration.Saudi2022QualiTest do
2 | use ExUnit.Case, async: true
3 |
4 | alias F1Bot.F1Session
5 | alias F1Bot.Replay
6 |
7 | @moduletag :uses_live_timing_data
8 |
9 | setup_all context do
10 | replay_options = %Replay.Options{
11 | exclude_files_regex: ~r/\.z\./
12 | }
13 |
14 | {:ok, %{session: session}} =
15 | "https://livetiming.formula1.com/static/2022/2022-03-27_Saudi_Arabian_Grand_Prix/2022-03-26_Qualifying"
16 | |> Replay.start_replay(replay_options)
17 |
18 | Map.put(context, :session, session)
19 | end
20 |
21 | test "correctly processes stints for #11 Sergio Perez", context do
22 | stints = stints_for_driver(context.session, 11)
23 |
24 | compounds = stints |> Enum.map(fn s -> s.compound end)
25 | lap_numbers = stints |> Enum.map(fn s -> s.lap_number end)
26 |
27 | expected_compounds = [:soft, :soft, :soft, :soft, :soft, :soft]
28 | expected_lap_numbers = [2, 4, 9, 12, 15, 18]
29 |
30 | assert compounds == expected_compounds
31 | assert lap_numbers == expected_lap_numbers
32 | end
33 |
34 | test "correctly processes lap times for #11 Sergio Perez", context do
35 | lap_times = lap_times_for_driver(context.session, 11, 100)
36 |
37 | expected_lap_times =
38 | [
39 | "1:30.111",
40 | # "2:27.094",
41 | "1:29.705",
42 | "1:28.924",
43 | "1:32.296",
44 | "1:28.554",
45 | "1:28.200"
46 | ]
47 | |> parse_lap_times()
48 |
49 | assert lap_times == expected_lap_times
50 | end
51 |
52 | defp stints_for_driver(session, driver_number) do
53 | {:ok, driver_data} = F1Session.driver_session_data(session, driver_number)
54 | driver_data.stints.data |> order_stints()
55 | end
56 |
57 | defp lap_times_for_driver(session, driver_number, max_time_sec) do
58 | max_time = Timex.Duration.from_seconds(max_time_sec)
59 |
60 | {:ok, driver_data} = F1Session.driver_session_data(session, driver_number)
61 |
62 | driver_data.laps.data
63 | |> Map.values()
64 | |> Enum.filter(fn l -> l.time != nil end)
65 | |> Enum.filter(fn l -> Timex.Duration.diff(l.time, max_time, :milliseconds) < 0 end)
66 | |> Enum.sort_by(fn l -> l.number end, :asc)
67 | |> Enum.map(fn l -> l.time end)
68 | end
69 |
70 | defp parse_lap_times(lap_times) do
71 | lap_times
72 | |> Enum.map(fn l ->
73 | {:ok, lap_time} = F1Bot.DataTransform.Parse.parse_lap_time(l)
74 | lap_time
75 | end)
76 | end
77 |
78 | defp order_stints(stints) do
79 | Enum.sort_by(stints, fn s -> s.number end, :asc)
80 | end
81 | end
82 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/lap_counter.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.LapCounter do
2 | @moduledoc """
3 | Stores current and maximum lap number for the session
4 | """
5 | use TypedStruct
6 |
7 | alias F1Bot.F1Session.Common.Event
8 |
9 | typedstruct do
10 | field(:current, integer() | nil)
11 | field(:total, integer() | nil)
12 | field(:lap_timestamps, map(), default: %{})
13 | end
14 |
15 | def new() do
16 | %__MODULE__{
17 | current: nil,
18 | total: nil
19 | }
20 | end
21 |
22 | def new(current, total) do
23 | %__MODULE__{
24 | current: current,
25 | total: total
26 | }
27 | end
28 |
29 | def update(lap_counter, current_lap, total_laps, timestamp) do
30 | lap_counter = update_timestamps(lap_counter, current_lap, timestamp)
31 |
32 | new_current_lap = current_lap || lap_counter.current
33 | new_total_laps = total_laps || lap_counter.total
34 |
35 | %{lap_counter | current: new_current_lap, total: new_total_laps}
36 | end
37 |
38 | def timestamp_to_lap_number(lap_counter, timestamp) do
39 | lap_counter.lap_timestamps
40 | |> Enum.sort_by(fn {lap, _timestamps} -> lap end, :asc)
41 | |> Enum.find_value(fn {lap, lap_ts} ->
42 | if F1Bot.Time.between?(timestamp, lap_ts.start, lap_ts.end) do
43 | lap
44 | else
45 | nil
46 | end
47 | end)
48 | |> case do
49 | nil -> {:error, :not_found}
50 | lap -> {:ok, lap}
51 | end
52 | end
53 |
54 | def to_event(lap_counter = %__MODULE__{}) do
55 | Event.new("lap_counter:changed", lap_counter)
56 | end
57 |
58 | defp update_timestamps(lap_counter, _current_lap = nil, _timestamp), do: lap_counter
59 |
60 | defp update_timestamps(lap_counter, current_lap, timestamp) when is_integer(current_lap) do
61 | lap_timestamps =
62 | lap_counter.lap_timestamps
63 | |> Map.update(
64 | current_lap,
65 | %{start: timestamp, end: nil},
66 | &MapUtils.patch_missing(&1, %{start: timestamp})
67 | )
68 |
69 | lap_counter = %{lap_counter | lap_timestamps: lap_timestamps}
70 |
71 | lap_counter
72 | |> maybe_update_prev_lap_timestamp(current_lap, timestamp)
73 | end
74 |
75 | defp maybe_update_prev_lap_timestamp(lap_counter, current_lap, timestamp) do
76 | if current_lap > 1 do
77 | prev_lap = current_lap - 1
78 |
79 | lap_timestamps =
80 | lap_counter.lap_timestamps
81 | |> Map.update(
82 | prev_lap,
83 | %{start: nil, end: timestamp},
84 | &MapUtils.patch_missing(&1, %{end: timestamp})
85 | )
86 |
87 | %{lap_counter | lap_timestamps: lap_timestamps}
88 | else
89 | lap_counter
90 | end
91 | end
92 | end
93 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/live_timing_handlers/car_telemetry.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.LiveTimingHandlers.CarTelemetry do
2 | @moduledoc """
3 | Handler for car telemetry received from live timing API.
4 |
5 | The handler decompresses and parses car telemetry channels and passes it on to the F1 session instance.
6 | """
7 | require Logger
8 | alias F1Bot.F1Session.LiveTimingHandlers
9 |
10 | alias F1Bot.F1Session
11 | alias LiveTimingHandlers.{Packet, ProcessingResult}
12 |
13 | @behaviour LiveTimingHandlers
14 | @scope "CarData"
15 |
16 | # {'0': 'RPM', '2': 'Speed', '3': 'nGear', '4': 'Throttle', '5': 'Brake', '45': 'DRS'}
17 | @channels %{
18 | "0" => :rpm,
19 | "2" => :speed,
20 | "3" => :gear,
21 | "4" => :throttle,
22 | "5" => :brake,
23 | "45" => :drs
24 | }
25 |
26 | @drs_values %{
27 | 0 => :off,
28 | 8 => :available,
29 | 10 => :on,
30 | 12 => :on,
31 | 14 => :on
32 | }
33 |
34 | @impl F1Bot.F1Session.LiveTimingHandlers
35 | def process_packet(
36 | session,
37 | %Packet{
38 | topic: @scope,
39 | data: encoded
40 | },
41 | _options
42 | ) do
43 | case F1Bot.ExternalApi.SignalR.Encoding.decode_live_timing_data(encoded) do
44 | {:ok, %{"Entries" => batches}} ->
45 | session = process_decoded_data(session, batches)
46 |
47 | result = %ProcessingResult{
48 | session: session,
49 | events: []
50 | }
51 |
52 | {:ok, result}
53 |
54 | {:error, error} ->
55 | {:error, "Error decoding telemetry data: #{error}"}
56 | end
57 | end
58 |
59 | defp process_decoded_data(session, batches) do
60 | batches
61 | |> Enum.reduce(session, fn batch, session ->
62 | %{"Cars" => cars, "Utc" => ts} = batch
63 | ts = F1Bot.DataTransform.Parse.parse_iso_timestamp(ts)
64 |
65 | reduce_telemetry_per_timestamp(session, cars, ts)
66 | end)
67 | end
68 |
69 | defp reduce_telemetry_per_timestamp(session, cars, timestamp) do
70 | cars
71 | |> Enum.reduce(session, fn {driver_number, %{"Channels" => channels}}, session ->
72 | driver_number = String.trim(driver_number) |> String.to_integer()
73 | channels = parse_telemetry_channels(channels, timestamp)
74 |
75 | F1Session.push_telemetry(session, driver_number, channels)
76 | end)
77 | end
78 |
79 | defp parse_telemetry_channels(channels, timestamp) do
80 | parsed =
81 | @channels
82 | |> Enum.map(fn {source, target} -> {target, channels[source]} end)
83 | |> Enum.into(%{})
84 |
85 | drs = Map.get(@drs_values, parsed.drs, :off)
86 |
87 | %{parsed | drs: drs}
88 | |> Map.put(:timestamp, timestamp)
89 | end
90 | end
91 |
--------------------------------------------------------------------------------
/lib/f1_bot/external_api/discord/commands/option_validator.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.ExternalApi.Discord.Commands.OptionValidator do
2 | @moduledoc """
3 | Parses and validates Discord command options
4 | """
5 | alias F1Bot
6 |
7 | def validate_graph_metric(options, name) do
8 | metric_option = Enum.find(options, fn opt -> opt.name == name end)
9 |
10 | case metric_option do
11 | %{value: x} when x in ["gap", "lap_time"] -> {:ok, String.to_atom(x)}
12 | nil -> {:error, "Metric option not provided"}
13 | _ -> {:error, "Invalid metric option"}
14 | end
15 | end
16 |
17 | def validate_graph_style(options, name) do
18 | metric_option = Enum.find(options, fn opt -> opt.name == name end)
19 |
20 | case metric_option do
21 | %{value: x} when x in ["points", "lines"] -> {:ok, String.to_atom(x)}
22 | nil -> {:ok, :line}
23 | _ -> {:error, "Invalid style option"}
24 | end
25 | end
26 |
27 | def validate_driver_list(options, name) do
28 | drivers_option = Enum.find(options, fn opt -> opt.name == name end)
29 |
30 | if drivers_option != nil do
31 | drivers =
32 | drivers_option.value
33 | |> String.split([",", " "])
34 | |> Enum.map(&String.replace(&1, ~r/[., ]/, ""))
35 | |> Enum.filter(fn x -> String.length(x) > 0 end)
36 |
37 | drivers =
38 | for str <- drivers do
39 | validate_driver_value(str)
40 | end
41 |
42 | errors =
43 | for {status, err} <- drivers,
44 | status == :error do
45 | err
46 | end
47 |
48 | drivers =
49 | for {status, driver} <- drivers,
50 | status == :ok do
51 | driver
52 | end
53 |
54 | if length(errors) > 0 do
55 | {:error, errors |> Enum.join(", ")}
56 | else
57 | {:ok, drivers}
58 | end
59 | else
60 | {:error, "Drivers option not provided"}
61 | end
62 | end
63 |
64 | def validate_driver(options, name) do
65 | driver_option = Enum.find(options, fn opt -> opt.name == name end)
66 |
67 | if driver_option != nil do
68 | driver_option.value
69 | |> String.trim()
70 | |> validate_driver_value()
71 | else
72 | {:error, "Driver option not provided"}
73 | end
74 | end
75 |
76 | defp validate_driver_value(str) do
77 | lookup_result =
78 | case Integer.parse(str) do
79 | :error ->
80 | F1Bot.driver_info_by_abbr(str)
81 |
82 | {int, _} ->
83 | F1Bot.driver_info_by_number(int)
84 | end
85 |
86 | case lookup_result do
87 | {:error, _} ->
88 | {:error, "Unknown driver #{str}"}
89 |
90 | {:ok, %{driver_number: num}} ->
91 | {:ok, num}
92 | end
93 | end
94 | end
95 |
--------------------------------------------------------------------------------
/lib/f1_bot/f1_session/driver_data_repo/lap.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.F1Session.DriverDataRepo.Lap do
2 | @moduledoc """
3 | Holds information about a single lap.
4 | """
5 | use TypedStruct
6 |
7 | alias F1Bot.F1Session.DriverDataRepo.{Stints, Sector}
8 | alias F1Bot.F1Session.TrackStatusHistory
9 |
10 | @type sector_map :: %{
11 | 1 => Sector.t() | nil,
12 | 2 => Sector.t() | nil,
13 | 3 => Sector.t() | nil
14 | }
15 |
16 | typedstruct do
17 | @typedoc "Lap information"
18 |
19 | field(:number, pos_integer())
20 | field(:time, Timex.Duration.t())
21 | field(:timestamp, DateTime.t())
22 |
23 | field(:sectors, sector_map(),
24 | default: %{1 => nil, 2 => nil, 3 => nil}
25 | )
26 |
27 | field(:is_outlier, boolean())
28 | field(:is_valid, boolean(), default: true)
29 | # TODO: Not implemened yet
30 | field(:is_deleted, boolean(), default: false)
31 | field(:top_speed, pos_integer(), default: 0)
32 | end
33 |
34 | def new(args) when is_list(args) do
35 | struct!(__MODULE__, args)
36 | end
37 |
38 | @spec is_neutralized?(t(), [TrackStatusHistory.interval()]) :: boolean()
39 | def is_neutralized?(lap = %__MODULE__{}, neutralized_intervals) do
40 | if lap.time == nil or lap.timestamp == nil do
41 | false
42 | else
43 | lap_start = Timex.subtract(lap.timestamp, lap.time)
44 | lap_end = lap.timestamp
45 |
46 | Enum.any?(neutralized_intervals, fn %{starts_at: starts_at, ends_at: ends_at} ->
47 | # Add a margin for drivers to return to racing speed
48 | ends_at =
49 | if ends_at == nil do
50 | nil
51 | else
52 | Timex.add(ends_at, Timex.Duration.from_seconds(5))
53 | end
54 |
55 | started_during_neutral = F1Bot.Time.between?(lap_start, starts_at, ends_at)
56 | ended_during_neutral = F1Bot.Time.between?(lap_end, starts_at, ends_at)
57 | short_neutral_during_lap = F1Bot.Time.between?(starts_at, lap_start, lap_end)
58 |
59 | started_during_neutral or ended_during_neutral or short_neutral_during_lap
60 | end)
61 | end
62 | end
63 |
64 | @spec is_outlap_after_red_flag?(t()) :: boolean()
65 | def is_outlap_after_red_flag?(lap = %__MODULE__{}) do
66 | lap.sectors == nil and lap.time != nil and Timex.Duration.to_seconds(lap.time) > 180
67 | end
68 |
69 | @spec is_inlap?(t(), Stints.t()) :: boolean()
70 | def is_inlap?(lap = %__MODULE__{}, stints = %Stints{}) do
71 | inlaps =
72 | stints.data
73 | |> Enum.map(&(&1.lap_number - 1))
74 |
75 | lap.number in inlaps
76 | end
77 |
78 | @spec is_outlap?(t(), Stints.t()) :: boolean()
79 | def is_outlap?(lap = %__MODULE__{}, stints = %Stints{}) do
80 | outlaps =
81 | stints.data
82 | |> Enum.map(& &1.lap_number)
83 |
84 | lap.number in outlaps
85 | end
86 | end
87 |
--------------------------------------------------------------------------------
/lib/f1_bot_web/components/delay_control.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb.Component.DelayControl do
2 | use F1BotWeb, :live_component
3 | alias F1Bot.DelayedEvents
4 |
5 | prop pubsub_delay_ms, :integer, required: true
6 | data delay_step_ms, :integer, default: DelayedEvents.delay_step()
7 | data min_delay_ms, :integer, default: DelayedEvents.min_delay_ms()
8 | data max_delay_ms, :integer, default: DelayedEvents.max_delay_ms()
9 | data can_decrease, :boolean, default: false
10 | data can_increase, :boolean, default: false
11 |
12 | def update(new_assigns, socket) do
13 | socket = assign(socket, new_assigns)
14 |
15 | assigns = socket.assigns
16 |
17 | socket =
18 | socket
19 | |> assign(
20 | :can_increase,
21 | assigns.pubsub_delay_ms + assigns.delay_step_ms <= assigns.max_delay_ms
22 | )
23 | |> assign(
24 | :can_decrease,
25 | assigns.pubsub_delay_ms - assigns.delay_step_ms >= assigns.min_delay_ms
26 | )
27 |
28 | {:ok, socket}
29 | end
30 |
31 | @impl true
32 | def render(assigns) do
33 | ~F"""
34 |
35 | Delay
36 |
37 |
61 | """
62 | end
63 |
64 | @impl true
65 | def handle_event("delay-inc", _params, socket) do
66 | delay_ms = socket.assigns.pubsub_delay_ms + socket.assigns.delay_step_ms
67 |
68 | send(self(), {:delay_control_set, delay_ms})
69 | socket = Component.Utility.save_params(socket, %{delay_ms: delay_ms})
70 |
71 | {:noreply, socket}
72 | end
73 |
74 | @impl true
75 | def handle_event("delay-dec", _params, socket) do
76 | delay_ms = socket.assigns.pubsub_delay_ms - socket.assigns.delay_step_ms
77 |
78 | send(self(), {:delay_control_set, delay_ms})
79 | socket = Component.Utility.save_params(socket, %{delay_ms: delay_ms})
80 |
81 | {:noreply, socket}
82 | end
83 | end
84 |
--------------------------------------------------------------------------------
/lib/f1_bot/application.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Application do
2 | @moduledoc false
3 |
4 | use Application
5 | require Logger
6 |
7 | @impl true
8 | def start(_type, _args) do
9 | if F1Bot.demo_mode?() do
10 | Logger.info("[DEMO] Starting in demo mode with url: #{F1Bot.demo_mode_url()}")
11 | end
12 |
13 | start_if_feature_flag_enabled(:start_discord, :nostrum)
14 |
15 | children =
16 | [
17 | {Finch, name: F1Bot.Finch},
18 | {DynamicSupervisor, name: F1Bot.DynamicSupervisor, strategy: :one_for_one},
19 | F1BotWeb.Telemetry,
20 | F1Bot.Repo,
21 | {Phoenix.PubSub, name: F1Bot.PubSub},
22 | F1Bot.DelayedEvents.Supervisor,
23 | F1Bot.Output.Discord,
24 | F1Bot.F1Session.Server,
25 | F1BotWeb.Supervisor,
26 | F1Bot.Replay.Server,
27 | F1Bot.TranscriberService
28 | ]
29 | |> add_if_feature_flag_enabled(:connect_to_signalr, {
30 | F1Bot.ExternalApi.SignalR.Client,
31 | [
32 | scheme: "https",
33 | hostname: "livetiming.formula1.com",
34 | base_path: "/signalr",
35 | user_agent: "",
36 | port: 443,
37 | hub: "Streaming",
38 | topics:
39 | case F1Bot.fetch_env(:signalr_topics) do
40 | {:ok, topics} -> topics
41 | end
42 | ]
43 | })
44 | |> add_if_feature_flag_enabled(:start_discord, F1Bot.ExternalApi.Discord.Commands)
45 | |> add_if_feature_flag_enabled(:auto_reload_session, {
46 | Task,
47 | fn -> F1Bot.reload_session(true) end
48 | })
49 | |> add_if_demo_mode_enabled(F1Bot.Demo.Supervisor)
50 |
51 | # See https://hexdocs.pm/elixir/Supervisor.html
52 | # for other strategies and supported options
53 | opts = [
54 | strategy: :one_for_one,
55 | max_restarts: 1000,
56 | name: F1Bot.Supervisor
57 | ]
58 |
59 | Supervisor.start_link(children, opts)
60 | end
61 |
62 | # Tell Phoenix to update the endpoint configuration
63 | # whenever the application is updated.
64 | @impl true
65 | def config_change(changed, _new, removed) do
66 | F1BotWeb.Endpoint.config_change(changed, removed)
67 | :ok
68 | end
69 |
70 | defp start_if_feature_flag_enabled(feature_flag, application) do
71 | if feature_flag_enabled?(feature_flag) do
72 | {:ok, _} = Application.ensure_all_started(application)
73 | end
74 | end
75 |
76 | defp add_if_feature_flag_enabled(children, feature_flag, child) do
77 | if feature_flag_enabled?(feature_flag) and not F1Bot.demo_mode?() do
78 | children ++ [child]
79 | else
80 | children
81 | end
82 | end
83 |
84 | defp add_if_demo_mode_enabled(children, child) do
85 | if F1Bot.demo_mode?() do
86 | children ++ [child]
87 | else
88 | children
89 | end
90 | end
91 |
92 | defp feature_flag_enabled?(feature_flag) do
93 | F1Bot.get_env(feature_flag, false)
94 | end
95 | end
96 |
--------------------------------------------------------------------------------
/lib/f1_bot/demo/fake_radio_generator.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.Demo.FakeRadioGenerator do
2 | use GenServer
3 |
4 | alias F1Bot.F1Session.Server
5 | alias F1Bot.F1Session.DriverDataRepo.Transcript
6 | alias F1Bot.DataTransform.Format
7 |
8 | def start_link(init_arg) do
9 | GenServer.start_link(__MODULE__, init_arg, name: __MODULE__)
10 | end
11 |
12 | @impl true
13 | def init(_init_arg) do
14 | F1Bot.PubSub.subscribe_to_event("aggregate_stats:fastest_sector")
15 | F1Bot.PubSub.subscribe_to_event("aggregate_stats:fastest_lap")
16 | {:ok, nil}
17 | end
18 |
19 | @impl true
20 | def handle_info(
21 | _e = %{
22 | scope: "aggregate_stats:fastest_sector",
23 | payload: %{
24 | driver_number: driver_number,
25 | type: type,
26 | sector: sector,
27 | sector_time: sector_time
28 | }
29 | },
30 | state
31 | ) do
32 | sector_time = Format.format_lap_time(sector_time, true)
33 |
34 | prefix =
35 | case type do
36 | :personal -> "New PB in sector #{sector}"
37 | :overall -> "Fastest sector #{sector} out of anyone"
38 | end
39 |
40 | msg = "#{prefix}, #{sector_time}"
41 |
42 | # TODO: Get session time
43 | utc_then = DateTime.utc_now()
44 |
45 | transcript = %Transcript{
46 | id: Ecto.UUID.generate(),
47 | driver_number: driver_number,
48 | duration_sec: 5,
49 | utc_date: utc_then,
50 | playhead_utc_date: utc_then,
51 | estimated_real_date: utc_then,
52 | message: msg,
53 | meeting_session_key: 0,
54 | meeting_key: 0
55 | }
56 |
57 | Server.process_transcript(transcript)
58 | Transcript.broadcast_to_channels(transcript)
59 |
60 | {:noreply, state}
61 | end
62 |
63 | @impl true
64 | def handle_info(
65 | _e = %{
66 | scope: "aggregate_stats:fastest_lap",
67 | payload: %{
68 | driver_number: driver_number,
69 | type: type,
70 | lap_time: lap_time
71 | }
72 | },
73 | state
74 | ) do
75 | lap_time = Format.format_lap_time(lap_time, true)
76 |
77 | prefix =
78 | case type do
79 | :personal -> "You just set a new PB"
80 | :overall -> "That's P1, you just set the fastest lap"
81 | end
82 |
83 | msg = "#{prefix}, #{lap_time}"
84 |
85 | # TODO: Get session time
86 | utc_then = DateTime.utc_now()
87 |
88 | transcript = %Transcript{
89 | id: Ecto.UUID.generate(),
90 | driver_number: driver_number,
91 | duration_sec: 5,
92 | utc_date: utc_then,
93 | playhead_utc_date: utc_then,
94 | estimated_real_date: utc_then,
95 | message: msg,
96 | meeting_session_key: 0,
97 | meeting_key: 0
98 | }
99 |
100 | Server.process_transcript(transcript)
101 | Transcript.broadcast_to_channels(transcript)
102 |
103 | {:noreply, state}
104 | end
105 | end
106 |
--------------------------------------------------------------------------------
/lib/f1_bot/external_api/discord/commands/graph.ex:
--------------------------------------------------------------------------------
1 | defmodule F1Bot.ExternalApi.Discord.Commands.Graph do
2 | @moduledoc """
3 | Handles Discord command for creating graphs
4 | """
5 | require Logger
6 | alias Nostrum.Struct.Interaction
7 | alias F1Bot
8 | alias F1Bot.ExternalApi.Discord
9 | alias F1Bot.ExternalApi.Discord.Commands.{Response, OptionValidator}
10 | alias F1Bot.Plotting
11 |
12 | @behaviour Discord.Commands
13 |
14 | @impl Discord.Commands
15 | def handle_interaction(interaction = %Interaction{}, internal_args) do
16 | flags = Map.get(internal_args, :flags, [])
17 |
18 | case parse_interaction_options(interaction) do
19 | {:ok, parsed_opts} ->
20 | flags
21 | |> Response.make_deferred_message()
22 | |> Response.send_interaction_response(interaction)
23 |
24 | do_create_chart(interaction, parsed_opts, internal_args)
25 |
26 | {:error, option_error} ->
27 | flags
28 | |> Response.make_message("Error: #{option_error}")
29 | |> Response.send_interaction_response(interaction)
30 | end
31 | end
32 |
33 | # Silence Dialyzer warnings for bad &Api.create_followup_message/2 types
34 | @dialyzer {:no_fail_call, do_create_chart: 3}
35 | @dialyzer {:no_return, do_create_chart: 3}
36 | defp do_create_chart(interaction, options, internal_args) do
37 | flags = Map.get(internal_args, :flags, [])
38 |
39 | {:ok, info} = F1Bot.session_info()
40 |
41 | chart_response =
42 | case options.metric do
43 | :gap ->
44 | Plotting.plot_gap(options.drivers, style: options.style)
45 |
46 | :lap_time ->
47 | x_axis = if info.type =~ ~r/^(quali|practice)/iu, do: :timestamp, else: :lap
48 | Plotting.plot_lap_times(options.drivers, style: options.style, x_axis: x_axis)
49 | end
50 |
51 | case chart_response do
52 | {:ok, file_path} ->
53 | flags
54 | |> Response.make_followup_message(nil, [file_path])
55 | |> Response.send_followup_response(interaction)
56 |
57 | Plotting.cleanup(file_path)
58 |
59 | {:error, :dataset_empty} ->
60 | flags
61 | |> Response.make_followup_message("Data is not available yet.")
62 | |> Response.send_followup_response(interaction)
63 |
64 | {:error, error} ->
65 | Logger.error("Error generating chart: #{inspect(error)}")
66 |
67 | flags
68 | |> Response.make_followup_message("Something went wrong.")
69 | |> Response.send_followup_response(interaction)
70 | end
71 | end
72 |
73 | defp parse_interaction_options(interaction = %Interaction{}) do
74 | %Interaction{
75 | data: %{
76 | options: options
77 | }
78 | } = interaction
79 |
80 | with {:ok, metric} <- OptionValidator.validate_graph_metric(options, "metric"),
81 | {:ok, drivers} <- OptionValidator.validate_driver_list(options, "drivers"),
82 | {:ok, style} <- OptionValidator.validate_graph_style(options, "style") do
83 | opts = %{
84 | metric: metric,
85 | drivers: drivers,
86 | style: style
87 | }
88 |
89 | {:ok, opts}
90 | end
91 | end
92 | end
93 |
--------------------------------------------------------------------------------
/lib/f1_bot_web.ex:
--------------------------------------------------------------------------------
1 | defmodule F1BotWeb do
2 | @moduledoc """
3 | The entrypoint for defining your web interface, such
4 | as controllers, components, channels, and so on.
5 |
6 | This can be used in your application as:
7 |
8 | use F1BotWeb, :controller
9 | use F1BotWeb, :html
10 |
11 | The definitions below will be executed for every controller,
12 | component, etc, so keep them short and clean, focused
13 | on imports, uses and aliases.
14 |
15 | Do NOT define functions inside the quoted expressions
16 | below. Instead, define additional modules and import
17 | those modules here.
18 | """
19 |
20 | def static_paths, do: ~w(assets fonts images favicon.png robots.txt)
21 |
22 | def controller do
23 | quote do
24 | use Phoenix.Controller,
25 | formats: [:html, :json],
26 | layouts: [html: F1BotWeb.Layouts]
27 |
28 | import Plug.Conn
29 |
30 | unquote(verified_routes())
31 | end
32 | end
33 |
34 | def html do
35 | quote do
36 | use Phoenix.Component
37 |
38 | # Import convenience functions from controllers
39 | import Phoenix.Controller,
40 | only: [get_csrf_token: 0, view_module: 1, view_template: 1]
41 |
42 | # Include general helpers for rendering HTML
43 | unquote(html_helpers())
44 | end
45 | end
46 |
47 | def live_view do
48 | quote do
49 | use Surface.LiveView,
50 | layout: {F1BotWeb.Layouts, :app}
51 |
52 | import F1BotWeb.LiveHelpers
53 |
54 | unquote(html_helpers())
55 | end
56 | end
57 |
58 | def live_component do
59 | quote do
60 | use Surface.LiveComponent
61 |
62 | import F1BotWeb.LiveHelpers
63 |
64 | unquote(html_helpers())
65 | end
66 | end
67 |
68 | def component do
69 | quote do
70 | use Surface.Component
71 |
72 | unquote(html_helpers())
73 | end
74 | end
75 |
76 | def router do
77 | quote do
78 | use Phoenix.Router
79 |
80 | import Plug.Conn
81 | import Phoenix.Controller
82 | import Phoenix.LiveView.Router
83 | end
84 | end
85 |
86 | def channel do
87 | quote do
88 | use Phoenix.Channel
89 | end
90 | end
91 |
92 | defp html_helpers do
93 | quote do
94 | # HTML escaping functionality
95 | import Phoenix.HTML
96 | # Core UI components and translation
97 | import F1BotWeb.Component.CoreComponents
98 | # import SampleAppWeb.Gettext
99 |
100 | # Shortcut for generating JS commands
101 | alias Phoenix.LiveView.JS
102 |
103 | alias F1BotWeb.Component
104 |
105 | # Routes generation with the ~p sigil
106 | unquote(verified_routes())
107 | end
108 | end
109 |
110 | def verified_routes do
111 | quote do
112 | use Phoenix.VerifiedRoutes,
113 | endpoint: F1BotWeb.Endpoint,
114 | router: F1BotWeb.Router,
115 | statics: F1BotWeb.static_paths()
116 | end
117 | end
118 |
119 | @doc """
120 | When used, dispatch to the appropriate controller/view/etc.
121 | """
122 | defmacro __using__(which) when is_atom(which) do
123 | apply(__MODULE__, which, [])
124 | end
125 | end
126 |
--------------------------------------------------------------------------------
38 |
47 |
48 | {(@pubsub_delay_ms / 1000) |> trunc()}s
49 |
50 |
59 |
60 |