retab 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03451c10ad95d1e8c1c4735d27f0111c41bd3f70c2c56f47a8b6c6f4b814d805
+  data.tar.gz: e2fb7d8224adcd5c7028132d39552a66262509b9536c9e4d1faf4c11131a2dce
+SHA512:
+  metadata.gz: 28d6058f953e1cebfbde309eddcd726c0654d4961d19aff4474d008e53d1e0be7815883fb43767ef800e34ccf32513a56ac0621a824216e1151471e5ddd10763
+  data.tar.gz: 9ac931a257550fbf1a1cb191ce1802887415b6d603d1e40bf9335e71b31c84acff26156172f9f8dbd3a4ea7f887f5705b18556ec27b501500df245ce6bff4dcf

data/lib/retab/base_client.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+# @oagen-ignore-file
+#
+# Hand-maintained HTTP runtime. Generated resource methods call
+# `@client.request(method:, path:, auth:, params:, body:, request_options:)`
+# and wrap the result in spec-derived model classes.
+#
+# This is intentionally minimal — net/http + JSON, no retry/backoff polish.
+# A future revision should mirror the WorkOS Ruby SDK's `BaseClient` for
+# retries, idempotency keys, and structured error mapping.
+
+require 'json'
+require 'net/http'
+require 'uri'
+
+module Retab
+  class BaseClient
+    attr_reader :configuration
+
+    def initialize(api_key: nil, api_host: nil, configuration: nil, **opts)
+      @configuration =
+        configuration ||
+          Configuration.new(api_key: api_key, api_host: api_host, **opts)
+      raise ConfigurationError, 'api_key is required' if @configuration.api_key.nil?
+    end
+
+    def api_key
+      @configuration.api_key
+    end
+
+    def api_host
+      @configuration.api_host
+    end
+
+    # Issue an HTTP request. Returns the raw `Net::HTTPResponse` so the
+    # spec-derived caller can read `.body`, `.code`, headers, and the
+    # `x-request-id`.
+    def request(method:, path:, auth: true, params: nil, body: nil, request_options: {})
+      uri = build_uri(path, params)
+      req = build_request(method, uri, body: body, auth: auth, request_options: request_options)
+      response = perform(uri, req, request_options: request_options)
+      raise_for_status(response)
+      response
+    end
+
+    private
+
+    def build_uri(path, params)
+      uri = URI.join(api_host, path)
+      if params && !params.empty?
+        query = URI.encode_www_form(params.reject { |_, v| v.nil? })
+        uri.query = query unless query.empty?
+      end
+      uri
+    end
+
+    def build_request(method, uri, body:, auth:, request_options:)
+      klass = {
+        get: Net::HTTP::Get,
+        post: Net::HTTP::Post,
+        put: Net::HTTP::Put,
+        patch: Net::HTTP::Patch,
+        delete: Net::HTTP::Delete,
+        head: Net::HTTP::Head,
+      }.fetch(method.to_sym) { raise ArgumentError, "unsupported HTTP method: #{method}" }
+      req = klass.new(uri.request_uri)
+      req['Accept'] = 'application/json'
+      req['User-Agent'] = @configuration.user_agent
+      if auth
+        key = (request_options[:api_key] || request_options['api_key'] || api_key)
+        req['Authorization'] = "Bearer #{key}" if key
+      end
+      if (idem = request_options[:idempotency_key] || request_options['idempotency_key'])
+        req['Idempotency-Key'] = idem
+      end
+      extra_headers = request_options[:headers] || request_options['headers'] || {}
+      extra_headers.each { |k, v| req[k.to_s] = v.to_s }
+      if body && %i[post put patch].include?(method.to_sym)
+        req['Content-Type'] = 'application/json'
+        req.body = body.is_a?(String) ? body : JSON.generate(body)
+      end
+      req
+    end
+
+    def perform(uri, req, request_options:)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.read_timeout = request_options[:timeout] || @configuration.timeout
+      http.open_timeout = request_options[:timeout] || @configuration.timeout
+      http.request(req)
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      raise TimeoutError, e.message
+    end
+
+    def raise_for_status(response)
+      code = response.code.to_i
+      return if code < 400
+      body = parse_body(response)
+      message = body.is_a?(Hash) ? (body['message'] || body['error'] || response.message) : response.message
+      args = {
+        message: message,
+        http_status: code,
+        request_id: response['x-request-id'],
+        code: body.is_a?(Hash) ? body['code'] : nil,
+        body: body,
+      }
+      case code
+      when 400 then raise BadRequestError.new(**args)
+      when 401 then raise AuthenticationError.new(**args)
+      when 403 then raise AuthorizationError.new(**args)
+      when 404 then raise NotFoundError.new(**args)
+      when 409 then raise ConflictError.new(**args)
+      when 422 then raise UnprocessableEntityError.new(**args)
+      when 429 then raise RateLimitExceededError.new(**args)
+      when 500..599 then raise InternalServerError.new(**args)
+      else raise APIError.new(**args)
+      end
+    end
+
+    def parse_body(response)
+      return nil if response.body.nil? || response.body.empty?
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      response.body
+    end
+  end
+end

