retab 0.1.10 → 0.1.12

data/lib/retab/workflow_runs.rb

@@ -20,6 +20,7 @@ module Retab
     # @param min_duration_ms [Integer, nil] Filter runs with duration >= this value in milliseconds
     # @param max_duration_ms [Integer, nil] Filter runs with duration <= this value in milliseconds
     # @param search [String, nil] Search by run ID (partial match)
+    # @param metadata [String, nil] Filter by metadata equality: a JSON object of key/value pairs (e.g. {"tenant":"acme"}). Pairs AND together.
     # @param before [String, nil]
     # @param after [String, nil]
     # @param limit [Integer, nil] Items per page
@@ -37,6 +38,7 @@ module Retab
       min_duration_ms: nil,
       max_duration_ms: nil,
       search: nil,
+      metadata: nil,
       before: nil,
       after: nil,
       limit: 20,
@@ -54,6 +56,7 @@ module Retab
         "min_duration_ms" => min_duration_ms,
         "max_duration_ms" => max_duration_ms,
         "search" => search,
+        "metadata" => metadata,
         "before" => before,
         "after" => after,
         "limit" => limit,
@@ -78,6 +81,7 @@ module Retab
           min_duration_ms: min_duration_ms,
           max_duration_ms: max_duration_ms,
           search: search,
+          metadata: metadata,
           before: before,
           after: cursor,
           limit: limit,
@@ -99,6 +103,7 @@ module Retab
           min_duration_ms: min_duration_ms,
           max_duration_ms: max_duration_ms,
           search: search,
+          metadata: metadata,
           before: before,
           limit: limit,
           order: order,
@@ -113,6 +118,7 @@ module Retab
     # @param documents [Hash{String => Retab::MimeData, Retab::FileRef, Pathname, IO, String, Hash}, nil] Mapping of start_document block IDs to their input documents.
     # @param json_inputs [Hash{String => Object}, nil] Mapping of start-json block IDs to their input JSON data.
     # @param version [String, nil] Workflow version to run: 'production', 'draft', or a pinned version id like 'ver_...'. Only valid for fresh-run creation.
+    # @param metadata [Hash{String => String}, nil] User-defined metadata to associate with this workflow run.
     # @param request_options [Hash] (see Retab::Types::RequestOptions)
     # @return [Retab::WorkflowRun]
     def create(
@@ -120,6 +126,7 @@ module Retab
       documents: nil,
       json_inputs: nil,
       version: nil,
+      metadata: nil,
       request_options: {}
     )
       documents = Retab::MimeData.coerce_document_map(documents, client: @client) unless documents.nil?
@@ -127,7 +134,8 @@ module Retab
         "workflow_id" => workflow_id,
         "documents" => documents,
         "json_inputs" => json_inputs,
