retab 0.1.0

data/lib/retab/jobs.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+require 'json'
+
+module Retab
+  class Jobs
+    def initialize(client)
+      @client = client
+    end
+
+    # List Jobs
+    # @param before [String, nil] First job ID from the current page, used to fetch the previous page
+    # @param after [String, nil] Last job ID from the previous page, used to fetch the next page
+    # @param limit [Integer, nil] Number of jobs to return
+    # @param order [Retab::Types::JobsOrder, nil] Sort order by created_at
+    # @param job_id [String, nil] Filter by job ID
+    # @param status [Retab::Types::JobsStatus, nil] Filter by status
+    # @param endpoint [Retab::Types::JobsEndpoint, nil] Filter by endpoint
+    # @param source [Retab::Types::JobsSource, nil] High-level source filter. Use api/project/workflow.
+    # @param project_id [String, nil] Filter by request.project_id
+    # @param workflow_id [String, nil] Filter by metadata.workflow_id
+    # @param workflow_block_id [String, nil] Filter by metadata.workflow_block_id or metadata.block_id
+    # @param model [String, nil] Filter by request.model
+    # @param filename_regex [String, nil] Regex or plain text pattern applied to request filenames.
+    # @param filename_contains [String, nil] Plain text substring applied to request filenames.
+    # @param document_type [Array<String>, nil] Filter by document type. Can be repeated. Accepted values: bmp, csv, doc, docm, docx, dotm, dotx, eml, gif, heic, heif, htm, html, jpeg, jpg, json, md, mhtml, msg, odp, ods, odt, ots, ott, pdf, png, ppt, pptx, rtf, svg, tif, tiff, tsv, txt, webp, xlam, xls, xlsb, xlsm, xlsx, xltm, xltx, xml, yaml, yml.
+    # @param from_date [String, nil] Filter jobs created on or after this date (YYYY-MM-DD)
+    # @param to_date [String, nil] Filter jobs created on or before this date (YYYY-MM-DD)
+    # @param metadata [String, nil] JSON object string to filter metadata key/value pairs.
+    # @param include_request [Boolean, nil] Whether to include the full original request body in each listed job.
+    # @param include_response [Boolean, nil] Whether to include full response payloads in each listed job.
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Types::ListStruct<Retab::Job>]
+    def list(
+      before: nil,
+      after: nil,
+      limit: 20,
+      order: 'desc',
+      job_id: nil,
+      status: nil,
+      endpoint: nil,
+      source: nil,
+      project_id: nil,
+      workflow_id: nil,
+      workflow_block_id: nil,
+      model: nil,
+      filename_regex: nil,
+      filename_contains: nil,
+      document_type: nil,
+      from_date: nil,
+      to_date: nil,
+      metadata: nil,
+      include_request: false,
+      include_response: false,
+      request_options: {}
+    )
+      params = {
+        'before' => before,
+        'after' => after,
+        'limit' => limit,
+        'order' => order,
+        'job_id' => job_id,
+        'status' => status,
+        'endpoint' => endpoint,
+        'source' => source,
+        'project_id' => project_id,
+        'workflow_id' => workflow_id,
+        'workflow_block_id' => workflow_block_id,
+        'model' => model,
+        'filename_regex' => filename_regex,
+        'filename_contains' => filename_contains,
+        'document_type' => document_type,
+        'from_date' => from_date,
+        'to_date' => to_date,
+        'metadata' => metadata,
+        'include_request' => include_request,
+        'include_response' => include_response
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: '/v1/jobs',
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      fetch_next = ->(cursor) {
+        list(
+          before: before,
+          after: cursor,
+          limit: limit,
+          order: order,
+          job_id: job_id,
+          status: status,
+          endpoint: endpoint,
+          source: source,
+          project_id: project_id,
+          workflow_id: workflow_id,
+          workflow_block_id: workflow_block_id,
+          model: model,
+          filename_regex: filename_regex,
+          filename_contains: filename_contains,
+          document_type: document_type,
+          from_date: from_date,
+          to_date: to_date,
+          metadata: metadata,
+          include_request: include_request,
+          include_response: include_response,
+          request_options: request_options
+        )
+      }
+      Retab::Types::ListStruct.from_response(
+        response,
+        model: Retab::Job,
+        filters: { before: before, limit: limit, order: order, job_id: job_id, status: status, endpoint: endpoint, source: source, project_id: project_id, workflow_id: workflow_id, workflow_block_id: workflow_block_id, model: model, filename_regex: filename_regex, filename_contains: filename_contains, document_type: document_type, from_date: from_date, to_date: to_date, metadata: metadata, include_request: include_request, include_response: include_response },
+        fetch_next: fetch_next
+      )
+    end
+
+    # Create Job
+    # @param endpoint [Retab::Types::CreateJobRequestEndpoint]
+    # @param request [Hash{String => Object}]
+    # @param metadata [Hash{String => String}, nil] Max 16 pairs; keys ≤64 chars, values ≤512 chars
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Job]
+    def create(
+      endpoint:,
+      request:,
+      metadata: nil,
+      request_options: {}
+    )
+      body = {
+        'endpoint' => endpoint,
+        'request' => request,
+        'metadata' => metadata
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/jobs',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Retab::Job.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
+
+    # Retrieve Job
+    # @param job_id [String]
+    # @param include_request [Boolean, nil] Include the original request payload in the response.
+    # @param include_response [Boolean, nil] Include the job response payload in the response.
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Job]
+    def get(
+      job_id:,
+      include_request: false,
+      include_response: false,
+      request_options: {}
+    )
+      params = {
+        'include_request' => include_request,
+        'include_response' => include_response
+      }.compact
+      response = @client.request(
+        method: :get,
+        path: "/v1/jobs/#{Retab::Util.encode_path(job_id)}",
+        auth: true,
+        params: params,
+        request_options: request_options
+      )
+      result = Retab::Job.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
+
+    # Cancel Job
+    # @param job_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Job]
+    def cancel(
+      job_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :post,
+        path: "/v1/jobs/#{Retab::Util.encode_path(job_id)}/cancel",
+        auth: true,
+        request_options: request_options
+      )
+      result = Retab::Job.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
+
+    # Retry Job
+    # @param job_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Job]
+    def retry(
+      job_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :post,
+        path: "/v1/jobs/#{Retab::Util.encode_path(job_id)}/retry",
+        auth: true,
+        request_options: request_options
+      )
+      result = Retab::Job.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
+  end
+end

