jumbotron 0.1.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59e55efb1ece4d237011869ce7416fd4cda99a2e95feb914c21e93a3f23aecaa
-  data.tar.gz: 2199925a6f4a46d2db581c63e2a5eb55b81a26483195a396a4b7c111ae41bee1
+  metadata.gz: 48040072e10a2363780b93b40c36c51e00683c247d616ae4cf8e0b245cca1815
+  data.tar.gz: 56fdebbcc73ab653ebf1293d7bc718bece9c24e035552e10a402d3d0cf4a34a2
 SHA512:
-  metadata.gz: ae7c4b2c06eed8291bafcb279940f0ca45ad5b33a62cc5970a5c1d353eae0c4d8bde4173e62811d13dade3038107940a828f37b2b3e1c1d6a7f2c118f62d5447
-  data.tar.gz: 8ecd32a04d755e5eb0422fccbb98b10beead9f3b88de8f8e885f2b8e4f458af6a672d1bdf9a63040b88e352186cea328565263dff18d001298b1a0cf97389748
+  metadata.gz: 22e5abd65bafd78af1bb38568088c5c7180321e28dc527cd8dec35ea61300d55f789a3e8723d35f3df00ddc3ef3ae7bddd8bbb7e6a4e1aac256eb0665bf24275
+  data.tar.gz: 3deca6bd03bb5f95ddb485306ebd68fb33ced87215df67002a19f84f383ba748182d437d0581fa065043fe44bc60d605f2773af70a85884a596ab44c82a4d9ab

