sports-odds-api 1.0.0

data/lib/sports_odds_api/resources/stream.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Stream
+      # Setup streamed (WebSocket) connection
+      #
+      # @overload events(event_id: nil, feed: nil, league_id: nil, request_options: {})
+      #
+      # @param event_id [String] An eventID to stream events for
+      #
+      # @param feed [String] The feed you would like to subscribe to
+      #
+      # @param league_id [String] A leagueID to stream events for
+      #
+      # @param request_options [SportsOddsAPI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [SportsOddsAPI::Models::StreamEventsResponse]
+      #
+      # @see SportsOddsAPI::Models::StreamEventsParams
+      def events(params = {})
+        parsed, options = SportsOddsAPI::StreamEventsParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "stream/events",
+          query: parsed.transform_keys(event_id: "eventID", league_id: "leagueID"),
+          model: SportsOddsAPI::Models::StreamEventsResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/resources/teams.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  module Resources
+    class Teams
+      # Some parameter documentations has been truncated, see
+      # {SportsOddsAPI::Models::TeamGetParams} for more details.
+      #
+      # Get a list of Teams by ID or league
+      #
+      # @overload get(cursor: nil, league_id: nil, limit: nil, sport_id: nil, team_id: nil, request_options: {})
+      #
+      # @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}, nil]
+      #
+      # @return [SportsOddsAPI::Internal::NextCursorPage<SportsOddsAPI::Models::Team>]
+      #
+      # @see SportsOddsAPI::Models::TeamGetParams
+      def get(params = {})
+        parsed, options = SportsOddsAPI::TeamGetParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "teams/",
+          query: parsed.transform_keys(league_id: "leagueID", sport_id: "sportID", team_id: "teamID"),
+          page: SportsOddsAPI::Internal::NextCursorPage,
+          model: SportsOddsAPI::Team,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [SportsOddsAPI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/sports_odds_api/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SportsOddsAPI
+  VERSION = "1.0.0"
+end

data/lib/sports_odds_api.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) &&
+   caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+
+# Package files.
+require_relative "sports_odds_api/version"
+require_relative "sports_odds_api/internal/util"
+require_relative "sports_odds_api/internal/type/converter"
+require_relative "sports_odds_api/internal/type/unknown"
+require_relative "sports_odds_api/internal/type/boolean"
+require_relative "sports_odds_api/internal/type/file_input"
+require_relative "sports_odds_api/internal/type/enum"
+require_relative "sports_odds_api/internal/type/union"
+require_relative "sports_odds_api/internal/type/array_of"
+require_relative "sports_odds_api/internal/type/hash_of"
+require_relative "sports_odds_api/internal/type/base_model"
+require_relative "sports_odds_api/internal/type/base_page"
+require_relative "sports_odds_api/internal/type/request_parameters"
+require_relative "sports_odds_api/internal"
+require_relative "sports_odds_api/request_options"
+require_relative "sports_odds_api/file_part"
+require_relative "sports_odds_api/errors"
+require_relative "sports_odds_api/internal/transport/base_client"
+require_relative "sports_odds_api/internal/transport/pooled_net_requester"
+require_relative "sports_odds_api/client"
+require_relative "sports_odds_api/internal/next_cursor_page"
+require_relative "sports_odds_api/models/account_get_usage_params"
+require_relative "sports_odds_api/models/account_usage"
+require_relative "sports_odds_api/models/event"
+require_relative "sports_odds_api/models/event_get_params"
+require_relative "sports_odds_api/models/league"
+require_relative "sports_odds_api/models/league_get_params"
+require_relative "sports_odds_api/models/league_get_response"
+require_relative "sports_odds_api/models/player"
+require_relative "sports_odds_api/models/player_get_params"
+require_relative "sports_odds_api/models/rate_limit_interval"
+require_relative "sports_odds_api/models/sport"
+require_relative "sports_odds_api/models/sport_get_params"
+require_relative "sports_odds_api/models/sport_get_response"
+require_relative "sports_odds_api/models/stat"
+require_relative "sports_odds_api/models/stat_get_params"
+require_relative "sports_odds_api/models/stat_get_response"
+require_relative "sports_odds_api/models/stream_events_params"
+require_relative "sports_odds_api/models/stream_events_response"
+require_relative "sports_odds_api/models/team"
+require_relative "sports_odds_api/models/team_get_params"
+require_relative "sports_odds_api/models"
+require_relative "sports_odds_api/resources/account"
+require_relative "sports_odds_api/resources/events"
+require_relative "sports_odds_api/resources/leagues"
+require_relative "sports_odds_api/resources/players"
+require_relative "sports_odds_api/resources/sports"
+require_relative "sports_odds_api/resources/stats"
+require_relative "sports_odds_api/resources/stream"
+require_relative "sports_odds_api/resources/teams"

data/manifest.yaml

@@ -0,0 +1,15 @@
+dependencies:
+  - English
+  - cgi
+  - date
+  - erb
+  - etc
+  - json
+  - net/http
+  - pathname
+  - rbconfig
+  - securerandom
+  - set
+  - stringio
+  - time
+  - uri

