datalab 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ae1f504f63608091a53657a07e315c7578fb6a1d31f260a083db626feabdf20
+  data.tar.gz: d41b72dcba3ce505311318220acf789b6329f56069ba27783c18c6936b76cbe1
+SHA512:
+  metadata.gz: '08a22067023a2ba935cad056132a9a190a5c5f16068ae77d51f59f68dd42f428eb5306d974599a6d0553a9a7a71ce733aa88e210af2a48af4699a68a223cdc4a'
+  data.tar.gz: f49525b822f5739ef7613d56ab0e87322e903f3debacd22ca43cbb73c8bd7989cab3bf5c80145e613ce74428ab2d9afd6b6fcc9da5665d6a269fc964d8df7077

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Endless International
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/datalab.gemspec

@@ -0,0 +1,35 @@
+Gem::Specification.new do | spec |
+
+  spec.name             = 'datalab'
+  spec.version          = '0.1.0'
+  spec.authors          = [ 'Kristoph Cichocki-Romanov' ]
+  spec.email            = [ 'rubygems.org@kristoph.net' ]
+
+  spec.summary          = 
+    "The Datalab gem implements a lightweight interface to the Datalab API which provides " \
+    "document to Markdown conversion as well as sophisticated OCR for documents and images."
+  spec.description      =
+    "The Datalab gem implements a lightweight interface to the Datalab API. The Datalab API " \
+    "can convert a number of document formats, including PDF, Word and Powerpoint to Markdown. " \
+    "In addition in offers sophisticate OCR, layout and line detection for documents an images." 
+  spec.license          = 'MIT'
+  spec.homepage         = 'https://github.com/EndlessInternational/datalab'
+  spec.metadata         = {
+    'source_code_uri'   => 'https://github.com/EndlessInternational/datalab',
+    'bug_tracker_uri'   => 'https://github.com/EndlessInternational/datalab/issues',
+#    'documentation_uri' => 'https://github.com/EndlessInternational/datalab'
+  }
+
+  spec.required_ruby_version = '>= 3.0'
+  spec.files            = Dir[ "lib/**/*.rb", "LICENSE", "README.md", "datalab.gemspec" ]
+  spec.require_paths    = [ "lib" ]
+
+  spec.add_runtime_dependency 'faraday', '~> 2.7'
+  spec.add_runtime_dependency 'faraday-multipart', '~>1.0'
+  spec.add_runtime_dependency 'dynamicschema', '~> 1.0.0.beta04'
+
+  spec.add_development_dependency 'rspec', '~> 3.13'
+  spec.add_development_dependency 'debug', '~> 1.9'
+  spec.add_development_dependency 'vcr', '~> 6.3'
+
+end

data/lib/datalab/error_result.rb

@@ -0,0 +1,55 @@
+module Datalab 
+  class ErrorResult
+
+    attr_reader :error_type, :error_description  
+    
+    def initialize( status_code, attributes = nil )
+      @error_code, @error_description = status_code_to_error( status_code )
+      if detail = attributes[ :detail ]&.first rescue nil
+        if message = detail[ :msg ]
+          @error_description = message 
+          if location = detail[ :loc ]
+            @error_description += " : " + [ location ].flatten.join( '/' )
+          end 
+        end
+      end
+    end 
+
+  private 
+    def status_code_to_error( status_code )
+      case status_code 
+      # this is here because I've noted invalid payloads being returned with a 200
+      when 200
+        [ :unexpected_error, 
+          "The response was successful but it did not include a valid payload." ]
+      when 400
+        [ :invalid_request_error, 
+          "There was an issue with the format or content of your request." ]
+      when 401
+        [ :authentication_error, 
+          "There's an issue with your API key." ]
+      when 402
+        [ :payment_required, 
+          "The request requires a paid account" ]
+      when 404
+        [ :not_found_error, 
+          "The requested resource was not found." ]
+      when 422 
+        [ :invalid_data_error,
+          "The request body is invalid." ]
+      when 429
+        [ :rate_limit_error, 
+          "Your account has hit a rate limit." ]
+      when 500..505
+        [ :api_error, 
+          "An unexpected Datalab server error has occurred." ]
+      when 529
+        [ :overloaded_error, 
+          "The Datalab service is overloaded." ]
+      else
+        [ :unknown_error, 
+          "The Datalab service returned an unexpected status code: '#{status_code}'." ]
+      end
+    end
+  end
+end

data/lib/datalab/marker_options.rb

