anthropic 0.1.0.pre.beta.9 → 0.1.0

data/rbi/anthropic/internal/transport/base_client.rbi

@@ -1,310 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Transport
-      # @api private
-      class BaseClient
-        extend Anthropic::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[
-                    Anthropic::Internal::Type::BasePage[
-                      Anthropic::Internal::Type::BaseModel
-                    ]
-                  ]
-                ),
-              stream:
-                T.nilable(
-                  T::Class[
-                    Anthropic::Internal::Type::BaseStream[
-                      T.anything,
-                      Anthropic::Internal::Type::BaseModel
-                    ]
-                  ]
-                ),
-              model: T.nilable(Anthropic::Internal::Type::Converter::Input),
-              options: T.nilable(Anthropic::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: Anthropic::Internal::Transport::BaseClient::RequestComponents
-            ).void
-          end
-          def validate!(req)
-          end
-
-          # @api private
-          sig do
-            params(
-              status: Integer,
-              headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-            ).returns(T::Boolean)
-          end
-          def should_retry?(status, headers:)
-          end
-
-          # @api private
-          sig do
-            params(
-              request: Anthropic::Internal::Transport::BaseClient::RequestInput,
-              status: Integer,
-              response_headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-            ).returns(Anthropic::Internal::Transport::BaseClient::RequestInput)
-          end
-          def follow_redirect(request, status:, response_headers:)
-          end
-
-          # @api private
-          sig do
-            params(
-              status: T.any(Integer, Anthropic::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(Anthropic::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:
-                Anthropic::Internal::Transport::BaseClient::RequestComponents,
-              opts: Anthropic::Internal::AnyHash
-            )
-            .returns(Anthropic::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: Anthropic::Internal::Transport::BaseClient::RequestInput,
-            redirect_count: Integer,
-            retry_count: Integer,
-            send_retry_header: T::Boolean
-          ).returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        private 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: Anthropic::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[
-                  Anthropic::Internal::Type::BasePage[
-                    Anthropic::Internal::Type::BaseModel
-                  ]
-                ]
-              ),
-            stream:
-              T.nilable(
-                T::Class[
-                  Anthropic::Internal::Type::BaseStream[
-                    T.anything,
-                    Anthropic::Internal::Type::BaseModel
-                  ]
-                ]
-              ),
-            model: T.nilable(Anthropic::Internal::Type::Converter::Input),
-            options: T.nilable(Anthropic::RequestOptions::OrHash)
-          ).returns(T.anything)
-        end
-        def request(
-          method,
-          path,
-          query: {},
-          headers: {},
-          body: nil,
-          unwrap: nil,
-          page: nil,
-          stream: nil,
-          model: Anthropic::Internal::Type::Unknown,
-          options: {}
-        )
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/transport/pooled_net_requester.rbi

@@ -1,79 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Transport
-      # @api private
-      class PooledNetRequester
-        extend Anthropic::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:
-                Anthropic::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: Anthropic::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: Anthropic::Internal::Transport::PooledNetRequester::DEFAULT_MAX_CONNECTIONS
-        )
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/array_of.rbi

@@ -1,104 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # Array of items of a given type.
-      class ArrayOf
-        include Anthropic::Internal::Type::Converter
-        include Anthropic::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        Elem = type_member(:out)
-
-        sig do
-          params(
-            type_info:
-              T.any(
-                Anthropic::Internal::AnyHash,
-                T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                Anthropic::Internal::Type::Converter::Input
-              ),
-            spec: Anthropic::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: Anthropic::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: Anthropic::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(
-                Anthropic::Internal::AnyHash,
-                T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                Anthropic::Internal::Type::Converter::Input
-              ),
-            spec: Anthropic::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