gte 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 566cb32a193255c0cf3d087a1a907cdbf0a96292ee58d4676fd18745d55ec1b2
+  data.tar.gz: 56479bb218282bf189ace46852a42766d4c2211230be635b6a79414cf3eb82c8
+SHA512:
+  metadata.gz: f873b83b16e4cf2685f26b84d26f4c3b8abd90a9d32d5e60046d1aad577d409704838d3da1329f741535fef1f1a90f1edeeeb6d4fbab559569117869ae42677e
+  data.tar.gz: d5d5b49b8f51cbf3222409b941fa39b3f00074bf34aafdfaf74d4a3fd37ab99ec8a90bba9be641efb42176b182fe191925042ae09d324c851324b27bd62031ce

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake'
+gem 'rake-compiler'
+gem 'rb_sys'
+gem 'rspec'
+gem 'rspec-benchmark'
+gem 'rubocop', require: false
+
+group :bench do
+  gem 'onnxruntime'
+  gem 'tokenizers'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 elcuervo
+
+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/README.md

@@ -0,0 +1,49 @@
+# gte
+![](https://images.unsplash.com/photo-1551225183-94acb7d595b6?q=80&w=2274&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D)
+
+`gte` is a Ruby gem with a Rust extension for fast text embeddings with ONNX Runtime.
+Inspired by https://github.com/fbilhaut/gte-rs
+
+## Quick Start
+
+```ruby
+require "gte"
+
+model = GTE.new(ENV.fetch("GTE_MODEL_DIR"))
+vector = model["query: hello world"]
+```
+
+## Model Directory
+
+A model directory must include `tokenizer.json` and one ONNX model, resolved in this order:
+
+1. `onnx/text_model.onnx`
+2. `text_model.onnx`
+3. `onnx/model.onnx`
+4. `model.onnx`
+
+## Development
+
+Run commands inside `nix develop`.
+
+```bash
+bundle exec rake compile
+cargo test --manifest-path ext/gte/Cargo.toml --no-default-features
+bundle exec rspec
+```
+
+## Benchmark
+
+The repo includes two benchmark paths:
+
+```bash
+bundle exec rake bench:pure_compare
+bundle exec rake bench:puma_compare
+bundle exec rake bench:matrix_sweep
+```
+
+For release tracking and regression detection, record a run entry in `RUNS.md`:
+
+```bash
+bundle exec rake bench:record_run
+```

data/Rakefile

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+rescue LoadError
+  # rspec not available in cross-compile environment
+end
+
+spec = Gem::Specification.load('gte.gemspec')
+
+Rake::ExtensionTask.new('gte', spec) do |ext|
+  ext.lib_dir = 'lib/gte'
+  ext.cross_compile = true
+  ext.cross_platform = %w[x86_64-linux arm64-darwin]
+end
+
+task default: %i[compile spec]
+
+def run_in_nix(*command)
+  sh('nix', 'develop', '-c', *command)
+end
+
+namespace :bench do
+  desc 'Run pure-Ruby (onnxruntime gem) vs GTE benchmark comparison inside nix develop'
+  task :pure_compare do
+    run_in_nix('bundle', 'exec', 'ruby', 'bench/pure_ruby_compare.rb')
+  end
+
+  desc 'Run Puma-like concurrent single-request benchmark (GTE vs pure Ruby)'
+  task :puma_compare do
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/puma_compare.rb',
+      '--output', 'bench/results/puma_compare_latest.json',
+      '--iterations', '80',
+      '--runs', '3'
+    )
+  end
+
+  desc 'Sweep execution-provider and thread settings for Puma-like benchmark'
+  task :matrix_sweep do
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/puma_matrix_sweep.rb',
+      '--iterations', '80',
+      '--runs', '3'
+    )
+  end
+
+  desc 'Run Puma benchmark, append RUNS.md entry, and enforce goal/regression checks'
+  task :record_run do
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/puma_compare.rb',
+      '--output', 'bench/results/puma_compare_latest.json',
+      '--iterations', '80',
+      '--runs', '3'
+    )
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/runs_ledger.rb', 'append',
+      '--result', 'bench/results/puma_compare_latest.json'
+    )
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/runs_ledger.rb', 'check',
+      '--result', 'bench/results/puma_compare_latest.json'
+    )
+  end
+
+  desc 'Validate current Puma benchmark output against 2x goal and regression policy'
+  task :check_goal do
+    run_in_nix(
+      'bundle', 'exec', 'ruby', 'bench/runs_ledger.rb', 'check',
+      '--result', 'bench/results/puma_compare_latest.json'
+    )
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ext/gte/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "gte"
+version = "0.0.1"
+edition = "2021"
+authors = ["elcuervo <elcuervo@elcuervo.net>"]
+license = "MIT"
+publish = false
+build = "build.rs"
+
+[lib]
+# cdylib: Ruby FFI extension; rlib: enables integration tests in tests/ to link as external crate
+crate-type = ["cdylib", "rlib"]
+
+[features]
+# ruby-ffi: gate magnus + rb-sys (Ruby C symbols) so Rust integration tests can link without Ruby.
+# This feature is enabled by default for the cdylib build (rake compile / extconf.rb).
+# When running `cargo test`, this feature must be excluded: `cargo test --no-default-features`.
+default = ["ruby-ffi"]
+ruby-ffi = ["dep:magnus", "dep:rb-sys"]
+
+[dependencies]
+rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"], optional = true }
+magnus = { version = "0.8", optional = true }
+ort = { version = "=2.0.0-rc.9", features = ["ndarray"] }
+ort-sys = "=2.0.0-rc.9"
+tokenizers = "0.21.0"
+ndarray = "0.16.0"
+half = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[dev-dependencies]
+criterion = "0.5"
+
+[[bench]]
+name = "hot_path"
+harness = false

