nba 0.1.1 → 0.2.0

data/lib/nba/home_page_leader.rb

@@ -0,0 +1,99 @@
+require "shale"
+require "equalizer"
+
+module NBA
+  # Represents a home page leader entry
+  #
+  # @api public
+  # @example
+  #   leader.rank #=> 1
+  #   leader.player #=> "Stephen Curry"
+  #   leader.pts #=> 26.4
+  class HomePageLeader < Shale::Mapper
+    include Equalizer.new(:player_id, :team_id, :rank)
+
+    #   Returns the rank
+    #   @api public
+    #   @example
+    #     leader.rank #=> 1
+    #   @return [Integer, nil] the rank
+    attribute :rank, Shale::Type::Integer
+
+    #   Returns the player ID
+    #   @api public
+    #   @example
+    #     leader.player_id #=> 201939
+    #   @return [Integer, nil] the player ID
+    attribute :player_id, Shale::Type::Integer
+
+    #   Returns the player name
+    #   @api public
+    #   @example
+    #     leader.player #=> "Stephen Curry"
+    #   @return [String, nil] the player name
+    attribute :player, Shale::Type::String
+
+    #   Returns the team ID
+    #   @api public
+    #   @example
+    #     leader.team_id #=> 1610612744
+    #   @return [Integer, nil] the team ID
+    attribute :team_id, Shale::Type::Integer
+
+    #   Returns the team abbreviation
+    #   @api public
+    #   @example
+    #     leader.team_abbreviation #=> "GSW"
+    #   @return [String, nil] the team abbreviation
+    attribute :team_abbreviation, Shale::Type::String
+
+    #   Returns points
+    #   @api public
+    #   @example
+    #     leader.pts #=> 26.4
+    #   @return [Float, nil] points
+    attribute :pts, Shale::Type::Float
+
+    #   Returns field goal percentage
+    #   @api public
+    #   @example
+    #     leader.fg_pct #=> 0.493
+    #   @return [Float, nil] field goal percentage
+    attribute :fg_pct, Shale::Type::Float
+
+    #   Returns three-point percentage
+    #   @api public
+    #   @example
+    #     leader.fg3_pct #=> 0.423
+    #   @return [Float, nil] three-point percentage
+    attribute :fg3_pct, Shale::Type::Float
+
+    #   Returns free throw percentage
+    #   @api public
+    #   @example
+    #     leader.ft_pct #=> 0.913
+    #   @return [Float, nil] free throw percentage
+    attribute :ft_pct, Shale::Type::Float
+
+    #   Returns efficiency rating
+    #   @api public
+    #   @example
+    #     leader.eff #=> 31.5
+    #   @return [Float, nil] efficiency rating
+    attribute :eff, Shale::Type::Float
+
+    #   Returns assists
+    #   @api public
+    #   @example
+    #     leader.ast #=> 6.1
+    #   @return [Float, nil] assists
+    attribute :ast, Shale::Type::Float
+
+    #   Returns rebounds
+    #   @api public
+    #   @example
+    #     leader.reb #=> 5.2
+    #   @return [Float, nil] rebounds
+    attribute :reb, Shale::Type::Float
+  end
+end

data/lib/nba/home_page_leaders.rb