-        "version" => version
+        "version" => version,
+        "metadata" => metadata
       }.compact
       response = @client.request(
         method: :post,

data/lib/retab/workflow_steps.rb

@@ -12,6 +12,7 @@ module Retab
 
     # List Workflow Run Steps
     # @param run_id [String, nil] Optional workflow run ID filter.
+    # @param workflow_id [String, nil]
     # @param block_id [String, nil] Optional logical block ID filter.
     # @param step_id [String, nil] Optional step ID filter.
     # @param block_type [Array<String>, nil] Optional block type filter. Repeat the query parameter for multiple values.
@@ -23,6 +24,7 @@ module Retab
     # @return [Retab::PaginatedList<Retab::WorkflowRunStep>]
     def list(
       run_id: nil,
+      workflow_id: nil,
       block_id: nil,
       step_id: nil,
       block_type: nil,
@@ -34,6 +36,7 @@ module Retab
     )
       params = {
         "run_id" => run_id,
+        "workflow_id" => workflow_id,
         "block_id" => block_id,
         "step_id" => step_id,
         "block_type" => block_type,
@@ -52,6 +55,7 @@ module Retab
       fetch_next = -> (cursor) {
         list(
           run_id: run_id,
+          workflow_id: workflow_id,
           block_id: block_id,
           step_id: step_id,
           block_type: block_type,
@@ -67,6 +71,7 @@ module Retab
         model: Retab::WorkflowRunStep,
         filters: {
           run_id: run_id,
+          workflow_id: workflow_id,
           block_id: block_id,
           step_id: step_id,
           block_type: block_type,

data/lib/retab/workflows/workflow.rb

@@ -12,9 +12,7 @@ module Retab
       project_id: :project_id,
       published: :published,
       created_at: :created_at,
-      updated_at: :updated_at,
-      capabilities: :capabilities,
-      authz_status: :authz_status
+      updated_at: :updated_at
     }.freeze
 
     attr_accessor(
@@ -24,9 +22,7 @@ module Retab
       :project_id,
       :published,
       :created_at,
-      :updated_at,
-      :capabilities,
-      :authz_status
+      :updated_at
     )
 
     def initialize(json)
@@ -39,8 +35,6 @@ module Retab
       @published = hash[:published] ? Retab::WorkflowPublished.new(hash[:published]) : nil
       @created_at = hash[:created_at]
       @updated_at = hash[:updated_at]
-      @capabilities = (hash[:capabilities] || [])
-      @authz_status = hash[:authz_status]
     end
   end
 end

data/lib/retab.rb

@@ -11,6 +11,7 @@ loader = Zeitwerk::Loader.for_gem
 require_relative "retab/inflections"
 loader.inflector.inflect(RETAB_INFLECTIONS)
 loader.collapse("#{__dir__}/retab/classifications")
+loader.collapse("#{__dir__}/retab/consensus")
 loader.collapse("#{__dir__}/retab/edit_templates")
 loader.collapse("#{__dir__}/retab/edits")
 loader.collapse("#{__dir__}/retab/experiment_run_metrics")
@@ -25,6 +26,7 @@ loader.collapse("#{__dir__}/retab/secrets")
 loader.collapse("#{__dir__}/retab/shared")
 loader.collapse("#{__dir__}/retab/splits")
 loader.collapse("#{__dir__}/retab/tables")
+loader.collapse("#{__dir__}/retab/usage")
 loader.collapse("#{__dir__}/retab/workflow_artifacts")
 loader.collapse("#{__dir__}/retab/workflow_block_executions")
 loader.collapse("#{__dir__}/retab/workflow_blocks")

data/rbi/retab/client.rbi

@@ -9,6 +9,9 @@ module Retab
     sig { returns(Retab::Classifications) }
     def classifications; end
 
+    sig { returns(Retab::Consensus) }
+    def consensus; end
+
     sig { returns(Retab::Edits) }
     def edits; end
 
@@ -36,6 +39,9 @@ module Retab
     sig { returns(Retab::Tables) }
     def tables; end
 
+    sig { returns(Retab::Usage) }
+    def usage; end
+
     sig { returns(Retab::Workflows) }
     def workflows; end
 

data/rbi/retab/consensus.rbi

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class Consensus
+    sig { params(client: Retab::BaseClient).void }
+    def initialize(client); end
+
+    sig do
+      params(
+        inputs: T.nilable(T::Array[T::Hash[String, T.untyped]]),
+        include_alignment: T.nilable(T::Boolean),
+        json_schema: T.nilable(T::Hash[String, T.untyped]),
+        request_options: T::Hash[Symbol, T.untyped]
+      ).returns(Retab::ReconciliationResult)
+    end
+    def create(inputs:, include_alignment:, json_schema:, request_options:); end
+
+  end
+end

data/rbi/retab/create_consensus_request.rbi

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class CreateConsensusRequest
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(T.nilable(T::Boolean)) }
+    def include_alignment; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def include_alignment=(value); end
+
+    sig { returns(T.nilable(T::Array[T::Hash[String, T.untyped]])) }
+    def inputs; end
+
+    sig { params(value: T.nilable(T::Array[T::Hash[String, T.untyped]])).returns(T.nilable(T::Array[T::Hash[String, T.untyped]])) }
+    def inputs=(value); end
+
+    sig { returns(T.nilable(T::Hash[String, T.untyped])) }
+    def json_schema; end
+
+    sig { params(value: T.nilable(T::Hash[String, T.untyped])).returns(T.nilable(T::Hash[String, T.untyped])) }
+    def json_schema=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/create_workflow_run_request.rbi

@@ -33,6 +33,12 @@ module Retab
     sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
     def version=(value); end
 
+    sig { returns(T.nilable(T::Hash[String, String])) }
+    def metadata; end
+
+    sig { params(value: T.nilable(T::Hash[String, String])).returns(T.nilable(T::Hash[String, String])) }
+    def metadata=(value); end
+
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end
 

data/rbi/retab/experiment_summary_metrics_response.rbi

@@ -63,6 +63,18 @@ module Retab
     sig { params(value: T.nilable(T::Array[Retab::ExperimentSummaryMetricDocument])).returns(T.nilable(T::Array[Retab::ExperimentSummaryMetricDocument])) }
     def documents=(value); end
 
+    sig { returns(T.nilable(Integer)) }
+    def scored_document_count; end
+
+    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
+    def scored_document_count=(value); end
+
+    sig { returns(T.nilable(Integer)) }
+    def total_document_count; end
+
+    sig { params(value: T.nilable(Integer)).returns(T.nilable(Integer)) }
+    def total_document_count=(value); end
+
     sig { returns(T.nilable(T.any(Retab::ExperimentExtractSummaryAggregate, Retab::ExperimentConfusionSummaryAggregate))) }
     def aggregate; end
 

data/rbi/retab/extraction_request.rbi

@@ -69,11 +69,11 @@ module Retab
     sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
     def background=(value); end
 
-    sig { returns(T.nilable(T::Hash[String, String])) }
-    def chunking_keys; end
+    sig { returns(T.nilable(T::Boolean)) }
+    def deep_extraction; end
 
-    sig { params(value: T.nilable(T::Hash[String, String])).returns(T.nilable(T::Hash[String, String])) }
-    def chunking_keys=(value); end
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def deep_extraction=(value); end
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end

data/rbi/retab/extractions.rbi

@@ -40,11 +40,11 @@ module Retab
         bust_cache: T.nilable(T::Boolean),
         stream: T.nilable(T::Boolean),
         background: T.nilable(T::Boolean),
-        chunking_keys: T.nilable(T::Hash[String, String]),
+        deep_extraction: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(Retab::Extraction)
     end
-    def create(document:, json_schema:, model:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, background:, chunking_keys:, request_options:); end
+    def create(document:, json_schema:, model:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, background:, deep_extraction:, request_options:); end
 
     sig do
       params(
@@ -58,11 +58,11 @@ module Retab
         bust_cache: T.nilable(T::Boolean),
         stream: T.nilable(T::Boolean),
         background: T.nilable(T::Boolean),
-        chunking_keys: T.nilable(T::Hash[String, String]),
+        deep_extraction: T.nilable(T::Boolean),
         request_options: T::Hash[Symbol, T.untyped]
       ).returns(NilClass)
     end
-    def create_stream(document:, json_schema:, model:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, background:, chunking_keys:, request_options:); end
+    def create_stream(document:, json_schema:, model:, instructions:, n_consensus:, metadata:, additional_messages:, bust_cache:, stream:, background:, deep_extraction:, request_options:); end
 
     sig do
       params(

data/rbi/retab/reconciliation_alignment.rbi

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconciliationAlignment
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(T.nilable(T::Array[T::Hash[String, T.untyped]])) }
+    def aligned_inputs; end
+
+    sig { params(value: T.nilable(T::Array[T::Hash[String, T.untyped]])).returns(T.nilable(T::Array[T::Hash[String, T.untyped]])) }
+    def aligned_inputs=(value); end
+
+    sig { returns(T.nilable(T::Array[Retab::ReconciliationPathAlignment])) }
+    def path_alignments; end
+
+    sig { params(value: T.nilable(T::Array[Retab::ReconciliationPathAlignment])).returns(T.nilable(T::Array[Retab::ReconciliationPathAlignment])) }
+    def path_alignments=(value); end
+
+    sig { returns(Integer) }
+    def reference_index; end
+
+    sig { params(value: Integer).returns(Integer) }
+    def reference_index=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconciliation_field.rbi

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconciliationField
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(Float) }
+    def likelihood; end
+
+    sig { params(value: Float).returns(Float) }
+    def likelihood=(value); end
+
+    sig { returns(String) }
+    def path; end
+
+    sig { params(value: String).returns(String) }
+    def path=(value); end
+
+    sig { returns(Integer) }
+    def supporting_input_count; end
+
+    sig { params(value: Integer).returns(Integer) }
+    def supporting_input_count=(value); end
+
+    sig { returns(Integer) }
+    def total_input_count; end
+
+    sig { params(value: Integer).returns(Integer) }
+    def total_input_count=(value); end
+
+    sig { returns(T.untyped) }
+    def value; end
+
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def value=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconciliation_path_alignment.rbi

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconciliationPathAlignment
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(String) }
+    def canonical_path; end
+
+    sig { params(value: String).returns(String) }
+    def canonical_path=(value); end
+
+    sig { returns(T.nilable(T::Array[T.nilable(String)])) }
+    def source_paths; end
+
+    sig { params(value: T.nilable(T::Array[T.nilable(String)])).returns(T.nilable(T::Array[T.nilable(String)])) }
+    def source_paths=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconciliation_result.rbi

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconciliationResult
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(Retab::ReconciliationAlignment) }
+    def alignment; end
+
+    sig { params(value: Retab::ReconciliationAlignment).returns(Retab::ReconciliationAlignment) }
+    def alignment=(value); end
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def consensus; end
+
+    sig { params(value: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def consensus=(value); end
+
+    sig { returns(T.nilable(T::Array[Retab::ReconciliationField])) }
+    def fields; end
+
+    sig { params(value: T.nilable(T::Array[Retab::ReconciliationField])).returns(T.nilable(T::Array[Retab::ReconciliationField])) }
+    def fields=(value); end
+
+    sig { returns(T::Hash[String, Float]) }
+    def likelihoods; end
+
+    sig { params(value: T::Hash[String, Float]).returns(T::Hash[String, Float]) }
+    def likelihoods=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/{review_field_confidence_lt.rbi → reconstruct_document_ref.rbi}

@@ -5,27 +5,27 @@
 # typed: strong
 
 module Retab
-  class ReviewFieldConfidenceLt
+  class ReconstructDocumentRef
     sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
     def initialize(json); end
 
-    sig { returns(T.nilable(String)) }
-    def kind; end
+    sig { returns(String) }
+    def filename; end
 
-    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
-    def kind=(value); end
+    sig { params(value: String).returns(String) }
+    def filename=(value); end
 
     sig { returns(String) }
-    def path; end
+    def id; end
 
     sig { params(value: String).returns(String) }
-    def path=(value); end
+    def id=(value); end
 
-    sig { returns(Float) }
-    def threshold; end
+    sig { returns(T.nilable(String)) }
+    def mime_type; end
 
-    sig { params(value: Float).returns(Float) }
-    def threshold=(value); end
+    sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
+    def mime_type=(value); end
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h; end

data/rbi/retab/reconstruct_enriched_row.rbi

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconstructEnrichedRow
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(T::Array[String]) }
+    def cells; end
+
+    sig { params(value: T::Array[String]).returns(T::Array[String]) }
+    def cells=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconstruct_enriched_table.rbi

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconstructEnrichedTable
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(String) }
+    def csv; end
+
+    sig { params(value: String).returns(String) }
+    def csv=(value); end
+
+    sig { returns(T::Array[String]) }
+    def header; end
+
+    sig { params(value: T::Array[String]).returns(T::Array[String]) }
+    def header=(value); end
+
+    sig { returns(String) }
+    def label; end
+
+    sig { params(value: String).returns(String) }
+    def label=(value); end
+
+    sig { returns(T::Array[Retab::ReconstructEnrichedRow]) }
+    def rows; end
+
+    sig { params(value: T::Array[Retab::ReconstructEnrichedRow]).returns(T::Array[Retab::ReconstructEnrichedRow]) }
+    def rows=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconstruct_enrichment_options.rbi

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconstructEnrichmentOptions
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(T.nilable(T::Boolean)) }
+    def fill_key_spans; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def fill_key_spans=(value); end
+
+    sig { returns(T.nilable(T::Boolean)) }
+    def flatten_header; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def flatten_header=(value); end
+
+    sig { returns(T.nilable(T::Boolean)) }
+    def promote_sections; end
+
+    sig { params(value: T.nilable(T::Boolean)).returns(T.nilable(T::Boolean)) }
+    def promote_sections=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconstruct_request.rbi

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconstructRequest
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(Retab::ReconstructDocumentRef) }
+    def document; end
+
+    sig { params(value: Retab::ReconstructDocumentRef).returns(Retab::ReconstructDocumentRef) }
+    def document=(value); end
+
+    sig { returns(T::Array[Retab::ReconstructSubdocument]) }
+    def subdocuments; end
+
+    sig { params(value: T::Array[Retab::ReconstructSubdocument]).returns(T::Array[Retab::ReconstructSubdocument]) }
+    def subdocuments=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end

data/rbi/retab/reconstruct_response.rbi

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# typed: strong
+
+module Retab
+  class ReconstructResponse
+    sig { params(json: T.any(String, T::Hash[Symbol, T.untyped])).void }
+    def initialize(json); end
+
+    sig { returns(T::Array[Retab::ReconstructEnrichedTable]) }
+    def tables; end
+
+    sig { params(value: T::Array[Retab::ReconstructEnrichedTable]).returns(T::Array[Retab::ReconstructEnrichedTable]) }
+    def tables=(value); end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h; end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args); end
+  end
+end