sportradar-api 0.10.7 → 0.11.1

data/lib/sportradar/api/baseball/game.rb

@@ -0,0 +1,472 @@
+module Sportradar
+  module Api
+    module Baseball
+      class Game < Data
+        attr_accessor :response, :id, :title, :home_id, :away_id, :score, :status, :coverage, :scheduled, :venue, :broadcast, :duration, :attendance, :team_stats, :player_stats, :changes, :lineup
+
+        attr_reader :inning, :half, :outs, :bases, :pitchers, :final, :rescheduled, :inning_over
+        attr_reader :outcome, :count
+        DEFAULT_BASES = { '1' => nil, '2' => nil, '3' => nil }
+
+        def initialize(data, **opts)
+          @response = data
+          @api      = opts[:api]
+          # @season   = opts[:season]
+          @updates  = {}
+          @changes  = {}
+
+          @score          = {}
+          @team_stats     = {}
+          @player_stats   = {}
+          @scoring_raw    = Scoring.new(data, game: self)
+          @lineup         = Lineup.new(data, game: self)
+          @teams_hash     = {}
+          @innings_hash   = {}
+          @home_runs      = nil
+          @away_runs      = nil
+          @home_id        = nil
+          @away_id        = nil
+          @outcome        = Outcome.new(data, game: self)
+          @count          = {}
+          @pitchers       = {}
+          @bases          = { '1' => nil, '2' => nil, '3' => nil }
+
+          @id = data['id']
+
+          update(data, **opts)
+        end
+        def lineup
+          @lineup ||= Lineup.new({}, game: self)
+        end
+
+        def timeouts
+          {}
+        end
+
+        def tied?
+          @score[away_id].to_i == @score[home_id].to_i
+        end
+        # def runs(team_id)
+        #   summary_stat(team_id, 'runs')
+        # end
+        def hits(team_id)
+          @scoring_raw.hits(team_id)
+        end
+        def errors(team_id)
+          @scoring_raw.errors(team_id)
+        end
+        def runs(team_id)
+          team_id.is_a?(Symbol) ? @score[@team_ids[team_id]] : @score[team_id]
+        end
+        def summary_stat(team_id, stat_name)
+          scoring.dig(team_id, stat_name)
+        end
+        def stats(team_id)
+          team_id.is_a?(Symbol) ? @team_stats[@team_ids[team_id]].to_i : @team_stats[team_id].to_i
+        end
+
+        def scoring
+          @scoring_raw.scores
+        end
+        def update_score(score)
+          @score.merge!(score)
+        end
+        def update_stats(team, stats)
+          @team_stats.merge!(team.id => stats.merge!(team: team))
+        end
+        def update_player_stats(player, stats)
+          @player_stats.merge!(player.id => stats.merge!(player: player))
+        end
+
+        def parse_score(data)
+          home_id = data.dig('home', 'id')
+          away_id = data.dig('away', 'id')
+          rhe = {
+            'runs'    => { home_id => data.dig('home', 'runs'), away_id => data.dig('away', 'runs')},
+            'hits'    => { home_id => data.dig('home', 'hits'), away_id => data.dig('away', 'hits')},
+            'errors'  => { home_id => data.dig('home', 'errors'), away_id => data.dig('away', 'errors')},
+          }
+          @scoring_raw.update(rhe, source: :rhe)
+          update_score(home_id => data.dig('home', 'runs'))
+          update_score(away_id => data.dig('away', 'runs'))
+        end
+
+        def parse_pitchers(data)
+          pitchers = {
+            'starting'  => { home_id => data.dig('home', 'starting_pitcher'), away_id => data.dig('away', 'starting_pitcher')},
+            'probable'  => { home_id => data.dig('home', 'probable_pitcher'), away_id => data.dig('away', 'probable_pitcher')},
+            'current'   => { home_id => data.dig('home', 'current_pitcher'),  away_id => data.dig('away', 'current_pitcher')},
+          }
+          @pitchers.merge!(pitchers) do |key, current_val, merge_val|
+            current_val.merge(merge_val) { |k, cur, mer| (mer || cur) }
+          end
+        end
+
+        def update(data, source: nil, **opts)
+          # via pbp
+          @status       = data['status']                if data['status']
+          @coverage     = data['coverage']              if data['coverage']
+          @day_night    = data['day_night']             if data['day_night']
+          @game_number  = data['game_number']           if data['game_number']
+          @home_id      = data['home_team'] || data.dig('home', 'id')   if data['home_team'] || data.dig('home', 'id')
+          @away_id      = data['away_team'] || data.dig('away', 'id')   if data['away_team'] || data.dig('away', 'id')
+          # @home_runs    = data['home_runs'].to_i      if data['home_runs']
+          # @away_runs    = data['away_runs'].to_i      if data['away_runs']
+
+          @scheduled    = Time.parse(data["scheduled"]) if data["scheduled"]
+          @venue        = Venue.new(data['venue']) if data['venue']
+          @broadcast    = Broadcast.new(data['broadcast']) if !data['broadcast'].to_h.empty?
+          @home         = Team.new(data['home'], api: api, game: self) if data['home']
+          @away         = Team.new(data['away'], api: api, game: self) if data['away']
+          @title        = data['title'] || @title || (home && away && "#{home.full_name} vs #{away.full_name}")
+
+          @duration     = data['duration']              if data['duration']
+          @attendance   = data['attendance']            if data['attendance']
+
+          @final        = data['final']                 if data['final']
+          @rescheduled  = data['rescheduled']           if data['rescheduled']
+
+          @team_ids     = { home: @home_id, away: @away_id}
+
+          update_bases(data)
+          parse_pitchers(data) if data['home'] && data['away']
+
+          lineup.update(data, source: source)
+          if data['scoring']
+            parse_score(data['scoring'])
+          elsif data.dig('home', 'hits')
+            parse_score(data)
+          end
+          @scoring_raw.update(data, source: source)
+          if data['outcome']
+            @outcome.update(data, source: nil)
+            @count.merge!(@outcome.count || {})
+          end
+          create_data(@teams_hash, data['team'], klass: Team, api: api, game: self) if data['team']
+        end
+
+        # def update_from_team(id, data)
+        # end
+
+        def update_bases(data)
+          if data.is_a?(Sportradar::Api::Baseball::Error)
+            puts data.inspect
+            return
+          end
+          @bases = if data.respond_to?(:runners)
+            hash = Array(data.runners).map { |runner| [runner.ending_base.to_s, runner.id] if !runner.out }.compact.to_h
+            DEFAULT_BASES.merge(hash)
+          elsif (runners = data.dig('outcome', 'runners'))
+            hash = runners.map { |runner| [runner['ending_base'].to_s, runner['id']] if !runner['out'] }.compact.to_h
+            DEFAULT_BASES.merge(hash)
+          else # probably new inning, no runners
+            DEFAULT_BASES.dup
+          end
+        rescue => e
+          puts data.inspect
+          raise e
+        end
+        def advance_inning
+          @inning_over = false
+          return unless count['outs'] == 3
+          if count['inning'] >= 9
+            if count['inning_half'] == 'T' && leading_team_id == home.id
+              return
+            elsif count['inning_half'] == 'B' && !tied?
+              return
+            end
+          end
+          @inning_over = true
+          @bases = DEFAULT_BASES.dup
+          half, inn = if count['inning_half'] == 'B'
+            ['T', count['inning'] += 1]
+          elsif count['inning_half'] == 'T'
+            ['B', count['inning']]
+          else
+            [nil, 1]
+          end
+          @count = {
+            'balls'       => 0,
+            'strikes'     => 0,
+            'outs'        => 0,
+            'inning'      => inn,
+            'inning_half' => half,
+          }
+        end
+
+        def extract_count(data) # extract from pbp
+          recent_pitches = pitches.last(10)
+          last_pitch = recent_pitches.reverse_each.detect(&:count)
+          return unless last_pitch
+          update_bases(last_pitch)
+          @count.merge!(last_pitch.count)
+          hi = last_pitch.at_bat.event.half_inning
+          @count.merge!('inning' => hi.number.to_i, 'inning_half' => hi.half)
+          advance_inning
+        end
+
+        def home
+          @teams_hash[@home_id] || @home
+        end
+
+        def away
+          @teams_hash[@away_id] || @away
+        end
+
+        def leading_team_id
+          return nil if tied?
+          score.max_by(&:last).first
+        end
+
+        def leading_team
+          @teams_hash[leading_team_id] || (@away_id == leading_team_id && away) || (@home_id == leading_team_id && home)
+        end
+
+        def team(team_id)
+          @teams_hash[team_id]
+        end
+
+        def assign_home(team)
+          @home_id = team.id
+          @teams_hash[team.id] = team
+        end
+
+        def assign_away(team)
+          @away_id = team.id
+          @teams_hash[team.id] = team
+        end
+
+        def box
+          @box ||= get_box
+        end
+
+        def pbp
+          if !future? && innings.empty?
+            get_pbp
+          end
+          @pbp ||= innings
+        end
+
+        def events
+          innings.flat_map(&:events)
+        end
+
+        def at_bats
+          events.map(&:at_bat).compact
+        end
+
+        def pitches
+          at_bats.flat_map(&:pitches)
+        end
+
+        def summary
+          @summary ||= get_summary
+        end
+
+        def innings
+          @innings_hash.values
+        end
+        def half_innings
+          innings.flat_map(&:half_innings)
+        end
+
+        # tracking updates
+        def remember(key, object)
+          @updates[key] = object&.dup
+        end
+
+        def not_updated?(key, object)
+          @updates[key] == object
+        end
+
+        def changed?(key)
+          @changes[key]
+        end
+
+        def check_newness(key, new_object)
+          @changes[key] = !not_updated?(key, new_object)
+          remember(key, new_object)
+        end
+
+        # status helpers
+
+        def realtime_state
+          if future?
+            'Scheduled'
+          elsif delayed?
+            'Delayed'
+          elsif finished?
+            'Final'
+          elsif postponed?
+            'Postponed'
+          else
+            inning_abbr
+          end
+        end
+
+        def inning_abbr
+          if !count.empty?
+            inning_half = self.count['inning_half']
+            inning = self.count['inning']
+            "#{(inning_half == 'B' ? 'Bottom' : 'Top')} #{(inning || 1).ordinalize}"
+          end
+        end
+
+        def postponed?
+          'postponed' == status
+        end
+
+        def unnecessary?
+          'unnecessary' == status
+        end
+
+        def cancelled?
+          ['unnecessary', 'postponed'].include? status
+        end
+
+        def delayed?
+          ['wdelay', 'delayed'].include? status
+        end
+
+        def future?
+          ['scheduled', 'delayed', 'created', 'time-tbd'].include? status
+        end
+
+        def started?
+          ['inprogress', 'wdelay', 'delayed'].include? status
+        end
+
+        def finished?
+          ['complete', 'closed'].include? status
+        end
+
+        def completed?
+          'complete' == status
+        end
+
+        def closed?
+          'closed' == status
+        end
+
+        # url path helpers
+        def path_base
+          "games/#{ id }"
+        end
+
+        def path_box
+          "#{ path_base }/boxscore"
+        end
+
+        def path_pbp
+          "#{ path_base }/pbp"
+        end
+
+        def path_summary
+          "#{ path_base }/summary"
+        end
+
+        # data retrieval
+
+        def get_box
+          data = api.get_data(path_box)
+          ingest_box(data)
+        end
+
+        def ingest_box(data)
+          data = data['game']
+          update(data, source: :box)
+          check_newness(:box, @clock)
+          data
+        end
+
+        def queue_pbp
+          url, headers, options, timeout = api.get_request_info(path_pbp)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_pbp)}
+        end
+
+        def get_pbp
+          data = api.get_data(path_pbp);
+          ingest_pbp(data)
+        end
+
+        def ingest_pbp(data)
+          data = data['game']
+          update(data, source: :pbp)
+          innings = data['innings'].each { |inning| inning['id'] = "#{data['id']}-#{inning['number']}" }
+          create_data(@innings_hash, innings, klass: Inning, api: api, game: self) if data['innings']
+          extract_count(data)
+          check_newness(:pitches, pitches.last&.id)
+          check_newness(:events, events.last&.description)
+          check_newness(:score, @score)
+          @pbp = @innings_hash.values
+          data
+        # rescue => e
+        #   binding.pry
+        end
+
+        def get_summary
+          data = api.get_data(path_summary)
+          ingest_summary(data)
+        end
+
+        def queue_summary
+          url, headers, options, timeout = api.get_request_info(path_summary)
+          {url: url, headers: headers, params: options, timeout: timeout, callback: method(:ingest_summary)}
+        end
+
+        def ingest_summary(data)
+          data = data['game']
+          update(data, source: :summary)
+          @inning = data.delete('inning').to_i
+          check_newness(:box, @clock)
+          check_newness(:score, @score)
+          data
+        end
+
+        def set_pbp(data)
+          create_data(@innings_hash, data, klass: inning_class, api: api, game: self)
+          @innings_hash
+        end
+
+        def api
+          @api || Sportradar::Api::Baseball::Mlb.new
+        end
+
+        def sim!
+          @api = api.sim!
+          self
+        end
+
+      end
+    end
+  end
+end
+
+__END__
+
+# mlb = Sportradar::Api::Baseball::Mlb::Hierarchy.new
+# res = mlb.get_schedule;
+# g = mlb.games.first
+# g = Sportradar::Api::Baseball::Game.new('id' => "8cd71519-429f-4461-88a2-8a0e134eb89b")
+g = Sportradar::Api::Baseball::Game.new('id' => "9d0fe41c-4e6b-4433-b376-2d09ed39d184");
+g = Sportradar::Api::Baseball::Game.new('id' => "fe9f37fd-6848-4a32-a999-9655044b7319");
+res = g.get_pbp;
+res = g.get_summary;
+res = g.get_box # probably not as useful as summary
+
+
+mlb = Sportradar::Api::Baseball::Mlb::Hierarchy.new
+res = mlb.get_daily_summary;
+g = mlb.games[8];
+g.count
+g.get_pbp;
+g.count
+
+# mlb = Sportradar::Api::Baseball::Mlb::Hierarchy.new;
+# res = mlb.get_daily_summary;
+# g = mlb.games.sort_by(&:scheduled).first;
+g = Sportradar::Api::Baseball::Game.new('id' => "8731b56d-9037-44d1-b890-fa496e94dc10");
+res = g.get_pbp;
+res = g.get_summary;
+g.pitchers
+