data/rbi/sports_odds_api/client.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module SportsOddsAPI
+  class Client < SportsOddsAPI::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    # API key via header
+    sig { returns(T.nilable(String)) }
+    attr_reader :api_key_header
+
+    # API key via query param
+    sig { returns(T.nilable(String)) }
+    attr_reader :api_key_param
+
+    sig { returns(SportsOddsAPI::Resources::Events) }
+    attr_reader :events
+
+    sig { returns(SportsOddsAPI::Resources::Teams) }
+    attr_reader :teams
+
+    sig { returns(SportsOddsAPI::Resources::Players) }
+    attr_reader :players
+
+    sig { returns(SportsOddsAPI::Resources::Leagues) }
+    attr_reader :leagues
+
+    sig { returns(SportsOddsAPI::Resources::Sports) }
+    attr_reader :sports
+
+    sig { returns(SportsOddsAPI::Resources::Stats) }
+    attr_reader :stats
+
+    sig { returns(SportsOddsAPI::Resources::Account) }
+    attr_reader :account
+
+    sig { returns(SportsOddsAPI::Resources::Stream) }
+    attr_reader :stream
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_query
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        api_key_header: T.nilable(String),
+        api_key_param: T.nilable(String),
+        base_url: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      # API key via header Defaults to `ENV["SPORTS_ODDS_API_KEY_HEADER"]`
+      api_key_header: ENV["SPORTS_ODDS_API_KEY_HEADER"],
+      # API key via query param Defaults to `ENV["SPORTS_ODDS_API_KEY_HEADER"]`
+      api_key_param: ENV["SPORTS_ODDS_API_KEY_HEADER"],
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["SPORTS_GAME_ODDS_BASE_URL"]`
+      base_url: ENV["SPORTS_GAME_ODDS_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: SportsOddsAPI::Client::DEFAULT_MAX_RETRIES,
+      timeout: SportsOddsAPI::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: SportsOddsAPI::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: SportsOddsAPI::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/sports_odds_api/errors.rbi

@@ -0,0 +1,205 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Errors
+    class Error < StandardError
+      sig { returns(T.nilable(StandardError)) }
+      attr_accessor :cause
+    end
+
+    class ConversionError < SportsOddsAPI::Errors::Error
+      sig { returns(T.nilable(StandardError)) }
+      def cause
+      end
+
+      # @api private
+      sig do
+        params(
+          on: T::Class[StandardError],
+          method: Symbol,
+          target: T.anything,
+          value: T.anything,
+          cause: T.nilable(StandardError)
+        ).returns(T.attached_class)
+      end
+      def self.new(on:, method:, target:, value:, cause: nil)
+      end
+    end
+
+    class APIError < SportsOddsAPI::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(T::Hash[String, String])) }
+      attr_accessor :headers
+
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: T.nilable(Integer),
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: nil
+      )
+      end
+    end
+
+    class APIConnectionError < SportsOddsAPI::Errors::APIError
+      sig { returns(NilClass) }
+      attr_accessor :status
+
+      sig { returns(NilClass) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+      end
+    end
+
+    class APITimeoutError < SportsOddsAPI::Errors::APIConnectionError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          headers: T.nilable(T::Hash[String, String]),
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        headers: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+      end
+    end
+
+    class APIStatusError < SportsOddsAPI::Errors::APIError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.for(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+
+      sig { returns(Integer) }
+      attr_accessor :status
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          headers: T.nilable(T::Hash[String, String]),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status:,
+        headers:,
+        body:,
+        request:,
+        response:,
+        message: nil
+      )
+      end
+    end
+
+    class BadRequestError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < SportsOddsAPI::Errors::APIStatusError
+      HTTP_STATUS = T.let((500..), T::Range[Integer])
+    end
+  end
+end

data/rbi/sports_odds_api/file_part.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module SportsOddsAPI
+  class FilePart
+    sig { returns(T.any(Pathname, StringIO, IO, String)) }
+    attr_reader :content
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :content_type
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :filename
+
+    # @api private
+    sig { returns(String) }
+    private def read
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_json(*a)
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_yaml(*a)
+    end
+
+    sig do
+      params(
+        content: T.any(Pathname, StringIO, IO, String),
+        filename: T.nilable(String),
+        content_type: T.nilable(String)
+      ).returns(T.attached_class)
+    end
+    def self.new(content, filename: nil, content_type: nil)
+    end
+  end
+end

data/rbi/sports_odds_api/internal/next_cursor_page.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module SportsOddsAPI
+  module Internal
+    class NextCursorPage
+      include SportsOddsAPI::Internal::Type::BasePage
+
+      Elem = type_member
+
+      sig { returns(T.nilable(T::Array[Elem])) }
+      attr_accessor :data
+
+      sig { returns(String) }
+      attr_accessor :next_cursor
+
+      # @api private
+      sig { returns(String) }
+      def inspect
+      end
+    end
+  end
+end