data/ext/gte/benches/hot_path.rs

@@ -0,0 +1,53 @@
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use gte::postprocess::{mean_pool, normalize_l2};
+use ndarray::{Array2, Array3};
+
+fn build_hidden_states(batch: usize, seq: usize, dim: usize) -> Array3<f32> {
+    Array3::from_shape_fn((batch, seq, dim), |(b, s, d)| {
+        (((b * 31 + s * 17 + d * 13) % 97) as f32) / 97.0
+    })
+}
+
+fn build_attention_mask(batch: usize, seq: usize) -> Array2<i64> {
+    Array2::from_shape_fn((batch, seq), |(_, s)| if s % 11 == 10 { 0 } else { 1 })
+}
+
+fn bench_mean_pool(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mean_pool");
+    for (batch, seq, dim) in [(1, 32, 384), (8, 64, 384), (32, 64, 768)] {
+        let hidden_states = build_hidden_states(batch, seq, dim);
+        let attention_mask = build_attention_mask(batch, seq);
+        group.bench_with_input(
+            BenchmarkId::from_parameter(format!("{batch}x{seq}x{dim}")),
+            &(batch, seq, dim),
+            |b, _| {
+                b.iter(|| {
+                    mean_pool(
+                        black_box(hidden_states.view()),
+                        black_box(attention_mask.view()),
+                    )
+                    .unwrap()
+                })
+            },
+        );
+    }
+    group.finish();
+}
+
+fn bench_normalize_l2(c: &mut Criterion) {
+    let mut group = c.benchmark_group("normalize_l2");
+    for (rows, dim) in [(1, 384), (8, 384), (32, 768), (128, 768)] {
+        let embeddings = Array2::from_shape_fn((rows, dim), |(row, col)| {
+            (((row * 19 + col * 7) % 113) as f32) / 113.0
+        });
+        group.bench_with_input(
+            BenchmarkId::from_parameter(format!("{rows}x{dim}")),
+            &(rows, dim),
+            |b, _| b.iter(|| normalize_l2(black_box(embeddings.clone()))),
+        );
+    }
+    group.finish();
+}
+
+criterion_group!(benches, bench_mean_pool, bench_normalize_l2);
+criterion_main!(benches);

data/ext/gte/build.rs

@@ -0,0 +1,25 @@
+fn main() {
+    let version = std::fs::read_to_string("../../VERSION")
+        .expect("VERSION file not found")
+        .trim()
+        .to_string();
+
+    let cargo_version = env!("CARGO_PKG_VERSION");
+
+    assert_eq!(
+        version, cargo_version,
+        "VERSION file ({}) doesn't match Cargo.toml ({}). Update Cargo.toml to match.",
+        version, cargo_version
+    );
+
+    println!("cargo:rerun-if-changed=../../VERSION");
+
+    // Ensure the ORT shared library can be found at runtime via @rpath on macOS.
+    // ORT_LIB_LOCATION is set by the Nix dev shell when ORT_STRATEGY=system.
+    if let Ok(ort_lib) = std::env::var("ORT_LIB_LOCATION") {
+        let lib_dir = std::path::Path::new(&ort_lib).join("lib");
+        if lib_dir.exists() {
+            println!("cargo:rustc-link-arg=-Wl,-rpath,{}", lib_dir.display());
+        }
+    }
+}

