turbopuffer-ruby 0.2.0.pre.alpha.1

data/lib/turbopuffer/models/query_performance.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    class QueryPerformance < Turbopuffer::Internal::Type::BaseModel
+      # @!attribute approx_namespace_size
+      #   the approximate number of documents in the namespace.
+      #
+      #   @return [Integer]
+      required :approx_namespace_size, Integer
+
+      # @!attribute cache_hit_ratio
+      #   The ratio of cache hits to total cache lookups.
+      #
+      #   @return [Float]
+      required :cache_hit_ratio, Float
+
+      # @!attribute cache_temperature
+      #   A qualitative description of the cache hit ratio (`hot`, `warm`, or `cold`).
+      #
+      #   @return [String]
+      required :cache_temperature, String
+
+      # @!attribute exhaustive_search_count
+      #   The number of unindexed documents processed by the query.
+      #
+      #   @return [Integer]
+      required :exhaustive_search_count, Integer
+
+      # @!attribute query_execution_ms
+      #   Request time measured on the server, excluding time spent waiting due to the
+      #   namespace concurrency limit.
+      #
+      #   @return [Integer]
+      required :query_execution_ms, Integer
+
+      # @!attribute server_total_ms
+      #   Request time measured on the server, including time spent waiting for other
+      #   queries to complete if the namespace was at its concurrency limit.
+      #
+      #   @return [Integer]
+      required :server_total_ms, Integer
+
+      # @!method initialize(approx_namespace_size:, cache_hit_ratio:, cache_temperature:, exhaustive_search_count:, query_execution_ms:, server_total_ms:)
+      #   Some parameter documentations has been truncated, see
+      #   {Turbopuffer::Models::QueryPerformance} for more details.
+      #
+      #   The performance information for a query.
+      #
+      #   @param approx_namespace_size [Integer] the approximate number of documents in the namespace.
+      #
+      #   @param cache_hit_ratio [Float] The ratio of cache hits to total cache lookups.
+      #
+      #   @param cache_temperature [String] A qualitative description of the cache hit ratio (`hot`, `warm`, or `cold`).
+      #
+      #   @param exhaustive_search_count [Integer] The number of unindexed documents processed by the query.
+      #
+      #   @param query_execution_ms [Integer] Request time measured on the server, excluding time spent waiting due to the nam
+      #
+      #   @param server_total_ms [Integer] Request time measured on the server, including time spent waiting for other quer
+    end
+  end
+end