data/lib/retab/classifications/category.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class Category < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      name: :name,
+      handle_key: :handle_key,
+      description: :description
+    }.freeze
+
+    attr_accessor \
+      :name,
+      :handle_key,
+      :description
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @name = hash[:name]
+      @handle_key = hash[:handle_key]
+      @description = hash[:description]
+    end
+  end
+end

data/lib/retab/classifications/classification.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class Classification < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      id: :id,
+      file: :file,
+      model: :model,
+      categories: :categories,
+      n_consensus: :n_consensus,
+      instructions: :instructions,
+      output: :output,
+      consensus: :consensus,
+      usage: :usage,
+      created_at: :created_at
+    }.freeze
+
+    attr_accessor \
+      :id,
+      :file,
+      :model,
+      :categories,
+      :n_consensus,
+      :instructions,
+      :output,
+      :consensus,
+      :usage,
+      :created_at
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @id = hash[:id]
+      @file = hash[:file] ? Retab::FileRef.new(hash[:file]) : nil
+      @model = hash[:model]
+      @categories = (hash[:categories] || []).map { |item| item ? Retab::Category.new(item) : nil }
+      @n_consensus = hash[:n_consensus]
+      @instructions = hash[:instructions]
+      @output = hash[:output] ? Retab::ClassificationDecision.new(hash[:output]) : nil
+      @consensus = hash[:consensus] ? Retab::ClassificationConsensus.new(hash[:consensus]) : nil
+      @usage = hash[:usage] ? Retab::RetabUsage.new(hash[:usage]) : nil
+      @created_at = hash[:created_at]
+    end
+  end
+end

data/lib/retab/classifications/classification_consensus.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class ClassificationConsensus < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      choices: :choices,
+      likelihoods: :likelihoods
+    }.freeze
+
+    attr_accessor \
+      :choices,
+      :likelihoods
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @choices = (hash[:choices] || []).map { |item| item ? Retab::ClassificationDecision.new(item) : nil }
+      @likelihoods = hash[:likelihoods]
+    end
+  end
+end

data/lib/retab/classifications/classification_decision.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class ClassificationDecision < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      reasoning: :reasoning,
+      category: :category
+    }.freeze
+
+    attr_accessor \
+      :reasoning,
+      :category
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @reasoning = hash[:reasoning]
+      @category = hash[:category]
+    end
+  end
+end

data/lib/retab/classifications/classification_request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class ClassificationRequest < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      document: :document,
+      categories: :categories,
+      model: :model,
+      first_n_pages: :first_n_pages,
+      instructions: :instructions,
+      n_consensus: :n_consensus,
+      bust_cache: :bust_cache
+    }.freeze
+
+    attr_accessor \
+      :document,
+      :categories,
+      :model,
+      :first_n_pages,
+      :instructions,
+      :n_consensus,
+      :bust_cache
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @document = hash[:document] ? Retab::MimeData.new(hash[:document]) : nil
+      @categories = (hash[:categories] || []).map { |item| item ? Retab::Category.new(item) : nil }
+      @model = hash[:model]
+      @first_n_pages = hash[:first_n_pages]
+      @instructions = hash[:instructions]
+      @n_consensus = hash[:n_consensus]
+      @bust_cache = hash[:bust_cache]
+    end
+  end
+end