@@ -0,0 +1,34 @@
+module Datalab
+  class MarkerOptions
+    include DynamicSchema::Definable 
+
+    schema do 
+      maximum_pages       Integer, as: :max_pages, in: (1..)
+      languages           String, array: true
+      force_ocr           [ TrueClass, FalseClass ]
+      paginate            [ TrueClass, FalseClass ]
+      extract_images      [ TrueClass, FalseClass ]
+    end
+
+    def self.build( options = nil, &block )
+      new( api_options: builder.build( options, &block ) )
+    end 
+
+    def self.build!( options = nil, &block )
+      new( api_options: builder.build!( options, &block ) )
+    end 
+
+    def initialize( options = {}, api_options: nil )
+      @options = self.class.builder.build( options || {} )
+      @options = api_options.merge( @options ) if api_options 
+      @options[ :formats ]&.map! { | format | string_camelize( format.to_s ) }
+    end
+
+    def to_h
+      @options.to_h 
+    end
+
+  end
+end
+
+

data/lib/datalab/marker_request.rb

@@ -0,0 +1,99 @@
+module Datalab 
+
+  ##
+  # The +MarkerRequest+ class encapsulates a document conversion request in the Datalab API. 
+  # After instantiating a new +MarkerRequest+ instance you can begin a markdown conversion 
+  # document by calling the +submit+ method and then subsequently retrieving the results by 
+  # calling the +retrieve+' method.
+  #
+  # === examples
+  # 
+  # require 'datalab'
+  #
+  # request = Datalab::MarkerRequest.new( api_key: ENV[ 'DATALAB_API_KEY' ] )
+  # 
+  # file = Faraday::UploadIO.new( ARGV[ 0 ], 'application/pdf' )
+  # response = request.submit( file )
+  # while response.success? && ( result = response.result ).success?
+  #   result = request.retrieve( result )
+  #   break if result.complete?
+  # end
+  #
+  # if response.success? 
+  #   if response.result.success?
+  #     puts response.result.markdown 
+  #   else 
+  #     puts response.result.failure_message
+  #   end
+  # else
+  #   puts response.result.error_description 
+  # end 
+  # 
+  class MarkerRequest < Request 
+
+    ## 
+    # The +submit+ method makes a Datalab '/marker' POST request which will begin conversion of 
+    # the given file to markdown.  
+    # 
+    # The response is always an instance of +Faraday::Response+. If +response.success?+ is true,
+    # then +response.result+ will be an instance +MarkerResult+. If the request is not successful 
+    # then +response.result+ will be an instance of +ErrorResult+.
+    #
+    # Remember that you should call +response.success?+ to validate that the call to the API was
+    # successful and then +response.result.success?+ to validate that the API processed the
+    # request successfuly. 
+    #
+    def submit( file, options = nil, &block )        
+      if options
+        options = options.is_a?( MarkerOptions ) ? options : MarkerOptions.build( options.to_h ) 
+        options = options.to_h
+      else 
+        options = {}
+      end
+      options[ :file ] = file 
+      response = post( "#{BASE_URI}/marker", options, &block )
+      result = nil 
+      if response.success?
+        attributes = ( JSON.parse( response.body, symbolize_names: true ) rescue nil )
+        attributes ||= { success: false, status: :failed, error: 'An unknown error occured.'  }
+        result = MarkerResult.new( attributes )
+      else
+        attributes = JSON.parse( response.body, symbolize_names: true ) rescue {}
+        result = ErrorResult.new( response.status, attributes )
+      end
+
+      ResponseMethods.install( response, result )  
+    end 
+
+    ## 
+    # The +retrieve+ method takes the successful result of the submit method and makes a Datalab 
+    # '/marker/{id}' GET request which will return the conversion progress result or, if 
+    # conversion has been completed, the conversion results. 
+    #  
+    # The response is always an instance of +Faraday::Response+. If +response.success?+ is +true+, 
+    # then +response.result+ will be an instance +Datalab::MarkerResult+. If the request is not 
+    # successful then +response.result+ will be an instance of +Datalab::ErrorResult+.
+    #
+    # Remember that you should call +response.success?+ to valida that the call to the API was
+    # successful and then +response.result.success?+ to validate that the API processed the
+    # request successfuly. 
+    #
+    def retrieve( submit_result, &block )
+      raise ArgumentError, "The first argument must be an instance of MarkerResult." \
+        unless submit_result.is_a?( MarkerResult )
+
+      response = get( "#{BASE_URI}/marker/#{submit_result.id}", &block )  
+      result = nil 
+      attributes = JSON.parse( response.body, symbolize_names: true ) rescue nil 
+
+      if response.success? 
+        result = submit_result.merge( attributes || { success: false, status: :failed } )
+      else
+        result = ErrorResult.new( response.status, attributes || {} )
+      end 
+
+      ResponseMethods.install( response, result )     
+    end
+
+  end 
+end

