sportradar-api 0.9.12 → 0.11.21

data/lib/sportradar/api/basketball/scoring.rb

@@ -0,0 +1,103 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Scoring < Data
+        attr_accessor :response, :api, :id, :home, :away, :scores
+
+        def initialize(data, **opts)
+          @api      = opts[:api]
+          @game     = opts[:game]
+          
+          @scores = {}
+          @id = data['id']
+          
+          update(data, **opts)
+        end
+
+        def update(data, source: nil, **opts)
+          new_scores = case source
+          when :box
+            parse_from_box(data)
+          when :pbp
+            parse_from_pbp(data)
+          when :summary
+            parse_from_box(data)
+          else
+            if data['quarter'] || data['half']
+              parse_from_pbp(data)
+            elsif data['team']
+              parse_from_box(data)
+            else # schedule requests
+              {}
+            end
+          end
+          # parse data structure
+          # handle data from team (all quarters)
+          # handle data from quarter (both teams)
+          # handle data from game?
+          @scores.each { |k, v| v.merge!(new_scores.delete(k) || {} ) }
+          new_scores.each { |k, v| @scores.merge!(k => v) }
+        end
+
+        def points(team_id)
+          @score[team_id].to_i
+        end
+
+
+        private
+
+        def parse_from_box(data)
+          return {} if data.dig('team', 0, 'scoring').is_a?(String) || data.dig('team', 0, 'scoring').nil? # game hasn't started yet
+          period_name = data.dig('team', 0, 'scoring').keys.first
+          id = data.dig('team', 0, 'id')
+          da = data.dig('team', 0, 'scoring', period_name)
+          da_ot = data.dig('team', 0, 'scoring', 'overtime')
+          arr = [da].compact.flatten(1)
+          a = arr + [da_ot].compact.flatten(1)
+          a.each { |h| h[id] = h.delete('points').to_i }
+          id = data.dig('team', 1, 'id')
+          da = data.dig('team', 1, 'scoring', period_name)
+          da_ot = data.dig('team', 1, 'scoring', 'overtime')
+          arr = [da].compact.flatten(1)
+          b = arr + [da_ot].compact.flatten(1)
+          b.each { |h| h[id] = h.delete('points').to_i }
+          a.zip(b).map{ |a, b| [a['sequence'].to_i, a.merge(b)] }.sort{ |(a,_), (b,_)| a <=> b }.to_h
+        end
+
+        def parse_from_box(data)
+          id = data.dig('home', 'id')
+          # binding.pry if id
+          da = data.dig('home', 'scoring')
+          return {} unless da
+          da.each { |h| h[id] = h.delete('points').to_i }
+          id = data.dig('away', 'id')
+          db = data.dig('away', 'scoring')
+          return {} unless db
+          db.each { |h| h[id] = h.delete('points').to_i }
+          da.zip(db).map{ |a, b| [a['sequence'].to_i, a.merge(b)] }.sort{ |(a,_), (b,_)| a <=> b }.to_h
+        end
+
+        def parse_from_pbp(data)
+          period_name = data.key?('quarter') ? 'quarter' : 'half'
+          period_name = 'periods'
+          return {} unless data[period_name] # game hasn't started
+          quarters = data[period_name]#[1..-1]
+          overtimes = data['overtime']
+          overtimes = [overtimes] if !overtimes.is_a?(Array)
+          quarters = quarters[0] if (quarters.is_a?(Array) && (quarters.size == 1) && quarters.first.is_a?(Array))
+          data = (quarters + overtimes).compact.map{|q| q['scoring'] }
+          data.map.with_index(1) { |h, i| [i, { h.dig('home', 'id') => h.dig('home', 'points').to_i, h.dig('away', 'id') => h.dig('away', 'points').to_i }] }.to_h
+        end
+
+        # def period_name
+        #   'quarter'
+        # end
+
+        def parse_from_summary(data)
+          # 
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/season.rb

@@ -0,0 +1,20 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Season < Data
+        attr_accessor :response
+
+        # def initialize(data, **opts)
+        #   @response = data
+        #   @api      = opts[:api]
+
+        #   @id       = response['id']
+        #   @name     = response['name']
+        #   @alias    = response['alias']
+
+        # end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/team.rb