@@ -0,0 +1,75 @@
+require "json"
+require_relative "client"
+require_relative "collection"
+require_relative "home_page_leader"
+require_relative "league"
+require_relative "response_parser"
+require_relative "utils"
+
+module NBA
+  # Provides methods to retrieve NBA home page leaders
+  module HomePageLeaders
+    # Result set name for home page leaders
+    # @return [String] the result set name
+    RESULT_SET = "HomePageLeaders".freeze
+
+    # Retrieves home page leaders for a season
+    #
+    # @api public
+    # @example
+    #   leaders = NBA::HomePageLeaders.all(season: 2023, stat_category: "PTS")
+    #   leaders.each { |l| puts "#{l.rank}. #{l.player}: #{l.pts}" }
+    # @param season [Integer] the season year
+    # @param season_type [String] the season type
+    # @param stat_category [String] the stat category (PTS, AST, REB, etc.)
+    # @param game_scope [String] the game scope (Season, Yesterday, etc.)
+    # @param player_or_team [String] player or team (Player, Team)
+    # @param player_scope [String] the player scope (All Players, Rookies)
+    # @param league [String, League] the league ID or League object
+    # @param client [Client] the API client to use
+    # @return [Collection] a collection of leaders
+    def self.all(season: Utils.current_season, season_type: "Regular Season", stat_category: "PTS",
+      game_scope: "Season", player_or_team: "Player", player_scope: "All Players",
+      league: League::NBA, client: CLIENT)
+      league_id = Utils.extract_league_id(league)
+      opts = {season: season, season_type: season_type, stat_category: stat_category,
+              game_scope: game_scope, player_or_team: player_or_team, player_scope: player_scope,
+              league_id: league_id}
+      ResponseParser.parse(client.get(build_path(opts)), result_set: RESULT_SET) { |data| build_leader(data) }
+    end
+
+    # Builds the API request path
+    # @api private
+    # @return [String] the request path
+    def self.build_path(opts)
+      "homepageleaders?GameScope=#{opts[:game_scope]}&LeagueID=#{opts[:league_id]}" \
+        "&PlayerOrTeam=#{opts[:player_or_team]}&PlayerScope=#{opts[:player_scope]}" \
+        "&Season=#{Utils.format_season(opts[:season])}&SeasonType=#{opts[:season_type]}" \
+        "&StatCategory=#{opts[:stat_category]}"
+    end
+    private_class_method :build_path
+
+    # Builds a HomePageLeader object from raw data
+    # @api private
+    # @param data [Hash] the row data
+    # @return [HomePageLeader] the leader object
+    def self.build_leader(data)
+      HomePageLeader.new(**leader_attributes(data))
+    end
+    private_class_method :build_leader
+
+    # Extracts leader attributes from data
+    # @api private
+    # @param data [Hash] the row data
+    # @return [Hash] leader attributes
+    def self.leader_attributes(data)
+      {rank: data["RANK"], player_id: data["PLAYER_ID"],
+       player: data["PLAYER"], team_id: data["TEAM_ID"],
+       team_abbreviation: data["TEAM_ABBREVIATION"],
+       pts: data["PTS"], fg_pct: data["FG_PCT"],
+       fg3_pct: data["FG3_PCT"], ft_pct: data["FT_PCT"],
+       eff: data["EFF"], ast: data["AST"], reb: data["REB"]}
+    end
+    private_class_method :leader_attributes
+  end
+end

data/lib/nba/home_page_stat.rb

@@ -0,0 +1,57 @@
+require "equalizer"
+require "shale"
+
+module NBA
+  # Represents a home page statistic entry
+  #
+  # @api public
+  # @example
+  #   stat.rank #=> 1
+  #   stat.team_abbreviation #=> "BOS"
+  #   stat.value #=> 120.5
+  class HomePageStat < Shale::Mapper
+    include Equalizer.new(:rank, :team_id)
+
+    #   Returns the rank
+    #   @api public
+    #   @example
+    #     stat.rank #=> 1
+    #   @return [Integer, nil] the rank
+    attribute :rank, Shale::Type::Integer
+
+    #   Returns the team ID
+    #   @api public
+    #   @example
+    #     stat.team_id #=> 1610612738
+    #   @return [Integer, nil] the team ID
+    attribute :team_id, Shale::Type::Integer
+
+    #   Returns the team abbreviation
+    #   @api public
+    #   @example
+    #     stat.team_abbreviation #=> "BOS"
+    #   @return [String, nil] the team abbreviation
+    attribute :team_abbreviation, Shale::Type::String
+
+    #   Returns the team name
+    #   @api public
+    #   @example
+    #     stat.team_name #=> "Boston Celtics"
+    #   @return [String, nil] the team name
+    attribute :team_name, Shale::Type::String
+
+    #   Returns the statistic value
+    #   @api public
+    #   @example
+    #     stat.value #=> 120.5
+    #   @return [Float, nil] the statistic value
+    attribute :value, Shale::Type::Float
+
+    #   Returns the statistic name
+    #   @api public
+    #   @example
+    #     stat.stat_name #=> "pts"
+    #   @return [String, nil] the statistic name
+    attribute :stat_name, Shale::Type::String
+  end
+end

data/lib/nba/home_page_v2.rb

