LightMem/src/lightmem/factory/text_embedder/dashscope.py

from __future__ import annotations

from http import HTTPStatus
from typing import Any, Dict, List, Optional, Union

import dashscope
import tiktoken

from lightmem.configs.text_embedder.base_config import BaseTextEmbedderConfig


class _FallbackTokenizer:
    def encode(self, text: str):
        return str(text).split()


class TextEmbedderDashScope:
    def __init__(self, config: Optional[BaseTextEmbedderConfig] = None):
        self.config = config or BaseTextEmbedderConfig()
        self.model = getattr(self.config, "model", None) or "text-embedding-v4"
        self.model_kwargs: Dict[str, Any] = dict(getattr(self.config, "model_kwargs", None) or {})
        self.default_text_type = self.model_kwargs.get("text_type", "document")
        self.batch_size = int(self.model_kwargs.get("batch_size", 10))
        self.total_calls = 0
        self.total_tokens = 0
        try:
            self.tokenizer = tiktoken.get_encoding("o200k_base")
        except Exception:
            self.tokenizer = _FallbackTokenizer()

        api_key = getattr(self.config, "api_key", None)
        if api_key:
            dashscope.api_key = api_key

        base_http_api_url = self.model_kwargs.get("base_http_api_url")
        if base_http_api_url:
            dashscope.base_http_api_url = base_http_api_url

    @classmethod
    def from_config(cls, config: BaseTextEmbedderConfig):
        return cls(config)

    @classmethod
    def probe_dimensions(cls, config: Optional[BaseTextEmbedderConfig] = None, probe_text: str = "dimension probe") -> int:
        embedder = cls(config=config)
        embedding = embedder.embed(probe_text)
        return len(embedding)

    def _build_params(self, text_type: Optional[str]) -> Dict[str, Any]:
        params: Dict[str, Any] = {"model": self.model}
        dimension = getattr(self.config, "embedding_dims", None)
        if dimension:
            params["dimension"] = dimension

        effective_text_type = text_type or self.default_text_type
        if effective_text_type:
            params["text_type"] = effective_text_type

        for key in ("output_type", "instruct"):
            value = self.model_kwargs.get(key)
            if value is not None:
                params[key] = value
        return params

    def _extract_usage_tokens(self, response: Any) -> int:
        usage = getattr(response, "usage", None)
        if usage is None and isinstance(response, dict):
            usage = response.get("usage")
        if usage is None:
            return 0
        if isinstance(usage, dict):
            return int(usage.get("total_tokens", 0) or 0)
        return int(getattr(usage, "total_tokens", 0) or 0)

    def _estimate_input_tokens(self, batch: Union[str, List[str]]) -> int:
        if isinstance(batch, list):
            return sum(len(self.tokenizer.encode(item)) for item in batch)
        return len(self.tokenizer.encode(batch))

    def _extract_embeddings(self, response: Any) -> List[List[float]]:
        output = getattr(response, "output", None)
        if output is None and isinstance(response, dict):
            output = response.get("output", {})
        if hasattr(output, "get"):
            embeddings = output.get("embeddings", [])
        else:
            embeddings = output["embeddings"]
        result: List[List[float]] = []
        for item in embeddings:
            if isinstance(item, dict):
                embedding = item.get("embedding")
            else:
                embedding = getattr(item, "embedding", None)
            if embedding is None:
                raise ValueError("DashScope embedding response did not contain an embedding vector.")
            result.append(list(embedding))
        if not result:
            raise ValueError("DashScope embedding response returned no vectors.")
        return result

    def _call_api(self, batch: Union[str, List[str]], text_type: Optional[str]) -> List[List[float]]:
        response = dashscope.TextEmbedding.call(
            input=batch,
            **self._build_params(text_type=text_type),
        )
        status_code = getattr(response, "status_code", None)
        if status_code not in (HTTPStatus.OK, 200):
            message = getattr(response, "message", None)
            code = getattr(response, "code", None)
            raise RuntimeError(f"DashScope embedding call failed: status_code={status_code}, code={code}, message={message}")

        embeddings = self._extract_embeddings(response)
        self.total_calls += 1
        usage_tokens = self._extract_usage_tokens(response)
        self.total_tokens += usage_tokens or self._estimate_input_tokens(batch)

        if getattr(self.config, "embedding_dims", None) is None and embeddings:
            self.config.embedding_dims = len(embeddings[0])
        return embeddings

    def embed(
        self,
        text: Union[str, List[str]],
        text_type: Optional[str] = None,
    ) -> Union[List[float], List[List[float]]]:
        if isinstance(text, list):
            if not text:
                return []
            embeddings: List[List[float]] = []
            for start in range(0, len(text), self.batch_size):
                batch = [str(item) for item in text[start : start + self.batch_size]]
                embeddings.extend(self._call_api(batch=batch, text_type=text_type))
            return embeddings

        single_embedding = self._call_api(batch=str(text), text_type=text_type)
        return single_embedding[0]

    def get_stats(self):
        return {
            "total_calls": self.total_calls,
            "total_tokens": self.total_tokens,
            "embedding_dims": getattr(self.config, "embedding_dims", None),
        }