openlayer 0.0.2 → 0.1.1

data/rbi/openlayer/errors.rbi

@@ -1,205 +0,0 @@
-# typed: strong
-
-module Openlayer
-  module Errors
-    class Error < StandardError
-      sig { returns(T.nilable(StandardError)) }
-      attr_accessor :cause
-    end
-
-    class ConversionError < Openlayer::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 < Openlayer::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 < Openlayer::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 < Openlayer::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 < Openlayer::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 < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 400
-    end
-
-    class AuthenticationError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 401
-    end
-
-    class PermissionDeniedError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 403
-    end
-
-    class NotFoundError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 404
-    end
-
-    class ConflictError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 409
-    end
-
-    class UnprocessableEntityError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 422
-    end
-
-    class RateLimitError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = 429
-    end
-
-    class InternalServerError < Openlayer::Errors::APIStatusError
-      HTTP_STATUS = T.let((500..), T::Range[Integer])
-    end
-  end
-end

data/rbi/openlayer/file_part.rbi

@@ -1,37 +0,0 @@
-# typed: strong
-
-module Openlayer
-  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(T.any(Pathname, 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/openlayer/internal/transport/base_client.rbi

@@ -1,293 +0,0 @@
-# typed: strong
-
-module Openlayer
-  module Internal
-    module Transport
-      # @api private
-      class BaseClient
-        extend Openlayer::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        RequestComponents =
-          T.type_alias do
-            {
-              method: Symbol,
-              path: T.any(String, T::Array[String]),
-              query:
-                T.nilable(
-                  T::Hash[String, T.nilable(T.any(T::Array[String], String))]
-                ),
-              headers:
-                T.nilable(
-                  T::Hash[
-                    String,
-                    T.nilable(
-                      T.any(
-                        String,
-                        Integer,
-                        T::Array[T.nilable(T.any(String, Integer))]
-                      )
-                    )
-                  ]
-                ),
-              body: T.nilable(T.anything),
-              unwrap:
-                T.nilable(
-                  T.any(
-                    Symbol,
-                    Integer,
-                    T::Array[T.any(Symbol, Integer)],
-                    T.proc.params(arg0: T.anything).returns(T.anything)
-                  )
-                ),
-              page:
-                T.nilable(
-                  T::Class[
-                    Openlayer::Internal::Type::BasePage[
-                      Openlayer::Internal::Type::BaseModel
-                    ]
-                  ]
-                ),
-              stream: T.nilable(T::Class[T.anything]),
-              model: T.nilable(Openlayer::Internal::Type::Converter::Input),
-              options: T.nilable(Openlayer::RequestOptions::OrHash)
-            }
-          end
-
-        RequestInput =
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              max_retries: Integer,
-              timeout: Float
-            }
-          end
-
-        # from whatwg fetch spec
-        MAX_REDIRECTS = 20
-
-        PLATFORM_HEADERS = T::Hash[String, String]
-
-        class << self
-          # @api private
-          sig do
-            params(
-              req: Openlayer::Internal::Transport::BaseClient::RequestComponents
-            ).void
-          end
-          def validate!(req)
-          end
-
-          # @api private
-          sig do
-            params(status: Integer, headers: T::Hash[String, String]).returns(
-              T::Boolean
-            )
-          end
-          def should_retry?(status, headers:)
-          end
-
-          # @api private
-          sig do
-            params(
-              request: Openlayer::Internal::Transport::BaseClient::RequestInput,
-              status: Integer,
-              response_headers: T::Hash[String, String]
-            ).returns(Openlayer::Internal::Transport::BaseClient::RequestInput)
-          end
-          def follow_redirect(request, status:, response_headers:)
-          end
-
-          # @api private
-          sig do
-            params(
-              status: T.any(Integer, Openlayer::Errors::APIConnectionError),
-              stream: T.nilable(T::Enumerable[String])
-            ).void
-          end
-          def reap_connection!(status, stream:)
-          end
-        end
-
-        sig { returns(URI::Generic) }
-        attr_reader :base_url
-
-        sig { returns(Float) }
-        attr_reader :timeout
-
-        sig { returns(Integer) }
-        attr_reader :max_retries
-
-        sig { returns(Float) }
-        attr_reader :initial_retry_delay
-
-        sig { returns(Float) }
-        attr_reader :max_retry_delay
-
-        sig { returns(T::Hash[String, String]) }
-        attr_reader :headers
-
-        sig { returns(T.nilable(String)) }
-        attr_reader :idempotency_header
-
-        # @api private
-        sig { returns(Openlayer::Internal::Transport::PooledNetRequester) }
-        attr_reader :requester
-
-        # @api private
-        sig do
-          params(
-            base_url: String,
-            timeout: Float,
-            max_retries: Integer,
-            initial_retry_delay: Float,
-            max_retry_delay: Float,
-            headers:
-              T::Hash[
-                String,
-                T.nilable(
-                  T.any(
-                    String,
-                    Integer,
-                    T::Array[T.nilable(T.any(String, Integer))]
-                  )
-                )
-              ],
-            idempotency_header: T.nilable(String)
-          ).returns(T.attached_class)
-        end
-        def self.new(
-          base_url:,
-          timeout: 0.0,
-          max_retries: 0,
-          initial_retry_delay: 0.0,
-          max_retry_delay: 0.0,
-          headers: {},
-          idempotency_header: nil
-        )
-        end
-
-        # @api private
-        sig { overridable.returns(T::Hash[String, String]) }
-        private def auth_headers
-        end
-
-        # @api private
-        sig { returns(String) }
-        private def generate_idempotency_key
-        end
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              req:
-                Openlayer::Internal::Transport::BaseClient::RequestComponents,
-              opts: Openlayer::Internal::AnyHash
-            )
-            .returns(Openlayer::Internal::Transport::BaseClient::RequestInput)
-        end
-        private def build_request(req, opts)
-        end
-
-        # @api private
-        sig do
-          params(
-            headers: T::Hash[String, String],
-            retry_count: Integer
-          ).returns(Float)
-        end
-        private def retry_delay(headers, retry_count:)
-        end
-
-        # @api private
-        sig do
-          params(
-            request: Openlayer::Internal::Transport::BaseClient::RequestInput,
-            redirect_count: Integer,
-            retry_count: Integer,
-            send_retry_header: T::Boolean
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        def send_request(
-          request,
-          redirect_count:,
-          retry_count:,
-          send_retry_header:
-        )
-        end
-
-        # Execute the request specified by `req`. This is the method that all resource
-        # methods call into.
-        #
-        # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Openlayer::Internal::Type::Unknown, options: {})
-        sig do
-          params(
-            method: Symbol,
-            path: T.any(String, T::Array[String]),
-            query:
-              T.nilable(
-                T::Hash[String, T.nilable(T.any(T::Array[String], String))]
-              ),
-            headers:
-              T.nilable(
-                T::Hash[
-                  String,
-                  T.nilable(
-                    T.any(
-                      String,
-                      Integer,
-                      T::Array[T.nilable(T.any(String, Integer))]
-                    )
-                  )
-                ]
-              ),
-            body: T.nilable(T.anything),
-            unwrap:
-              T.nilable(
-                T.any(
-                  Symbol,
-                  Integer,
-                  T::Array[T.any(Symbol, Integer)],
-                  T.proc.params(arg0: T.anything).returns(T.anything)
-                )
-              ),
-            page:
-              T.nilable(
-                T::Class[
-                  Openlayer::Internal::Type::BasePage[
-                    Openlayer::Internal::Type::BaseModel
-                  ]
-                ]
-              ),
-            stream: T.nilable(T::Class[T.anything]),
-            model: T.nilable(Openlayer::Internal::Type::Converter::Input),
-            options: T.nilable(Openlayer::RequestOptions::OrHash)
-          ).returns(T.anything)
-        end
-        def request(
-          method,
-          path,
-          query: {},
-          headers: {},
-          body: nil,
-          unwrap: nil,
-          page: nil,
-          stream: nil,
-          model: Openlayer::Internal::Type::Unknown,
-          options: {}
-        )
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect
-        end
-      end
-    end
-  end
-end

data/rbi/openlayer/internal/transport/pooled_net_requester.rbi

@@ -1,79 +0,0 @@
-# typed: strong
-
-module Openlayer
-  module Internal
-    module Transport
-      # @api private
-      class PooledNetRequester
-        extend Openlayer::Internal::Util::SorbetRuntimeSupport
-
-        Request =
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              deadline: Float
-            }
-          end
-
-        # from the golang stdlib
-        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
-        KEEP_ALIVE_TIMEOUT = 30
-
-        DEFAULT_MAX_CONNECTIONS = T.let(T.unsafe(nil), Integer)
-
-        class << self
-          # @api private
-          sig { params(url: URI::Generic).returns(Net::HTTP) }
-          def connect(url)
-          end
-
-          # @api private
-          sig { params(conn: Net::HTTP, deadline: Float).void }
-          def calibrate_socket_timeout(conn, deadline)
-          end
-
-          # @api private
-          sig do
-            params(
-              request:
-                Openlayer::Internal::Transport::PooledNetRequester::Request,
-              blk: T.proc.params(arg0: String).void
-            ).returns([Net::HTTPGenericRequest, T.proc.void])
-          end
-          def build_request(request, &blk)
-          end
-        end
-
-        # @api private
-        sig do
-          params(
-            url: URI::Generic,
-            deadline: Float,
-            blk: T.proc.params(arg0: Net::HTTP).void
-          ).void
-        end
-        private def with_pool(url, deadline:, &blk)
-        end
-
-        # @api private
-        sig do
-          params(
-            request: Openlayer::Internal::Transport::PooledNetRequester::Request
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        def execute(request)
-        end
-
-        # @api private
-        sig { params(size: Integer).returns(T.attached_class) }
-        def self.new(
-          size: Openlayer::Internal::Transport::PooledNetRequester::DEFAULT_MAX_CONNECTIONS
-        )
-        end
-      end
-    end
-  end
-end

data/rbi/openlayer/internal/type/array_of.rbi

@@ -1,104 +0,0 @@
-# typed: strong
-
-module Openlayer
-  module Internal
-    module Type
-      # @api private
-      #
-      # Array of items of a given type.
-      class ArrayOf
-        include Openlayer::Internal::Type::Converter
-        include Openlayer::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        Elem = type_member(:out)
-
-        sig do
-          params(
-            type_info:
-              T.any(
-                Openlayer::Internal::AnyHash,
-                T.proc.returns(Openlayer::Internal::Type::Converter::Input),
-                Openlayer::Internal::Type::Converter::Input
-              ),
-            spec: Openlayer::Internal::AnyHash
-          ).returns(T.attached_class)
-        end
-        def self.[](type_info, spec = {})
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(T::Array[T.anything], T.anything),
-              state: Openlayer::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(T::Array[T.anything], T.anything))
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(T::Array[T.anything], T.anything),
-              state: Openlayer::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(T::Array[T.anything], T.anything))
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { returns(T.anything) }
-        def to_sorbet_type
-        end
-
-        # @api private
-        sig { returns(Elem) }
-        protected def item_type
-        end
-
-        # @api private
-        sig { returns(T::Boolean) }
-        protected def nilable?
-        end
-
-        # @api private
-        sig do
-          params(
-            type_info:
-              T.any(
-                Openlayer::Internal::AnyHash,
-                T.proc.returns(Openlayer::Internal::Type::Converter::Input),
-                Openlayer::Internal::Type::Converter::Input
-              ),
-            spec: Openlayer::Internal::AnyHash
-          ).void
-        end
-        def initialize(type_info, spec = {})
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-      end
-    end
-  end
-end