gte 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c754b4675ee105e9a280cd9deafa00a81b9e02ee629131f3e908400006b6ae4
-  data.tar.gz: 40a0d3e04c3d2943ae50910164d644ecb763eac99a02044dc962cc141a0e13c5
+  metadata.gz: 245f038cae58b7059fcc966479eb642316ab2611e64acf555214eec54713ce00
+  data.tar.gz: d23d0b248eeffd2d24d6be8e3190bbc9b06681cb265ecf05a6b174bcaa7b55b4
 SHA512:
-  metadata.gz: 16614e01e7a33a53339ba9fe7cf32fe7606041518a24177258d7a6e5550516e8cff741d0f0df02b7e5863fc763c02ae81b943dc4b18295701a4cafdec6627cb0
-  data.tar.gz: 348e1fd1d9f4c44214b5101ba339109b5ececfbef18b48b7c11324a64481f476d8da831cc5148d17a85c41b525ee753c296d4421a4fb2adda269a3f5fe38cda6
+  metadata.gz: 188f5f5ee4320d1bead817a2d43b033eff2aeaed3e17b61bc9a49bef6c4e7edc0e4c9983f494b3b9eab314ea2171a6f95cff7dcffd3aeb3c5a6180f7c0b60a3c
+  data.tar.gz: 5d514fcb9fbed57b5ef1bb488003b474ecd6e1e497e97ad223ea7daecc4e78c396fe17269bc6da48d3dadf865d7c6b36a7878f5c006b0c2144e09212ff8435d4

data/Rakefile

@@ -31,7 +31,7 @@ extension_task = Rake::ExtensionTask.new('gte', spec) do |ext|
   ext.cross_platform = cross_platforms
 end
 
-if cross_target && !cross_target.empty? && ENV['RUBY_CC_VERSION']
+if cross_target && !cross_target.empty? && ENV.fetch('RUBY_CC_VERSION', nil) && cross_target != 'x86_64-linux'
   ruby_version = ENV['RUBY_CC_VERSION'].split(':').first
   lib_binary_path = File.join(extension_task.lib_dir, File.basename(extension_task.binary(cross_target)))
   copy_task = "copy:gte:#{cross_target}:#{ruby_version}"

data/VERSION

@@ -1 +1 @@
-0.0.8
+0.0.10

data/ext/gte/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "gte"
-version = "0.0.8"
+version = "0.0.10"
 edition = "2021"
 authors = ["elcuervo <elcuervo@elcuervo.net>"]
 license = "MIT"

data/ext/gte/benches/hot_path.rs

@@ -1,4 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use gte::embedder::Embedder;
+use gte::model_config::ModelLoadOverrides;
 use gte::postprocess::{mean_pool, normalize_l2};
 use ndarray::{Array2, Array3};
 
@@ -49,5 +51,90 @@ fn bench_normalize_l2(c: &mut Criterion) {
     group.finish();
 }
 