data/lib/retab/classifications.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+require 'json'
+
+module Retab
+  class Classifications
+    def initialize(client)
+      @client = client
+    end
+
+    # List Classifications
+    # @param before [String, nil]
+    # @param after [String, nil]
+    # @param limit [Integer, nil]
+    # @param order [Retab::Types::ClassificationsOrder, nil]
+    # @param filename [String, nil]
+    # @param from_date [String, nil]
+    # @param to_date [String, nil]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Types::ListStruct<Retab::Classification>]
+    def list(
+      before: nil,
+      after: nil,
+      limit: 10,
+      order: 'desc',
+      filename: nil,
+      from_date: nil,
+      to_date: nil,
+      request_options: {}
+    )
+      params = {
+        'before' => before,
+        'after' => after,
+        'limit' => limit,
+        'order' => order,
+        'filename' => filename,
+        'from_date' => from_date,
+        'to_date' => to_date
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/classifications',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      fetch_next = ->(cursor) {
+        list(
+          before: before,
+          after: cursor,
+          limit: limit,
+          order: order,
+          filename: filename,
+          from_date: from_date,
+          to_date: to_date,
+          request_options: request_options
+        )
+      }
+      Retab::Types::ListStruct.from_response(
+        response,
+        model: Retab::Classification,
+        filters: { before: before, limit: limit, order: order, filename: filename, from_date: from_date, to_date: to_date },
+        fetch_next: fetch_next
+      )
+    end
+
+    # Create Classification
+    # @param document [Retab::MimeData, Pathname, IO, String, Hash] The document to classify
+    # @param categories [Array<Retab::Category>] The categories to classify the document into
+    # @param model [String, nil] The model to use for classification
+    # @param first_n_pages [Integer, nil] Only use the first N pages of the document for classification. Useful for large documents where classification can be determined from early pages.
+    # @param instructions [String, nil] Free-form instructions appended to the system prompt to steer the classification.
+    # @param n_consensus [Integer, nil] Number of classification runs to use for consensus voting. Uses deterministic single-pass when set to 1.
+    # @param bust_cache [Boolean, nil] If true, skip the LLM cache and force a fresh completion
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Classification]
+    def create(
+      document:,
+      categories:,
+      model: nil,
+      first_n_pages: nil,
+      instructions: nil,
+      n_consensus: nil,
+      bust_cache: nil,
+      request_options: {}
+    )
+      document = Retab::MimeData.coerce(document) unless document.nil?
+      body = {
+        'document' => document,
+        'categories' => categories,
+        'model' => model,
+        'first_n_pages' => first_n_pages,
+        'instructions' => instructions,
+        'n_consensus' => n_consensus,
+        'bust_cache' => bust_cache
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/classifications',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Retab::Classification.new(response.body)
+      result.last_response = Retab::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # Get Classification
+    # @param classification_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Classification]
+    def get(
+      classification_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :get,
+        path: "/v1/classifications/#{Retab::Util.encode_path(classification_id)}",
+        auth: true,
+        request_options: request_options
+      )
+      result = Retab::Classification.new(response.body)
+      result.last_response = Retab::Types::ApiResponse.new(http_status: response.code.to_i, http_headers: response.each_header.to_h, request_id: response["x-request-id"])
+      result
+    end
+
+    # Delete Classification
+    # @param classification_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [void]
+    def delete(
+      classification_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :delete,
+        path: "/v1/classifications/#{Retab::Util.encode_path(classification_id)}",
+        auth: true,
+        request_options: request_options
+      )
+      nil
+    end
+  end
+end

data/lib/retab/client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class Client < BaseClient
+
+    def schemas
+      @schemas ||= Retab::Schemas.new(self)
+    end
+
+    def extractions
+      @extractions ||= Retab::Extractions.new(self)
+    end
+
+    def classifications
+      @classifications ||= Retab::Classifications.new(self)
+    end
+
+    def parses
+      @parses ||= Retab::Parses.new(self)
+    end
+
+    def partitions
+      @partitions ||= Retab::Partitions.new(self)
+    end
+
+    def splits
+      @splits ||= Retab::Splits.new(self)
+    end
+
+    def files
+      @files ||= Retab::Files.new(self)
+    end
+
+    def workflow_runs
+      @workflow_runs ||= Retab::WorkflowRuns.new(self)
+    end
+
+    def workflow_steps
+      @workflow_steps ||= Retab::WorkflowSteps.new(self)
+    end
+
+    def workflow_reviews
+      @workflow_reviews ||= Retab::WorkflowReviews.new(self)
+    end
+
+    def workflow_review_versions
+      @workflow_review_versions ||= Retab::WorkflowReviewVersions.new(self)
+    end
+
+    def workflow_artifacts
+      @workflow_artifacts ||= Retab::WorkflowArtifacts.new(self)
+    end
+
+    def workflow_test_runs
+      @workflow_test_runs ||= Retab::WorkflowTestRuns.new(self)
+    end
+
+    def workflow_test_run_results
+      @workflow_test_run_results ||= Retab::WorkflowTestRunResults.new(self)
+    end
+
+    def workflow_blocks
+      @workflow_blocks ||= Retab::WorkflowBlocks.new(self)
+    end
+
+    def workflow_edges
+      @workflow_edges ||= Retab::WorkflowEdges.new(self)
+    end
+
+    def workflow_tests
+      @workflow_tests ||= Retab::WorkflowTests.new(self)
+    end
+
+    def experiment_runs
+      @experiment_runs ||= Retab::ExperimentRuns.new(self)
+    end
+
+    def experiment_run_results
+      @experiment_run_results ||= Retab::ExperimentRunResults.new(self)
+    end
+
+    def experiment_run_metrics
+      @experiment_run_metrics ||= Retab::ExperimentRunMetrics.new(self)
+    end
+
+    def workflow_experiments
+      @workflow_experiments ||= Retab::WorkflowExperiments.new(self)
+    end
+
+    def workflow_block_executions
+      @workflow_block_executions ||= Retab::WorkflowBlockExecutions.new(self)
+    end
+
+    def workflows
+      @workflows ||= Retab::Workflows.new(self)
+    end
+
+    def workflow_specs
+      @workflow_specs ||= Retab::WorkflowSpecs.new(self)
+    end
+
+    def edit_templates
+      @edit_templates ||= Retab::EditTemplates.new(self)
+    end
+
+    def edits
+      @edits ||= Retab::Edits.new(self)
+    end
+
+    def jobs
+      @jobs ||= Retab::Jobs.new(self)
+    end
+  end
+end

data/lib/retab/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# @oagen-ignore-file
+#
+# Hand-maintained configuration. Mirrors the spec-derived resources' usage
+# of `@client.api_key` and friends.
+
+module Retab
+  class Configuration
+    DEFAULT_API_HOST = 'https://api.retab.com'
+
+    attr_accessor :api_key, :api_host, :timeout, :max_retries, :user_agent
+
+    def initialize(api_key: nil, api_host: nil, timeout: nil, max_retries: nil, user_agent: nil)
+      @api_key = api_key
+      @api_host = api_host || DEFAULT_API_HOST
+      @timeout = timeout || 60
+      @max_retries = max_retries || 3
+      @user_agent = user_agent || "retab-ruby/#{Retab::VERSION rescue '0.1.0'}"
+    end
+  end
+end

data/lib/retab/edit_templates/create_edit_template_request.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class CreateEditTemplateRequest < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      name: :name,
+      document: :document,
+      form_fields: :form_fields
+    }.freeze
+
+    attr_accessor \
+      :name,
+      :document,
+      :form_fields
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @name = hash[:name]
+      @document = hash[:document] ? Retab::MimeData.new(hash[:document]) : nil
+      @form_fields = (hash[:form_fields] || []).map { |item| item ? Retab::FormField.new(item) : nil }
+    end
+  end
+end