@@ -0,0 +1,110 @@
+require "json"
+require_relative "client"
+require_relative "collection"
+require_relative "home_page_stat"
+require_relative "league"
+require_relative "response_parser"
+require_relative "utils"
+
+module NBA
+  # Provides methods to retrieve NBA home page V2 statistics
+  module HomePageV2
+    # Stat categories available in home page V2
+    STAT_CATEGORIES = {
+      pts: "HomePageStat1",
+      reb: "HomePageStat2",
+      ast: "HomePageStat3",
+      stl: "HomePageStat4",
+      fg_pct: "HomePageStat5",
+      ft_pct: "HomePageStat6",
+      fg3_pct: "HomePageStat7",
+      blk: "HomePageStat8"
+    }.freeze
+
+    # Retrieves home page V2 statistics for a stat category
+    #
+    # @api public
+    # @example
+    #   stats = NBA::HomePageV2.all(stat_category: :pts, season: 2023)
+    #   stats.each { |s| puts "#{s.rank}. #{s.team_abbreviation}: #{s.value}" }
+    # @param stat_category [Symbol] the stat category (:pts, :reb, :ast, etc.)
+    # @param season [Integer] the season year (defaults to current season)
+    # @param season_type [String] the season type (Regular Season, Playoffs, etc.)
+    # @param game_scope [String] the game scope (Season, Yesterday, etc.)
+    # @param player_or_team [String] player or team stats (Player, Team)
+    # @param player_scope [String] the player scope (All Players, Rookies)
+    # @param stat_type [String] the stat type (Traditional, Advanced, etc.)
+    # @param league [String, League] the league ID or League object
+    # @param client [Client] the API client to use
+    # @return [Collection] a collection of home page stats
+    def self.all(stat_category:, season: Utils.current_season, season_type: "Regular Season",
+      game_scope: "Season", player_or_team: "Team", player_scope: "All Players",
+      stat_type: "Traditional", league: League::NBA, client: CLIENT)
+      result_set = STAT_CATEGORIES.fetch(stat_category)
+      league_id = Utils.extract_league_id(league)
+      opts = {season: season, season_type: season_type, game_scope: game_scope,
+              player_or_team: player_or_team, player_scope: player_scope,
+              stat_type: stat_type, league_id: league_id}
+      response = client.get(build_path(opts))
+      parse_response(response, result_set, stat_category)
+    end
+
+    # Builds the API request path
+    # @api private
+    # @return [String] the request path
+    def self.build_path(opts)
+      "homepagev2?GameScope=#{opts[:game_scope]}&LeagueID=#{opts[:league_id]}" \
+        "&PlayerOrTeam=#{opts[:player_or_team]}&PlayerScope=#{opts[:player_scope]}" \
+        "&Season=#{Utils.format_season(opts[:season])}&SeasonType=#{opts[:season_type]}" \
+        "&StatType=#{opts[:stat_type]}"
+    end
+    private_class_method :build_path
+
+    # Parses the API response
+    # @api private
+    # @param response [String, nil] the raw API response
+    # @param result_set [String] the result set name
+    # @param stat_category [Symbol] the stat category
+    # @return [Collection] parsed stats
+    def self.parse_response(response, result_set, stat_category)
+      ResponseParser.parse(response, result_set: result_set) do |data|
+        build_stat(data, stat_category)
+      end
+    end
+    private_class_method :parse_response
+
+    # Builds a HomePageStat object from raw data
+    # @api private
+    # @param data [Hash] the row data
+    # @param stat_category [Symbol] the stat category
+    # @return [HomePageStat] the stat object
+    def self.build_stat(data, stat_category)
+      HomePageStat.new(**stat_attributes(data, stat_category))
+    end
+    private_class_method :build_stat
+
+    # Extracts stat attributes from data
+    # @api private
+    # @param data [Hash] the row data
+    # @param stat_category [Symbol] the stat category name
+    # @return [Hash] stat attributes
+    def self.stat_attributes(data, stat_category)
+      {rank: data["RANK"], team_id: data["TEAM_ID"],
+       team_abbreviation: data["TEAM_ABBREVIATION"],
+       team_name: data["TEAM_NAME"],
+       value: extract_value(data), stat_name: stat_category}
+    end
+    private_class_method :stat_attributes
+
+    # Extracts the stat value from data (different keys per result set)
+    # @api private
+    # @param data [Hash] the row data
+    # @return [Float, nil] the stat value
+    def self.extract_value(data)
+      value_keys = %w[PTS REB AST STL FG_PCT FT_PCT FG3_PCT BLK]
+      value_keys.each { |key| return data.fetch(key) if data.key?(key) }
+      nil
+    end
+    private_class_method :extract_value
+  end
+end

data/lib/nba/hustle_stats_box_score.rb

