trafilatura 0.3.7-aarch64-linux

data/lib/trafilatura/trafilatura_generated.rb

@@ -0,0 +1,1325 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the details of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+
+module Trafilatura
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+end
+
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return Trafilatura.rust_call(:ffi_trafilatura_uniffi_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return Trafilatura.rust_call(:ffi_trafilatura_uniffi_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    Trafilatura.rust_call(:ffi_trafilatura_uniffi_rustbuffer_free, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The Record type ExtractResult.
+
+  def self.check_lower_TypeExtractResult(v)
+    
+    
+    
+    
+    RustBuffer.check_lower_TypeMetadata(v.metadata)
+  end
+
+  def self.alloc_from_TypeExtractResult(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExtractResult(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExtractResult
+    consumeWithStream do |stream|
+      return stream.readTypeExtractResult
+    end
+  end
+
+  # The Record type ExtractionConfig.
+
+  def self.check_lower_TypeExtractionConfig(v)
+    
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeExtractionConfig(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExtractionConfig(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExtractionConfig
+    consumeWithStream do |stream|
+      return stream.readTypeExtractionConfig
+    end
+  end
+
+  # The Record type ExtractionOptions.
+
+  def self.check_lower_TypeExtractionOptions(v)
+    RustBuffer.check_lower_TypeExtractionConfig(v.config)
+    RustBuffer.check_lower_Optionalstring(v.original_url)
+    RustBuffer.check_lower_Optionalstring(v.target_language)
+    
+    RustBuffer.check_lower_TypeExtractionFocus(v.focus)
+    
+    
+    
+    
+    
+    
+    RustBuffer.check_lower_Optionali64(v.max_tree_size)
+    RustBuffer.check_lower_Optionalstring(v.prune_selector)
+    RustBuffer.check_lower_TypeHtmlDateMode(v.html_date_mode)
+    RustBuffer.check_lower_Optionalstring(v.html_date_override)
+  end
+
+  def self.alloc_from_TypeExtractionOptions(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExtractionOptions(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExtractionOptions
+    consumeWithStream do |stream|
+      return stream.readTypeExtractionOptions
+    end
+  end
+
+  # The Record type Metadata.
+
+  def self.check_lower_TypeMetadata(v)
+    
+    
+    
+    
+    
+    
+    RustBuffer.check_lower_Optionalstring(v.date)
+    RustBuffer.check_lower_Sequencestring(v.categories)
+    RustBuffer.check_lower_Sequencestring(v.tags)
+    
+    
+    
+    
+    
+    
+  end
+
+  def self.alloc_from_TypeMetadata(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeMetadata(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeMetadata
+    consumeWithStream do |stream|
+      return stream.readTypeMetadata
+    end
+  end
+
+  # The Enum type ExtractionFocus.
+
+  def self.check_lower_TypeExtractionFocus(v)
+  end
+
+  def self.alloc_from_TypeExtractionFocus(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeExtractionFocus(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeExtractionFocus
+    consumeWithStream do |stream|
+      return stream.readTypeExtractionFocus
+    end
+  end
+  
+
+  # The Enum type HtmlDateMode.
+
+  def self.check_lower_TypeHtmlDateMode(v)
+  end
+
+  def self.alloc_from_TypeHtmlDateMode(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeHtmlDateMode(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeHtmlDateMode
+    consumeWithStream do |stream|
+      return stream.readTypeHtmlDateMode
+    end
+  end
+  
+
+  
+
+  # The Optional<T> type for i64.
+
+  def self.check_lower_Optionali64(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionali64(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionali64(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionali64
+    consumeWithStream do |stream|
+      return stream.readOptionali64
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalstring
+    consumeWithStream do |stream|
+      return stream.readOptionalstring
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def self.check_lower_Sequencestring(v)
+    v.each do |item|
+      
+    end
+  end
+
+  def self.alloc_from_Sequencestring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequencestring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequencestring
+    consumeWithStream do |stream|
+      return stream.readSequencestring
+    end
+  end
+
+  
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def readI32
+    unpack_from 4, 'l>'
+  end
+
+  def readI64
+    unpack_from 8, 'q>'
+  end
+
+  def readBool
+    v = unpack_from 1, 'c'
+
+    return false if v == 0
+    return true if v == 1
+
+    raise InternalError, 'Unexpected byte for Boolean type'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  # The Record type ExtractResult.
+
+  def readTypeExtractResult
+    ExtractResult.new(
+      content_text: readString,
+      comments_text: readString,
+      content_html: readString,
+      comments_html: readString,
+      metadata: readTypeMetadata
+    )
+  end
+
+  # The Record type ExtractionConfig.
+
+  def readTypeExtractionConfig
+    ExtractionConfig.new(
+      min_extracted_size: readI32,
+      min_extracted_comment_size: readI32,
+      min_output_size: readI32,
+      min_output_comment_size: readI32
+    )
+  end
+
+  # The Record type ExtractionOptions.
+
+  def readTypeExtractionOptions
+    ExtractionOptions.new(
+      config: readTypeExtractionConfig,
+      original_url: readOptionalstring,
+      target_language: readOptionalstring,
+      enable_fallback: readBool,
+      focus: readTypeExtractionFocus,
+      exclude_comments: readBool,
+      exclude_tables: readBool,
+      include_images: readBool,
+      include_links: readBool,
+      deduplicate: readBool,
+      require_essential_metadata: readBool,
+      max_tree_size: readOptionali64,
+      prune_selector: readOptionalstring,
+      html_date_mode: readTypeHtmlDateMode,
+      html_date_override: readOptionalstring
+    )
+  end
+
+  # The Record type Metadata.
+
+  def readTypeMetadata
+    Metadata.new(
+      title: readString,
+      author: readString,
+      url: readString,
+      hostname: readString,
+      description: readString,
+      sitename: readString,
+      date: readOptionalstring,
+      categories: readSequencestring,
+      tags: readSequencestring,
+      id: readString,
+      fingerprint: readString,
+      license: readString,
+      language: readString,
+      image: readString,
+      page_type: readString
+    )
+  end
+
+  
+  
+  # The Enum type ExtractionFocus.
+
+  def readTypeExtractionFocus
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return ExtractionFocus::BALANCED
+    end
+    if variant == 2
+      return ExtractionFocus::FAVOR_RECALL
+    end
+    if variant == 3
+      return ExtractionFocus::FAVOR_PRECISION
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeExtractionFocus'
+  end
+
+  
+
+  
+  
+  # The Enum type HtmlDateMode.
+
+  def readTypeHtmlDateMode
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+      return HtmlDateMode::AUTOMATIC
+    end
+    if variant == 2
+      return HtmlDateMode::FAST
+    end
+    if variant == 3
+      return HtmlDateMode::EXTENSIVE
+    end
+    if variant == 4
+      return HtmlDateMode::DISABLED
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeHtmlDateMode'
+  end
+
+  
+
+  
+
+  
+
+  # The Error type TrafilaturaError
+
+  def readTypeTrafilaturaError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return TrafilaturaError::ParseError.new(
+            readString()
+        )
+    end
+    if variant == 2
+        return TrafilaturaError::LanguageMismatch.new(
+            readString(),
+            readString()
+        )
+    end
+    if variant == 3
+        return TrafilaturaError::InsufficientContent.new(
+            readString()
+        )
+    end
+    if variant == 4
+        return TrafilaturaError::MissingMetadata.new(
+            readString()
+        )
+    end
+    if variant == 5
+        return TrafilaturaError::DuplicateContent.new
+    end
+    if variant == 6
+        return TrafilaturaError::TreeTooLarge.new(
+            readI64()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeTrafilaturaError'
+  end
+  
+
+  # The Optional<T> type for i64.
+
+  def readOptionali64
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readI64
+    else
+      raise InternalError, 'Unexpected flag byte for Optionali64'
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def readOptionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readString
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def readSequencestring
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readString
+    end
+
+    items
+  end
+
+  
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_I32(v)
+    v = Trafilatura::uniffi_in_range(v, "i32", -2**31, 2**31)
+    pack_into(4, 'l>', v)
+  end
+
+  def write_I64(v)
+    v = Trafilatura::uniffi_in_range(v, "i64", -2**63, 2**63)
+    pack_into(8, 'q>', v)
+  end
+
+  def write_Bool(v)
+    pack_into(1, 'c', v ? 1 : 0)
+  end
+
+  def write_String(v)
+    v = Trafilatura::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Record type ExtractResult.
+
+  def write_TypeExtractResult(v)
+    self.write_String(v.content_text)
+    self.write_String(v.comments_text)
+    self.write_String(v.content_html)
+    self.write_String(v.comments_html)
+    self.write_TypeMetadata(v.metadata)
+  end
+
+  # The Record type ExtractionConfig.
+
+  def write_TypeExtractionConfig(v)
+    self.write_I32(v.min_extracted_size)
+    self.write_I32(v.min_extracted_comment_size)
+    self.write_I32(v.min_output_size)
+    self.write_I32(v.min_output_comment_size)
+  end
+
+  # The Record type ExtractionOptions.
+
+  def write_TypeExtractionOptions(v)
+    self.write_TypeExtractionConfig(v.config)
+    self.write_Optionalstring(v.original_url)
+    self.write_Optionalstring(v.target_language)
+    self.write_Bool(v.enable_fallback)
+    self.write_TypeExtractionFocus(v.focus)
+    self.write_Bool(v.exclude_comments)
+    self.write_Bool(v.exclude_tables)
+    self.write_Bool(v.include_images)
+    self.write_Bool(v.include_links)
+    self.write_Bool(v.deduplicate)
+    self.write_Bool(v.require_essential_metadata)
+    self.write_Optionali64(v.max_tree_size)
+    self.write_Optionalstring(v.prune_selector)
+    self.write_TypeHtmlDateMode(v.html_date_mode)
+    self.write_Optionalstring(v.html_date_override)
+  end
+
+  # The Record type Metadata.
+
+  def write_TypeMetadata(v)
+    self.write_String(v.title)
+    self.write_String(v.author)
+    self.write_String(v.url)
+    self.write_String(v.hostname)
+    self.write_String(v.description)
+    self.write_String(v.sitename)
+    self.write_Optionalstring(v.date)
+    self.write_Sequencestring(v.categories)
+    self.write_Sequencestring(v.tags)
+    self.write_String(v.id)
+    self.write_String(v.fingerprint)
+    self.write_String(v.license)
+    self.write_String(v.language)
+    self.write_String(v.image)
+    self.write_String(v.page_type)
+  end
+
+  # The Enum type ExtractionFocus.
+
+  def write_TypeExtractionFocus(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  # The Enum type HtmlDateMode.
+
+  def write_TypeHtmlDateMode(v)
+    pack_into(4, 'l>', v)
+ end
+   
+
+  
+
+  # The Optional<T> type for i64.
+
+  def write_Optionali64(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_I64(v)
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def write_Optionalstring(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_String(v)
+    end
+  end
+
+  # The Sequence<T> type for string.
+
+  def write_Sequencestring(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_String(item)
+    end
+  end
+
+  
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+
+
+
+module TrafilaturaError
+  class ParseError < StandardError
+    def initialize(reason)
+        @reason = reason
+        super()
+      end
+
+    attr_reader :reason
+    
+
+    def to_s
+     "#{self.class.name}(reason=#{@reason.inspect})"
+    end
+  end
+  class LanguageMismatch < StandardError
+    def initialize(expected, got)
+        @expected = expected
+        @got = got
+        super()
+      end
+
+    attr_reader :expected, :got
+    
+
+    def to_s
+     "#{self.class.name}(expected=#{@expected.inspect}, got=#{@got.inspect})"
+    end
+  end
+  class InsufficientContent < StandardError
+    def initialize(reason)
+        @reason = reason
+        super()
+      end
+
+    attr_reader :reason
+    
+
+    def to_s
+     "#{self.class.name}(reason=#{@reason.inspect})"
+    end
+  end
+  class MissingMetadata < StandardError
+    def initialize(reason)
+        @reason = reason
+        super()
+      end
+
+    attr_reader :reason
+    
+
+    def to_s
+     "#{self.class.name}(reason=#{@reason.inspect})"
+    end
+  end
+  class DuplicateContent < StandardError
+    def initialize()
+        super()
+      end
+
+    def to_s
+     "#{self.class.name}()"
+    end
+  end
+  class TreeTooLarge < StandardError
+    def initialize(size)
+        @size = size
+        super()
+      end
+
+    attr_reader :size
+    
+
+    def to_s
+     "#{self.class.name}(size=#{@size.inspect})"
+    end
+  end
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+
+
+  TrafilaturaError => :readTypeTrafilaturaError,
+
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consumeIntoString()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib File.join(__dir__, 'libtrafilatura_uniffi.so')
+  
+
+  attach_function :uniffi_trafilatura_uniffi_fn_func_create_readable_document,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_trafilatura_uniffi_fn_func_default_config,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_trafilatura_uniffi_fn_func_default_options,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_trafilatura_uniffi_fn_func_extract,
+    [RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_trafilatura_uniffi_fn_func_extract_simple,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_trafilatura_uniffi_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_trafilatura_uniffi_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_trafilatura_uniffi_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_trafilatura_uniffi_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_trafilatura_uniffi_checksum_func_create_readable_document,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_trafilatura_uniffi_checksum_func_default_config,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_trafilatura_uniffi_checksum_func_default_options,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_trafilatura_uniffi_checksum_func_extract,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_trafilatura_uniffi_checksum_func_extract_simple,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_trafilatura_uniffi_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+  
+
+class ExtractionFocus
+  BALANCED = 1
+  FAVOR_RECALL = 2
+  FAVOR_PRECISION = 3
+  
+end
+
+
+  
+  
+  
+
+class HtmlDateMode
+  AUTOMATIC = 1
+  FAST = 2
+  EXTENSIVE = 3
+  DISABLED = 4
+  
+end
+
+
+  
+  
+  # Record type ExtractResult
+class ExtractResult
+  attr_reader :content_text, :comments_text, :content_html, :comments_html, :metadata
+
+  def initialize(content_text:, comments_text:, content_html:, comments_html:, metadata:)
+    @content_text = content_text
+    @comments_text = comments_text
+    @content_html = content_html
+    @comments_html = comments_html
+    @metadata = metadata
+  end
+
+  def ==(other)
+    if @content_text != other.content_text
+      return false
+    end
+    if @comments_text != other.comments_text
+      return false
+    end
+    if @content_html != other.content_html
+      return false
+    end
+    if @comments_html != other.comments_html
+      return false
+    end
+    if @metadata != other.metadata
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type ExtractionConfig
+class ExtractionConfig
+  attr_reader :min_extracted_size, :min_extracted_comment_size, :min_output_size, :min_output_comment_size
+
+  def initialize(min_extracted_size:, min_extracted_comment_size:, min_output_size:, min_output_comment_size:)
+    @min_extracted_size = min_extracted_size
+    @min_extracted_comment_size = min_extracted_comment_size
+    @min_output_size = min_output_size
+    @min_output_comment_size = min_output_comment_size
+  end
+
+  def ==(other)
+    if @min_extracted_size != other.min_extracted_size
+      return false
+    end
+    if @min_extracted_comment_size != other.min_extracted_comment_size
+      return false
+    end
+    if @min_output_size != other.min_output_size
+      return false
+    end
+    if @min_output_comment_size != other.min_output_comment_size
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type ExtractionOptions
+class ExtractionOptions
+  attr_reader :config, :original_url, :target_language, :enable_fallback, :focus, :exclude_comments, :exclude_tables, :include_images, :include_links, :deduplicate, :require_essential_metadata, :max_tree_size, :prune_selector, :html_date_mode, :html_date_override
+
+  def initialize(config:, original_url:, target_language:, enable_fallback:, focus:, exclude_comments:, exclude_tables:, include_images:, include_links:, deduplicate:, require_essential_metadata:, max_tree_size:, prune_selector:, html_date_mode:, html_date_override:)
+    @config = config
+    @original_url = original_url
+    @target_language = target_language
+    @enable_fallback = enable_fallback
+    @focus = focus
+    @exclude_comments = exclude_comments
+    @exclude_tables = exclude_tables
+    @include_images = include_images
+    @include_links = include_links
+    @deduplicate = deduplicate
+    @require_essential_metadata = require_essential_metadata
+    @max_tree_size = max_tree_size
+    @prune_selector = prune_selector
+    @html_date_mode = html_date_mode
+    @html_date_override = html_date_override
+  end
+
+  def ==(other)
+    if @config != other.config
+      return false
+    end
+    if @original_url != other.original_url
+      return false
+    end
+    if @target_language != other.target_language
+      return false
+    end
+    if @enable_fallback != other.enable_fallback
+      return false
+    end
+    if @focus != other.focus
+      return false
+    end
+    if @exclude_comments != other.exclude_comments
+      return false
+    end
+    if @exclude_tables != other.exclude_tables
+      return false
+    end
+    if @include_images != other.include_images
+      return false
+    end
+    if @include_links != other.include_links
+      return false
+    end
+    if @deduplicate != other.deduplicate
+      return false
+    end
+    if @require_essential_metadata != other.require_essential_metadata
+      return false
+    end
+    if @max_tree_size != other.max_tree_size
+      return false
+    end
+    if @prune_selector != other.prune_selector
+      return false
+    end
+    if @html_date_mode != other.html_date_mode
+      return false
+    end
+    if @html_date_override != other.html_date_override
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type Metadata
+class Metadata
+  attr_reader :title, :author, :url, :hostname, :description, :sitename, :date, :categories, :tags, :id, :fingerprint, :license, :language, :image, :page_type
+
+  def initialize(title:, author:, url:, hostname:, description:, sitename:, date:, categories:, tags:, id:, fingerprint:, license:, language:, image:, page_type:)
+    @title = title
+    @author = author
+    @url = url
+    @hostname = hostname
+    @description = description
+    @sitename = sitename
+    @date = date
+    @categories = categories
+    @tags = tags
+    @id = id
+    @fingerprint = fingerprint
+    @license = license
+    @language = language
+    @image = image
+    @page_type = page_type
+  end
+
+  def ==(other)
+    if @title != other.title
+      return false
+    end
+    if @author != other.author
+      return false
+    end
+    if @url != other.url
+      return false
+    end
+    if @hostname != other.hostname
+      return false
+    end
+    if @description != other.description
+      return false
+    end
+    if @sitename != other.sitename
+      return false
+    end
+    if @date != other.date
+      return false
+    end
+    if @categories != other.categories
+      return false
+    end
+    if @tags != other.tags
+      return false
+    end
+    if @id != other.id
+      return false
+    end
+    if @fingerprint != other.fingerprint
+      return false
+    end
+    if @license != other.license
+      return false
+    end
+    if @language != other.language
+      return false
+    end
+    if @image != other.image
+      return false
+    end
+    if @page_type != other.page_type
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+  
+
+def self.create_readable_document(result)
+    result = result
+    RustBuffer.check_lower_TypeExtractResult(result)
+    
+  result = Trafilatura.rust_call(:uniffi_trafilatura_uniffi_fn_func_create_readable_document,RustBuffer.alloc_from_TypeExtractResult(result))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.default_config()
+  result = Trafilatura.rust_call(:uniffi_trafilatura_uniffi_fn_func_default_config,)
+  return result.consumeIntoTypeExtractionConfig
+end
+
+
+  
+  
+
+def self.default_options()
+  result = Trafilatura.rust_call(:uniffi_trafilatura_uniffi_fn_func_default_options,)
+  return result.consumeIntoTypeExtractionOptions
+end
+
+
+  
+  
+
+def self.extract(html, options)
+    html = Trafilatura::uniffi_utf8(html)
+    
+    
+    options = options
+    RustBuffer.check_lower_TypeExtractionOptions(options)
+    
+  result = Trafilatura.rust_call_with_error(TrafilaturaError,:uniffi_trafilatura_uniffi_fn_func_extract,RustBuffer.allocFromString(html),RustBuffer.alloc_from_TypeExtractionOptions(options))
+  return result.consumeIntoTypeExtractResult
+end
+
+
+  
+  
+
+def self.extract_simple(html)
+    html = Trafilatura::uniffi_utf8(html)
+    
+    
+  result = Trafilatura.rust_call_with_error(TrafilaturaError,:uniffi_trafilatura_uniffi_fn_func_extract_simple,RustBuffer.allocFromString(html))
+  return result.consumeIntoTypeExtractResult
+end
+
+
+  
+
+  
+end
+