data/lib/retab/mime.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+# @oagen-ignore-file
+#
+# Hand-maintained file. The generator emits this on first run and then
+# leaves it alone; spec changes do not touch it. Mirrors the ergonomic
+# MimeData input handling from the Python (`prepare_mime_document`), Node
+# (`coerceMimeData`), Go (`InferMIMEData`), and Rust (`From<T>` impls) SDKs.
+
+require 'base64'
+require 'pathname'
+require 'uri'
+
+module Retab
+  # Wire-shape MimeData. Mirrors the spec's `MIMEData` component schema.
+  #
+  # Customers rarely build this directly. Pass any of the supported
+  # input shapes to a resource method's `document:` keyword and the
+  # generator-emitted code calls `Retab::MimeData.coerce(input)` to
+  # produce the canonical wire form before serialization.
+  #
+  # Supported input types:
+  #   - `Retab::MimeData`     (passthrough)
+  #   - `Pathname`                  (file path; reads bytes, base64-encodes)
+  #   - `File`, `IO`, `StringIO`     (any IO-like; reads bytes, base64-encodes)
+  #   - `String` containing a URL  (`http://`, `https://`, `data:`, `gs://`)
+  #   - `String` containing a path on disk (falls back to file-read)
+  #   - `Hash` with `:filename` + `:url` keys (already-built wire shape)
+  class MimeData
+    attr_accessor :filename, :url
+
+    # Set by resource methods when MimeData is returned from the API (see
+    # `Files#complete_upload`). Mirrors the spec-derived models' BaseModel
+    # `last_response` field.
+    attr_accessor :last_response
+
+    # Two calling conventions are supported:
+    #   - keyword form (canonical for customer code):
+    #       Retab::MimeData.new(filename: 'x.pdf', url: 'data:...')
+    #   - positional Hash / JSON string (used by spec-derived model
+    #     classes whose `initialize(json)` deserializes a nested
+    #     `MIMEData` field via `Retab::MimeData.new(hash[:document])`):
+    #       Retab::MimeData.new({ filename: 'x.pdf', url: 'data:...' })
+    #       Retab::MimeData.new('{"filename": "x.pdf", "url": "data:..."}')
+    def initialize(arg = nil, filename: nil, url: nil)
+      case arg
+      when nil
+        @filename = filename
+        @url = url
+      when Hash
+        sym = arg.transform_keys(&:to_sym)
+        @filename = sym[:filename]
+        @url = sym[:url]
+      when String
+        require 'json'
+        parsed = JSON.parse(arg, symbolize_names: true)
+        @filename = parsed[:filename]
+        @url = parsed[:url]
+      else
+        raise ArgumentError, "cannot initialize Retab::MimeData from #{arg.class}"
+      end
+    end
+
+    # Single entry point used by every generator-emitted resource method.
+    def self.coerce(input)
+      case input
+      when MimeData
+        input
+      when Pathname
+        from_pathname(input)
+      when ::IO, ::StringIO, ::File
+        from_io(input)
+      when Hash
+        from_hash(input)
+      when String
+        from_string(input)
+      else
+        raise ArgumentError,
+          "cannot coerce #{input.class} to Retab::MimeData; supply a Pathname, IO, String (URL or path), Hash, or MimeData"
+      end
+    end
+
+    def to_h
+      { filename: filename, url: url }
+    end
+
+    # JSON serialization. Body construction in resource methods passes the
+    # MimeData object straight into `JSON.generate`; without `to_json` it
+    # would fall back to `to_s` and ship the inspect string.
+    def to_json(*args)
+      require 'json'
+      to_h.to_json(*args)
+    end
+
+    def as_json(*)
+      to_h
+    end
+
+    private_class_method def self.from_pathname(path)
+      bytes = path.binread
+      filename = path.basename.to_s
+      new(filename: filename, url: bytes_to_data_url(bytes, filename))
+    end
+
+    private_class_method def self.from_io(io)
+      io.binmode if io.respond_to?(:binmode)
+      bytes = io.read
+      filename = io.respond_to?(:path) && io.path ? ::File.basename(io.path) : 'document'
+      new(filename: filename, url: bytes_to_data_url(bytes, filename))
+    end
+
+    private_class_method def self.from_hash(hash)
+      sym = hash.transform_keys(&:to_sym)
+      new(filename: sym.fetch(:filename, 'document'), url: sym.fetch(:url))
+    end
+
+    private_class_method def self.from_string(str)
+      if str.match?(%r{\A(https?|gs|data):}i)
+        # It's a URL.
+        filename =
+          begin
+            uri = URI.parse(str)
+            ::File.basename(uri.path.to_s.empty? ? 'document' : uri.path)
+          rescue URI::InvalidURIError
+            'document'
+          end
+        new(filename: filename, url: str)
+      elsif ::File.exist?(str)
+        from_pathname(Pathname.new(str))
+      else
+        # Treat as raw text payload — base64-encode as a data URL.
+        new(filename: 'document', url: bytes_to_data_url(str, 'document', mime: 'text/plain'))
+      end
+    end
+
+    private_class_method def self.bytes_to_data_url(bytes, filename, mime: nil)
+      mime ||= guess_mime_type(filename) || 'application/octet-stream'
+      "data:#{mime};base64,#{Base64.strict_encode64(bytes)}"
+    end
+
+    EXTENSION_MIME_MAP = {
+      '.pdf' => 'application/pdf',
+      '.png' => 'image/png',
+      '.jpg' => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif' => 'image/gif',
+      '.webp' => 'image/webp',
+      '.txt' => 'text/plain',
+      '.csv' => 'text/csv',
+      '.json' => 'application/json',
+      '.xml' => 'application/xml',
+      '.html' => 'text/html',
+      '.md' => 'text/markdown',
+      '.docx' => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      '.xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      '.pptx' => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    }.freeze
+
+    private_class_method def self.guess_mime_type(filename)
+      EXTENSION_MIME_MAP[::File.extname(filename).downcase]
+    end
+  end
+end

data/lib/retab/parses/parse.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class Parse < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      id: :id,
+      file: :file,
+      model: :model,
+      table_parsing_format: :table_parsing_format,
+      image_resolution_dpi: :image_resolution_dpi,
+      instructions: :instructions,
+      output: :output,
+      usage: :usage,
+      created_at: :created_at
+    }.freeze
+
+    attr_accessor \
+      :id,
+      :file,
+      :model,
+      :table_parsing_format,
+      :image_resolution_dpi,
+      :instructions,
+      :output,
+      :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]
+      @table_parsing_format = hash[:table_parsing_format]
+      @image_resolution_dpi = hash[:image_resolution_dpi]
+      @instructions = hash[:instructions]
+      @output = hash[:output] ? Retab::ParseOutput.new(hash[:output]) : nil
+      @usage = hash[:usage] ? Retab::RetabUsage.new(hash[:usage]) : nil
+      @created_at = hash[:created_at]
+    end
+  end
+end