@@ -0,0 +1,182 @@
+require "json"
+require_relative "client"
+require_relative "collection"
+require_relative "box_score_hustle_player_stat"
+require_relative "box_score_hustle_team_stat"
+require_relative "utils"
+
+module NBA
+  # Provides methods to retrieve hustle statistics for a game via hustlestatsboxscore endpoint
+  module HustleStatsBoxScore
+    # Result set name for availability status
+    # @return [String] the result set name
+    HUSTLE_STATS_AVAILABLE = "HustleStatsAvailable".freeze
+
+    # Result set name for player stats
+    # @return [String] the result set name
+    PLAYER_STATS = "PlayerStats".freeze
+
+    # Result set name for team stats
+    # @return [String] the result set name
+    TEAM_STATS = "TeamStats".freeze
+
+    # API endpoint path
+    # @return [String] the endpoint path
+    ENDPOINT = "hustlestatsboxscore".freeze
+
+    # Retrieves hustle statistics for players in a game
+    #
+    # @api public
+    # @example
+    #   stats = NBA::HustleStatsBoxScore.player_stats(game: "0022400001")
+    # @param game [String, Game] the game ID or Game object
+    # @param client [Client] the API client to use
+    # @return [Collection] a collection of player hustle stats
+    def self.player_stats(game:, client: CLIENT)
+      game_id = Utils.extract_id(game)
+      parse_stats(client.get("#{ENDPOINT}?GameID=#{game_id}"), game_id, PLAYER_STATS, :build_player_stat)
+    end
+
+    # Retrieves hustle statistics for teams in a game
+    #
+    # @api public
+    # @example
+    #   stats = NBA::HustleStatsBoxScore.team_stats(game: "0022400001")
+    # @param game [String, Game] the game ID or Game object
+    # @param client [Client] the API client to use
+    # @return [Collection] a collection of team hustle stats
+    def self.team_stats(game:, client: CLIENT)
+      game_id = Utils.extract_id(game)
+      parse_stats(client.get("#{ENDPOINT}?GameID=#{game_id}"), game_id, TEAM_STATS, :build_team_stat)
+    end
+
+    # Checks if hustle stats are available for a game
+    #
+    # @api public
+    # @example
+    #   NBA::HustleStatsBoxScore.available?(game: "0022400001") #=> true
+    # @param game [String, Game] the game ID or Game object
+    # @param client [Client] the API client to use
+    # @return [Boolean] true if hustle stats are available
+    def self.available?(game:, client: CLIENT)
+      game_id = Utils.extract_id(game)
+      stats_available?(client.get("#{ENDPOINT}?GameID=#{game_id}"))
+    end
+
+    # Parses hustle stats from API response
+    # @api private
+    # @param response [String] the API response
+    # @param game_id [String] the game ID
+    # @param result_set_name [String] the result set name to find
+    # @param builder_method [Symbol] the method to build stat objects
+    # @return [Collection] collection of stat objects
+    def self.parse_stats(response, game_id, result_set_name, builder_method)
+      return Collection.new unless response
+
+      result_set = find_result_set(JSON.parse(response), result_set_name)
+      return Collection.new unless result_set
+
+      headers = result_set["headers"]
+      rows = result_set["rowSet"]
+      return Collection.new unless headers && rows
+
+      Collection.new(rows.map { |row| __send__(builder_method, headers, row, game_id) })
+    end
+    private_class_method :parse_stats
+
+    # Checks if hustle stats are available in the response
+    # @api private
+    # @param response [String] the API response
+    # @return [Boolean] true if stats are available
+    def self.stats_available?(response)
+      return false unless response
+
+      result_set = find_result_set(JSON.parse(response), HUSTLE_STATS_AVAILABLE)
+      return false unless result_set
+
+      rows = result_set["rowSet"]
+      headers = result_set["headers"]
+      return false unless rows && !rows.empty? && headers
+
+      headers.zip(rows.first).to_h["HUSTLE_STATUS"].eql?(1)
+    end
+    private_class_method :stats_available?
+
+    # Finds a result set by name in the response data
+    # @api private
+    # @param data [Hash] the parsed JSON data
+    # @param name [String] the result set name to find
+    # @return [Hash, nil] the result set hash or nil
+    def self.find_result_set(data, name)
+      result_sets = data["resultSets"]
+      return unless result_sets
+
+      result_sets.find { |rs| rs.fetch("name").eql?(name) }
+    end
+    private_class_method :find_result_set
+
+    # Builds a player stat object from row data
+    # @api private
+    # @param headers [Array<String>] the column headers
+    # @param row [Array] the row data
+    # @param game_id [String] the game ID
+    # @return [BoxScoreHustlePlayerStat] the player stat object
+    def self.build_player_stat(headers, row, game_id)
+      data = headers.zip(row).to_h
+      BoxScoreHustlePlayerStat.new(**player_identity(data, game_id), **hustle_stats(data))
+    end
+    private_class_method :build_player_stat
+
+    # Builds a team stat object from row data
+    # @api private
+    # @param headers [Array<String>] the column headers
+    # @param row [Array] the row data
+    # @param game_id [String] the game ID
+    # @return [BoxScoreHustleTeamStat] the team stat object
+    def self.build_team_stat(headers, row, game_id)
+      data = headers.zip(row).to_h
+      BoxScoreHustleTeamStat.new(**team_identity(data, game_id), **hustle_stats(data))
+    end
+    private_class_method :build_team_stat
+
+    # Extracts player identity attributes from data
+    # @api private
+    # @param data [Hash] the row data hash
+    # @param game_id [String] the game ID
+    # @return [Hash] player identity attributes
+    def self.player_identity(data, game_id)
+      {game_id: game_id, team_id: data.fetch("TEAM_ID"), team_abbreviation: data.fetch("TEAM_ABBREVIATION"),
+       team_city: data.fetch("TEAM_CITY"), player_id: data.fetch("PLAYER_ID"), player_name: data.fetch("PLAYER_NAME"),
+       start_position: data.fetch("START_POSITION"), comment: data.fetch("COMMENT"),
+       min: data.fetch("MINUTES"), pts: data.fetch("PTS")}
+    end
+    private_class_method :player_identity
+
+    # Extracts team identity attributes from data
+    # @api private
+    # @param data [Hash] the row data hash
+    # @param game_id [String] the game ID
+    # @return [Hash] team identity attributes
+    def self.team_identity(data, game_id)
+      {game_id: game_id, team_id: data.fetch("TEAM_ID"), team_name: data.fetch("TEAM_NAME"),
+       team_abbreviation: data.fetch("TEAM_ABBREVIATION"), team_city: data.fetch("TEAM_CITY"),
+       min: data.fetch("MINUTES"), pts: data.fetch("PTS")}
+    end
+    private_class_method :team_identity
+
+    # Extracts hustle stats attributes from data
+    # @api private
+    # @param data [Hash] the row data hash
+    # @return [Hash] hustle stats attributes
+    def self.hustle_stats(data)
+      {contested_shots: data.fetch("CONTESTED_SHOTS"), contested_shots_2pt: data.fetch("CONTESTED_SHOTS_2PT"),
+       contested_shots_3pt: data.fetch("CONTESTED_SHOTS_3PT"), deflections: data.fetch("DEFLECTIONS"),
+       charges_drawn: data.fetch("CHARGES_DRAWN"), screen_assists: data.fetch("SCREEN_ASSISTS"),
+       screen_ast_pts: data.fetch("SCREEN_AST_PTS"), loose_balls_recovered: data.fetch("LOOSE_BALLS_RECOVERED"),
+       off_loose_balls_recovered: data.fetch("OFF_LOOSE_BALLS_RECOVERED"),
+       def_loose_balls_recovered: data.fetch("DEF_LOOSE_BALLS_RECOVERED"), box_outs: data.fetch("BOX_OUTS"),
+       off_box_outs: data.fetch("OFF_BOXOUTS"), def_box_outs: data.fetch("DEF_BOXOUTS")}
+    end
+    private_class_method :hustle_stats
+  end
+end