data/app/adapters/jumbotron/adapters/sandbox/nfl.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      class Nfl < Base
+        TERMINAL_LIFECYCLES = %w[completed cancelled].freeze
+        INTERRUPTED_LIFECYCLES = %w[postponed suspended].freeze
+
+        adapter_id "sandbox_nfl"
+
+        provider :sandbox
+        sport "football"
+        league "nfl-sandbox"
+
+        endpoint :scoreboard,
+                 resource: Providers::Sandbox::Resources::Scoreboard,
+                 transformer: NflHelpers::Scoreboard
+        endpoint :projection,
+                 resource: Providers::Sandbox::Resources::Projection,
+                 transformer: NflHelpers::Projection
+
+        policy :far_future,
+               type: :future_game_update,
+               cadence: Cadence.new(every: 1, unit: :week),
+               eligible: lambda { |game, now:|
+                 TERMINAL_LIFECYCLES.exclude?(game.lifecycle) &&
+                   game.scheduled_at > now + 6.weeks
+               }
+
+        policy :near_future,
+               type: :future_game_update,
+               cadence: Cadence.new(every: 1, unit: :day),
+               eligible: lambda { |game, now:|
+                 return false if TERMINAL_LIFECYCLES.include?(game.lifecycle)
+
+                 game.scheduled_at.between?(now + 2.weeks, now + 6.weeks)
+               }
+
+        policy :upcoming,
+               type: :future_game_update,
+               cadence: Cadence.new(every: 1, unit: :hour),
+               eligible: lambda { |game, now:|
+                 return false if TERMINAL_LIFECYCLES.include?(game.lifecycle)
+
+                 game.scheduled_at > now && game.scheduled_at < now + 2.weeks
+               }
+
+        policy :live,
+               type: :live_game_update,
+               cadence: Cadence.new(every: 1, unit: :minute),
+               eligible: lambda { |game, now:|
+                 return false if TERMINAL_LIFECYCLES.include?(game.lifecycle)
+                 return false if INTERRUPTED_LIFECYCLES.include?(game.lifecycle)
+
+                 now >= game.scheduled_at
+               }
+
+        policy :interrupted,
+               type: :interrupted_game_update,
+               cadence: Cadence.new(every: 1, unit: :hour),
+               eligible: ->(game, **) { INTERRUPTED_LIFECYCLES.include?(game.lifecycle) }
+
+        policy :post_final_record,
+               type: :post_final_game_update,
+               cadence: Cadence.new(every: 15, unit: :minute),
+               eligible: lambda { |game, now:|
+                 return false unless game.lifecycle == "completed"
+                 return false if game.changed_at.nil? || game.changed_at < now - 6.hours
+
+                 participants = game.game_participants
+                 participants.present? &&
+                   participants.any? { |participant| participant.record_summary_post_game.blank? }
+               }
+
+        policy :far_future_lines,
+               type: :future_line_update,
+               cadence: Cadence.new(every: 1, unit: :week),
+               eligible: lambda { |game, now:|
+                 TERMINAL_LIFECYCLES.exclude?(game.lifecycle) &&
+                   game.scheduled_at > now + 6.weeks
+               }
+
+        policy :near_future_lines,
+               type: :future_line_update,
+               cadence: Cadence.new(every: 1, unit: :day),
+               eligible: lambda { |game, now:|
+                 return false if TERMINAL_LIFECYCLES.include?(game.lifecycle)
+
+                 game.scheduled_at.between?(now + 2.weeks, now + 6.weeks)
+               }
+
+        policy :upcoming_lines,
+               type: :future_line_update,
+               cadence: Cadence.new(every: 1, unit: :hour),
+               eligible: lambda { |game, now:|
+                 return false if TERMINAL_LIFECYCLES.include?(game.lifecycle)
+
+                 game.scheduled_at > now && game.scheduled_at < now + 2.weeks
+               }
+
+        policy :in_progress_lines,
+               type: :live_line_update,
+               cadence: Cadence.new(every: 1, unit: :hour),
+               eligible: lambda { |game, now:|
+                 game.lifecycle == "in_progress" && now >= game.scheduled_at
+               }
+
+        policy :interrupted_lines,
+               type: :interrupted_line_update,
+               cadence: Cadence.new(every: 1, unit: :hour),
+               eligible: ->(game, **) { INTERRUPTED_LIFECYCLES.include?(game.lifecycle) }
+
+        register!
+
+        def self.acquisition_scope_for(game)
+          NflHelpers::AcquisitionScope.call(game)
+        end
+
+        def self.line_acquisition_scope_for(game)
+          NflHelpers::LineAcquisitionScope.call(game)
+        end
+
+        def self.acquire_line_odds(acquisition)
+          parts = acquisition.to_h.symbolize_keys
+          Providers::Sandbox::Resources::CompetitionOdds.acquire(adapter: self, **parts)
+        end
+
+        def self.translate_line_odds(odds, observed_at:, acquisition:)
+          NflHelpers::CompetitionOdds.call(odds, observed_at: observed_at, acquisition: acquisition)
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/acquisition_scope.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module AcquisitionScope
+          module_function
+
+          def call(game) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            group = game.schedule_group
+            event = identity_for(game, "event")
+            competition = identity_for(game, "competition")
+            home = participant_payload_for(game, "home")
+            away = participant_payload_for(game, "away")
+            return unless valid?(group, event, home, away)
+
+            {
+              endpoint: :scoreboard,
+              acquisition: {
+                game_id: game.id,
+                event_id: event.provider_id,
+                competition_id: competition&.provider_id,
+                scheduled_at: game.scheduled_at.iso8601,
+                season_year: season_identity(game.season.name),
+                season_phase_key: game.season_phase.name,
+                week_number: group.number,
+                home: home,
+                away: away
+              }
+            }
+          rescue ArgumentError, NoMethodError, TypeError
+            nil
+          end
+
+          def season_identity(value)
+            Integer(value, exception: false) || value.to_s
+          end
+          private_class_method :season_identity
+
+          def identity_for(game, namespace)
+            game.provider_identities.find do |identity|
+              identity.provider == "sandbox" && identity.object_namespace == namespace
+            end
+          end
+          private_class_method :identity_for
+
+          def participant_payload_for(game, role) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            participant = game.game_participants.find { |row| row.role == role }
+            return if participant.nil?
+
+            identity = participant.team.provider_identities.find do |candidate|
+              candidate.provider == "espn" && candidate.object_namespace == "team"
+            end
+            return if identity.nil?
+
+            {
+              provider_id: identity.provider_id,
+              name: participant.team.name,
+              nickname: participant.team.nickname,
+              abbreviation: participant.team.abbreviation
+            }
+          end
+          private_class_method :participant_payload_for
+
+          def valid?(group, event, home, away)
+            group&.kind == "week" && group.number.present? && event.present? && home.present? && away.present?
+          end
+          private_class_method :valid?
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/competition_odds.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        class CompetitionOdds
+          BOOKMAKER_ID = "synthetic-consensus"
+          BOOKMAKER_NAME = "Sandbox Sportsbook"
+
+          def self.call(payload, observed_at:, acquisition:) # rubocop:disable Metrics/MethodLength
+            event_id, competition_id = identity_values(payload, acquisition)
+            values = payload.symbolize_keys.reverse_merge(acquisition.symbolize_keys)
+
+            Canonical::LineIngestInput.new(
+              observed_at: observed_at,
+              provider: "sandbox",
+              adapter_scope: "sandbox_nfl",
+              game_identities: game_identities(event_id, competition_id),
+              observations: observations(
+                home_spread: BigDecimal(values.fetch(:home_spread).to_s),
+                total: BigDecimal(values.fetch(:total).to_s)
+              )
+            )
+          rescue ArgumentError, KeyError => e
+            raise TransformError, "invalid sandbox line observation: #{e.message}"
+          end
+
+          def self.identity_values(payload, acquisition)
+            data = payload.symbolize_keys
+            scope = acquisition.symbolize_keys
+            event_id = data[:event_id].presence || scope.fetch(:event_id)
+            [event_id, data[:competition_id].presence || scope[:competition_id] || event_id]
+          end
+          private_class_method :identity_values
+
+          def self.game_identities(event_id, competition_id)
+            [
+              Canonical::ProviderIdentityRef.new(provider: "sandbox", namespace: "event", id: event_id.to_s),
+              Canonical::ProviderIdentityRef.new(
+                provider: "sandbox",
+                namespace: "competition",
+                id: competition_id.to_s
+              )
+            ]
+          end
+          private_class_method :game_identities
+
+          def self.observations(home_spread:, total:) # rubocop:disable Metrics/MethodLength
+            identity = Canonical::ProviderIdentityRef.new(
+              provider: "sandbox",
+              namespace: "bookmaker",
+              id: BOOKMAKER_ID
+            )
+            [
+              line(identity, "spread", "home", home_spread),
+              line(identity, "spread", "away", -home_spread),
+              line(identity, "total", "over", total),
+              line(identity, "total", "under", total)
+            ]
+          end
+          private_class_method :observations
+
+          def self.line(identity, market, outcome, value)
+            Canonical::LineObservationInput.new(
+              bookmaker_identity: identity,
+              bookmaker_name: BOOKMAKER_NAME,
+              market: market,
+              outcome: outcome,
+              source: "observed",
+              line_value: BigDecimal(value.to_s),
+              price_american: -110
+            )
+          end
+          private_class_method :line
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/current_observation_state.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module CurrentObservationState
+          module_function
+
+          def call(game)
+            SyntheticObservation::Current.new(
+              lifecycle: game.lifecycle,
+              progress: progress(game),
+              home_score: participant(game, "home").score,
+              away_score: participant(game, "away").score
+            )
+          end
+
+          def participant(game, role)
+            game.game_participants.find { |row| row.role == role } ||
+              raise(ArgumentError, "sandbox game requires #{role} participant")
+          end
+          private_class_method :participant
+
+          def progress(game)
+            return if game.progress_state.nil?
+
+            Jumbotron::Canonical::GameProgress.new(
+              state: game.progress_state,
+              segment: Jumbotron::Canonical::GameSegment.new(
+                kind: game.progress_segment_kind,
+                number: game.progress_segment_number
+              ),
+              clock: clock(game)
+            )
+          end
+          private_class_method :progress
+
+          def clock(game)
+            return if game.progress_clock_mode.nil?
+
+            Jumbotron::Canonical::GameClock.new(
+              mode: game.progress_clock_mode,
+              seconds: game.progress_clock_seconds,
+              display: game.progress_clock_display
+            )
+          end
+          private_class_method :clock
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/line_acquisition_scope.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module LineAcquisitionScope
+          module_function
+
+          def call(game) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+            identities = game.provider_identities.index_by(&:object_namespace)
+            event = identities["event"]
+            mapping = game.sandbox_game_mapping
+            return if event.nil? || event.provider != "sandbox" || event.provider_id.blank? || mapping.nil?
+
+            {
+              endpoint: :competition_odds,
+              acquisition: {
+                event_id: event.provider_id,
+                competition_id: identities["competition"]&.provider_id || event.provider_id,
+                home_spread: mapping.home_spread.to_s,
+                total: mapping.total.to_s
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/monotonic_observation.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module MonotonicObservation
+          ACTIVE_ORDINALS = { 1 => 1, 2 => 2, 3 => 4, 4 => 5 }.freeze
+
+          module_function
+
+          def call(proposed:, current:, plan:)
+            validate_current_scores!(current, plan)
+            proposed_ordinal = ordinal(proposed.lifecycle, proposed.progress)
+            current_ordinal = ordinal(current.lifecycle, current.progress)
+            state = select_state(proposed, current, proposed_ordinal, current_ordinal)
+            build_observation(state, proposed, current, plan)
+          end
+
+          def select_state(proposed, current, proposed_ordinal, current_ordinal)
+            return current if current_ordinal > proposed_ordinal
+            return proposed unless current_ordinal == proposed_ordinal
+            return proposed unless active_progress?(proposed.progress) && active_progress?(current.progress)
+
+            proposed.with(progress: clamp_clock(proposed.progress, current.progress))
+          end
+          private_class_method :select_state
+
+          def build_observation(state, proposed, current, plan)
+            return completed_observation(plan) if state.lifecycle == "completed"
+            return state if state.lifecycle == "scheduled"
+
+            ObservationValues.observation(
+              lifecycle: state.lifecycle,
+              progress: state.progress,
+              home_score: [proposed.home_score || 0, current.home_score || 0].max,
+              away_score: [proposed.away_score || 0, current.away_score || 0].max
+            )
+          end
+          private_class_method :build_observation
+
+          def completed_observation(plan)
+            home_result, away_result = ObservationValues.results(plan.home_score, plan.away_score)
+            ObservationValues.observation(
+              lifecycle: "completed",
+              progress: nil,
+              home_score: plan.home_score,
+              away_score: plan.away_score,
+              home_result: home_result,
+              away_result: away_result
+            )
+          end
+          private_class_method :completed_observation
+
+          def active_progress?(progress)
+            progress&.state == "active"
+          end
+          private_class_method :active_progress?
+
+          def clamp_clock(proposed, current)
+            proposed_seconds = proposed.clock&.seconds
+            current_seconds = current.clock&.seconds
+            return proposed if proposed_seconds.nil? || current_seconds.nil? || proposed_seconds <= current_seconds
+
+            proposed.with(clock: current.clock)
+          end
+          private_class_method :clamp_clock
+
+          def ordinal(lifecycle, progress)
+            return 0 if lifecycle == "scheduled"
+            return 6 if lifecycle == "completed"
+
+            validate_in_progress!(lifecycle, progress)
+            return 3 if progress.state == "intermission" && progress.segment.number == 2
+
+            active_ordinal(progress)
+          end
+          private_class_method :ordinal
+
+          def validate_in_progress!(lifecycle, progress)
+            raise ArgumentError, "unsupported sandbox lifecycle #{lifecycle.inspect}" unless lifecycle == "in_progress"
+            return if %w[active intermission].include?(progress&.state)
+
+            raise ArgumentError, "in-progress sandbox game requires canonical progress"
+          end
+          private_class_method :validate_in_progress!
+
+          def active_ordinal(progress)
+            return ACTIVE_ORDINALS.fetch(progress.segment.number) if progress.state == "active"
+
+            raise ArgumentError, "sandbox intermission must follow quarter two"
+          rescue KeyError
+            raise ArgumentError, "sandbox game requires quarter progress from 1 through 4"
+          end
+          private_class_method :active_ordinal
+
+          def validate_current_scores!(current, plan)
+            return if valid_score?(current.home_score, plan.home_score) &&
+                      valid_score?(current.away_score, plan.away_score)
+
+            raise ArgumentError, "persisted sandbox score exceeds selected final"
+          end
+          private_class_method :validate_current_scores!
+
+          def valid_score?(score, final_score)
+            score.nil? || score <= final_score
+          end
+          private_class_method :valid_score?
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/observation_values.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module ObservationValues
+          module_function
+
+          def observation(**attributes)
+            defaults = {
+              progress: nil,
+              home_score: nil,
+              away_score: nil,
+              home_result: nil,
+              away_result: nil
+            }
+            SyntheticObservation::Observation.new(**defaults, **attributes)
+          end
+
+          def progress(state:, quarter:, clock: nil)
+            Canonical::GameProgress.new(
+              state: state,
+              segment: Canonical::GameSegment.new(kind: "quarter", number: quarter),
+              clock: clock
+            )
+          end
+
+          def clock(local_seconds:, quarter_seconds:, game_clock_seconds:)
+            elapsed = ((local_seconds / quarter_seconds.to_f) * game_clock_seconds).floor
+            remaining = [game_clock_seconds - elapsed, 0].max
+            Canonical::GameClock.new(
+              mode: "remaining",
+              seconds: remaining,
+              display: format("%<minutes>d:%<seconds>02d", minutes: remaining / 60, seconds: remaining % 60)
+            )
+          end
+
+          def score_at(final_score, fraction)
+            (final_score * fraction).floor
+          end
+
+          def results(home_score, away_score)
+            return %w[win loss] if home_score > away_score
+            return %w[loss win] if away_score > home_score
+
+            %w[tie tie]
+          end
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/outcome_candidates.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module OutcomeCandidates
+          Outcome = Data.define(:home_score, :away_score)
+          SCORE_OFFSETS = [[0, 0], [3, 0], [0, 3], [-3, 0], [0, -3]].freeze
+
+          module_function
+
+          def call(home_spread:, total:)
+            spread_value = BigDecimal(home_spread.to_s)
+            total_value = BigDecimal(total.to_s)
+            home = ((total_value - spread_value) / 2).round
+            away = ((total_value + spread_value) / 2).round
+
+            SCORE_OFFSETS.filter_map do |home_offset, away_offset|
+              candidate(home + home_offset, away + away_offset)
+            end.uniq
+          rescue ArgumentError, TypeError
+            []
+          end
+
+          def candidate(home_score, away_score)
+            return if home_score.negative? || away_score.negative? || home_score == away_score
+
+            Outcome.new(home_score: home_score, away_score: away_score)
+          end
+          private_class_method :candidate
+        end
+      end
+    end
+  end
+end

data/app/adapters/jumbotron/adapters/sandbox/nfl_helpers/projection.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Jumbotron
+  module Adapters
+    module Sandbox
+      module NflHelpers
+        module Projection
+          module_function
+
+          def call(payload, observed_at:)
+            data = payload.symbolize_keys
+            Canonical::SyncInput.new(
+              observed_at: observed_at,
+              games: [game_input(data)],
+              teams: []
+            )
+          rescue ArgumentError, KeyError, TypeError => e
+            raise TransformError, "invalid sandbox projection: #{e.message}"
+          end
+
+          def game_input(data) # rubocop:disable Metrics/MethodLength
+            Canonical::GameInput.new(
+              provider_identities: game_identities(data),
+              scheduled_at: Time.iso8601(data.fetch(:scheduled_at).to_s),
+              lifecycle: "scheduled",
+              neutral_site: data.fetch(:neutral_site, false),
+              season_year: data.fetch(:season),
+              season_phase_key: data.fetch(:season_phase),
+              schedule_group: schedule_group(data),
+              venue: nil,
+              participants: %i[home away].map { |role| participant(data.fetch(role), role) },
+              progress: nil
+            )
+          end
+          private_class_method :game_input
+
+          def game_identities(data)
+            event_id = data.fetch(:event_id).to_s
+            competition_id = data.fetch(:competition_id, event_id).to_s
+            [
+              Canonical::ProviderIdentityRef.new(provider: "sandbox", namespace: "event", id: event_id),
+              Canonical::ProviderIdentityRef.new(
+                provider: "sandbox",
+                namespace: "competition",
+                id: competition_id
+              )
+            ].uniq
+          end
+          private_class_method :game_identities
+
+          def schedule_group(data)
+            number = Integer(data.fetch(:week_number))
+            Canonical::ScheduleGroupInput.new(
+              kind: "week",
+              number: number,
+              name: data.fetch(:week_name).to_s
+            )
+          end
+          private_class_method :schedule_group
+
+          def participant(raw, role) # rubocop:disable Metrics/MethodLength
+            data = raw.symbolize_keys
+            Canonical::ParticipantInput.new(
+              provider_identities: [
+                Canonical::ProviderIdentityRef.new(
+                  provider: "espn",
+                  namespace: "team",
+                  id: data.fetch(:provider_id).to_s
+                )
+              ],
+              team_name: data.fetch(:name).to_s,
+              team_nickname: data[:nickname].presence,
+              team_abbreviation: data[:abbreviation].presence,
+              role: role.to_s,
+              score: nil,
+              result: nil,
+              record_summary: nil
+            )
+          end
+          private_class_method :participant
+        end
+      end
+    end
+  end
+end