@@ -0,0 +1,136 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Team < Data
+        attr_accessor :response, :id, :market, :name, :alias, :full_name, :venue, :records, :player_stats, :team_stats, :seed
+
+        def initialize(data, **opts)
+          @response = data
+          @api      = opts[:api]
+
+          @games_hash   = {}
+          @players_hash = {}
+          @player_stats = {}
+          @records      = {}
+          @stats        = nil
+          @points       = nil
+
+          case data
+          when String
+            @id = data
+          when Hash
+            @id = data['id']
+            update(data, **opts)
+          end
+        end
+
+        def profile
+          Profile.new(self)
+        end
+
+        def update(data, **opts)
+          handle_names(data)
+          @venue    = Venue.new(data['venue']) if data['venue']
+
+          @seed     = data['seed'].to_i             if data['seed']
+          @alias    = data['alias']                 if data['alias']
+          @points   = data['points'].to_i           if data['points']
+          # @home     = data['home'] == 'true'        if data['home']
+          # @away     = data['away'] == 'true'        if data['away']
+          # @scoring  = data.dig('scoring', 'quarter') if data.dig('scoring', 'quarter')
+
+          parse_records(data)                                          if data['records']
+          # binding.pry if data['players']
+          parse_players(data.dig('players'), opts[:game])   if data.dig('players')
+          # parse_stats(data['statistics'])                             if data['statistics']
+          if opts[:game]
+            add_game(opts[:game])
+            opts[:game].update_score(id => @points)             if @points
+            opts[:game].update_stats(self, data['statistics'])  if data['statistics']
+          end
+        end
+        def handle_names(data)
+          # need to do some more work here
+          @name = data['name'] if data['name']
+          if data['name'] && !data.key?('market')
+            @full_name = data['name']
+          elsif data['name'] && data['market']
+            @market = data['market']
+            @full_name = [@market, data['name']].join(' ')
+          end
+        end
+
+        def record(type = 'overall')
+          @records[type]
+        end
+
+        def games
+          @games_hash.values
+        end
+        def add_game(game)
+          @games_hash[game.id] = game.id if game
+        end
+
+        # def parse_stats(data)
+        #   @stats = data
+        # end
+
+        def players
+          get_roster if @players_hash.empty?
+          @players_hash.values
+        end
+        alias :roster :players
+        def parse_players(data, game)
+          create_data(@players_hash, data, klass: player_class, api: api, team: self, game: game)
+        end
+        def update_player_stats(player, stats, game = nil)
+          game ? game.update_player_stats(player, stats) : @player_stats.merge!(player.id => stats.merge!(player: player))
+        end
+
+        def get_roster
+          data = api.get_data(path_roster)
+          ingest_roster(data)
+        end
+        def ingest_roster(data)
+          update(data)
+          data
+        end
+
+        def get_season_stats
+          data = api.get_data(path_season_stats)
+          ingest_season_stats(data)
+        end
+        def ingest_season_stats(data)
+          parse_season_stats(data)
+        end
+
+        def parse_records(data)
+          @records['overall'] = Record.new(data, type: 'overall')
+          data['records'].each { |record| @records[record['record_type']] = Record.new(record, type: record['record_type']) }
+        end
+
+        def parse_season_stats(data)
+          @team_stats = data.dig('own_record')
+          update(data)
+          player_data = data.dig('players')
+          create_data(@players_hash, player_data, klass: player_class, api: api, team: self)
+          data
+        end
+
+        def path_base
+          "teams/#{ id }"
+        end
+        def path_base_stats(season_year = api.default_year, default_season = api.default_season)
+          "seasontd/#{season_year}/#{default_season}/teams/#{id}"
+        end
+        def path_roster
+          "#{ path_base }/profile"
+        end
+        def path_season_stats
+          "#{ path_base_stats }/statistics"
+        end
+
+      end
+    end
+  end
+end

data/lib/sportradar/api/basketball/venue.rb