data/lib/nba/infographic_fan_duel_player.rb

@@ -0,0 +1,139 @@
+require "json"
+require_relative "client"
+require_relative "collection"
+require_relative "infographic_fan_duel_player_stat"
+require_relative "utils"
+
+module NBA
+  # Provides methods to retrieve FanDuel infographic player statistics
+  module InfographicFanDuelPlayer
+    # Result set name for FanDuel player stats
+    # @return [String] the result set name
+    FAN_DUEL_PLAYER = "FanDuelPlayer".freeze
+
+    # Retrieves FanDuel infographic statistics for all players in a game
+    #
+    # @api public
+    # @example
+    #   stats = NBA::InfographicFanDuelPlayer.find(game: "0022400001")
+    #   stats.each { |s| puts "#{s.player_name}: #{s.fan_duel_pts} FD pts" }
+    # @param game [String, Game] the game ID or Game object
+    # @param client [Client] the API client to use
+    # @return [Collection] a collection of FanDuel player stats
+    def self.find(game:, client: CLIENT)
+      game_id = Utils.extract_id(game)
+      path = "infographicfanduelplayer?GameID=#{game_id}"
+      response = client.get(path)
+      parse_response(response, game_id)
+    end
+
+    # Parses the API response
+    #
+    # @api private
+    # @param response [String, nil] the JSON response
+    # @param game_id [String] the game ID
+    # @return [Collection] collection of player stats
+    def self.parse_response(response, game_id)
+      return Collection.new unless response
+
+      data = JSON.parse(response)
+      result_set = find_result_set(data)
+      return Collection.new unless result_set
+
+      headers = result_set["headers"]
+      rows = result_set["rowSet"]
+      return Collection.new unless headers && rows
+
+      stats = rows.map { |row| build_player_stat(headers, row, game_id) }
+      Collection.new(stats)
+    end
+    private_class_method :parse_response
+
+    # Finds the result set
+    #
+    # @api private
+    # @param data [Hash] the parsed JSON data
+    # @return [Hash, nil] the result set
+    def self.find_result_set(data)
+      result_sets = data["resultSets"]
+      return unless result_sets
+
+      result_sets.find { |rs| rs["name"].eql?(FAN_DUEL_PLAYER) }
+    end
+    private_class_method :find_result_set
+
+    # Builds a player stat from a row
+    #
+    # @api private
+    # @param headers [Array<String>] the column headers
+    # @param row [Array] the row data
+    # @param game_id [String] the game ID
+    # @return [InfographicFanDuelPlayerStat] the player stat object
+    def self.build_player_stat(headers, row, game_id)
+      data = headers.zip(row).to_h
+      InfographicFanDuelPlayerStat.new(**player_stat_attributes(data, game_id))
+    end
+    private_class_method :build_player_stat
+
+    # Extracts player stat attributes from row data
+    #
+    # @api private
+    # @param data [Hash] the player stat row data
+    # @param game_id [String] the game ID
+    # @return [Hash] the player stat attributes
+    def self.player_stat_attributes(data, game_id)
+      identity_attributes(data, game_id).merge(fantasy_attributes(data), shooting_attributes(data), counting_attributes(data))
+    end
+    private_class_method :player_stat_attributes
+
+    # Extracts identity attributes
+    #
+    # @api private
+    # @param data [Hash] the player stat data
+    # @param game_id [String] the game ID
+    # @return [Hash] the identity attributes
+    def self.identity_attributes(data, game_id)
+      {game_id: game_id, player_id: data["PLAYER_ID"], player_name: data["PLAYER_NAME"],
+       team_id: data["TEAM_ID"], team_name: data["TEAM_NAME"],
+       team_abbreviation: data["TEAM_ABBREVIATION"], jersey_num: data["JERSEY_NUM"],
+       player_position: data["PLAYER_POSITION"], location: data["LOCATION"]}
+    end
+    private_class_method :identity_attributes
+
+    # Extracts fantasy attributes
+    #
+    # @api private
+    # @param data [Hash] the player stat data
+    # @return [Hash] the fantasy attributes
+    def self.fantasy_attributes(data)
+      {fan_duel_pts: data["FAN_DUEL_PTS"], nba_fantasy_pts: data["NBA_FANTASY_PTS"],
+       usg_pct: data["USG_PCT"], min: data["MIN"]}
+    end
+    private_class_method :fantasy_attributes
+
+    # Extracts shooting attributes
+    #
+    # @api private
+    # @param data [Hash] the player stat data
+    # @return [Hash] the shooting attributes
+    def self.shooting_attributes(data)
+      {fgm: data["FGM"], fga: data["FGA"], fg_pct: data["FG_PCT"],
+       fg3m: data["FG3M"], fg3a: data["FG3A"], fg3_pct: data["FG3_PCT"],
+       ftm: data["FTM"], fta: data["FTA"], ft_pct: data["FT_PCT"]}
+    end
+    private_class_method :shooting_attributes
+
+    # Extracts counting stats attributes
+    #
+    # @api private
+    # @param data [Hash] the player stat data
+    # @return [Hash] the counting stats attributes
+    def self.counting_attributes(data)
+      {oreb: data["OREB"], dreb: data["DREB"], reb: data["REB"],
+       ast: data["AST"], tov: data["TOV"], stl: data["STL"],
+       blk: data["BLK"], blka: data["BLKA"], pf: data["PF"],
+       pfd: data["PFD"], pts: data["PTS"], plus_minus: data["PLUS_MINUS"]}
+    end
+    private_class_method :counting_attributes
+  end
+end