data/lib/turbopuffer/models/row.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    class Row < Turbopuffer::Internal::Type::BaseModel
+      # @!attribute id
+      #   An identifier for a document.
+      #
+      #   @return [String, Integer]
+      required :id, union: -> { Turbopuffer::ID }
+
+      # @!attribute vector
+      #   A vector embedding associated with a document.
+      #
+      #   @return [Array<Float>, String, nil]
+      optional :vector, union: -> { Turbopuffer::Vector }
+
+      # @!method initialize(id:, vector: nil)
+      #   A single document, in a row-based format.
+      #
+      #   @param id [String, Integer] An identifier for a document.
+      #
+      #   @param vector [Array<Float>, String] A vector embedding associated with a document.
+
+      def method_missing(name, *args, &block)
+        if @data.key?(name)
+          @data[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        @data.key?(name) || super
+      end
+    end
+  end
+end

data/lib/turbopuffer/models/tokenizer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    # The tokenizer to use for full-text search on an attribute.
+    module Tokenizer
+      extend Turbopuffer::Internal::Type::Enum
+
+      PRE_TOKENIZED_ARRAY = :pre_tokenized_array
+      WORD_V0 = :word_v0
+      WORD_V1 = :word_v1
+
+      # @!method self.values
+      #   @return [Array<Symbol>]
+    end
+  end
+end

data/lib/turbopuffer/models/vector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    # A vector embedding associated with a document.
+    module Vector
+      extend Turbopuffer::Internal::Type::Union
+
+      # A dense vector encoded as an array of floats.
+      variant -> { Turbopuffer::Models::Vector::FloatArray }
+
+      # A dense vector encoded as a base64 string.
+      variant String
+
+      # @!method self.variants
+      #   @return [Array(Array<Float>, String)]
+
+      # @type [Turbopuffer::Internal::Type::Converter]
+      FloatArray = Turbopuffer::Internal::Type::ArrayOf[Float]
+    end
+  end
+end

data/lib/turbopuffer/models/vector_encoding.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    # The encoding to use for vectors in the response.
+    module VectorEncoding
+      extend Turbopuffer::Internal::Type::Enum
+
+      FLOAT = :float
+      BASE64 = :base64
+
+      # @!method self.values
+      #   @return [Array<Symbol>]
+    end
+  end
+end

data/lib/turbopuffer/models/write_billing.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  module Models
+    class WriteBilling < Turbopuffer::Internal::Type::BaseModel
+      # @!attribute billable_logical_bytes_written
+      #   The number of billable logical bytes written to the namespace.
+      #
+      #   @return [Integer]
+      required :billable_logical_bytes_written, Integer
+
+      # @!attribute query
+      #   The billing information for a query.
+      #
+      #   @return [Turbopuffer::Models::QueryBilling, nil]
+      optional :query, -> { Turbopuffer::QueryBilling }
+
+      # @!method initialize(billable_logical_bytes_written:, query: nil)
+      #   The billing information for a write request.
+      #
+      #   @param billable_logical_bytes_written [Integer] The number of billable logical bytes written to the namespace.
+      #
+      #   @param query [Turbopuffer::Models::QueryBilling] The billing information for a query.
+    end
+  end
+end

data/lib/turbopuffer/models.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  [Turbopuffer::Internal::Type::BaseModel, *Turbopuffer::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, Turbopuffer::Internal::AnyHash) } }
+  end
+
+  Turbopuffer::Internal::Util.walk_namespaces(Turbopuffer::Models).each do |mod|
+    case mod
+    in Turbopuffer::Internal::Type::Enum | Turbopuffer::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
+
+  Turbopuffer::Internal::Util.walk_namespaces(Turbopuffer::Models)
+                             .lazy
+                             .grep(Turbopuffer::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
+
+  AttributeSchema = Turbopuffer::Models::AttributeSchema
+
+  AttributeSchemaConfig = Turbopuffer::Models::AttributeSchemaConfig
+
+  AttributeType = Turbopuffer::Models::AttributeType
+
+  ClientNamespacesParams = Turbopuffer::Models::ClientNamespacesParams
+
+  Columns = Turbopuffer::Models::Columns
+
+  DistanceMetric = Turbopuffer::Models::DistanceMetric
+
+  FullTextSearch = Turbopuffer::Models::FullTextSearch
+
+  FullTextSearchConfig = Turbopuffer::Models::FullTextSearchConfig
+
+  ID = Turbopuffer::Models::ID
+
+  IncludeAttributes = Turbopuffer::Models::IncludeAttributes
+
+  Language = Turbopuffer::Models::Language
+
+  NamespaceDeleteAllParams = Turbopuffer::Models::NamespaceDeleteAllParams
+
+  NamespaceHintCacheWarmParams = Turbopuffer::Models::NamespaceHintCacheWarmParams
+
+  NamespaceMetadata = Turbopuffer::Models::NamespaceMetadata
+
+  NamespaceMetadataParams = Turbopuffer::Models::NamespaceMetadataParams
+
+  NamespaceMultiQueryParams = Turbopuffer::Models::NamespaceMultiQueryParams
+
+  NamespaceQueryParams = Turbopuffer::Models::NamespaceQueryParams
+
+  NamespaceRecallParams = Turbopuffer::Models::NamespaceRecallParams
+
+  NamespaceSchemaParams = Turbopuffer::Models::NamespaceSchemaParams
+
+  NamespaceSummary = Turbopuffer::Models::NamespaceSummary
+
+  NamespaceUpdateSchemaParams = Turbopuffer::Models::NamespaceUpdateSchemaParams
+
+  NamespaceWriteParams = Turbopuffer::Models::NamespaceWriteParams
+
+  Query = Turbopuffer::Models::Query
+
+  QueryBilling = Turbopuffer::Models::QueryBilling
+
+  QueryPerformance = Turbopuffer::Models::QueryPerformance
+
+  Row = Turbopuffer::Models::Row
+
+  Tokenizer = Turbopuffer::Models::Tokenizer
+
+  Vector = Turbopuffer::Models::Vector
+
+  VectorEncoding = Turbopuffer::Models::VectorEncoding
+
+  WriteBilling = Turbopuffer::Models::WriteBilling
+end

data/lib/turbopuffer/namespace.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  class Namespace < Turbopuffer::Resources::Namespaces
+    # Returns the namespace ID.
+    #
+    # @return [String]
+    def id
+      @client.default_namespace
+    end
+
+    # @api private
+    #
+    # @param client [Turbopuffer::Client]
+    # @param namespace [String]
+    def initialize(client, namespace)
+      client = client.dup
+      client.instance_variable_set(:@default_namespace, namespace)
+      super(client: client)
+    end
+  end
+end

data/lib/turbopuffer/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Turbopuffer
+  # 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 < Turbopuffer::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Turbopuffer::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Turbopuffer::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, Turbopuffer::Internal::Type::HashOf[Turbopuffer::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, Turbopuffer::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, Turbopuffer::Internal::Type::HashOf[Turbopuffer::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(Turbopuffer::RequestOptions, Turbopuffer::Internal::AnyHash) }
+    end
+  end
+end