-criterion_group!(benches, bench_mean_pool, bench_normalize_l2);
+// Replicates the fixed-padding regression: a short input (4 tokens, like "cat")
+// padded to max_length costs proportionally more in every downstream operation.
+// Siglip2 regressed from 7ms → 44ms when tokenizer.json had "padding.strategy.Fixed: 64".
+// Each row here represents: (label, actual_tokens, padded_to)
+//   batch_longest → seq = actual_tokens
+//   fixed         → seq = max_length regardless of input
+fn bench_padding_impact(c: &mut Criterion) {
+    let dim = 768;
+    let mut group = c.benchmark_group("padding_impact");
+
+    for (label, seq) in [
+        ("batch_longest/4tok", 4usize),
+        ("fixed/siglip2_max_64", 64usize),
+        ("fixed/e5_max_512", 512usize),
+    ] {
+        let hidden_states = build_hidden_states(1, seq, dim);
+        let attention_mask = build_attention_mask(1, seq);
+        group.bench_with_input(
+            BenchmarkId::from_parameter(label),
+            &seq,
+            |b, _| {
+                b.iter(|| {
+                    mean_pool(
+                        black_box(hidden_states.view()),
+                        black_box(attention_mask.view()),
+                    )
+                    .unwrap()
+                })
+            },
+        );
+    }
+    group.finish();
+}
+
+// End-to-end inference bench. Requires real ONNX models on disk. Skips
+// silently when env vars not set so default `cargo bench` stays cheap.
+//   GTE_BENCH_E5_DIR       — sentence-transformers / E5-style text model dir
+//   GTE_BENCH_SIGLIP2_DIR  — siglip2 text encoder dir
+//   GTE_BENCH_CLIP_DIR     — clip text encoder dir
+// Sweeps threads ∈ {0 (auto/all-cores), 1, 2} to validate DEFAULT_THREADS=0.
+fn bench_embedding_e2e(c: &mut Criterion) {
+    let cases = [
+        ("e5", "GTE_BENCH_E5_DIR", "query: cat", "query: ".to_string() + &"the quick brown fox jumps over the lazy dog ".repeat(20)),
+        ("siglip2", "GTE_BENCH_SIGLIP2_DIR", "cat", "a photo of ".to_string() + &"a cat sitting on a mat ".repeat(10)),
+        ("clip", "GTE_BENCH_CLIP_DIR", "cat", "a photo of ".to_string() + &"a cat sitting on a mat ".repeat(10)),
+    ];
+
+    let mut group = c.benchmark_group("embedding_e2e");
+    group.sample_size(20);
+
+    for (model_label, env_var, short_input, long_input) in cases.iter() {
+        let Some(dir) = std::env::var(env_var).ok().filter(|v| !v.is_empty()) else {
+            continue;
+        };
+
+        for &threads in &[0usize, 1, 2] {
+            let embedder = match Embedder::from_dir(&dir, threads, 3, ModelLoadOverrides::default()) {
+                Ok(e) => e,
+                Err(err) => {
+                    eprintln!("skip {model_label} threads={threads}: {err}");
+                    continue;
+                }
+            };
+
+            for (input_label, input) in [("short", short_input.to_string()), ("long", long_input.clone())] {
+                let id = BenchmarkId::from_parameter(format!("{model_label}/threads_{threads}/{input_label}"));
+                group.bench_with_input(id, &input, |b, text| {
+                    b.iter(|| {
+                        embedder
+                            .embed(black_box(vec![text.clone()]))
+                            .expect("embed succeeds")
+                    })
+                });
+            }
+        }
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_mean_pool,
+    bench_normalize_l2,
+    bench_padding_impact,
+    bench_embedding_e2e
+);
 criterion_main!(benches);

data/ext/gte/src/ruby_embedder.rs

@@ -4,6 +4,7 @@ use crate::embedder::{normalize_l2, Embedder};
 use crate::error::GteError;
 use crate::model_config::ModelLoadOverrides;
 use crate::reranker::Reranker;
+use crate::tokenizer::Tokenized;
 use magnus::{function, method, prelude::*, wrap, Error, RArray, Ruby};
 use std::os::raw::c_void;
 use std::panic::{catch_unwind, AssertUnwindSafe};
@@ -32,9 +33,10 @@ pub struct RbTensor {
 // GVL-release helpers
 // ---------------------------------------------------------------------------
 
+// Tokenized holds only Vec<i64> fields — safe to send across threads.
 struct InferArgs {
     embedder: *const Embedder,
-    texts: *const Vec<String>,
+    tokenized: *const Tokenized,
     normalize: bool,
     result: Option<crate::error::Result<ndarray::Array2<f32>>>,
 }
@@ -63,8 +65,9 @@ fn panic_payload_to_string(payload: Box<dyn std::any::Any + Send>) -> String {
 unsafe extern "C" fn run_without_gvl(ptr: *mut c_void) -> *mut c_void {
     let args = &mut *(ptr as *mut InferArgs);
     let run_result = catch_unwind(AssertUnwindSafe(|| {
-        let tokenized = (*args.embedder).tokenize(&*args.texts)?;
-        let embeddings = (*args.embedder).run(&tokenized)?;
+        // Tokenization happens before GVL release (in rb_embed / rb_embed_one).
+        // Only ONNX inference runs here without the GVL.
+        let embeddings = (*args.embedder).run(&*args.tokenized)?;
         if args.normalize { Ok(normalize_l2(embeddings)) } else { Ok(embeddings) }
     }));
     args.result = Some(match run_result {
@@ -95,12 +98,12 @@ unsafe extern "C" fn run_score_without_gvl(ptr: *mut c_void) -> *mut c_void {
 fn infer_without_gvl(
     embedder: &Arc<Embedder>,
     normalize: bool,
-    texts: Vec<String>,
+    tokenized: &Tokenized,
 ) -> Result<ndarray::Array2<f32>, Error> {
     let embeddings = unsafe {
         let mut args = InferArgs {
             embedder: Arc::as_ptr(embedder),
-            texts: &texts as *const Vec<String>,
+            tokenized: tokenized as *const Tokenized,
             normalize,
             result: None,
         };
@@ -195,12 +198,14 @@ impl RbEmbedder {
 
     pub fn rb_embed(_ruby: &Ruby, rb_self: &Self, texts: RArray) -> Result<RbTensor, Error> {
         let texts: Vec<String> = texts.to_vec()?;
-        let embeddings = infer_without_gvl(&rb_self.inner, rb_self.normalize, texts)?;
+        let tokenized = rb_self.inner.tokenize(&texts).map_err(magnus::Error::from)?;
+        let embeddings = infer_without_gvl(&rb_self.inner, rb_self.normalize, &tokenized)?;
         tensor_from_array(embeddings)
     }
 
     pub fn rb_embed_one(_ruby: &Ruby, rb_self: &Self, text: String) -> Result<RbTensor, Error> {
-        let embeddings = infer_without_gvl(&rb_self.inner, rb_self.normalize, vec![text])?;
+        let tokenized = rb_self.inner.tokenize(&[text]).map_err(magnus::Error::from)?;
+        let embeddings = infer_without_gvl(&rb_self.inner, rb_self.normalize, &tokenized)?;
         tensor_from_array(embeddings)
     }
 }
@@ -292,6 +297,10 @@ impl RbTensor {
         Self::row(ruby, rb_self, 0)
     }
 
+    pub fn first_binary_f32(ruby: &Ruby, rb_self: &Self) -> Result<magnus::RString, Error> {
+        Self::row_binary_f32(ruby, rb_self, 0)
+    }
+
     pub fn row_binary_f32(
         ruby: &Ruby,
         rb_self: &Self,
@@ -354,6 +363,7 @@ pub fn register(ruby: &Ruby) -> Result<(), Error> {
     tensor_class.define_method("row", method!(RbTensor::row, 1))?;
     tensor_class.define_method("first", method!(RbTensor::first, 0))?;
     tensor_class.define_method("row_binary_f32", method!(RbTensor::row_binary_f32, 1))?;
+    tensor_class.define_method("first_binary_f32", method!(RbTensor::first_binary_f32, 0))?;
     tensor_class.define_method("to_a", method!(RbTensor::to_a, 0))?;
     tensor_class.define_method("to_binary_f32", method!(RbTensor::to_binary_f32, 0))?;
     Ok(())

data/ext/gte/src/session.rs

@@ -28,7 +28,7 @@ pub fn build_session<P: AsRef<Path>>(model_path: P, config: &ModelConfig) -> Res
         .map_err(ort_err)?
         .with_optimization_level(opt_level)
         .map_err(ort_err)?
-        .with_memory_pattern(true)
+        .with_memory_pattern(false)
         .map_err(ort_err)?;
 
     let providers = preferred_execution_providers(config.execution_providers.as_deref());
@@ -54,12 +54,6 @@ pub fn build_session<P: AsRef<Path>>(model_path: P, config: &ModelConfig) -> Res
 // Session pool
 // ---------------------------------------------------------------------------
 
-const AUTO_THREAD_POOL_CAP: usize = 6;
-
-/// Keep enough sessions to cover the configured thread budget without
-/// oversubscribing CPU parallelism. In ORT auto-thread mode (`num_threads == 0`)
-/// we still keep a modest pool because request-level concurrency benefits from
-/// more than one session even when ORT manages thread counts internally.
 fn pool_capacity(num_threads: usize) -> usize {
     let available_parallelism = std::thread::available_parallelism()
         .map(|n| n.get())
@@ -72,8 +66,10 @@ fn pool_capacity_with_parallelism(num_threads: usize, available_parallelism: usi
         return 1;
     }
 
+    // Auto-thread mode: ORT grabs all cores per session. One session avoids
+    // N² intra-op oversubscription when multiple Ruby threads call concurrently.
     if num_threads == 0 {
-        return available_parallelism.clamp(1, AUTO_THREAD_POOL_CAP);
+        return 1;
     }
 
     available_parallelism.div_ceil(num_threads).max(1)
@@ -347,10 +343,12 @@ mod tests {
     }
 
     #[test]
-    fn pool_capacity_uses_bounded_parallel_pool_for_auto_thread_mode() {
+    fn pool_capacity_uses_single_session_for_auto_thread_mode() {
+        // Auto-thread = ORT uses all cores per session. Pool=1 avoids N²
+        // intra-op oversubscription under concurrent Ruby threads.
         assert_eq!(pool_capacity_with_parallelism(0, 1), 1);
-        assert_eq!(pool_capacity_with_parallelism(0, 4), 4);
-        assert_eq!(pool_capacity_with_parallelism(0, 8), 6);
+        assert_eq!(pool_capacity_with_parallelism(0, 4), 1);
+        assert_eq!(pool_capacity_with_parallelism(0, 8), 1);
     }
 
     #[test]

data/ext/gte/src/tokenizer.rs

@@ -113,18 +113,11 @@ pub fn parse_padding_mode_override(value: Option<&str>) -> Result<Option<Padding
 fn resolve_padding_strategy(
     padding_mode: PaddingMode,
     max_length: usize,
-    fixed_padding_length: Option<usize>,
+    _fixed_padding_length: Option<usize>,
 ) -> PaddingStrategy {
     match padding_mode {
-        PaddingMode::BatchLongest => PaddingStrategy::BatchLongest,
+        PaddingMode::BatchLongest | PaddingMode::Auto => PaddingStrategy::BatchLongest,
         PaddingMode::Fixed => PaddingStrategy::Fixed(max_length),
-        PaddingMode::Auto => {
-            if fixed_padding_length.is_some() {
-                PaddingStrategy::Fixed(max_length)
-            } else {
-                PaddingStrategy::BatchLongest
-            }
-        }
     }
 }
 
@@ -225,10 +218,25 @@ mod tests {
     }
 
     #[test]
-    fn resolve_padding_strategy_uses_fixed_for_auto_when_model_has_fixed_padding() {
-        match resolve_padding_strategy(PaddingMode::Auto, 64, Some(64)) {
-            PaddingStrategy::Fixed(64) => {}
-            other => panic!("expected Fixed(64), got {:?}", other),
-        }
+    fn resolve_padding_strategy_auto_always_uses_batch_longest() {
+        // Auto ignores fixed_padding_length from tokenizer.json — BatchLongest is
+        // always faster for inference and correct for variable-length inputs.
+        // Use PaddingMode::Fixed explicitly when fixed-length padding is required.
+        assert!(matches!(
+            resolve_padding_strategy(PaddingMode::Auto, 64, Some(64)),
+            PaddingStrategy::BatchLongest
+        ));
+        assert!(matches!(
+            resolve_padding_strategy(PaddingMode::Auto, 512, None),
+            PaddingStrategy::BatchLongest
+        ));
+    }
+
+    #[test]
+    fn resolve_padding_strategy_fixed_uses_max_length() {
+        assert!(matches!(
+            resolve_padding_strategy(PaddingMode::Fixed, 64, None),
+            PaddingStrategy::Fixed(64)
+        ));
     }
 }

data/ext/gte/tests/inference_integration_test.rs

@@ -1,12 +1,14 @@
 use gte::embedder::Embedder;
 use gte::model_config::ModelLoadOverrides;
 
+fn model_dir(env_var: &str) -> Option<String> {
+    std::env::var(env_var).ok().filter(|v| !v.is_empty())
+}
+
 #[test]
-#[ignore = "requires ext/gte/tests/fixtures/e5/tokenizer.json and model.onnx"]
 fn test_e5_single_embedding_shape() {
-    const DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/e5");
-
-    let embedder = Embedder::from_dir(DIR, 0, 3, ModelLoadOverrides::default())
+    let Some(dir) = model_dir("GTE_BENCH_E5_DIR") else { return };
+    let embedder = Embedder::from_dir(&dir, 0, 3, ModelLoadOverrides::default())
         .expect("embedder should initialize");
     let result = embedder
         .embed(vec!["query: Hello world".to_string()])
@@ -17,11 +19,9 @@ fn test_e5_single_embedding_shape() {
 }
 
 #[test]
-#[ignore = "requires ext/gte/tests/fixtures/clip/tokenizer.json and model.onnx"]
 fn test_clip_single_embedding_shape() {
-    const DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/clip");
-
-    let embedder = Embedder::from_dir(DIR, 0, 3, ModelLoadOverrides::default())
+    let Some(dir) = model_dir("GTE_BENCH_CLIP_DIR") else { return };
+    let embedder = Embedder::from_dir(&dir, 0, 3, ModelLoadOverrides::default())
         .expect("embedder should initialize");
     let result = embedder
         .embed(vec!["a photo of a cat".to_string()])
@@ -32,11 +32,9 @@ fn test_clip_single_embedding_shape() {
 }
 
 #[test]
-#[ignore = "requires ext/gte/tests/fixtures/e5/tokenizer.json and model.onnx"]
 fn test_e5_batch_embedding_shape() {
-    const DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/e5");
-
-    let embedder = Embedder::from_dir(DIR, 0, 3, ModelLoadOverrides::default())
+    let Some(dir) = model_dir("GTE_BENCH_E5_DIR") else { return };
+    let embedder = Embedder::from_dir(&dir, 0, 3, ModelLoadOverrides::default())
         .expect("embedder should initialize");
     let texts = vec![
         "query: first sentence".to_string(),
@@ -51,11 +49,9 @@ fn test_e5_batch_embedding_shape() {
 }
 
 #[test]
-#[ignore = "requires ext/gte/tests/fixtures/e5/tokenizer.json and model.onnx"]
 fn test_e5_long_input_truncation_no_error() {
-    const DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/e5");
-
-    let embedder = Embedder::from_dir(DIR, 0, 3, ModelLoadOverrides::default())
+    let Some(dir) = model_dir("GTE_BENCH_E5_DIR") else { return };
+    let embedder = Embedder::from_dir(&dir, 0, 3, ModelLoadOverrides::default())
         .expect("embedder should initialize");
     let very_long_text = "word ".repeat(1000);
     let result = embedder

data/ext/gte/tests/padding_regression_test.rs

@@ -0,0 +1,94 @@
+// Regression tests for the fixed-padding performance bug.
+//
+// Root cause: PaddingMode::Auto silently read "padding.strategy.Fixed: N" from
+// tokenizer.json and applied it, padding every input to max_length tokens.
+// A query like "cat" (1 token) was padded to 64 tokens for Siglip2, making
+// inference ~6x slower (44ms vs 7ms measured on Heroku).
+//
+// These tests use tests/fixtures/minimal/tokenizer.json which has
+// "padding.strategy.Fixed: 64" baked in — exactly the condition that triggered
+// the regression in production models like Siglip2.
+
+use gte::model_config::PaddingMode;
+use gte::tokenizer::Tokenizer;
+
+const TOKENIZER: &str = concat!(
+    env!("CARGO_MANIFEST_DIR"),
+    "/tests/fixtures/minimal/tokenizer.json"
+);
+
+// Short input tokenizes to 1 token with this vocabulary.
+const SHORT_INPUT: &str = "cat";
+const MAX_LENGTH: usize = 64;
+
+#[test]
+fn auto_padding_uses_batch_longest_regardless_of_tokenizer_json() {
+    // fixed_padding_length: Some(MAX_LENGTH) simulates what model_profile::read_tokenizer_profile
+    // returns when tokenizer.json has "padding.strategy.Fixed: 64".
+    let tokenizer = Tokenizer::new(TOKENIZER, MAX_LENGTH, false, PaddingMode::Auto, Some(MAX_LENGTH))
+        .expect("tokenizer should load");
+
+    let tokenized = tokenizer
+        .tokenize(&[SHORT_INPUT.to_string()])
+        .expect("tokenize should succeed");
+
+    // Old behavior: cols == 64 (silently padded to max_length)
+    // New behavior: cols == actual token count (1 for "cat")
+    assert!(
+        tokenized.cols < MAX_LENGTH,
+        "Auto padding should use batch_longest, got cols={} (expected < {}). \
+         This is the Siglip2 regression: short queries were padded to max_length, \
+         making inference ~6x slower.",
+        tokenized.cols,
+        MAX_LENGTH
+    );
+}
+
+#[test]
+fn fixed_padding_mode_pads_to_max_length() {
+    let tokenizer = Tokenizer::new(TOKENIZER, MAX_LENGTH, false, PaddingMode::Fixed, None)
+        .expect("tokenizer should load");
+
+    let tokenized = tokenizer
+        .tokenize(&[SHORT_INPUT.to_string()])
+        .expect("tokenize should succeed");
+
+    assert_eq!(
+        tokenized.cols, MAX_LENGTH,
+        "Fixed mode should pad to max_length"
+    );
+    assert_eq!(tokenized.input_ids.len(), MAX_LENGTH);
+    assert_eq!(tokenized.attn_masks.len(), MAX_LENGTH);
+}
+
+#[test]
+fn batch_longest_padding_uses_longest_sequence_in_batch() {
+    let tokenizer = Tokenizer::new(TOKENIZER, MAX_LENGTH, false, PaddingMode::BatchLongest, None)
+        .expect("tokenizer should load");
+
+    // "cat" = 1 token, "hello world" = 2 tokens — batch pads to 2, not 64
+    let tokenized = tokenizer
+        .tokenize(&["cat".to_string(), "hello world".to_string()])
+        .expect("tokenize should succeed");
+
+    assert_eq!(tokenized.rows, 2);
+    assert!(
+        tokenized.cols < MAX_LENGTH,
+        "BatchLongest should pad to longest in batch (2 tokens), not max_length ({}). Got cols={}",
+        MAX_LENGTH,
+        tokenized.cols
+    );
+}
+
+#[test]
+fn auto_padding_with_no_fixed_hint_also_uses_batch_longest() {
+    // Sanity check: Auto with fixed_padding_length=None also uses BatchLongest
+    let tokenizer = Tokenizer::new(TOKENIZER, MAX_LENGTH, false, PaddingMode::Auto, None)
+        .expect("tokenizer should load");
+
+    let tokenized = tokenizer
+        .tokenize(&[SHORT_INPUT.to_string()])
+        .expect("tokenize should succeed");
+
+    assert!(tokenized.cols < MAX_LENGTH);
+}

data/lib/gte/embedder.rb

@@ -2,7 +2,7 @@
 
 module GTE
   class Embedder
-    DEFAULT_THREADS = 1
+    DEFAULT_THREADS = 0
     DEFAULT_OPTIMIZATION_LEVEL = 3
 
     class << self

data/lib/gte/model.rb

@@ -23,5 +23,9 @@ module GTE
       when Array then embed(input)
       end
     end
+
+    def embed_binary(text)
+      embed(text).row_binary_f32(0)
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gte
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - elcuervo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-28 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -110,6 +110,7 @@ files:
 - ext/gte/src/tokenizer.rs
 - ext/gte/tests/embedder_unit_test.rs
 - ext/gte/tests/inference_integration_test.rs
+- ext/gte/tests/padding_regression_test.rs
 - ext/gte/tests/postprocess_unit_test.rs
 - ext/gte/tests/tokenizer_unit_test.rs
 - lib/gte.rb