data/lib/datalab/marker_result.rb

@@ -0,0 +1,75 @@
+module Datalab 
+  class MarkerResult 
+
+    def initialize( attributes )
+      @success = 
+        attributes[ :success ] || 
+        [ :processing, :complete ].include?( attributes[ :status ]&.to_sym )
+      @attributes = attributes || {}
+    end
+
+    def id 
+      @attributes[ :request_id ]
+    end
+
+    ##
+    # The +success?+ method returns +true+ if the converstion was successful. 
+    #
+    # Note that the response +success?+ tells you if the call to the Datalab API was successful 
+    # while this +success?+ method tells you if the actual conversaion operation began 
+    # successfully.
+    #
+    def success?  
+      @success || false 
+    end
+
+    def status 
+      @attributes[ :status ]&.to_sym || :processing 
+    end 
+
+    def processing?
+      status == :processing 
+    end 
+
+    def complete?
+      status == :complete
+    end 
+
+    ##
+    # If +success?+ returns +false+ this method will return a message explaining the reason 
+    # for the failure.
+    # 
+    def failure_message
+      @attributes[ :error ]
+    end 
+
+    ##
+    # The +markdown+ method returns the markdown content extracted from the given document. 
+    #
+    def markdown 
+      @attributes[ :markdown ]
+    end 
+
+    ##
+    #
+    #
+    def images 
+      @attribute[ :images ]
+    end
+
+    def metadata 
+      unless @metadata 
+        metadata = @attributes[ :metadata ] || {}
+        @metadata = metadata.transform_keys do | key |
+          key.to_s.gsub( /([a-z])([A-Z])/, '\1_\2' ).downcase
+        end
+      end 
+      @metadata 
+    end
+
+    def merge( attributes )
+      self.class.new( ( @attributes || {} ).merge( attributes ) )
+    end
+
+  end
+end

data/lib/datalab/module_methods.rb

@@ -0,0 +1,18 @@
+module Datalab
+  module ModuleMethods
+    DEFAULT_CONNECTION = Faraday.new do | builder | 
+      builder.request :multipart
+      builder.request :url_encoded
+      builder.adapter Faraday.default_adapter 
+    end
+    
+    def connection( connection = nil )
+      @connection = connection || @connection || DEFAULT_CONNECTION    
+    end
+
+    def api_key( api_key = nil )
+      @api_key = api_key || @api_key
+      @api_key 
+    end  
+  end
+end

data/lib/datalab/ocr_options.rb

@@ -0,0 +1,30 @@
+module Datalab
+  class OcrOptions
+    include DynamicSchema::Definable 
+
+    schema do 
+      maximum_pages       Integer, as: :max_pages, in: (1..)
+      languages           String, array: true
+    end
+
+    def self.build( options = nil, &block )
+      new( api_options: builder.build( options, &block ) )
+    end 
+
+    def self.build!( options = nil, &block )
+      new( api_options: builder.build!( options, &block ) )
+    end 
+
+    def initialize( options = {}, api_options: nil )
+      @options = self.class.builder.build( options || {} )
+      @options = api_options.merge( @options ) if api_options 
+    end
+
+    def to_h
+      @options.to_h 
+    end
+
+  end
+end
+
+

data/lib/datalab/ocr_page.rb

@@ -0,0 +1,23 @@
+module Datalab
+  class OcrPage
+    def initialize( attributes )
+      @attributes = attributes&.dup || {}
+    end
+  
+    def text_lines 
+      ( @attributes[ :text_lines ] || [] ).map( &OcrTextLine.method( :new ) ) 
+    end
+
+    def languages 
+      @attributes[ :languages ]
+    end
+
+    def number
+      @attributes[ :page ]
+    end
+
+    def bounding_rectangle 
+      @attributes[ :image_bbox ]
+    end 
+  end
+end

data/lib/datalab/ocr_request.rb

