vespaembed 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

vespaembed/worker.py

@@ -0,0 +1,313 @@
+"""Background worker for training runs."""
+
+import argparse
+import json
+import signal
+import sys
+import traceback
+from pathlib import Path
+
+# Import tasks to register them
+import vespaembed.tasks  # noqa: F401
+from vespaembed.core.config import (
+    DataConfig,
+    LoraConfig,
+    OutputConfig,
+    TrainingConfig,
+    TrainingHyperparameters,
+    UnslothConfig,
+)
+from vespaembed.core.trainer import VespaEmbedTrainer
+from vespaembed.db import update_run_status
+from vespaembed.enums import RunStatus
+from vespaembed.utils.logging import logger
+
+
+class TrainingWorker:
+    """Worker that executes training in a subprocess."""
+
+    def __init__(self, run_id: int, config: dict):
+        self.run_id = run_id
+        self.config = config
+        self.trainer = None
+        self.stopped = False
+
+        # Set up signal handlers
+        signal.signal(signal.SIGTERM, self._handle_signal)
+        signal.signal(signal.SIGINT, self._handle_signal)
+
+    def _handle_signal(self, signum, frame):
+        """Handle termination signals."""
+        logger.info(f"Received signal {signum}, stopping training...")
+        self.stopped = True
+        if self.trainer:
+            # Trainer will check for stop flag
+            pass
+        sys.exit(0)
+
+    def _send_update(self, update_type: str, data: dict):
+        """Send update to the web server via file."""
+        update_dir = Path.home() / ".vespaembed" / "updates"
+        update_dir.mkdir(parents=True, exist_ok=True)
+
+        update_file = update_dir / f"run_{self.run_id}.jsonl"
+        update = {"type": update_type, "run_id": self.run_id, **data}
+
+        with open(update_file, "a") as f:
+            f.write(json.dumps(update) + "\n")
+
+    def _log_config(self):
+        """Log training configuration to UI."""
+        c = self.config
+        lines = [
+            "=" * 50,
+            "Training Configuration",
+            "=" * 50,
+            f"  Base Model:      {c.get('base_model', '--')}",
+            f"  Task:            {c.get('task', '--')}",
+        ]
+
+        if c.get("loss_variant"):
+            lines.append(f"  Loss Variant:    {c['loss_variant']}")
+
+        # Data source
+        if c.get("train_filename"):
+            lines.append(f"  Training Data:   {c['train_filename'].split('/')[-1]}")
+        elif c.get("hf_dataset"):
+            lines.append(f"  Training Data:   {c['hf_dataset']}")
+
+        # Training params
+        lines.extend(
+            [
+                f"  Epochs:          {c.get('epochs', 3)}",
+                f"  Batch Size:      {c.get('batch_size', 32)}",
+                f"  Learning Rate:   {c.get('learning_rate', 2e-5)}",
+                f"  Optimizer:       {c.get('optimizer', 'adamw_torch')}",
+                f"  Scheduler:       {c.get('scheduler', 'linear')}",
+                f"  Warmup Ratio:    {c.get('warmup_ratio', 0.1)}",
+                f"  Weight Decay:    {c.get('weight_decay', 0.01)}",
+            ]
+        )
+
+        # Precision
+        if c.get("bf16"):
+            lines.append("  Precision:       BF16")
+        elif c.get("fp16"):
+            lines.append("  Precision:       FP16")
+        else:
+            lines.append("  Precision:       FP32")
+
+        # Optional features
+        if c.get("gradient_checkpointing"):
+            lines.append("  Grad Checkpoint: Enabled")
+        if c.get("gradient_accumulation_steps", 1) > 1:
+            lines.append(f"  Grad Accum:      {c['gradient_accumulation_steps']}")
+
+        # LoRA
+        if c.get("lora_enabled"):
+            lines.append(f"  LoRA:            r={c.get('lora_r', 64)}, alpha={c.get('lora_alpha', 128)}")
+
+        # Unsloth
+        if c.get("unsloth_enabled"):
+            lines.append(f"  Unsloth:         Enabled ({c.get('unsloth_save_method', 'merged_16bit')})")
+
+        # Matryoshka
+        if c.get("matryoshka_dims"):
+            lines.append(f"  Matryoshka:      {c['matryoshka_dims']}")
+
+        lines.append("=" * 50)
+
+        # Send each line as a log message
+        for line in lines:
+            self._send_update("log", {"message": line})
+
+    def run(self):
+        """Execute the training run."""
+        try:
+            logger.info(f"Starting training run {self.run_id}")
+            self._send_update("status", {"status": "running"})
+
+            # Log configuration to UI
+            self._log_config()
+
+            # Determine data source - file upload or HuggingFace dataset
+            train_source = self.config.get("train_filename") or self.config.get("hf_dataset")
+            eval_source = self.config.get("eval_filename")
+            eval_split = None
+
+            # For HuggingFace datasets, eval can come from a different split
+            hf_eval_split = self.config.get("hf_eval_split")
+            if self.config.get("hf_dataset") and hf_eval_split:
+                # Use the same dataset but different split for eval
+                eval_source = self.config.get("hf_dataset")
+                eval_split = hf_eval_split
+
+            # Build data config
+            data_config = DataConfig(
+                train=train_source,
+                eval=eval_source,
+                subset=self.config.get("hf_subset"),
+                split=self.config.get("hf_train_split", "train"),
+                eval_split=eval_split,
+            )
+
+            # Parse matryoshka_dims if present (comes as comma-separated string from UI)
+            matryoshka_dims = None
+            if self.config.get("matryoshka_dims"):
+                dims_str = self.config["matryoshka_dims"]
+                if isinstance(dims_str, str):
+                    matryoshka_dims = [int(d.strip()) for d in dims_str.split(",") if d.strip()]
+                elif isinstance(dims_str, list):
+                    matryoshka_dims = dims_str
+
+            # Parse lora_target_modules (comes as comma-separated string from UI)
+            modules_str = self.config.get("lora_target_modules", "query, key, value, dense")
+            if isinstance(modules_str, str):
+                lora_target_modules = [m.strip() for m in modules_str.split(",") if m.strip()]
+            else:
+                lora_target_modules = modules_str  # Already a list
+
+            # Build LoRA config
+            lora_config = LoraConfig(
+                enabled=self.config.get("lora_enabled", False),
+                r=self.config.get("lora_r", 64),
+                alpha=self.config.get("lora_alpha", 128),
+                dropout=self.config.get("lora_dropout", 0.1),
+                target_modules=lora_target_modules,
+            )
+
+            # Build Unsloth config
+            unsloth_config = UnslothConfig(
+                enabled=self.config.get("unsloth_enabled", False),
+                save_method=self.config.get("unsloth_save_method", "merged_16bit"),
+            )
+
+            # Build training config with nested structure
+            training_config = TrainingConfig(
+                task=self.config["task"],
+                base_model=self.config["base_model"],
+                data=data_config,
+                training=TrainingHyperparameters(
+                    epochs=self.config.get("epochs", 3),
+                    batch_size=self.config.get("batch_size", 32),
+                    learning_rate=self.config.get("learning_rate", 2e-5),
+                    warmup_ratio=self.config.get("warmup_ratio", 0.1),
+                    weight_decay=self.config.get("weight_decay", 0.01),
+                    fp16=self.config.get("fp16", False),
+                    bf16=self.config.get("bf16", False),
+                    eval_steps=self.config.get("eval_steps", 500),
+                    save_steps=self.config.get("save_steps", 500),
+                    logging_steps=self.config.get("logging_steps", 100),
+                    gradient_accumulation_steps=self.config.get("gradient_accumulation_steps", 1),
+                    optimizer=self.config.get("optimizer", "adamw_torch"),
+                    scheduler=self.config.get("scheduler", "linear"),
+                ),
+                output=OutputConfig(
+                    dir=self.config["output_dir"],  # Required - set by web app
+                    push_to_hub=self.config.get("push_to_hub", False),
+                    hf_username=self.config.get("hf_username"),
+                ),
+                lora=lora_config,
+                unsloth=unsloth_config,
+                max_seq_length=self.config.get("max_seq_length"),  # None = auto-detect
+                gradient_checkpointing=self.config.get("gradient_checkpointing", False),
+                matryoshka_dims=matryoshka_dims,
+                loss_variant=self.config.get("loss_variant"),
+            )
+
+            # Create trainer with progress callback
+            self.trainer = VespaEmbedTrainer(
+                config=training_config,
+                progress_callback=self._progress_callback,
+            )
+
+            # Run training
+            self.trainer.train()
+
+            # Update status on completion
+            update_run_status(self.run_id, RunStatus.COMPLETED)
+            self._send_update("complete", {"output_dir": training_config.output.dir})
+            logger.info(f"Training run {self.run_id} completed successfully")
+
+        except Exception as e:
+            logger.error(f"Training run {self.run_id} failed: {e}")
+            logger.error(traceback.format_exc())
+            update_run_status(self.run_id, RunStatus.ERROR, error_message=str(e))
+            self._send_update("error", {"message": str(e)})
+            sys.exit(1)
+
+    def _progress_callback(self, progress: dict):
+        """Callback for training progress updates."""
+        progress_type = progress.get("type", "progress")
+
+        if progress_type == "train_start":
+            self._send_update("progress", progress)
+            self._send_update(
+                "log",
+                {"message": f"Training started: {progress['total_steps']} steps, {progress['total_epochs']} epochs"},
+            )
+        elif progress_type == "train_end":
+            self._send_update("progress", progress)
+            elapsed = self._format_time(progress.get("elapsed_seconds", 0))
+            self._send_update("log", {"message": f"Training completed in {elapsed}"})
+        else:
+            self._send_update("progress", progress)
+            self._send_update("log", {"message": self._format_progress(progress)})
+
+    def _format_time(self, seconds: float) -> str:
+        """Format seconds into human readable time."""
+        if seconds < 60:
+            return f"{seconds:.0f}s"
+        elif seconds < 3600:
+            mins = int(seconds // 60)
+            secs = int(seconds % 60)
+            return f"{mins}m {secs}s"
+        else:
+            hours = int(seconds // 3600)
+            mins = int((seconds % 3600) // 60)
+            return f"{hours}h {mins}m"
+
+    def _format_progress(self, progress: dict) -> str:
+        """Format progress as a log message like tqdm."""
+        step = progress.get("step", 0)
+        total = progress.get("total_steps", 0)
+        pct = progress.get("progress_pct", 0)
+        epoch = progress.get("epoch", 0)
+        total_epochs = progress.get("total_epochs", 0)
+        loss = progress.get("loss")
+        lr = progress.get("learning_rate")
+        eta = progress.get("eta_seconds", 0)
+
+        # Format: [Step 100/1000 (10%)] Epoch 1/3 | Loss: 0.5234 | LR: 2.00e-05 | ETA: 5m 30s
+        parts = [f"[Step {step}/{total} ({pct:.0f}%)]"]
+
+        if total_epochs:
+            parts.append(f"Epoch {epoch:.1f}/{total_epochs}")
+
+        if loss is not None:
+            parts.append(f"Loss: {loss:.4f}")
+
+        if lr is not None:
+            parts.append(f"LR: {lr:.2e}")
+
+        if eta > 0:
+            parts.append(f"ETA: {self._format_time(eta)}")
+
+        return " | ".join(parts)
+
+
+def main():
+    """Main entry point for the worker."""
+    parser = argparse.ArgumentParser(description="VespaEmbed Training Worker")
+    parser.add_argument("--run-id", type=int, required=True, help="Run ID")
+    parser.add_argument("--config", type=str, required=True, help="Training config JSON")
+
+    args = parser.parse_args()
+
+    config = json.loads(args.config)
+    worker = TrainingWorker(run_id=args.run_id, config=config)
+    worker.run()
+
+
+if __name__ == "__main__":
+    main()

vespaembed-0.0.2.dist-info/METADATA

@@ -0,0 +1,325 @@
+Metadata-Version: 2.4
+Name: vespaembed
+Version: 0.0.2
+Summary: vespaembed: no-code training for embedding models
+Author: Abhishek Thakur
+License: Apache 2.0
+Project-URL: Homepage, https://github.com/vespaai-playground/vespaembed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentence-transformers>=3.0.0
+Requires-Dist: transformers>=4.40.0
+Requires-Dist: accelerate>=0.26.0
+Requires-Dist: torch>=2.0.0
+Requires-Dist: datasets>=2.18.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: fastapi>=0.111.0
+Requires-Dist: uvicorn>=0.30.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: websockets>=12.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: tensorboard>=2.15.0
+Requires-Dist: peft>=0.18.1
+Requires-Dist: unsloth>=2026.1.4
+Provides-Extra: unsloth
+Requires-Dist: unsloth; extra == "unsloth"
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.14.0; extra == "onnx"
+Requires-Dist: onnxruntime>=1.23.2; extra == "onnx"
+Provides-Extra: dev
+Requires-Dist: black==26.1.0; extra == "dev"
+Requires-Dist: isort==7.0.0; extra == "dev"
+Requires-Dist: flake8==7.3.0; extra == "dev"
+Requires-Dist: pytest>=9.0.2; extra == "dev"
+Requires-Dist: pytest-cov>=7.0.0; extra == "dev"
+Dynamic: license-file
+
+# VespaEmbed
+
+No-code training for embedding models. Train custom embedding models with a web UI or CLI.
+
+## Features
+
+- **Web UI** - Visual interface for configuring and monitoring training
+- **CLI** - Command-line interface for scripting and automation
+- **Multiple Tasks** - Support for pairs, triplets, similarity scoring, and unsupervised learning
+- **Loss Variants** - Choose from multiple loss functions per task
+- **Matryoshka Embeddings** - Train multi-dimensional embeddings for flexible retrieval
+- **LoRA Support** - Parameter-efficient fine-tuning with LoRA adapters
+- **Unsloth Integration** - Faster training with Unsloth optimizations
+- **HuggingFace Integration** - Load datasets, models from HuggingFace Hub, push models to Hub
+
+## Installation
+
+> **Note:** VespaEmbed is in experimental phase. Install from source.
+
+```bash
+git clone https://github.com/vespaai-playground/vespaembed.git
+cd vespaembed
+uv sync
+```
+
+### Optional Dependencies
+
+```bash
+# For Unsloth acceleration (requires NVIDIA/AMD GPU)
+uv sync --extra unsloth
+
+# For ONNX export
+uv sync --extra onnx
+
+# For development
+uv sync --extra dev
+```
+
+## Quick Start
+
+### Web UI
+
+Launch the web interface:
+
+```bash
+vespaembed
+```
+
+Open http://localhost:8000 in your browser. The UI lets you:
+- Upload training data (CSV or JSONL)
+- Select task type and base model
+- Configure hyperparameters
+- Monitor training progress
+- Download trained models
+
+### CLI
+
+Train a model from the command line:
+
+```bash
+vespaembed train \
+  --data examples/data/pairs.csv \
+  --task pairs \
+  --base-model sentence-transformers/all-MiniLM-L6-v2 \
+  --epochs 3
+```
+
+Or use a YAML config file:
+
+```bash
+vespaembed train --config config.yaml
+```
+
+## Tasks
+
+VespaEmbed supports 4 training tasks based on your data format:
+
+### Pairs
+
+Text pairs for semantic search. Use when you have query-document pairs without explicit negatives.
+
+**Data format:**
+```csv
+anchor,positive
+What is machine learning?,Machine learning is a subset of AI...
+How does photosynthesis work?,Photosynthesis converts sunlight...
+```
+
+**Loss variants:** `mnr` (default), `mnr_symmetric`, `gist`, `cached_mnr`, `cached_gist`
+
+### Triplets
+
+Text triplets with hard negatives. Use when you have explicit negative examples.
+
+**Data format:**
+```csv
+anchor,positive,negative
+What is Python?,Python is a programming language...,A python is a large snake...
+```
+
+**Loss variants:** `mnr` (default), `mnr_symmetric`, `gist`, `cached_mnr`, `cached_gist`
+
+### Similarity
+
+Text pairs with similarity scores (STS-style). Use when you have continuous similarity labels.
+
+**Data format:**
+```csv
+sentence1,sentence2,score
+A man is playing guitar,A person plays music,0.85
+The cat is sleeping,A dog is running,0.12
+```
+
+**Loss variants:** `cosine` (default), `cosent`, `angle`
+
+### TSDAE
+
+Unsupervised learning with denoising auto-encoder. Use when you only have unlabeled text for domain adaptation.
+
+**Data format:**
+```csv
+text
+Machine learning is transforming how we analyze data.
+Natural language processing enables computers to understand human language.
+```
+
+## Configuration
+
+### CLI Arguments
+
+```bash
+vespaembed train \
+  --data <path>              # Training data (CSV, JSONL, or HF dataset)
+  --task <task>              # Task type: pairs, triplets, similarity, tsdae
+  --base-model <model>       # Base model name or path
+  --project <name>           # Project name (optional)
+  --eval-data <path>         # Evaluation data (optional)
+  --epochs <n>               # Number of epochs (default: 3)
+  --batch-size <n>           # Batch size (default: 32)
+  --learning-rate <lr>       # Learning rate (default: 2e-5)
+  --optimizer <opt>          # Optimizer (default: adamw_torch)
+  --scheduler <sched>        # LR scheduler (default: linear)
+  --matryoshka               # Enable Matryoshka embeddings
+  --matryoshka-dims <dims>   # Dimensions (default: 768,512,256,128,64)
+  --unsloth                  # Use Unsloth for faster training
+  --subset <name>            # HuggingFace dataset subset
+  --split <name>             # HuggingFace dataset split
+```
+
+### Optimizers
+
+| Option | Description |
+|--------|-------------|
+| `adamw_torch` | AdamW (default) |
+| `adamw_torch_fused` | Fused AdamW (faster on CUDA) |
+| `adamw_8bit` | 8-bit AdamW (memory efficient) |
+| `adafactor` | Adafactor (memory efficient, no momentum) |
+| `sgd` | SGD with momentum |
+
+### Schedulers
+
+| Option | Description |
+|--------|-------------|
+| `linear` | Linear decay (default) |
+| `cosine` | Cosine annealing |
+| `cosine_with_restarts` | Cosine with warm restarts |
+| `constant` | Constant learning rate |
+| `constant_with_warmup` | Constant after warmup |
+| `polynomial` | Polynomial decay |
+
+### YAML Configuration
+
+```yaml
+task: pairs
+base_model: sentence-transformers/all-MiniLM-L6-v2
+
+data:
+  train: train.csv
+  eval: eval.csv            # optional
+
+training:
+  epochs: 3
+  batch_size: 32
+  learning_rate: 2e-5
+  warmup_ratio: 0.1
+  weight_decay: 0.01
+  fp16: true
+  eval_steps: 500
+  save_steps: 500
+  logging_steps: 100
+  optimizer: adamw_torch    # adamw_torch, adamw_8bit, adafactor, sgd
+  scheduler: linear         # linear, cosine, constant, polynomial
+
+output:
+  dir: ./output
+  push_to_hub: false
+  hf_username: null
+
+# Optional: LoRA configuration
+lora:
+  enabled: false
+  r: 64
+  alpha: 128
+  dropout: 0.1
+  target_modules: [query, key, value, dense]
+
+# Optional: Matryoshka dimensions
+matryoshka_dims: [768, 512, 256, 128, 64]
+
+# Optional: Loss variant (uses task default if not specified)
+loss_variant: mnr
+```
+
+### HuggingFace Datasets
+
+Load datasets directly from HuggingFace Hub:
+
+```bash
+vespaembed train \
+  --data sentence-transformers/all-nli \
+  --subset triplet \
+  --split train \
+  --task triplets \
+  --base-model sentence-transformers/all-MiniLM-L6-v2
+```
+
+## CLI Commands
+
+| Command | Description |
+|---------|-------------|
+| `vespaembed` | Launch web UI (default) |
+| `vespaembed serve` | Launch web UI |
+| `vespaembed train` | Train a model |
+| `vespaembed evaluate` | Evaluate a model |
+| `vespaembed export` | Export model to ONNX |
+| `vespaembed info` | Show task information |
+
+## Output
+
+Trained models are saved to `~/.vespaembed/projects/<project-name>/`:
+
+```
+~/.vespaembed/projects/my-project/
+├── final/              # Final trained model
+├── checkpoint-500/     # Training checkpoints
+├── checkpoint-1000/
+└── logs/               # TensorBoard logs
+```
+
+## Column Aliases
+
+VespaEmbed automatically recognizes common column name variations:
+
+| Task | Expected | Also Accepts |
+|------|----------|--------------|
+| pairs | `anchor` | `query`, `question`, `sent1`, `sentence1`, `text1` |
+| pairs | `positive` | `document`, `answer`, `pos`, `sent2`, `sentence2`, `text2` |
+| triplets | `negative` | `neg`, `hard_negative`, `sent3`, `sentence3`, `text3` |
+| similarity | `sentence1` | `sent1`, `text1`, `anchor`, `query` |
+| similarity | `sentence2` | `sent2`, `text2`, `positive`, `document` |
+| similarity | `score` | `similarity`, `label`, `sim_score` |
+| tsdae | `text` | `sentence`, `sentences`, `content`, `input` |
+
+## Development
+
+```bash
+# Install dev dependencies
+uv sync --extra dev
+
+# Run tests
+uv run pytest tests/
+
+# Run tests with coverage
+uv run pytest tests/ --cov=vespaembed
+
+# Format code
+make format
+
+# Lint
+make lint
+```
+
+## License
+
+Apache 2.0

vespaembed-0.0.2.dist-info/RECORD

@@ -0,0 +1,47 @@
+vespaembed/__init__.py,sha256=QvlVh4JTl3JL7jQAja76yKtT-IvF4631ASjWY1wS6AQ,22
+vespaembed/db.py,sha256=9m46Ljc8e2s8NnhRJRkf3pj-U72PGM3o94pEec8IFoo,4272
+vespaembed/enums.py,sha256=1ovPAJW-5f4TrI8dnHMJYitau30s5TeMk0s2Ptkppaw,1453
+vespaembed/worker.py,sha256=2vI292BWRKKK-hBtTQj3fxj5sKmuuXODubYk6yCH5hU,12230
+vespaembed/cli/__init__.py,sha256=rWKimiyk7YndJfRCEAlZdsDv5l96Cixwl_UX6Nq2vf0,433
+vespaembed/cli/vespaembed.py,sha256=LcGh9k5fQPjHoDOzf-1dUhcACDxQLXIXpVGmjCylbdI,1616
+vespaembed/cli/commands/__init__.py,sha256=4lIRTQRXe_QQbtFJDNgeRJ3BZf4bD7FmhEScVWeI6S8,376
+vespaembed/cli/commands/evaluate.py,sha256=bx74DrSdCqzP6KWXBx_6N1VcFE-vOt9FkFYKkvkTpU8,2595
+vespaembed/cli/commands/export.py,sha256=SB8cIC1FqHXLKdrqvL2ca_mzJDGe-W9ECdYV9T5z--k,2614
+vespaembed/cli/commands/info.py,sha256=3n0hz7TmUdKX7ZvgmBnOFtpNtMu3VA_3zujGidGY1G8,1615
+vespaembed/cli/commands/serve.py,sha256=Qw_MxtsrIwfk45vs9l3cMvCn9_H8MKxUXYOg-Nqf940,1403
+vespaembed/cli/commands/train.py,sha256=IEYMWr5hrZGAshVljHAJ10Z7Iw8QFiGb54fe39PIRKI,9015
+vespaembed/core/__init__.py,sha256=NcgBvvomhTlLim8WG84cFnnGNDFKSJolmUrBsbvafvM,145
+vespaembed/core/config.py,sha256=eERuTr4j-Gpp0TovrRmE7GGECuIWhbUTGzbJ1Kuk8ik,6041
+vespaembed/core/registry.py,sha256=CrSIQxx6a9QQF7po-YhseMfcHs5IBDd_3LwHpxUACWE,5179
+vespaembed/core/trainer.py,sha256=9PPMEpH-hOqqO7ZaMqrYlVzHKffAbUIvo3makBXB-0U,22802
+vespaembed/datasets/__init__.py,sha256=F1QDj036DWAjRQO38u4dK04tzzRtPwGLk_AMbtfjIp8,80
+vespaembed/datasets/loader.py,sha256=aRasiQxqIpaH7sfbZrp_7h-xc8zHFfgojCQFWVHvsWE,2252
+vespaembed/datasets/formats/__init__.py,sha256=UDhvPk9FHq8RR_V-uphciNDYH3Ut--DvT7j8DmbQSTQ,235
+vespaembed/datasets/formats/csv.py,sha256=jcYgaLtNbuE5CFtg9jHha4VekKay67y6LKTXCWPasGA,290
+vespaembed/datasets/formats/huggingface.py,sha256=v6zY4wTNLOe-Qx-TxJBPwF5QM6WMkcXPDlmd2Dar_9k,865
+vespaembed/datasets/formats/jsonl.py,sha256=8VsfzZHWU_16z7npBETSyDVqDvzosprW_U9wNdt3exE,512
+vespaembed/evaluation/__init__.py,sha256=hE8xZ0xG-qPTP1_At5dcZG1p1wwUATFtJZlxhUindmc,91
+vespaembed/evaluation/factory.py,sha256=_6b_b5Sj279owCWSLp94KPRKcZeUq-tnF9IyxNRBFWM,2715
+vespaembed/models/__init__.py,sha256=EVHS2Xuvr12JLIm9BA8SXvCsJcSPRcIKGBmuNHFYNrA,140
+vespaembed/models/export.py,sha256=fdX21e6UEZpHhhKU9gwpUBgYJWRmX9_S6EbWP6-QWwA,2436
+vespaembed/models/loader.py,sha256=7VWWTpPXeVp9eJq4EsmNdA1zBVYf9BQQRRF1v9ObnJ8,813
+vespaembed/static/css/styles.css,sha256=yOXm9UW41s4nZpG2CBQA5tw6bHzEBFeUMofb6LdqNWk,37350
+vespaembed/static/js/app.js,sha256=kri7JVLSNGWludIYj_ZKQLrJ6fzziQlUv5dd0L2NxBI,52969
+vespaembed/tasks/__init__.py,sha256=cMSdguS9t2mElHfiVpZJ5BcnXtyBQmHnT2I30INZ-gs,883
+vespaembed/tasks/base.py,sha256=ER2H91HYsKE25tJc6J3TkYkgwVhsZkICRDb5MSXLaek,5105
+vespaembed/tasks/pairs.py,sha256=VRmY7bu3fNQTPtopq-GvfsHH4g2yVdHL-Nr2KdU4-28,3520
+vespaembed/tasks/similarity.py,sha256=xk5hGoALNJnelM0n5lRys1gF30KiVdlUplgcxBI0lz8,3037
+vespaembed/tasks/triplets.py,sha256=ZTfF6yFQS_368LJ-rV4qVQGqrxxGzS0eiGO1f4tqICU,3581
+vespaembed/tasks/tsdae.py,sha256=VcJbyABee9yfv2leNe_yVMDa48XfronAFcEDDIVrZKo,3434
+vespaembed/templates/index.html,sha256=z4vIejLAgSOL0ISTJpmyMqSegCew-X3Aj4wv1xV4knY,30185
+vespaembed/utils/__init__.py,sha256=ZvKPCgX-ISxoj8LEwkMZ0BgVK3MZcE3TExkNBOkRhfk,74
+vespaembed/utils/logging.py,sha256=xxbMAohRsmfB5TZX-43iX488_2p-KBmttdBRuCyA4dE,1736
+vespaembed/web/__init__.py,sha256=rFAxCq3VJ7UDoLoYVZPshpAoetYV9JPlKpJdHREC_PM,37
+vespaembed/web/app.py,sha256=0GdPAWs5y2bhJv6XCmZMdf6-LMnZrLA5RHxtylbxu_4,19380
+vespaembed/web/api/__init__.py,sha256=GLiedM-kLCaQTZCa_UmkqIrjEGjwvGdDdfKpZhUFgN0,16
+vespaembed-0.0.2.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+vespaembed-0.0.2.dist-info/METADATA,sha256=COTsjigAH1BnJZiuUgOVPi698eiIJ6g7oJ4Ud6SBeGw,8655
+vespaembed-0.0.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+vespaembed-0.0.2.dist-info/entry_points.txt,sha256=_yO09x95rXw-0RhJkMmXAt5bjBOysVy10jbe4KJuMIg,62
+vespaembed-0.0.2.dist-info/top_level.txt,sha256=GhqAsJ29dVFnUrvwec8lRqDCC1BqlWntZZFibsgCEdY,11
+vespaembed-0.0.2.dist-info/RECORD,,

{vespaembed-0.0.1.dist-info → vespaembed-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any