anthropic 0.1.0.pre.beta.9 → 0.1.0

data/rbi/anthropic/internal/type/base_model.rbi

@@ -1,304 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      class BaseModel
-        extend Anthropic::Internal::Type::Converter
-        extend Anthropic::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        KnownField =
-          T.type_alias do
-            {
-              mode: T.nilable(Symbol),
-              required: T::Boolean,
-              nilable: T::Boolean
-            }
-          end
-
-        OrHash =
-          T.type_alias do
-            T.any(
-              Anthropic::Internal::Type::BaseModel,
-              Anthropic::Internal::AnyHash
-            )
-          end
-
-        class << self
-          # @api private
-          #
-          # Assumes superclass fields are totally defined before fields are accessed /
-          # defined on subclasses.
-          sig { params(child: T.self_type).void }
-          def inherited(child)
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  Anthropic::Internal::Type::BaseModel::KnownField,
-                  {
-                    type_fn:
-                      T.proc.returns(
-                        Anthropic::Internal::Type::Converter::Input
-                      )
-                  }
-                )
-              ]
-            )
-          end
-          def known_fields
-          end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  Anthropic::Internal::Type::BaseModel::KnownField,
-                  { type: Anthropic::Internal::Type::Converter::Input }
-                )
-              ]
-            )
-          end
-          def fields
-          end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              required: T::Boolean,
-              type_info:
-                T.any(
-                  {
-                    const:
-                      T.nilable(
-                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
-                      ),
-                    enum:
-                      T.nilable(
-                        T.proc.returns(
-                          Anthropic::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          Anthropic::Internal::Type::Converter::Input
-                        )
-                      ),
-                    api_name: Symbol,
-                    nil?: T::Boolean
-                  },
-                  T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                  Anthropic::Internal::Type::Converter::Input
-                ),
-              spec: Anthropic::Internal::AnyHash
-            ).void
-          end
-          private def add_field(name_sym, required:, type_info:, spec:)
-          end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              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 required(name_sym, type_info, spec = {})
-          end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              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 optional(name_sym, type_info, spec = {})
-          end
-
-          # @api private
-          #
-          # `request_only` attributes not excluded from `.#coerce` when receiving responses
-          # even if well behaved servers should not send them
-          sig { params(blk: T.proc.void).void }
-          private def request_only(&blk)
-          end
-
-          # @api private
-          #
-          # `response_only` attributes are omitted from `.#dump` when making requests
-          sig { params(blk: T.proc.void).void }
-          private def response_only(&blk)
-          end
-
-          sig { params(other: T.anything).returns(T::Boolean) }
-          def ==(other)
-          end
-
-          sig { returns(Integer) }
-          def hash
-          end
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
-
-        sig { returns(Integer) }
-        def hash
-        end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value:
-                  T.any(
-                    Anthropic::Internal::Type::BaseModel,
-                    T::Hash[T.anything, T.anything],
-                    T.anything
-                  ),
-                state: Anthropic::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(T.attached_class, T.anything))
-          end
-          def coerce(value, state:)
-          end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(T.attached_class, T.anything),
-                state: Anthropic::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
-          end
-          def dump(value, state:)
-          end
-
-          # @api private
-          sig { returns(T.anything) }
-          def to_sorbet_type
-          end
-        end
-
-        class << self
-          # @api private
-          sig do
-            params(
-              model: Anthropic::Internal::Type::BaseModel,
-              convert: T::Boolean
-            ).returns(Anthropic::Internal::AnyHash)
-          end
-          def recursively_to_h(model, convert:)
-          end
-        end
-
-        # Returns the raw value associated with the given key, if found. Otherwise, nil is
-        # returned.
-        #
-        # It is valid to lookup keys that are not in the API spec, for example to access
-        # undocumented features. This method does not parse response data into
-        # higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
-        sig { params(key: Symbol).returns(T.nilable(T.anything)) }
-        def [](key)
-        end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(Anthropic::Internal::AnyHash) }
-        def to_h
-        end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(Anthropic::Internal::AnyHash) }
-        def to_hash
-        end
-
-        # In addition to the behaviour of `#to_h`, this method will recursively call
-        # `#to_h` on nested models.
-        sig { overridable.returns(Anthropic::Internal::AnyHash) }
-        def deep_to_h
-        end
-
-        sig do
-          params(keys: T.nilable(T::Array[Symbol])).returns(
-            Anthropic::Internal::AnyHash
-          )
-        end
-        def deconstruct_keys(keys)
-        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
-
-        # Create a new instance of a model.
-        sig do
-          params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(
-            T.attached_class
-          )
-        end
-        def self.new(data = {})
-        end
-
-        class << self
-          # @api private
-          sig { params(depth: Integer).returns(String) }
-          def inspect(depth: 0)
-          end
-        end
-
-        sig { returns(String) }
-        def to_s
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/base_page.rbi