data/lib/retab/parses/parse_output.rb

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

data/lib/retab/parses/parse_request.rb

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

data/lib/retab/parses.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+require 'json'
+
+module Retab
+  class Parses
+    def initialize(client)
+      @client = client
+    end
+
+    # List Parses
+    # @param before [String, nil]
+    # @param after [String, nil]
+    # @param limit [Integer, nil]
+    # @param order [Retab::Types::ParsesOrder, 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::Parse>]
+    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/parses',
+        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::Parse,
+        filters: { before: before, limit: limit, order: order, filename: filename, from_date: from_date, to_date: to_date },
+        fetch_next: fetch_next
+      )
+    end
+
+    # Create Parse
+    # @param document [Retab::MimeData, Pathname, IO, String, Hash] The document to parse
+    # @param model [String, nil] The model to use for parsing
+    # @param table_parsing_format [Retab::Types::ParseRequestTableParsingFormat, nil] Format used to render tables extracted from the document
+    # @param image_resolution_dpi [Integer, nil] DPI used when rasterizing pages for the parser
+    # @param instructions [String, nil] Free-form instructions appended to the system prompt to steer the parse.
+    # @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::Parse]
+    def create(
+      document:,
+      model: nil,
+      table_parsing_format: nil,
+      image_resolution_dpi: nil,
+      instructions: nil,
+      bust_cache: nil,
+      request_options: {}
+    )
+      document = Retab::MimeData.coerce(document) unless document.nil?
+      body = {
+        'document' => document,
+        'model' => model,
+        'table_parsing_format' => table_parsing_format,
+        'image_resolution_dpi' => image_resolution_dpi,
+        'instructions' => instructions,
+        'bust_cache' => bust_cache
+      }.compact
+      response = @client.request(
+        method: :post,
+        path: '/v1/parses',
+        auth: true,
+        body: body,
+        request_options: request_options
+      )
+      result = Retab::Parse.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 Parse
+    # @param parse_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [Retab::Parse]
+    def get(
+      parse_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :get,
+        path: "/v1/parses/#{Retab::Util.encode_path(parse_id)}",
+        auth: true,
+        request_options: request_options
+      )
+      result = Retab::Parse.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 Parse
+    # @param parse_id [String]
+    # @param request_options [Hash] (see Retab::Types::RequestOptions)
+    # @return [void]
+    def delete(
+      parse_id:,
+      request_options: {}
+    )
+      response = @client.request(
+        method: :delete,
+        path: "/v1/parses/#{Retab::Util.encode_path(parse_id)}",
+        auth: true,
+        request_options: request_options
+      )
+      nil
+    end
+  end
+end

data/lib/retab/partitions/partition.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# This file is auto-generated by oagen. Do not edit.
+
+module Retab
+  class Partition < Retab::Types::BaseModel
+
+    HASH_ATTRS = {
+      id: :id,
+      file: :file,
+      model: :model,
+      key: :key,
+      instructions: :instructions,
+      n_consensus: :n_consensus,
+      allow_overlap: :allow_overlap,
+      output: :output,
+      consensus: :consensus,
+      usage: :usage,
+      created_at: :created_at
+    }.freeze
+
+    attr_accessor \
+      :id,
+      :file,
+      :model,
+      :key,
+      :instructions,
+      :n_consensus,
+      :allow_overlap,
+      :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]
+      @key = hash[:key]
+      @instructions = hash[:instructions]
+      @n_consensus = hash[:n_consensus]
+      @allow_overlap = hash[:allow_overlap]
+      @output = (hash[:output] || []).map { |item| item ? Retab::PartitionChunk.new(item) : nil }
+      @consensus = hash[:consensus] ? Retab::PartitionConsensus.new(hash[:consensus]) : nil
+      @usage = hash[:usage] ? Retab::RetabUsage.new(hash[:usage]) : nil
+      @created_at = hash[:created_at]
+    end
+  end
+end