sports-odds-api 1.0.0

data/lib/sports_odds_api/models/team.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Models
+    # @see SportsOddsAPI::Resources::Teams#get
+    class Team < SportsOddsAPI::Internal::Type::BaseModel
+      # @!attribute colors
+      #
+      #   @return [SportsOddsAPI::Models::Team::Colors, nil]
+      optional :colors, -> { SportsOddsAPI::Team::Colors }
+
+      # @!attribute league_id
+      #
+      #   @return [String, nil]
+      optional :league_id, String, api_name: :leagueID
+
+      # @!attribute logo
+      #
+      #   @return [String, nil]
+      optional :logo, String
+
+      # @!attribute lookups
+      #
+      #   @return [SportsOddsAPI::Models::Team::Lookups, nil]
+      optional :lookups, -> { SportsOddsAPI::Team::Lookups }
+
+      # @!attribute names
+      #
+      #   @return [SportsOddsAPI::Models::Team::Names, nil]
+      optional :names, -> { SportsOddsAPI::Team::Names }
+
+      # @!attribute sport_id
+      #
+      #   @return [String, nil]
+      optional :sport_id, String, api_name: :sportID
+
+      # @!attribute standings
+      #
+      #   @return [SportsOddsAPI::Models::Team::Standings, nil]
+      optional :standings, -> { SportsOddsAPI::Team::Standings }
+
+      # @!attribute team_id
+      #
+      #   @return [String, nil]
+      optional :team_id, String, api_name: :teamID
+
+      # @!method initialize(colors: nil, league_id: nil, logo: nil, lookups: nil, names: nil, sport_id: nil, standings: nil, team_id: nil)
+      #   @param colors [SportsOddsAPI::Models::Team::Colors]
+      #   @param league_id [String]
+      #   @param logo [String]
+      #   @param lookups [SportsOddsAPI::Models::Team::Lookups]
+      #   @param names [SportsOddsAPI::Models::Team::Names]
+      #   @param sport_id [String]
+      #   @param standings [SportsOddsAPI::Models::Team::Standings]
+      #   @param team_id [String]
+
+      # @see SportsOddsAPI::Models::Team#colors
+      class Colors < SportsOddsAPI::Internal::Type::BaseModel
+        # @!attribute primary
+        #
+        #   @return [String, nil]
+        optional :primary, String
+
+        # @!attribute primary_contrast
+        #
+        #   @return [String, nil]
+        optional :primary_contrast, String, api_name: :primaryContrast
+
+        # @!attribute secondary
+        #
+        #   @return [String, nil]
+        optional :secondary, String
+
+        # @!attribute secondary_contrast
+        #
+        #   @return [String, nil]
+        optional :secondary_contrast, String, api_name: :secondaryContrast
+
+        # @!method initialize(primary: nil, primary_contrast: nil, secondary: nil, secondary_contrast: nil)
+        #   @param primary [String]
+        #   @param primary_contrast [String]
+        #   @param secondary [String]
+        #   @param secondary_contrast [String]
+      end
+
+      # @see SportsOddsAPI::Models::Team#lookups
+      class Lookups < SportsOddsAPI::Internal::Type::BaseModel
+        # @!attribute team_name
+        #
+        #   @return [Array<String>, nil]
+        optional :team_name, SportsOddsAPI::Internal::Type::ArrayOf[String], api_name: :teamName
+
+        # @!method initialize(team_name: nil)
+        #   @param team_name [Array<String>]
+      end
+
+      # @see SportsOddsAPI::Models::Team#names
+      class Names < SportsOddsAPI::Internal::Type::BaseModel
+        # @!attribute long
+        #
+        #   @return [String, nil]
+        optional :long, String
+
+        # @!attribute medium
+        #
+        #   @return [String, nil]
+        optional :medium, String
+
+        # @!attribute short
+        #
+        #   @return [String, nil]
+        optional :short, String
+
+        # @!method initialize(long: nil, medium: nil, short: nil)
+        #   @param long [String]
+        #   @param medium [String]
+        #   @param short [String]
+      end
+
+      # @see SportsOddsAPI::Models::Team#standings
+      class Standings < SportsOddsAPI::Internal::Type::BaseModel
+        # @!attribute losses
+        #
+        #   @return [Float, nil]
+        optional :losses, Float
+
+        # @!attribute played
+        #
+        #   @return [Float, nil]
+        optional :played, Float
+
+        # @!attribute position
+        #
+        #   @return [String, nil]
+        optional :position, String
+
+        # @!attribute record
+        #
+        #   @return [String, nil]
+        optional :record, String
+
+        # @!attribute ties
+        #
+        #   @return [Float, nil]
+        optional :ties, Float
+
+        # @!attribute wins
+        #
+        #   @return [Float, nil]
+        optional :wins, Float
+
+        # @!method initialize(losses: nil, played: nil, position: nil, record: nil, ties: nil, wins: nil)
+        #   @param losses [Float]
+        #   @param played [Float]
+        #   @param position [String]
+        #   @param record [String]
+        #   @param ties [Float]
+        #   @param wins [Float]
+      end
+    end
+  end
+end