@@ -1,42 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # This module provides a base implementation for paginated responses in the SDK.
-      module BasePage
-        Elem = type_member(:out)
-
-        sig { overridable.returns(T::Boolean) }
-        def next_page?
-        end
-
-        sig { overridable.returns(T.self_type) }
-        def next_page
-        end
-
-        sig { overridable.params(blk: T.proc.params(arg0: Elem).void).void }
-        def auto_paging_each(&blk)
-        end
-
-        sig { returns(T::Enumerable[Elem]) }
-        def to_enum
-        end
-
-        # @api private
-        sig do
-          params(
-            client: Anthropic::Internal::Transport::BaseClient,
-            req: Anthropic::Internal::Transport::BaseClient::RequestComponents,
-            headers: T.any(T::Hash[String, String], Net::HTTPHeader),
-            page_data: T.anything
-          ).void
-        end
-        def initialize(client:, req:, headers:, page_data:)
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/base_stream.rbi

@@ -1,68 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # This module provides a base implementation for streaming responses in the SDK.
-      module BaseStream
-        include Enumerable
-
-        Message = type_member(:in)
-        Elem = type_member(:out)
-
-        class << self
-          # Attempt to close the underlying transport when the stream itself is garbage
-          # collected.
-          #
-          # This should not be relied upon for resource clean up, as the garbage collector
-          # is not guaranteed to run.
-          sig do
-            params(stream: T::Enumerable[T.anything]).returns(
-              T.proc.params(arg0: Integer).void
-            )
-          end
-          def defer_closing(stream)
-          end
-        end
-
-        sig { void }
-        def close
-        end
-
-        # @api private
-        sig { overridable.returns(T::Enumerable[Elem]) }
-        private def iterator
-        end
-
-        sig { params(blk: T.proc.params(arg0: Elem).void).void }
-        def each(&blk)
-        end
-
-        sig { returns(T::Enumerator[Elem]) }
-        def to_enum
-        end
-
-        # @api private
-        sig do
-          params(
-            model:
-              T.any(T::Class[T.anything], Anthropic::Internal::Type::Converter),
-            url: URI::Generic,
-            status: Integer,
-            response: Net::HTTPResponse,
-            stream: T::Enumerable[Message]
-          ).void
-        end
-        def initialize(model:, url:, status:, response:, stream:)
-        end
-
-        # @api private
-        sig { returns(String) }
-        def inspect
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/boolean.rbi

@@ -1,56 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # Ruby has no Boolean class; this is something for models to refer to.
-      class Boolean
-        extend Anthropic::Internal::Type::Converter
-        extend Anthropic::Internal::Util::SorbetRuntimeSupport
-
-        abstract!
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.===(other)
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def self.==(other)
-        end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(T::Boolean, T.anything),
-                state: Anthropic::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(T::Boolean, T.anything))
-          end
-          def coerce(value, state:)
-          end
-
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(T::Boolean, T.anything),
-                state: Anthropic::Internal::Type::Converter::DumpState
-              )
-              .returns(T.any(T::Boolean, T.anything))
-          end
-          def dump(value, state:)
-          end
-
-          # @api private
-          sig { returns(T.anything) }
-          def to_sorbet_type
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/converter.rbi