data/lib/sportradar/api/baseball/half_inning.rb

@@ -0,0 +1,69 @@
+module Sportradar
+  module Api
+    module Baseball
+      class HalfInning < Data
+        attr_accessor :response, :id, :inning, :type, :half, :number
+
+        def initialize(data, **opts)
+          @response = data
+          @api      = opts[:api]
+          @inning   = opts[:inning]
+          @id       = data["id"]
+          *@inning_id, @number, @half = data['id'].split('-')
+
+          @events_hash = {}
+
+          update(data)
+
+        end
+
+        def update(data, **opts)
+          @half     = data['half']
+          @events   = data['events'].map{ |hash| Event.new(hash, half_inning: self) }
+          # create_data(@events_hash, data['events'], klass: Event, api: @api, half_inning: self)
+        end
+
+        def over?
+          pitches.last&.count&.dig('outs') == 3
+        end
+
+        def pitches
+          at_bats.flat_map(&:pitches)
+        end
+
+        def at_bats
+          events.map(&:at_bat).compact
+        end
+
+        def lineup_changes
+          # events_by_klass(LineupChange)
+        end
+
+        def events
+          # @events_hash.values
+          @events
+        end
+
+        def hits
+          at_bats.flat_map(&:pitches).select {|pitch| pitch.is_hit }
+        end
+
+        def hit_count
+          hits.count
+        end
+
+        def errors
+          at_bats.flat_map(&:pitches).flat_map(&:errors).compact
+        end
+
+        def error_count
+          errors.count
+        end
+        # private def events_by_klass(klass)
+        #   @events_hash.each_value.grep(klass)
+        # end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/baseball/inning.rb