data/ext/gte/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rb_sys/mkmf'
+
+create_rust_makefile('gte/gte')

data/ext/gte/src/embedder.rs

@@ -0,0 +1,342 @@
+use crate::error::{GteError, Result};
+use crate::model_config::{ExtractorMode, ModelConfig};
+use crate::postprocess::normalize_l2 as normalize_l2_rows;
+use crate::session::{build_session, run_session};
+use crate::tokenizer::{Tokenized, Tokenizer};
+use ndarray::Array2;
+use ort::session::Session;
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ModelFamily {
+    E5Like,
+    SiglipLike,
+    ClipLike,
+    Other,
+}
+
+pub struct Embedder {
+    tokenizer: Tokenizer,
+    session: Session,
+    config: ModelConfig,
+}
+
+impl Embedder {
+    pub fn new<P1, P2>(tokenizer_path: P1, model_path: P2, config: ModelConfig) -> Result<Self>
+    where
+        P1: AsRef<Path>,
+        P2: AsRef<Path>,
+    {
+        let tokenizer = Tokenizer::new(tokenizer_path, config.max_length, config.with_type_ids)?;
+        let session = build_session(model_path, &config)?;
+        Ok(Self {
+            tokenizer,
+            session,
+            config,
+        })
+    }
+
+    pub fn from_dir<P: AsRef<Path>>(
+        dir: P,
+        num_threads: usize,
+        optimization_level: u8,
+    ) -> Result<Self> {
+        let dir = dir.as_ref();
+        let tokenizer_path = dir.join("tokenizer.json");
+        let model_path = resolve_model_path(dir)?;
+
+        if !tokenizer_path.exists() {
+            return Err(GteError::Tokenizer(format!(
+                "tokenizer.json not found in {}",
+                dir.display()
+            )));
+        }
+
+        let max_length = read_max_length(dir);
+        let temp_config = ModelConfig {
+            max_length,
+            output_tensor: String::new(),
+            mode: ExtractorMode::Raw,
+            with_type_ids: false,
+            with_attention_mask: true,
+            num_threads,
+            optimization_level,
+        };
+        let session = build_session(&model_path, &temp_config)?;
+
+        validate_supported_inputs(&session)?;
+        let with_type_ids = session.inputs.iter().any(|i| i.name == "token_type_ids");
+        let with_attention_mask = session.inputs.iter().any(|i| i.name == "attention_mask");
+        let output_tensor = select_output_tensor(&session)?;
+        let output_base = output_basename(output_tensor.as_str()).to_string();
+        let mode = infer_extraction_mode(&session, output_tensor.as_str())?;
+        if matches!(mode, ExtractorMode::MeanPool) && !with_attention_mask {
+            return Err(GteError::Inference(
+                "cannot use mean pooling without attention_mask input".to_string(),
+            ));
+        }
+
+        let tuned_num_threads = tune_num_threads(
+            num_threads,
+            with_attention_mask,
+            with_type_ids,
+            output_base.as_str(),
+        );
+
+        let config = ModelConfig {
+            max_length,
+            output_tensor,
+            mode,
+            with_type_ids,
+            with_attention_mask,
+            num_threads: tuned_num_threads,
+            optimization_level,
+        };
+
+        let session = if tuned_num_threads != num_threads {
+            build_session(&model_path, &config)?
+        } else {
+            session
+        };
+
+        let tokenizer = Tokenizer::new(&tokenizer_path, config.max_length, config.with_type_ids)?;
+
+        Ok(Self {
+            tokenizer,
+            session,
+            config,
+        })
+    }
+
+    pub fn embed(&self, texts: Vec<String>) -> Result<Array2<f32>> {
+        let tokenized = self.tokenize(&texts)?;
+        self.run(&tokenized)
+    }
+
+    pub fn tokenize(&self, texts: &[String]) -> crate::error::Result<Tokenized> {
+        self.tokenizer.tokenize(texts)
+    }
+
+    pub fn run(&self, tokenized: &Tokenized) -> crate::error::Result<Array2<f32>> {
+        run_session(&self.session, tokenized, &self.config)
+    }
+
+}
+
+fn tune_num_threads(
+    requested: usize,
+    with_attention_mask: bool,
+    with_type_ids: bool,
+    output_name: &str,
+) -> usize {
+    if requested > 0 {
+        return requested;
+    }
+
+    let family = infer_model_family(with_attention_mask, with_type_ids, output_name);
+    let target_concurrency = puma_target_concurrency();
+    let host_cores = host_parallelism();
+    let budgeted_threads = (host_cores / target_concurrency).max(1);
+
+    match family {
+        // Puma-like workloads typically run many concurrent single-item requests where
+        // one intra-op thread per request gives the best tail behavior.
+        ModelFamily::E5Like | ModelFamily::ClipLike | ModelFamily::SiglipLike => {
+            budgeted_threads.min(1)
+        }
+        ModelFamily::Other => 0,
+    }
+}
+
+fn infer_model_family(
+    with_attention_mask: bool,
+    with_type_ids: bool,
+    output_name: &str,
+) -> ModelFamily {
+    if output_name == "last_hidden_state" && with_attention_mask && with_type_ids {
+        return ModelFamily::E5Like;
+    }
+    if output_name == "last_hidden_state" && with_attention_mask && !with_type_ids {
+        return ModelFamily::SiglipLike;
+    }
+    if output_name == "text_embeds" && !with_attention_mask {
+        return ModelFamily::ClipLike;
+    }
+    ModelFamily::Other
+}
+
+fn puma_target_concurrency() -> usize {
+    std::env::var("GTE_PUMA_CONCURRENCY")
+        .ok()
+        .and_then(|raw| raw.parse::<usize>().ok())
+        .filter(|value| *value > 0)
+        .unwrap_or(16)
+}
+
+fn host_parallelism() -> usize {
+    std::thread::available_parallelism()
+        .map(|n| n.get())
+        .unwrap_or(1)
+}
+
+fn resolve_model_path(dir: &Path) -> Result<PathBuf> {
+    let candidates = [
+        dir.join("onnx").join("text_model.onnx"),
+        dir.join("text_model.onnx"),
+        dir.join("onnx").join("model.onnx"),
+        dir.join("model.onnx"),
+    ];
+    for path in &candidates {
+        if path.exists() {
+            return Ok(path.clone());
+        }
+    }
+    Err(GteError::Inference(format!(
+        "no ONNX model found in {} (checked text_model.onnx and model.onnx)",
+        dir.display()
+    )))
+}
+
+const SUPPORTED_INPUTS: [&str; 3] = ["input_ids", "attention_mask", "token_type_ids"];
+
+fn validate_supported_inputs(session: &Session) -> Result<()> {
+    let unsupported: Vec<String> = session
+        .inputs
+        .iter()
+        .filter(|i| !SUPPORTED_INPUTS.contains(&i.name.as_str()))
+        .map(|i| i.name.clone())
+        .collect();
+
+    if unsupported.is_empty() {
+        return Ok(());
+    }
+
+    let mut message = format!(
+        "unsupported model inputs for text embedding API: {}",
+        unsupported.join(", ")
+    );
+    if unsupported.iter().any(|n| n == "pixel_values") {
+        message.push_str(
+            ". This looks like a multimodal graph. Provide a text-only export (for example onnx/text_model.onnx).",
+        );
+    } else {
+        message.push_str(". Supported inputs are: input_ids, attention_mask, token_type_ids.");
+    }
+    Err(GteError::Inference(message))
+}
+
+fn output_name_matches(name: &str, preferred: &str) -> bool {
+    let lower = name.to_ascii_lowercase();
+    lower == preferred || lower.ends_with(&format!("/{}", preferred))
+}
+
+fn select_output_tensor(session: &Session) -> Result<String> {
+    const PREFERRED: [&str; 4] = [
+        "text_embeds",
+        "pooler_output",
+        "sentence_embedding",
+        "last_hidden_state",
+    ];
+
+    for preferred in PREFERRED {
+        if let Some(output) = session
+            .outputs
+            .iter()
+            .find(|o| output_name_matches(o.name.as_str(), preferred))
+        {
+            return Ok(output.name.clone());
+        }
+    }
+
+    session
+        .outputs
+        .first()
+        .map(|o| o.name.clone())
+        .ok_or_else(|| GteError::Inference("model has no outputs".into()))
+}
+
+fn read_max_length(dir: &Path) -> usize {
+    (|| -> Option<usize> {
+        let contents = std::fs::read_to_string(dir.join("tokenizer_config.json")).ok()?;
+        let json: serde_json::Value = serde_json::from_str(&contents).ok()?;
+        let v = json.get("model_max_length")?;
+        let n = v
+            .as_u64()
+            .or_else(|| v.as_f64().filter(|&f| f > 0.0 && f < 1e15).map(|f| f as u64))?;
+        Some((n as usize).min(8192))
+    })()
+    .unwrap_or(512)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{infer_model_family, tune_num_threads, ModelFamily};
+
+    #[test]
+    fn infer_model_family_recognizes_known_signatures() {
+        assert_eq!(
+            infer_model_family(true, true, "last_hidden_state"),
+            ModelFamily::E5Like
+        );
+        assert_eq!(
+            infer_model_family(true, false, "last_hidden_state"),
+            ModelFamily::SiglipLike
+        );
+        assert_eq!(
+            infer_model_family(false, false, "text_embeds"),
+            ModelFamily::ClipLike
+        );
+        assert_eq!(infer_model_family(true, false, "pooler_output"), ModelFamily::Other);
+    }
+
+    #[test]
+    fn tune_num_threads_respects_requested_value() {
+        assert_eq!(tune_num_threads(7, true, true, "last_hidden_state"), 7);
+    }
+
+    #[test]
+    fn tune_num_threads_returns_ort_default_for_other_family() {
+        assert_eq!(tune_num_threads(0, true, false, "pooler_output"), 0);
+    }
+}
+
+fn output_basename(name: &str) -> &str {
+    name.rsplit('/').next().unwrap_or(name)
+}
+
+fn infer_extraction_mode(session: &Session, output_tensor: &str) -> Result<ExtractorMode> {
+    let output = session
+        .outputs
+        .iter()
+        .find(|o| o.name == output_tensor)
+        .ok_or_else(|| {
+            GteError::Inference(format!(
+                "output tensor '{}' not found in model outputs",
+                output_tensor
+            ))
+        })?;
+
+    let ndims = match &output.output_type {
+        ort::value::ValueType::Tensor { dimensions, .. } => dimensions.len(),
+        other => {
+            return Err(GteError::Inference(format!(
+                "output is not a tensor: {:?}",
+                other
+            )))
+        }
+    };
+
+    match (output_basename(output_tensor), ndims) {
+        ("last_hidden_state", 3) => Ok(ExtractorMode::MeanPool),
+        (_, 2) => Ok(ExtractorMode::Raw),
+        (_, 3) => Ok(ExtractorMode::MeanPool),
+        (_, n) => Err(GteError::Inference(format!(
+            "unexpected output tensor rank {} for '{}': expected 2 (Raw) or 3 (MeanPool)",
+            n, output_tensor
+        ))),
+    }
+}
+
+pub fn normalize_l2(embeddings: Array2<f32>) -> Array2<f32> {
+    normalize_l2_rows(embeddings)
+}

