fastembed-cloud 0.1.0__py3-none-any.whl

fastembed_cloud/__init__.py

@@ -0,0 +1,24 @@
+"""
+fastembed-cloud — Cloud embeddings via AINative API.
+
+Drop-in replacement for fastembed that generates embeddings via API
+instead of downloading and running ONNX models locally.
+
+Usage:
+    from fastembed_cloud import CloudTextEmbedding
+
+    model = CloudTextEmbedding()
+    embeddings = model.embed(["hello world", "semantic search"])
+
+Or use the smart TextEmbedding that prefers local fastembed when installed:
+
+    from fastembed_cloud import TextEmbedding
+
+    model = TextEmbedding()
+    embeddings = model.embed(["hello world"])
+"""
+
+from fastembed_cloud.embedding import CloudTextEmbedding, TextEmbedding
+
+__version__ = "0.1.0"
+__all__ = ["CloudTextEmbedding", "TextEmbedding"]

fastembed_cloud/embedding.py

@@ -0,0 +1,300 @@
+"""
+fastembed-cloud — Embedding Classes
+
+CloudTextEmbedding: Always uses the AINative API (no local models).
+TextEmbedding: Smart hybrid — uses local fastembed if installed, cloud otherwise.
+
+API endpoint: POST /api/v1/public/embeddings/generate
+Request body: {"texts": [...], "model": "bge-m3", "normalize": true}
+Response: {"embeddings": [[...], ...], "model": ..., "dimensions": ..., "count": ...}
+
+Refs #3943
+"""
+
+import os
+from typing import Iterator, List, Optional, Union
+
+import requests
+
+from fastembed_cloud.provision import resolve_api_key
+
+# Model aliases — map fastembed model names to AINative model names
+MODEL_MAP = {
+    "BAAI/bge-small-en-v1.5": "BAAI/bge-small-en-v1.5",
+    "BAAI/bge-base-en-v1.5": "BAAI/bge-base-en-v1.5",
+    "BAAI/bge-large-en-v1.5": "BAAI/bge-large-en-v1.5",
+    "BAAI/bge-m3": "bge-m3",
+    "bge-small": "BAAI/bge-small-en-v1.5",
+    "bge-base": "BAAI/bge-base-en-v1.5",
+    "bge-large": "BAAI/bge-large-en-v1.5",
+    "bge-m3": "bge-m3",
+}
+
+# Model dimensions for reference
+MODEL_DIMENSIONS = {
+    "BAAI/bge-small-en-v1.5": 384,
+    "BAAI/bge-base-en-v1.5": 768,
+    "BAAI/bge-large-en-v1.5": 1024,
+    "bge-m3": 1024,
+}
+
+DEFAULT_MODEL = "BAAI/bge-small-en-v1.5"
+DEFAULT_BASE_URL = "https://api.ainative.studio"
+GENERATE_PATH = "/api/v1/public/embeddings/generate"
+
+
+def _chunked(iterable, size):
+    """Split an iterable into chunks of the given size."""
+    batch = []
+    for item in iterable:
+        batch.append(item)
+        if len(batch) >= size:
+            yield batch
+            batch = []
+    if batch:
+        yield batch
+
+
+class CloudTextEmbedding:
+    """
+    Generate text embeddings via AINative's free Embeddings API.
+
+    Drop-in replacement for fastembed.TextEmbedding — same interface,
+    no local model downloads, no ONNX runtime needed.
+
+    Args:
+        model_name: Model to use. Defaults to BAAI/bge-small-en-v1.5 (384d).
+            Supported: bge-small (384d), bge-base (768d), bge-large (1024d), bge-m3 (1024d).
+        api_key: AINative API key. Auto-resolved from env/config/provisioning if not set.
+        base_url: API base URL. Defaults to https://api.ainative.studio.
+        batch_size: Max texts per API call. Defaults to 64.
+        normalize: Normalize embeddings to unit length. Defaults to True.
+
+    Example:
+        >>> from fastembed_cloud import CloudTextEmbedding
+        >>> model = CloudTextEmbedding()
+        >>> embeddings = list(model.embed(["hello world", "semantic search"]))
+        >>> len(embeddings[0])  # 384 dimensions
+        384
+    """
+
+    def __init__(
+        self,
+        model_name: str = DEFAULT_MODEL,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        batch_size: int = 64,
+        normalize: bool = True,
+        **kwargs,  # Accept extra kwargs for fastembed compat
+    ):
+        self.model_name = MODEL_MAP.get(model_name, model_name)
+        self._api_key = resolve_api_key(api_key)
+        self._base_url = (
+            base_url
+            or os.environ.get("AINATIVE_API_URL")
+            or os.environ.get("ZERODB_API_URL")
+            or DEFAULT_BASE_URL
+        )
+        self._batch_size = batch_size
+        self._normalize = normalize
+        self._session = requests.Session()
+        self._session.headers.update({
+            "x-api-key": self._api_key,
+            "Content-Type": "application/json",
+        })
+
+    @property
+    def dim(self) -> int:
+        """Return the embedding dimension for the current model."""
+        return MODEL_DIMENSIONS.get(self.model_name, 384)
+
+    def embed(
+        self,
+        documents: Union[List[str], Iterator[str]],
+        batch_size: Optional[int] = None,
+        **kwargs,
+    ) -> List[List[float]]:
+        """
+        Embed a list of documents.
+
+        Args:
+            documents: List of text strings to embed (max 100 per batch).
+            batch_size: Override default batch size.
+
+        Returns:
+            List of embedding vectors (each a list of floats).
+
+        Raises:
+            RuntimeError: If the API returns an error.
+        """
+        docs = list(documents)
+        if not docs:
+            return []
+
+        bs = batch_size or self._batch_size
+        results = []
+
+        for batch in _chunked(docs, min(bs, 100)):
+            embeddings = self._call_api(batch)
+            results.extend(embeddings)
+
+        return results
+
+    def query_embed(self, query: str, **kwargs) -> List[float]:
+        """
+        Embed a single query string.
+
+        Args:
+            query: Text to embed.
+
+        Returns:
+            Embedding vector as a list of floats.
+        """
+        result = self.embed([query])
+        if not result:
+            raise RuntimeError("Empty response from embedding API")
+        return result[0]
+
+    def passage_embed(self, texts: Union[List[str], Iterator[str]], **kwargs) -> List[List[float]]:
+        """
+        Embed passages (alias for embed, provided for fastembed compatibility).
+
+        Args:
+            texts: List of passage strings.
+
+        Returns:
+            List of embedding vectors.
+        """
+        return self.embed(texts, **kwargs)
+
+    def _call_api(self, texts: List[str]) -> List[List[float]]:
+        """
+        Call the AINative embeddings API.
+
+        Args:
+            texts: Batch of texts to embed.
+
+        Returns:
+            List of embedding vectors.
+
+        Raises:
+            RuntimeError: On API error.
+        """
+        url = f"{self._base_url}{GENERATE_PATH}"
+        payload = {
+            "texts": texts,
+            "model": self.model_name,
+            "normalize": self._normalize,
+        }
+
+        try:
+            resp = self._session.post(url, json=payload, timeout=30)
+        except requests.RequestException as exc:
+            raise RuntimeError(f"Embedding API request failed: {exc}") from exc
+
+        if resp.status_code == 401:
+            raise RuntimeError(
+                "Invalid API key. Set AINATIVE_API_KEY or pass api_key= parameter."
+            )
+        if resp.status_code == 429:
+            raise RuntimeError(
+                "Rate limited. Wait a moment and try again, or upgrade at https://ainative.studio"
+            )
+        if resp.status_code != 200:
+            detail = resp.text[:200] if resp.text else "Unknown error"
+            raise RuntimeError(
+                f"Embedding API error (HTTP {resp.status_code}): {detail}"
+            )
+
+        data = resp.json()
+        embeddings = data.get("embeddings")
+        if embeddings is None:
+            raise RuntimeError(f"Unexpected API response format: {list(data.keys())}")
+
+        return embeddings
+
+    def __repr__(self) -> str:
+        return f"CloudTextEmbedding(model={self.model_name!r}, dim={self.dim})"
+
+
+class TextEmbedding:
+    """
+    Smart embedding: uses local fastembed if installed, falls back to cloud.
+
+    This is a hybrid class that checks for the `fastembed` package at init time.
+    If fastembed is available, it uses local ONNX inference (faster, offline).
+    If not, it transparently falls back to AINative's cloud API (no downloads).
+
+    Args:
+        model_name: Model to use. Defaults to BAAI/bge-small-en-v1.5.
+        api_key: AINative API key (only used if falling back to cloud).
+        **kwargs: Additional kwargs passed to the underlying embedding class.
+
+    Example:
+        >>> from fastembed_cloud import TextEmbedding
+        >>> model = TextEmbedding()  # Uses local if fastembed installed, cloud otherwise
+        >>> embeddings = list(model.embed(["hello world"]))
+    """
+
+    def __init__(
+        self,
+        model_name: str = DEFAULT_MODEL,
+        api_key: Optional[str] = None,
+        **kwargs,
+    ):
+        self._local = None
+        self._cloud = None
+
+        try:
+            from fastembed import TextEmbedding as LocalTextEmbedding
+            self._local = LocalTextEmbedding(model_name=model_name, **kwargs)
+        except ImportError:
+            self._cloud = CloudTextEmbedding(
+                model_name=model_name, api_key=api_key, **kwargs
+            )
+
+    @property
+    def is_cloud(self) -> bool:
+        """True if using cloud API, False if using local fastembed."""
+        return self._cloud is not None
+
+    @property
+    def dim(self) -> int:
+        """Return the embedding dimension for the current model."""
+        if self._cloud:
+            return self._cloud.dim
+        # Local fastembed doesn't always expose dim, use our map
+        model_name = getattr(self._local, "model_name", DEFAULT_MODEL)
+        return MODEL_DIMENSIONS.get(model_name, 384)
+
+    def embed(self, documents: Union[List[str], Iterator[str]], **kwargs) -> List[List[float]]:
+        """
+        Embed documents using the best available backend.
+
+        Args:
+            documents: Texts to embed.
+
+        Returns:
+            List of embedding vectors.
+        """
+        if self._cloud:
+            return self._cloud.embed(documents, **kwargs)
+        # Local fastembed returns a generator of numpy arrays
+        return [emb.tolist() for emb in self._local.embed(list(documents), **kwargs)]
+
+    def query_embed(self, query: str, **kwargs) -> List[float]:
+        """Embed a single query."""
+        if self._cloud:
+            return self._cloud.query_embed(query, **kwargs)
+        result = list(self._local.query_embed(query))
+        if hasattr(result[0], "tolist"):
+            return result[0].tolist()
+        return result[0]
+
+    def passage_embed(self, texts: Union[List[str], Iterator[str]], **kwargs) -> List[List[float]]:
+        """Embed passages."""
+        return self.embed(texts, **kwargs)
+
+    def __repr__(self) -> str:
+        backend = "local" if self._local else "cloud"
+        return f"TextEmbedding(backend={backend!r})"