@@ -0,0 +1,42 @@
+module Sportradar
+  module Api
+    module Baseball
+      class Inning < Data
+        attr_accessor :response, :id, :game, :number, :sequence, :scoring
+
+        def initialize(data, **opts)
+          @response = data
+          @api      = opts[:api]
+          @game     = opts[:game]
+
+          @id       = data["id"]
+          @number   = data['number']
+          @sequence = data['sequence']
+
+          parse_scoring(data['scoring']) if data['scoring']
+
+          @half_innings_hash = {}
+
+          update(data)
+        end
+        def update(data, **opts)
+          # update scoring
+          halfs = data['halfs'].each { |inning| inning['id'] = "#{data['id']}-#{inning['half']}" }
+          create_data(@half_innings_hash, halfs, klass: HalfInning, api: @api, inning: self)
+        end
+        def parse_scoring(data)
+          @scoring = data.each_with_object({}) { |(_, data), hash| hash[data['id']] = data['runs'].to_s } # from PBP
+        end
+
+        def half_innings
+          @half_innings_hash.values
+        end
+
+        def events
+          half_innings.flat_map(&:events)
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/baseball/lineup.rb

@@ -0,0 +1,116 @@
+module Sportradar
+  module Api
+    module Baseball
+      class Lineup < Data
+        attr_reader :roster, :home, :away, :game
+        def initialize(data, game: nil)
+          @game = game
+        end
+
+        def update(data, source: nil)
+          case source
+          when :pbp
+          when :summary
+            @roster = (data.dig('home', 'roster') || []) + (data.dig('away', 'roster') || [])
+            return unless data.dig('home', 'lineup') && data.dig('away', 'lineup')
+            @home_team_lineup = data.dig('home', 'lineup')
+            @away_team_lineup = data.dig('away', 'lineup')
+            initialize_home
+            initialize_away
+          end
+        end
+
+        def update_from_lineup_event(data)
+          if data.dig('lineup', 'team_id') == game.home_id
+            update_home(find_player(data.dig('lineup', 'player_id')), data.dig('lineup', 'order'))
+          elsif data.dig('lineup', 'team_id') == game.away_id
+            update_away(find_player(data.dig('lineup', 'player_id')), data.dig('lineup', 'order'))
+          end
+        end
+
+        def update_home(player, order)
+          return if order == 0
+          idx = home.index do |h|
+            h['order'] == order
+          end
+          home[idx] = { 'order' => order }
+          home[idx].merge!(player)
+        end
+
+        def update_away(player, order)
+          return if order == 0
+          idx = away.index do |h|
+            h['order'] == order
+          end
+          away[idx] = { 'order' => order}
+          away[idx].merge!(player)
+        end
+
+        def find_player(id)
+          roster.detect do |player|
+            player['id'] == id
+          end
+        end
+
+        def initial_lineup
+          [
+            { 'order' => 1 },
+            { 'order' => 2 },
+            { 'order' => 3 },
+            { 'order' => 4 },
+            { 'order' => 5 },
+            { 'order' => 6 },
+            { 'order' => 7 },
+            { 'order' => 8 },
+            { 'order' => 9 },
+          ]
+        end
+
+        def next_batters(team, number_of_upcoming_batters = 3)
+          if team == 'home'
+            last_at_bat = game.at_bats.select{|at_bat| at_bat.event.half_inning.half == 'B'}.last
+            if last_at_bat # first inning
+              last_position = @home_team_lineup.detect{|htl| htl['id'] == last_at_bat.hitter_id}&.dig('order')
+              upcoming = home.rotate(last_position || 0)
+            else
+              upcoming = home
+            end
+          elsif team == 'away'
+            last_at_bat = game.at_bats.select{|at_bat| at_bat.event.half_inning.half == 'T'}.last
+            if last_at_bat # first inning
+              last_position = @away_team_lineup.detect{|atl| atl['id'] == last_at_bat.hitter_id}&.dig('order')
+              upcoming = away.rotate(last_position || 0)
+            else
+              upcoming = away
+            end
+          end
+          upcoming[0..(number_of_upcoming_batters - 1)]
+        rescue => e
+          i ||= 0
+          game.get_summary
+          i += 1
+          retry unless i > 2
+        end
+
+        private
+
+        def initialize_away
+          @away = initial_lineup.dup
+          @away_team_lineup.sort_by{|t| t['sequence']}.each do |al|
+            # al.merge!(find_player(al['id']))
+            update_away(find_player(al['id']), al['order'])
+          end.sort_by{|al| al['order']}
+        end
+
+        def initialize_home
+          @home = initial_lineup.dup
+          @home_team_lineup.sort_by{|t| t['sequence']}.each do |hl|
+            # hl.merge!(find_player(hl['id']))
+            update_home(find_player(hl['id']), hl['order'])
+          end.sort_by{|hl| hl['order']}
+        end
+
+      end
+    end
+  end
+end