data/lib/sports_odds_api/models/team_get_params.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Models
+    # @see SportsOddsAPI::Resources::Teams#get
+    class TeamGetParams < SportsOddsAPI::Internal::Type::BaseModel
+      extend SportsOddsAPI::Internal::Type::RequestParameters::Converter
+      include SportsOddsAPI::Internal::Type::RequestParameters
+
+      # @!attribute cursor
+      #   The cursor for the request. Used to get the next group of Teams. This should be
+      #   the nextCursor from the prior response.
+      #
+      #   @return [String, nil]
+      optional :cursor, String
+
+      # @!attribute league_id
+      #   A single leagueID or comma-separated list of leagueIDs to get Teams for
+      #
+      #   @return [String, nil]
+      optional :league_id, String
+
+      # @!attribute limit
+      #   The maximum number of Teams to return
+      #
+      #   @return [Float, nil]
+      optional :limit, Float
+
+      # @!attribute sport_id
+      #   A single sportID or comma-separated list of sportIDs to get Teams for
+      #
+      #   @return [String, nil]
+      optional :sport_id, String
+
+      # @!attribute team_id
+      #   A single teamID or comma-separated list of teamIDs to get data for
+      #
+      #   @return [String, nil]
+      optional :team_id, String
+
+      # @!method initialize(cursor: nil, league_id: nil, limit: nil, sport_id: nil, team_id: nil, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {SportsOddsAPI::Models::TeamGetParams} for more details.
+      #
+      #   @param cursor [String] The cursor for the request. Used to get the next group of Teams. This should be
+      #
+      #   @param league_id [String] A single leagueID or comma-separated list of leagueIDs to get Teams for
+      #
+      #   @param limit [Float] The maximum number of Teams to return
+      #
+      #   @param sport_id [String] A single sportID or comma-separated list of sportIDs to get Teams for
+      #
+      #   @param team_id [String] A single teamID or comma-separated list of teamIDs to get data for
+      #
+      #   @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/sports_odds_api/models.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  [
+    SportsOddsAPI::Internal::Type::BaseModel,
+    *SportsOddsAPI::Internal::Type::BaseModel.subclasses
+  ].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, SportsOddsAPI::Internal::AnyHash) } }
+  end
+
+  SportsOddsAPI::Internal::Util.walk_namespaces(SportsOddsAPI::Models).each do |mod|
+    case mod
+    in SportsOddsAPI::Internal::Type::Enum | SportsOddsAPI::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  SportsOddsAPI::Internal::Util.walk_namespaces(SportsOddsAPI::Models)
+                               .lazy
+                               .grep(SportsOddsAPI::Internal::Type::Union)
+                               .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
+  AccountGetUsageParams = SportsOddsAPI::Models::AccountGetUsageParams
+
+  AccountUsage = SportsOddsAPI::Models::AccountUsage
+
+  Event = SportsOddsAPI::Models::Event
+
+  EventGetParams = SportsOddsAPI::Models::EventGetParams
+
+  League = SportsOddsAPI::Models::League
+
+  LeagueGetParams = SportsOddsAPI::Models::LeagueGetParams
+
+  Player = SportsOddsAPI::Models::Player
+
+  PlayerGetParams = SportsOddsAPI::Models::PlayerGetParams
+
+  RateLimitInterval = SportsOddsAPI::Models::RateLimitInterval
+
+  Sport = SportsOddsAPI::Models::Sport
+
+  SportGetParams = SportsOddsAPI::Models::SportGetParams
+
+  Stat = SportsOddsAPI::Models::Stat
+
+  StatGetParams = SportsOddsAPI::Models::StatGetParams
+
+  StreamEventsParams = SportsOddsAPI::Models::StreamEventsParams
+
+  Team = SportsOddsAPI::Models::Team
+
+  TeamGetParams = SportsOddsAPI::Models::TeamGetParams
+end