data/ext/gte/src/error.rs

@@ -0,0 +1,48 @@
+#[derive(Debug)]
+pub enum GteError {
+    Tokenizer(String),
+    Inference(String),
+    Ort(String),
+    Shape(String),
+}
+
+impl std::fmt::Display for GteError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            GteError::Tokenizer(msg) => write!(f, "GTE tokenizer error: {}", msg),
+            GteError::Inference(msg) => write!(f, "GTE inference error: {}", msg),
+            GteError::Ort(msg) => write!(f, "GTE ORT error: {}", msg),
+            GteError::Shape(msg) => write!(f, "GTE shape error: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for GteError {}
+
+impl From<ort::Error> for GteError {
+    fn from(e: ort::Error) -> Self {
+        GteError::Ort(e.to_string())
+    }
+}
+
+impl From<ndarray::ShapeError> for GteError {
+    fn from(e: ndarray::ShapeError) -> Self {
+        GteError::Shape(e.to_string())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, GteError>;
+
+#[cfg(feature = "ruby-ffi")]
+impl From<GteError> for magnus::Error {
+    fn from(e: GteError) -> Self {
+        use magnus::prelude::*;
+
+        let ruby = magnus::Ruby::get().expect("From<GteError> called from Ruby thread");
+        let module = ruby.define_module("GTE").expect("GTE module must exist");
+        let gte_error_class = module
+            .const_get::<_, magnus::ExceptionClass>("Error")
+            .expect("GTE::Error must be defined before embedder methods are called");
+        magnus::Error::new(gte_error_class, e.to_string())
+    }
+}