@@ -0,0 +1,54 @@
+module Sportradar
+  module Api
+    module Basketball
+      class Venue < Data
+        attr_accessor :response, :id, :name, :address, :city, :state, :country, :zip, :capacity, :timezone
+        @all_hash = {}
+        def self.new(data, **opts)
+          existing = @all_hash[data['id']]
+          if existing
+            existing.update(data, **opts)
+            existing
+          else
+            @all_hash[data['id']] = super
+          end
+        end
+        def self.all
+          @all_hash.values
+        end
+
+        def initialize(data, **opts)
+          @response = data
+          @id       = data["id"]
+
+          update(data, **opts)
+        end
+        def update(data, **opts)
+          @name     = data['name']
+          @address  = data['address']
+          @city     = data['city']
+          @state    = data['state']
+          @zip      = data['zip']
+          @country  = data['country']
+          @capacity = data['capacity']
+          @timezone = data['timezone']
+        end
+
+        def location
+          "#{name}, #{city}"
+        end
+
+        KEYS_SCHEDULE = ["id", "name", "capacity", "address", "city", "state", "zip", "country"]
+      end
+    end
+  end
+end
+
+__END__
+
+sr = Sportradar::Api::Nba.new
+lh = sr.league_hierarchy;
+t = lh.teams.first;
+t.venue.id
+t.venue.name
+t.venue.city

data/lib/sportradar/api/basketball.rb

@@ -0,0 +1,35 @@
+require_relative 'basketball/season'
+require_relative 'basketball/game'
+require_relative 'basketball/team'
+require_relative 'basketball/record'
+require_relative 'basketball/venue'
+require_relative 'basketball/broadcast'
+require_relative 'basketball/injury'
+require_relative 'basketball/plays'
+require_relative 'basketball/scoring'
+
+require_relative 'basketball/nba'
+require_relative 'basketball/nba/hierarchy'
+require_relative 'basketball/nba/conference'
+require_relative 'basketball/nba/division'
+require_relative 'basketball/nba/season'
+require_relative 'basketball/nba/series'
+require_relative 'basketball/nba/schedule'
+require_relative 'basketball/nba/game'
+require_relative 'basketball/nba/team'
+require_relative 'basketball/nba/player'
+require_relative 'basketball/nba/quarter'
+
+require_relative 'basketball/ncaamb'
+require_relative 'basketball/ncaamb/season'
+require_relative 'basketball/ncaamb/schedule'
+require_relative 'basketball/ncaamb/tournament'
+require_relative 'basketball/ncaamb/round'
+require_relative 'basketball/ncaamb/bracket'
+require_relative 'basketball/ncaamb/game'
+require_relative 'basketball/ncaamb/half'
+require_relative 'basketball/ncaamb/hierarchy'
+require_relative 'basketball/ncaamb/division'
+require_relative 'basketball/ncaamb/conference'
+require_relative 'basketball/ncaamb/team'
+require_relative 'basketball/ncaamb/player'

data/lib/sportradar/api/{nfl/broadcast.rb → broadcast.rb}

@@ -1,6 +1,6 @@
 module Sportradar
   module Api
-    class Nfl::Broadcast < Data
+    class Broadcast < Data
       attr_accessor :response, :network
 
       def initialize(data)

data/lib/sportradar/api/content/article.rb

@@ -16,7 +16,7 @@ module Sportradar
         @credit = data["credit"]
         @content = data["content"]["long"] if data["content"] && data["content"]["long"]
         @provider = OpenStruct.new(data["provider"]) if data["provider"]
-        @references = parse_into_array(selector: response["refs"]["ref"], klass: Sportradar::Api::Content::Reference) if response["refs"] && response["refs"]["ref"]
+        @references = parse_into_array(selector: response["refs"], klass: Sportradar::Api::Content::Reference) if response["refs"]
       end
 
       def transaction?

data/lib/sportradar/api/content/article_list.rb

@@ -9,7 +9,7 @@ module Sportradar
         @provider = data["provider"]
         @start_time = Time.parse(data["start_time"]) if data["start_time"]
         @end_time = Time.parse(data["end_time"]) if data["end_time"]
-        @articles = parse_into_array(selector: response["item"], klass: Sportradar::Api::Content::Article) if response["item"]
+        @articles = parse_into_array(selector: response["items"], klass: Sportradar::Api::Content::Article) if response["items"]
       end
 
     end

data/lib/sportradar/api/content.rb

@@ -3,7 +3,7 @@ module Sportradar
     class Content < Request
       attr_accessor :sport, :access_level
 
-      def initialize( sport, access_level = 't')
+      def initialize( sport, access_level = default_access_level)
         raise Sportradar::Api::Error::InvalidSport unless allowed_sports.include? sport
         @sport = sport
         raise Sportradar::Api::Error::InvalidAccessLevel unless allowed_access_levels.include? access_level
