jumbotron 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02e887f5ad4260dddda6dde8d391430ffbad31b7b7069dd851e9560cd6f92540
-  data.tar.gz: 1a18545151d81f504bc9bf208316ff2b1cf68086f062cf590d0953f9ca28e546
+  metadata.gz: 727d9ee2cecff54934b335484762a677ebfa7ee2bfe4a7f7dc408e04b0f7f6b0
+  data.tar.gz: 3c16c45a725c58a7fc654172819752a9c4e69fd06f554353f51c8e127feb7eca
 SHA512:
-  metadata.gz: c20c23af5c011df7a9ea866a1923e37abf79b3eea2dfe82e47b561051f3ba6bc43dfb519def7288007e71c7a801020e9d5b32f3d2a76be82c6b85061c2f9bbe1
-  data.tar.gz: 5414a02d268f32a257752bc29e47b959c46a0dc9b6d680da58c789ff22bd6d76a56a4c264a0068bc32f91aef79a40827b4568a731807dedfcf975966a452d63c
+  metadata.gz: c7334f554705bccc4937c73975a77defce7bf08f0aeb23d984652eaa05cc4e43ddcecb0d1f3414a25f0e970f0dc34573e0adbbfdbc489252aeee6156b2e69a78
+  data.tar.gz: a02bd5b23d138019d874124ac178652a8a8a936e238a1d1d9f2d54939903d03ea26accda1e72c90ba6899652f0fe41c73fd9593377b8b01ed0a8ef9889fb3654

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

@@ -66,6 +66,21 @@ module Jumbotron
                  INTERRUPTED_LIFECYCLES.include?(game.lifecycle)
                }
 
+        # Bounded post-final scoreboard re-observation when post-game record is still
+        # missing (Strategy B). Stops after window or once post_game is persisted.
+        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
+                 return false if participants.empty?
+
+                 participants.any? { |participant| participant.record_summary_post_game.blank? }
+               }
+
         policy :far_future_lines,
                type: :future_line_update,
                cadence: Cadence.new(every: 1, unit: :week),

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/scoreboard.rb

@@ -80,11 +80,14 @@ module Jumbotron
             raise TransformError, "venue id required" if venue.id.blank?
             raise TransformError, "venue name required" if venue.full_name.blank?
 
+            address = venue.respond_to?(:address) ? venue.address : nil
             Canonical::VenueInput.new(
               provider_identities: [
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "venue", id: venue.id.to_s)
               ],
-              name: venue.full_name.to_s
+              name: venue.full_name.to_s,
+              city: address&.city.presence,
+              region: address&.state.presence
             )
           end
           private_class_method :transform_venue
@@ -104,13 +107,22 @@ module Jumbotron
               ],
               team_name: name.to_s,
               team_nickname: TeamNickname.resolve(team),
+              team_abbreviation: team.abbreviation.presence,
               role: competitor.home_away.to_s,
               score: coerce_score(competitor.score),
-              result: coerce_result(competitor.winner, lifecycle)
+              result: coerce_result(competitor.winner, lifecycle),
+              record_summary: total_record_summary(competitor)
             )
           end
           private_class_method :transform_participant
 
+          def self.total_record_summary(competitor)
+            records = competitor.respond_to?(:records) ? Array(competitor.records) : []
+            total = records.find { |record| record.type.to_s == "total" }
+            total&.summary.presence
+          end
+          private_class_method :total_record_summary
+
           def self.coerce_score(raw)
             return nil if raw.nil? || raw == ""
 

data/app/adapters/jumbotron/adapters/espn/nfl_helpers/teams.rb

@@ -25,7 +25,8 @@ module Jumbotron
                 Canonical::ProviderIdentityRef.new(provider: "espn", namespace: "team", id: team.id.to_s)
               ],
               name: name.to_s,
-              nickname: TeamNickname.resolve(team)
+              nickname: TeamNickname.resolve(team),
+              abbreviation: team.abbreviation.presence
             )
           end
           private_class_method :transform_team

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