fastembed_cloud/provision.py

@@ -0,0 +1,175 @@
+"""
+fastembed-cloud — Auto-Provisioning
+
+Zero-friction cloud provisioning for embedding users.
+On first use, if no API key is found, automatically provisions
+a free AINative account (72-hour TTL) that can be claimed later.
+
+Credential resolution order:
+1. Explicit api_key parameter
+2. AINATIVE_API_KEY environment variable
+3. ZERODB_API_KEY environment variable (shared with zerodb ecosystem)
+4. ~/.zerodb/credentials.json (shared credential store)
+5. Auto-provision via /api/v1/public/instant-db
+
+Refs #3943
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+ZERODB_DIR = Path.home() / ".zerodb"
+CREDS_PATH = ZERODB_DIR / "credentials.json"
+CONFIG_PATH = ZERODB_DIR / "config.json"
+CLOUD_API_URL = "https://api.ainative.studio"
+PROVISION_ENDPOINT = "/api/v1/public/instant-db"
+
+
+def resolve_api_key(explicit_key: Optional[str] = None) -> str:
+    """
+    Resolve an API key from all available sources.
+
+    Args:
+        explicit_key: Key passed directly by the user.
+
+    Returns:
+        A valid API key string.
+
+    Raises:
+        RuntimeError: If auto-provisioning fails and no key is available.
+    """
+    # 1. Explicit parameter
+    if explicit_key:
+        return explicit_key
+
+    # 2. Environment variables
+    env_key = (
+        os.environ.get("AINATIVE_API_KEY")
+        or os.environ.get("ZERODB_API_KEY")
+    )
+    if env_key:
+        return env_key
+
+    # 3. Credentials file (shared with zerodb ecosystem)
+    creds = _load_credentials()
+    if creds:
+        return creds
+
+    # 4. Auto-provision
+    return _auto_provision()
+
+
+def _load_credentials() -> Optional[str]:
+    """Load API key from ~/.zerodb/credentials.json."""
+    if CREDS_PATH.exists():
+        try:
+            data = json.loads(CREDS_PATH.read_text())
+            key = data.get("api_key")
+            if key:
+                return key
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    if CONFIG_PATH.exists():
+        try:
+            data = json.loads(CONFIG_PATH.read_text())
+            key = data.get("api_key") or data.get("cloud_api_key")
+            if key:
+                return key
+        except (json.JSONDecodeError, KeyError):
+            pass
+
+    return None
+
+
+def _auto_provision() -> str:
+    """
+    Auto-provision a free AINative account for embedding access.
+
+    Returns:
+        API key string.
+
+    Raises:
+        RuntimeError: If provisioning fails.
+    """
+    print(
+        "\n  No API key found — provisioning a free AINative account for embeddings...",
+        file=sys.stderr,
+    )
+
+    import requests
+
+    try:
+        resp = requests.post(
+            f"{CLOUD_API_URL}{PROVISION_ENDPOINT}",
+            json={"agree_terms": True, "source": "fastembed-cloud"},
+            timeout=15,
+        )
+
+        if resp.status_code == 429:
+            raise RuntimeError(
+                "Rate limited — too many provisions from this IP. "
+                "Sign up at https://ainative.studio/signup and set AINATIVE_API_KEY."
+            )
+
+        if resp.status_code not in (200, 201):
+            raise RuntimeError(
+                f"Provisioning failed (HTTP {resp.status_code}). "
+                "Sign up at https://ainative.studio/signup and set AINATIVE_API_KEY."
+            )
+
+        data = resp.json()
+        api_key = data.get("api_key", "")
+        if not api_key:
+            raise RuntimeError("Provisioning returned empty API key.")
+
+        # Save credentials for reuse
+        _save_credentials(data)
+        _print_success(data)
+        return api_key
+
+    except requests.RequestException as exc:
+        raise RuntimeError(
+            f"Network error during provisioning: {exc}. "
+            "Set AINATIVE_API_KEY manually or sign up at https://ainative.studio/signup"
+        ) from exc
+
+
+def _save_credentials(data: dict) -> None:
+    """Save provisioned credentials to ~/.zerodb/ for ecosystem sharing."""
+    ZERODB_DIR.mkdir(parents=True, exist_ok=True)
+
+    creds = {
+        "api_key": data.get("api_key", ""),
+        "project_id": data.get("project_id", ""),
+        "base_url": data.get("base_url", CLOUD_API_URL),
+        "expires_at": data.get("expires_at", ""),
+        "claim_url": data.get("claim_url", ""),
+        "provisioned_at": datetime.utcnow().isoformat(),
+        "source": "fastembed-cloud",
+    }
+
+    CREDS_PATH.write_text(json.dumps(creds, indent=2) + "\n")
+
+
+def _print_success(data: dict) -> None:
+    """Print success message with claim URL."""
+    expires = data.get("expires_at", "72 hours")
+    claim_url = data.get("claim_url", "https://ainative.studio/signup")
+    api_key = data.get("api_key", "")
+
+    print(
+        f"\n  Auto-provisioned! Free embeddings API ready.\n"
+        f"\n"
+        f"  API Key:   {api_key[:12]}...\n"
+        f"  Expires:   {expires}\n"
+        f"  Saved to:  ~/.zerodb/credentials.json\n"
+        f"\n"
+        f"  To keep access permanently, claim your account:\n"
+        f"  {claim_url}\n",
+        file=sys.stderr,
+    )

fastembed_cloud-0.1.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: fastembed-cloud
+Version: 0.1.0
+Summary: Cloud embeddings via AINative API — drop-in fastembed replacement, no model downloads
+Author-email: AINative Studio <support@ainative.studio>
+License: MIT
+Project-URL: Homepage, https://github.com/AINative-Studio/fastembed-cloud
+Project-URL: Documentation, https://docs.ainative.studio/embeddings
+Project-URL: Repository, https://github.com/AINative-Studio/fastembed-cloud
+Project-URL: Issues, https://github.com/AINative-Studio/fastembed-cloud/issues
+Keywords: fastembed,fastembed-alternative,embeddings,text-embeddings,cloud-embeddings,free-embeddings,ainative,zerodb,bge,baai,onnx-alternative,vector-embeddings,semantic-search,similarity-search,sentence-transformers-alternative,auto-provisioning,serverless,no-download,claude,cursor,windsurf,rag,retrieval-augmented-generation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: local
+Requires-Dist: fastembed>=0.3.0; extra == "local"
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.20; extra == "numpy"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: responses>=0.23; extra == "dev"
+Dynamic: license-file
+
+# fastembed-cloud
+
+Cloud text embeddings via AINative API. Drop-in replacement for [fastembed](https://github.com/qdrant/fastembed) — same interface, no model downloads, no ONNX runtime.
+
+## Why?
+
+fastembed is great, but requires downloading 100MB+ ONNX models locally. `fastembed-cloud` gives you the same API backed by a free cloud service — zero setup, zero downloads.
+
+| | fastembed | fastembed-cloud |
+|---|---|---|
+| First-run latency | 30-120s (model download) | 0s |
+| Disk usage | 100MB-1GB per model | 0 |
+| ONNX runtime | Required | Not needed |
+| Offline support | Yes | No (cloud API) |
+| Cost | Free (local compute) | Free (AINative API) |
+
+## Install
+
+```bash
+pip install fastembed-cloud
+```
+
+## Quick Start
+
+```python
+from fastembed_cloud import CloudTextEmbedding
+
+# Auto-provisions a free API key on first run
+model = CloudTextEmbedding()
+
+# Single query
+embedding = model.query_embed("What is semantic search?")
+print(f"Dimensions: {len(embedding)}")  # 384
+
+# Batch embedding
+docs = ["First document", "Second document", "Third document"]
+embeddings = model.embed(docs)
+print(f"Embedded {len(embeddings)} documents")
+```
+
+## Models
+
+| Model | Dimensions | ID |
+|---|---|---|
+| BGE-small-en-v1.5 | 384 | `BAAI/bge-small-en-v1.5` (default) |
+| BGE-base-en-v1.5 | 768 | `BAAI/bge-base-en-v1.5` |
+| BGE-large-en-v1.5 | 1024 | `BAAI/bge-large-en-v1.5` |
+| BGE-M3 (multilingual) | 1024 | `bge-m3` |
+
+```python
+model = CloudTextEmbedding(model_name="bge-m3")
+embedding = model.query_embed("Multilingual embedding")
+print(len(embedding))  # 1024
+```
+
+## Smart Hybrid: Local + Cloud
+
+`TextEmbedding` automatically uses local fastembed if installed, cloud otherwise:
+
+```python
+from fastembed_cloud import TextEmbedding
+
+model = TextEmbedding()
+print(model.is_cloud)  # True if fastembed not installed
+
+embeddings = model.embed(["works either way"])
+```
+
+Install fastembed alongside for local-first with cloud fallback:
+
+```bash
+pip install fastembed-cloud[local]
+```
+
+## Authentication
+
+Credentials are resolved in this order:
+
+1. `api_key` parameter: `CloudTextEmbedding(api_key="your-key")`
+2. `AINATIVE_API_KEY` environment variable
+3. `ZERODB_API_KEY` environment variable (shared with ZeroDB ecosystem)
+4. `~/.zerodb/credentials.json` (auto-saved from any ZeroDB tool)
+5. Auto-provisioning (free 72-hour account, claim to keep permanently)
+
+### Auto-Provisioning
+
+On first use with no credentials, fastembed-cloud automatically provisions a free account:
+
+```
+$ python -c "from fastembed_cloud import CloudTextEmbedding; CloudTextEmbedding().query_embed('test')"
+
+  No API key found — provisioning a free AINative account for embeddings...
+
+  Auto-provisioned! Free embeddings API ready.
+
+  API Key:   zdb_abc12345...
+  Expires:   72 hours
+  Saved to:  ~/.zerodb/credentials.json
+
+  To keep access permanently, claim your account:
+  https://ainative.studio/signup
+```
+
+## Batch Embedding
+
+Handles large datasets efficiently with automatic batching:
+
+```python
+model = CloudTextEmbedding(batch_size=100)
+
+# Automatically batches into chunks of 100
+large_dataset = ["document " + str(i) for i in range(10000)]
+embeddings = model.embed(large_dataset)
+```
+
+## Use with Vector Databases
+
+### Qdrant
+
+```python
+from qdrant_client import QdrantClient
+from fastembed_cloud import CloudTextEmbedding
+
+client = QdrantClient(":memory:")
+model = CloudTextEmbedding()
+
+docs = ["AI is transforming healthcare", "Machine learning for finance"]
+embeddings = model.embed(docs)
+
+client.add(
+    collection_name="my_docs",
+    documents=docs,
+    embeddings=embeddings,
+)
+```
+
+### ChromaDB
+
+```python
+import chromadb
+from fastembed_cloud import CloudTextEmbedding
+
+client = chromadb.Client()
+collection = client.create_collection("my_docs")
+model = CloudTextEmbedding()
+
+docs = ["First doc", "Second doc"]
+embeddings = model.embed(docs)
+
+collection.add(
+    documents=docs,
+    embeddings=embeddings,
+    ids=["id1", "id2"],
+)
+```
+
+## API Reference
+
+### CloudTextEmbedding
+
+Always uses the cloud API.
+
+```python
+CloudTextEmbedding(
+    model_name="BAAI/bge-small-en-v1.5",  # Model to use
+    api_key=None,                           # API key (auto-resolved)
+    base_url=None,                          # API URL (default: api.ainative.studio)
+    batch_size=64,                          # Max texts per API call
+    normalize=True,                         # Normalize to unit vectors
+)
+```
+
+**Methods:**
+- `embed(documents, batch_size=None)` — Embed a list of texts. Returns `list[list[float]]`.
+- `query_embed(query)` — Embed a single query. Returns `list[float]`.
+- `passage_embed(texts)` — Alias for `embed()` (fastembed compatibility).
+
+**Properties:**
+- `dim` — Embedding dimensions (e.g., 384 for bge-small).
+- `model_name` — Resolved model name.
+
+### TextEmbedding
+
+Smart hybrid: local fastembed if available, cloud otherwise.
+
+```python
+TextEmbedding(
+    model_name="BAAI/bge-small-en-v1.5",
+    api_key=None,
+    **kwargs,
+)
+```
+
+**Properties:**
+- `is_cloud` — `True` if using cloud API, `False` if using local fastembed.
+
+## License
+
+MIT

fastembed_cloud-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+fastembed_cloud/__init__.py,sha256=-rzkqUNYE57RWvFVzK2RmhRNZjlT73a5ebNlesB3Kz8,691
+fastembed_cloud/embedding.py,sha256=HrddbQcB6RK4CyfpefN3-3IuEMh-8UuNATR0V1KaJv0,9757
+fastembed_cloud/provision.py,sha256=TDvw3mGa5c8LnjhQ1JWuaqVcBQoC3lhB1oB05ltn054,5036
+fastembed_cloud-0.1.0.dist-info/licenses/LICENSE,sha256=-3M2h1U80S6mPyiuvRG25A0l1xZGpa7eO43lysBIzBY,1072
+fastembed_cloud-0.1.0.dist-info/METADATA,sha256=iNLn8UxhdB8HmKADpR4G-PeOR7KmA2htXnIRm3uqqvc,6984
+fastembed_cloud-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+fastembed_cloud-0.1.0.dist-info/top_level.txt,sha256=YnPhtvONgzU9-vZccnMcaCYe9m548-fj_rWnmBN9sd8,16
+fastembed_cloud-0.1.0.dist-info/RECORD,,

fastembed_cloud-0.1.0.dist-info/WHEEL

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

fastembed_cloud-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AINative Studio
+
+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.

fastembed_cloud-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fastembed_cloud