@@ -13,8 +13,8 @@ module Sportradar
       def news( date = Date.today, content_type: 'all' )
         raise Sportradar::Api::Error::InvalidType unless allowed_news_types.include? content_type
         response = get request_url("#{provider }/news/#{date_path(date)}/#{content_type}")
-        if response.success? && response["content"]
-          Sportradar::Api::Content::ArticleList.new response["content"]
+        if response.success? && response["items"]
+          Sportradar::Api::Content::ArticleList.new response.to_h
         else
           response
         end
@@ -23,8 +23,8 @@ module Sportradar
       def analysis( date = Date.today, content_type: 'all' )
         raise Sportradar::Api::Error::InvalidType unless allowed_analysis_types.include? content_type
         response = get request_url("#{provider }/analysis/#{date_path(date)}/#{content_type}")
-        if response.success? && response["content"]
-          Sportradar::Api::Content::ArticleList.new response["content"]
+        if response.success? && response["items"]
+          Sportradar::Api::Content::ArticleList.new response.to_h
         else
           response
         end
@@ -32,10 +32,22 @@ module Sportradar
 
       private
 
+      def default_access_level
+        if (ENV['SPORTRADAR_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV']) == 'production'
+          'p'
+        else
+          't'
+        end
+      end
+
       def request_url(path)
         "/content-#{sport}-#{access_level}#{version}/#{path}"
       end
 
+      def content_format
+        'json'
+      end
+
       def api_key
         if access_level == 'p'
           Sportradar::Api.api_key_params("content_#{sport}", "production")

data/lib/sportradar/api/data.rb

@@ -18,6 +18,59 @@ module Sportradar
           [ klass.new(selector) ]
         end
       end
+      def parse_into_array_with_options(selector: , klass: , **opts)
+        if selector.is_a?(Array)
+          selector.map {|x| klass.new(x, **opts) }
+        elsif selector.is_a?(Hash)
+          [ klass.new(selector, **opts) ]
+        else
+          []
+        end
+      end
+
+      def structure_links(links_arr)
+        links_arr.map { |hash| [hash['rel'], hash['href'].gsub('.xml', '')] }.to_h
+      end
+
+      # @param existing [Hash{String=>Data}] Existing data hash, ID => entity
+      # @param data [Hash, Array] new data to update with
+      def update_data(existing, data)
+        case data
+        when Array
+          data.each { |hash| existing[hash['id']].update(hash) }
+        when Hash
+          existing[data['id']].update(data)
+        else
+          # raise
+        end
+        existing
+      end
+
+      # @param existing [Hash{String=>Data}] Existing data hash, ID => entity
+      # @param data [Hash, Array] new data to update with
+      def create_data(existing = {}, data, klass: nil, identifier: 'id', **opts)
+        existing ||= {} # handles nil case, typically during object instantiation
+        case data
+        when [], {}
+          existing
+        when Array
+          data.each do |hash|
+            current = existing[hash[identifier]]
+            if current
+              current.update(hash, **opts)
+            else
+              current = klass.new(hash, **opts)
+              existing[current.id] = current
+            end
+            existing[current.id]
+          end
+        when Hash
+          existing[data[identifier]] = klass.new(data, **opts)
+        else
+          # raise
+        end
+        existing
+      end
 
       def parse_out_hashes(data_element)
         if data_element && data_element.is_a?(Array)

data/lib/sportradar/api/football/README.md