data/lib/sports_odds_api/request_options.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < SportsOddsAPI::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in SportsOddsAPI::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query,
+             SportsOddsAPI::Internal::Type::HashOf[SportsOddsAPI::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, SportsOddsAPI::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, SportsOddsAPI::Internal::Type::HashOf[SportsOddsAPI::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(SportsOddsAPI::RequestOptions, SportsOddsAPI::Internal::AnyHash) }
+    end
+  end
+end

data/lib/sports_odds_api/resources/account.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Account
+      # Get rate-limits and usage data about your API key
+      #
+      # @overload get_usage(request_options: {})
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [SportsOddsAPI::Models::AccountUsage]
+      #
+      # @see SportsOddsAPI::Models::AccountGetUsageParams
+      def get_usage(params = {})
+        @client.request(
+          method: :get,
+          path: "account/usage",
+          unwrap: :data,
+          model: SportsOddsAPI::AccountUsage,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/events.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Events
+      # Some parameter documentations has been truncated, see
+      # {SportsOddsAPI::Models::EventGetParams} for more details.
+      #
+      # Get a list of Events
+      #
+      # @overload get(bookmaker_id: nil, cancelled: nil, cursor: nil, ended: nil, event_id: nil, finalized: nil, include_alt_lines: nil, include_opposing_odds: nil, league_id: nil, limit: nil, live: nil, odd_id: nil, odds_available: nil, odds_present: nil, player_id: nil, sport_id: nil, started: nil, starts_after: nil, starts_before: nil, team_id: nil, type: nil, request_options: {})
+      #
+      # @param bookmaker_id [String] A bookmakerID or comma-separated list of bookmakerIDs to include odds for
+      #
+      # @param cancelled [Boolean] Only include cancelled Events (true), only non-cancelled Events (false) or all E
+      #
+      # @param cursor [String] The cursor for the request. Used to get the next group of Events. This should be
+      #
+      # @param ended [Boolean] Only include Events which have have ended (true), only Events which have not end
+      #
+      # @param event_id [String] An eventID or comma-separated list of eventIDs to get Event data for
+      #
+      # @param finalized [Boolean] Only include finalized Events (true), exclude unfinalized Events (false) or all
+      #
+      # @param include_alt_lines [Boolean] Whether to include alternate lines in the odds byBookmaker data
+      #
+      # @param include_opposing_odds [Boolean] Whether to include opposing odds for each included oddID
+      #
+      # @param league_id [String] A leagueID or comma-separated list of leagueIDs to get Events for
+      #
+      # @param limit [Float] The maximum number of Events to return
+      #
+      # @param live [Boolean] Only include live Events (true), only non-live Events (false) or all Events (omi
+      #
+      # @param odd_id [String] An oddID or comma-separated list of oddIDs to include odds for
+      #
+      # @param odds_available [Boolean] Whether you want only Events which do (true) or do not (false) have odds markets
+      #
+      # @param odds_present [Boolean] Whether you want only Events which do (true) or do not (false) have any associat
+      #
+      # @param player_id [String] A playerID or comma-separated list of playerIDs to include Events (and associate
+      #
+      # @param sport_id [String] A sportID or comma-separated list of sportIDs to get Events for
+      #
+      # @param started [Boolean] Only include Events which have have previously started (true), only Events which
+      #
+      # @param starts_after [Time] Get Events that start after this date
+      #
+      # @param starts_before [Time] Get Events that start before this date
+      #
+      # @param team_id [String] A teamID or comma-separated list of teamIDs to include Events for
+      #
+      # @param type [String] Only include Events of the specified type
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [SportsOddsAPI::Internal::NextCursorPage<SportsOddsAPI::Models::Event>]
+      #
+      # @see SportsOddsAPI::Models::EventGetParams
+      def get(params = {})
+        parsed, options = SportsOddsAPI::EventGetParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "events/",
+          query: parsed.transform_keys(
+            bookmaker_id: "bookmakerID",
+            event_id: "eventID",
+            include_alt_lines: "includeAltLines",
+            include_opposing_odds: "includeOpposingOdds",
+            league_id: "leagueID",
+            odd_id: "oddID",
+            odds_available: "oddsAvailable",
+            odds_present: "oddsPresent",
+            player_id: "playerID",
+            sport_id: "sportID",
+            starts_after: "startsAfter",
+            starts_before: "startsBefore",
+            team_id: "teamID"
+          ),
+          page: SportsOddsAPI::Internal::NextCursorPage,
+          model: SportsOddsAPI::Event,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/leagues.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Leagues
+      # Get a list of Leagues
+      #
+      # @overload get(league_id: nil, sport_id: nil, request_options: {})
+      #
+      # @param league_id [String] The league to get data for
+      #
+      # @param sport_id [String] The sport to get leagues for
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<SportsOddsAPI::Models::League>]
+      #
+      # @see SportsOddsAPI::Models::LeagueGetParams
+      def get(params = {})
+        parsed, options = SportsOddsAPI::LeagueGetParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "leagues/",
+          query: parsed.transform_keys(league_id: "leagueID", sport_id: "sportID"),
+          unwrap: :data,
+          model: SportsOddsAPI::Internal::Type::ArrayOf[SportsOddsAPI::League],
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/players.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Players
+      # Some parameter documentations has been truncated, see
+      # {SportsOddsAPI::Models::PlayerGetParams} for more details.
+      #
+      # Get a list of Players for a specific Team or Event
+      #
+      # @overload get(cursor: nil, event_id: nil, limit: nil, player_id: nil, team_id: nil, request_options: {})
+      #
+      # @param cursor [String] The cursor for the request. Used to get the next group of Players. This should b
+      #
+      # @param event_id [String] EventID to get Players data for
+      #
+      # @param limit [Float] The maximum number of Players to return
+      #
+      # @param player_id [String] PlayerID to get data for
+      #
+      # @param team_id [String] TeamID to get Players data for
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [SportsOddsAPI::Internal::NextCursorPage<SportsOddsAPI::Models::Player>]
+      #
+      # @see SportsOddsAPI::Models::PlayerGetParams
+      def get(params = {})
+        parsed, options = SportsOddsAPI::PlayerGetParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "players/",
+          query: parsed.transform_keys(event_id: "eventID", player_id: "playerID", team_id: "teamID"),
+          page: SportsOddsAPI::Internal::NextCursorPage,
+          model: SportsOddsAPI::Player,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/sports.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Sports
+      # Get a list of sports
+      #
+      # @overload get(request_options: {})
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<SportsOddsAPI::Models::Sport>]
+      #
+      # @see SportsOddsAPI::Models::SportGetParams
+      def get(params = {})
+        @client.request(
+          method: :get,
+          path: "sports/",
+          unwrap: :data,
+          model: SportsOddsAPI::Internal::Type::ArrayOf[SportsOddsAPI::Sport],
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/stats.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Stats
+      # Some parameter documentations has been truncated, see
+      # {SportsOddsAPI::Models::StatGetParams} for more details.
+      #
+      # Get a list of StatIDs
+      #
+      # @overload get(sport_id: nil, stat_id: nil, stat_level: nil, request_options: {})
+      #
+      # @param sport_id [String] SportID to get StatIDs for
+      #
+      # @param stat_id [String] StatID to get data for
+      #
+      # @param stat_level [String] Level of the stat, must be used in combination with sportID. Must be one of all,
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Array<SportsOddsAPI::Models::Stat>]
+      #
+      # @see SportsOddsAPI::Models::StatGetParams
+      def get(params = {})
+        parsed, options = SportsOddsAPI::StatGetParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "stats/",
+          query: parsed.transform_keys(sport_id: "sportID", stat_id: "statID", stat_level: "statLevel"),
+          unwrap: :data,
+          model: SportsOddsAPI::Internal::Type::ArrayOf[SportsOddsAPI::Stat],
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end