@@ -1,162 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      module Converter
-        extend Anthropic::Internal::Util::SorbetRuntimeSupport
-
-        Input =
-          T.type_alias do
-            T.any(Anthropic::Internal::Type::Converter, T::Class[T.anything])
-          end
-
-        CoerceState =
-          T.type_alias do
-            {
-              strictness: T.any(T::Boolean, Symbol),
-              exactness: {
-                yes: Integer,
-                no: Integer,
-                maybe: Integer
-              },
-              branched: Integer
-            }
-          end
-
-        DumpState = T.type_alias { { can_retry: T::Boolean } }
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              value: T.anything,
-              state: Anthropic::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.anything)
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              value: T.anything,
-              state: Anthropic::Internal::Type::Converter::DumpState
-            )
-            .returns(T.anything)
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-
-        class << self
-          # @api private
-          sig do
-            params(
-              spec:
-                T.any(
-                  {
-                    const:
-                      T.nilable(
-                        T.any(NilClass, T::Boolean, Integer, Float, Symbol)
-                      ),
-                    enum:
-                      T.nilable(
-                        T.proc.returns(
-                          Anthropic::Internal::Type::Converter::Input
-                        )
-                      ),
-                    union:
-                      T.nilable(
-                        T.proc.returns(
-                          Anthropic::Internal::Type::Converter::Input
-                        )
-                      )
-                  },
-                  T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                  Anthropic::Internal::Type::Converter::Input
-                )
-            ).returns(T.proc.returns(T.anything))
-          end
-          def self.type_info(spec)
-          end
-
-          # @api private
-          #
-          # Based on `target`, transform `value` into `target`, to the extent possible:
-          #
-          # 1. if the given `value` conforms to `target` already, return the given `value`
-          # 2. if it's possible and safe to convert the given `value` to `target`, then the
-          #    converted value
-          # 3. otherwise, the given `value` unaltered
-          #
-          # The coercion process is subject to improvement between minor release versions.
-          # See https://docs.pydantic.dev/latest/concepts/unions/#smart-mode
-          sig do
-            params(
-              target: Anthropic::Internal::Type::Converter::Input,
-              value: T.anything,
-              state: Anthropic::Internal::Type::Converter::CoerceState
-            ).returns(T.anything)
-          end
-          def self.coerce(
-            target,
-            value,
-            # The `strictness` is one of `true`, `false`, or `:strong`. This informs the
-            # coercion strategy when we have to decide between multiple possible conversion
-            # targets:
-            #
-            # - `true`: the conversion must be exact, with minimum coercion.
-            # - `false`: the conversion can be approximate, with some coercion.
-            # - `:strong`: the conversion must be exact, with no coercion, and raise an error
-            #   if not possible.
-            #
-            # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
-            # any given conversion attempt, the exactness will be updated based on how closely
-            # the value recursively matches the target type:
-            #
-            # - `yes`: the value can be converted to the target type with minimum coercion.
-            # - `maybe`: the value can be converted to the target type with some reasonable
-            #   coercion.
-            # - `no`: the value cannot be converted to the target type.
-            #
-            # See implementation below for more details.
-            state: {
-              strictness: true,
-              exactness: {
-                yes: 0,
-                no: 0,
-                maybe: 0
-              },
-              branched: 0
-            }
-          )
-          end
-
-          # @api private
-          sig do
-            params(
-              target: Anthropic::Internal::Type::Converter::Input,
-              value: T.anything,
-              state: Anthropic::Internal::Type::Converter::DumpState
-            ).returns(T.anything)
-          end
-          def self.dump(target, value, state: { can_retry: true })
-          end
-
-          # @api private
-          sig { params(target: T.anything, depth: Integer).returns(String) }
-          def self.inspect(target, depth:)
-          end
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/internal/type/enum.rbi

@@ -1,82 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # A value from among a specified list of options. OpenAPI enum values map to Ruby
-      # values in the SDK as follows:
-      #
-      # 1. boolean => true | false
-      # 2. integer => Integer
-      # 3. float => Float
-      # 4. string => Symbol
-      #
-      # We can therefore convert string values to Symbols, but can't convert other
-      # values safely.
-      module Enum
-        include Anthropic::Internal::Type::Converter
-        include Anthropic::Internal::Util::SorbetRuntimeSupport
-
-        # All of the valid Symbol values for this enum.
-        sig do
-          overridable.returns(
-            T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)]
-          )
-        end
-        def values
-        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
-        #
-        # Unlike with primitives, `Enum` additionally validates that the value is a member
-        # of the enum.
-        sig do
-          override
-            .params(
-              value: T.any(String, Symbol, T.anything),
-              state: Anthropic::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(Symbol, T.anything))
-        end
-        def coerce(value, state:)
-        end
-
-        # @api private
-        sig do
-          override
-            .params(
-              value: T.any(Symbol, T.anything),
-              state: Anthropic::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(Symbol, T.anything))
-        end
-        def dump(value, state:)
-        end
-
-        # @api private
-        sig { returns(T.anything) }
-        def to_sorbet_type
-        end
-
-        # @api private
-        sig { params(depth: Integer).returns(String) }
-        def inspect(depth: 0)
-        end
-      end
-    end
-  end
-end