@@ -0,0 +1,98 @@
+module Datalab 
+
+  ##
+  # The +OcrRequest+ class encapsulates a document or image recognition request in the Datalab API. 
+  # After instantiating a new +OcrRequest+ instance you can begin recognition by calling the 
+  # +submit+ method and then subsequently retrieving the results by calling the +retrieve+ method.
+  #
+  # === examples
+  # 
+  # require 'datalab'
+  #
+  # request = Datalab::OcrRequest.new( api_key: ENV[ 'DATALAB_API_KEY' ] )
+  # 
+  # file = Faraday::UploadIO.new( ARGV[ 0 ], 'image/jpeg' )
+  # response = request.submit( file )
+  # while response.success? && ( result = response.result ).success?
+  #   result = request.retrieve( result )
+  #   break if result.complete?
+  # end
+  #
+  # if response.success? 
+  #   if response.result.success?
+  #     puts response.result.markdown 
+  #   else 
+  #     puts response.result.failure_message
+  #   end
+  # else
+  #   puts response.result.error_description 
+  # end 
+  # 
+  class OcrRequest < Request 
+
+    ## 
+    # The +submit+ method makes a Datalab '/ocr' POST request which will begin recognition of the 
+    # given file.  
+    # 
+    # The response is always an instance of +Faraday::Response+. If +response.success?+ is true,
+    # then +response.result+ will be an instance +OcrResult+. If the request is not successful 
+    # then +response.result+ will be an instance of +ErrorResult+.
+    #
+    # Remember that you should call +response.success?+ to validate that the call to the API was
+    # successful and then +response.result.success?+ to validate that the API processed the
+    # request successfuly. 
+    #
+    def submit( file, options = nil, &block )        
+      if options
+        options = options.is_a?( OcrOptions ) ? options : OcrOptions.build( options.to_h ) 
+        options = options.to_h
+      else 
+        options = {}
+      end
+      options[ :file ] = file 
+      response = post( "#{BASE_URI}/ocr", options, &block )
+      result = nil 
+      if response.success?
+        attributes = ( JSON.parse( response.body, symbolize_names: true ) rescue nil )
+        attributes ||= { success: false, status: :failed, error: 'An unknown error occured.'  }
+        result = OcrResult.new( attributes )
+      else
+        attributes = JSON.parse( response.body, symbolize_names: true ) rescue {}
+        result = ErrorResult.new( response.status, attributes )
+      end
+
+      ResponseMethods.install( response, result )  
+    end 
+
+    ## 
+    # The +retrieve+ method takes the successful result of the submit method and makes a Datalab 
+    # '/ocr/{id}' GET request which will return the recognition progress result or, if recognition 
+    # has been completed, the recognition results. 
+    #  
+    # The response is always an instance of +Faraday::Response+. If +response.success?+ is +true+, 
+    # then +response.result+ will be an instance +Datalab::OcrResult+. If the request is not 
+    # successful then +response.result+ will be an instance of +Datalab::ErrorResult+.
+    #
+    # Remember that you should call +response.success?+ to valide that the call to the API was
+    # successful and then +response.result.success?+ to validate that the API processed the
+    # request successfuly. 
+    #
+    def retrieve( submit_result, &block )
+      raise ArgumentError, "The first argument must be an instance of OcrResult." \
+        unless submit_result.is_a?( OcrResult )
+
+      response = get( "#{BASE_URI}/ocr/#{submit_result.id}", &block )  
+      result = nil 
+      attributes = JSON.parse( response.body, symbolize_names: true ) rescue nil 
+
+      if response.success? 
+        result = submit_result.merge( attributes || { success: false, status: :failed } )
+      else
+        result = ErrorResult.new( response.status, attributes || {} )
+      end 
+
+      ResponseMethods.install( response, result )     
+    end
+
+  end 
+end

data/lib/datalab/ocr_result.rb

@@ -0,0 +1,64 @@
+module Datalab 
+  class OcrResult 
+
+    def initialize( attributes )
+      @success = 
+        attributes[ :success ] || 
+        [ :processing, :complete ].include?( attributes[ :status ]&.to_sym )
+      @attributes = attributes || {}
+    end
+
+    def id 
+      @attributes[ :request_id ]
+    end
+
+    ##
+    # The +success?+ method returns +true+ if the converstion was successful. 
+    #
+    # Note that the response +success?+ tells you if the call to the Datalab API was successful 
+    # while this +success?+ method tells you if the actual conversaion operation began 
+    # successfully.
+    #
+    def success?  
+      @success || false 
+    end
+
+    def status 
+      @attributes[ :status ]&.to_sym || :processing 
+    end 
+
+    def processing?
+      status == :processing 
+    end 
+
+    def complete?
+      status == :complete
+    end 
+
+    ##
+    # If +success?+ returns +false+ this method will return a message explaining the reason 
+    # for the failure.
+    # 
+    def failure_message
+      @attributes[ :error ]
+    end 
+
+    ##
+    # The +pages+ method returns the pages extracted from the given document. If the given 
+    # document was an image the result is an array with a single page. If no pages were recognized
+    # the result is an empty array.
+    #
+    def pages
+      ( @attributes[ :pages ] || [] ).map( &OcrPage.method( :new ) ) 
+    end 
+
+    def page_count
+      @attributes[ :page_count ]
+    end
+
+    def merge( attributes )
+      self.class.new( ( @attributes || {} ).merge( attributes ) )
+    end
+
+  end
+end