@@ -0,0 +1,62 @@
+# Sportradar Football
+
+![API Reference](https://developer.sportradar.com/files/indexFootball.html)
+
+## NFL
+
+Get started with official NFL api v1:
+
+```ruby
+nfl = Sportradar::Api::Football::Nfl.new
+nfl = Sportradar::Api::Football::Nfl.new(year: 2016)
+res = nfl.get_schedule          # => res is the raw response data hash. the `nfl` object now has weeks present to interact with
+res = nfl.get_weekly_schedule   # => res is the raw response data hash. the `nfl` object now has weeks present to interact with
+nfl.weeks.count                 # => 17
+nfl.games.count                 # => 256
+nfl.weeks.first.games.count     # => 16
+game = nfl.games.sample         # => Sportradar::Api::Football::Nfl::Game
+res = game.get_pbp              # => res is raw response data hash. the `game` object now has quarters/drives/plays to interact with
+game.quarters.size              # => 4 (unless the game went to overtime)
+game.drives.size                # => (20-30) most NFL games have between 20 and 30 drives
+game.plays.size                 # => 150 most NFL games have about 150 total plays
+
+game.get_statistics             # => res is raw response data hash. the `game` object now has team stats to interact with
+game.home.stats.passing         # => Sportradar::Api::Football::StatPack::Passing => passing stats
+game.home.stats.passing.players.first
+```
+
+
+```ruby
+nfl = Marshal.load(File.binread('nfl.bin'));
+ncaafb = Marshal.load(File.binread('ncaafb.bin'));
+g1 = nfl.games.sample;
+g2 = ncaafb.games.sample
+g2.year
+g1.year
+games = [g1, g2]
+games.map(&:year)
+games.map(&:week)
+games.map(&:week_number)
+g1
+g1.year
+g1.week_number
+games.map(&:type)
+games.map(&:path_pbp)
+games.map(&:plays)
+games.map(&:drives).map(&:count)
+games.map(&:plays).map(&:count)
+games.map(&:quarter)
+games.map(&:score)
+games.each(&:get_statistics);
+games.each(&:get_box);
+games.map(&:score)
+games.each(&:get_pbp);
+games.map(&:plays).map(&:count)
+games.map(&:drives).map(&:count)
+
+
+uri = '2015/REG/1/WKY/MSH'
+game = Sportradar::Api::Football::Ncaafb::Game.new('uri' => uri)
+```
+
+

data/lib/sportradar/api/football/drive.rb

@@ -0,0 +1,114 @@
+module Sportradar
+  module Api
+    module Football
+      class Drive < Data
+        attr_accessor :response, :api, :id, :sequence, :start_reason, :end_reason, :play_count, :duration, :first_downs, :gain, :penalty_yards, :scoring_drive, :quarter, :team
+
+        def self.new(data, **opts)
+          if data['type'] == 'event'
+            Event.new(data, **opts)
+          else
+            super
+          end
+        end
+
+        def initialize(data, **opts)
+          @id            = data["id"]
+          @api           = opts[:api]
+          @plays_hash    = {}
+          @events_hash   = {}
+
+          update(data, **opts)
+        end
+
+        def update(data, **opts)
+          @response       = data
+          @type           = data['type']
+          @team           = data['team']
+          @clock          = data['clock']
+          @overtime       = !!opts[:quarter]&.overtime? || @overtime
+
+          @sequence       = data["sequence"]
+          @start_reason   = data["start_reason"]
+          @end_reason     = data["end_reason"]
+          @play_count     = data["play_count"]
+          @duration       = data["duration"]
+          @first_downs    = data["first_downs"]
+          @gain           = data["gain"]
+          @penalty_yards  = data["penalty_yards"]
+          @scoring_drive  = data["scoring_drive"]
+
+          @quarter_data = data['quarter']
+          @team_data    = data['team']
+
+          handle_plays_and_events(data, **opts)
+
+          self
+        end
+
+        def overtime?
+          @overtime
+        end
+
+        def plays
+          @plays_hash.values
+        end
+
+        def events
+          @events_hash.values
+        end
+
+        def over?
+          @end_reason != 'UNKNOWN' && !@end_reason.nil?
+        end
+
+        def end_reason_possibilities
+          [
+            'UNKNOWN',
+            'Touchdown',
+            'Safety',
+            'Field Goal',
+            'Missed FG',
+            'Blocked FG',
+            'Blocked FG, Downs',
+            'Blocked FG, Safety',
+            'Punt',
+            'Blocked Punt',
+            'Blocked Punt, Downs',
+            'Blocked Punt, Safety',
+            'Downs',
+            'Interception',
+            'Fumble',
+            'Fumble, Safety',
+            'Muffed FG',
+            'Muffed Punt',
+            'Muffed Kickoff',
+            'Kickoff',
+            'Own Kickoff',
+            'Onside Kick',
+            'Kickoff, No Play',
+            'End of Half',
+            'End of Game',
+          ]
+        end
+        def normalized_end_reason
+          case end_reason
+          when 'Touchdown'
+            'Touchdown'
+          when 'Field Goal', 'Missed FG', "Blocked FG, Downs", 'Muffed FG', 'Blocked FG, Safety'
+            'Field Goal'
+          when 'Downs'
+            'Downs'
+          when 'Interception', 'Fumble'
+            'Turnover'
+          when 'Punt'
+            'Punt'
+          else
+            'Other'
+          end
+        end
+      end
+
+    end
+  end
+end