data/lib/retab/edit_templates/edit_template.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class EditTemplate < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      id: :id,
+      name: :name,
+      file: :file,
+      form_fields: :form_fields,
+      field_count: :field_count,
+      created_at: :created_at,
+      updated_at: :updated_at
+    }.freeze
+
+    attr_accessor \
+      :id,
+      :name,
+      :file,
+      :form_fields,
+      :field_count,
+      :created_at,
+      :updated_at
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @id = hash[:id]
+      @name = hash[:name]
+      @file = hash[:file] ? Retab::FileRef.new(hash[:file]) : nil
+      @form_fields = (hash[:form_fields] || []).map { |item| item ? Retab::FormField.new(item) : nil }
+      @field_count = hash[:field_count]
+      @created_at = hash[:created_at]
+      @updated_at = hash[:updated_at]
+    end
+  end
+end

data/lib/retab/edit_templates/update_edit_template_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class UpdateEditTemplateRequest < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      name: :name,
+      form_fields: :form_fields
+    }.freeze
+
+    attr_accessor \
+      :name,
+      :form_fields
+
+    def initialize(json)
+      hash = self.class.normalize(json)
+      @name = hash[:name]
+      @form_fields = (hash[:form_fields] || []).map { |item| item ? Retab::FormField.new(item) : nil }
+    end
+  end
+end