data/lib/datalab/ocr_text_line.rb

@@ -0,0 +1,23 @@
+module Datalab
+  class OcrTextLine
+    def initialize( attributes )
+      @attributes = attributes&.dup || {}
+    end
+  
+    def text 
+      @attributes[ :text ]
+    end
+
+    def confidence
+      @attributes[ :confidence ]
+    end
+
+    def bounding_polygon
+      @attributes[ :polygon ]
+    end
+
+    def bounding_rectangle 
+      @attributes[ :image_bbox ]
+    end 
+  end
+end

data/lib/datalab/request.rb

@@ -0,0 +1,38 @@
+module Datalab 
+
+  ##
+  # The +Request+ class encapsulates a request to the Datalab API. This class serves as the 
+  # implementation of the MarkerRequest, OcrRequest and other classes and should not be used
+  # directly.
+  #  
+  class Request 
+
+    BASE_URI = 'https://www.datalab.to/api/v1'
+   
+    ##
+    # The +initialize+ method initializes the +Request+ instance. You can pass an +api_key+ and
+    # and optionally a (Faraday) +connection+.
+    #
+    def initialize( connection: nil, api_key: nil )
+      @connection = connection || Datalab.connection
+      @api_key = api_key || Datalab.api_key
+      raise ArgumentError, "An 'api_key' is required unless configured using 'Datalab.api_key'." \
+        unless @api_key
+    end
+
+  protected
+
+    def post( uri, body, &block )
+      @connection.post( uri, body, 'X-Api-Key' => @api_key, &block )
+    end 
+
+    def get( uri, &block )
+      @connection.get( uri ) do | request |
+        request.headers[ 'X-Api-Key' ] = @api_key
+        block.call( request ) if block 
+      end
+    end 
+
+  end
+
+end

data/lib/datalab/response_methods.rb

@@ -0,0 +1,15 @@
+module Datalab 
+  #
+  # The ResponseMethods module extends a Faraday reponse, adding the +result+ method. 
+  #
+  module ResponseMethods
+    def self.install( response, result )
+      response.instance_variable_set( "@_datalab_result", result )
+      response.extend( ResponseMethods )    
+    end 
+
+    def result
+      @_datalab_result
+    end 
+  end
+end 

data/lib/datalab.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'base64'
+require 'uri'
+
+require 'faraday'
+require 'faraday/multipart'
+require 'dynamic_schema'
+
+require_relative 'datalab/error_result'
+require_relative 'datalab/request'
+require_relative 'datalab/response_methods'
+
+require_relative 'datalab/marker_options'
+require_relative 'datalab/marker_result'
+require_relative 'datalab/marker_request'
+
+require_relative 'datalab/ocr_text_line'
+require_relative 'datalab/ocr_page'
+require_relative 'datalab/ocr_options'
+require_relative 'datalab/ocr_result'
+require_relative 'datalab/ocr_request'
+
+require_relative 'datalab/module_methods'
+
+module Datalab
+  extend ModuleMethods
+end
+
+

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: datalab
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kristoph Cichocki-Romanov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dynamicschema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta04
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta04
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: debug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.3'
+description: The Datalab gem implements a lightweight interface to the Datalab API.
+  The Datalab API can convert a number of document formats, including PDF, Word and
+  Powerpoint to Markdown. In addition in offers sophisticate OCR, layout and line
+  detection for documents an images.
+email:
+- rubygems.org@kristoph.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- datalab.gemspec
+- lib/datalab.rb
+- lib/datalab/error_result.rb
+- lib/datalab/marker_options.rb
+- lib/datalab/marker_request.rb
+- lib/datalab/marker_result.rb
+- lib/datalab/module_methods.rb
+- lib/datalab/ocr_options.rb
+- lib/datalab/ocr_page.rb
+- lib/datalab/ocr_request.rb
+- lib/datalab/ocr_result.rb
+- lib/datalab/ocr_text_line.rb
+- lib/datalab/request.rb
+- lib/datalab/response_methods.rb
+homepage: https://github.com/EndlessInternational/datalab
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/EndlessInternational/datalab
+  bug_tracker_uri: https://github.com/EndlessInternational/datalab/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.19
+signing_key:
+specification_version: 4
+summary: The Datalab gem implements a lightweight interface to the Datalab API which
+  provides document to Markdown conversion as well as sophisticated OCR for documents
+  and images.
+test_files: []