Skip to content

The fastest, litest AI Gateway. Rust core with Python SDK. Call 100+ LLM APIs in OpenAI (or native) format with cost tracking, guardrails, load balancing, and logging [Bedrock, Azure, OpenAI, Anthropic, OpenAI, VertexAI, vLLM, Nvidia NIM]

14.9 KB
Raw Blame
"""
Unit tests for Perplexity embedding transformation logic.
"""

import base64
import datetime
import struct
from unittest.mock import MagicMock

import httpx
import pytest
from pydantic import ValidationError

from litellm.litellm_core_utils.litellm_logging import Logging
from litellm.llms.perplexity.embedding.transformation import (
    PerplexityEmbeddingConfig,
    PerplexityEmbeddingError,
)
from litellm.types.utils import EmbeddingResponse


class TestPerplexityEmbeddingConfig:
    def setup_method(self):
        self.config = PerplexityEmbeddingConfig()
        self.model = "pplx-embed-v1-0.6b"
        self.logging_obj = MagicMock()

    def test_get_complete_url_default(self):
        """Test default URL construction."""
        url = self.config.get_complete_url(
            api_base=None,
            api_key="test-key",
            model=self.model,
            optional_params={},
            litellm_params={},
        )
        assert url == "https://api.perplexity.ai/v1/embeddings"

    def test_get_complete_url_custom_base(self):
        """Test URL construction with custom api_base."""
        url = self.config.get_complete_url(
            api_base="https://custom.api.com",
            api_key="test-key",
            model=self.model,
            optional_params={},
            litellm_params={},
        )
        assert url == "https://custom.api.com/v1/embeddings"

    def test_get_complete_url_already_has_embeddings(self):
        """Test URL construction when api_base already ends with /embeddings."""
        url = self.config.get_complete_url(
            api_base="https://custom.api.com/v1/embeddings",
            api_key="test-key",
            model=self.model,
            optional_params={},
            litellm_params={},
        )
        assert url == "https://custom.api.com/v1/embeddings"

    def test_get_supported_openai_params(self):
        """Test that supported params are correctly listed."""
        supported = self.config.get_supported_openai_params(self.model)
        assert "dimensions" in supported
        assert "encoding_format" in supported

    def test_map_openai_params_dimensions(self):
        """Test that dimensions parameter is correctly mapped."""
        result = self.config.map_openai_params(
            non_default_params={"dimensions": 512},
            optional_params={},
            model=self.model,
            drop_params=False,
        )
        assert result["dimensions"] == 512

    def test_map_openai_params_encoding_format(self):
        """Test that encoding_format parameter is correctly mapped."""
        result = self.config.map_openai_params(
            non_default_params={"encoding_format": "base64_int8"},
            optional_params={},
            model=self.model,
            drop_params=False,
        )
        assert result["encoding_format"] == "base64_int8"

    def test_map_openai_params_unsupported_dropped(self):
        """Test that unsupported parameters are not passed through."""
        result = self.config.map_openai_params(
            non_default_params={"dimensions": 256, "user": "test-user"},
            optional_params={},
            model=self.model,
            drop_params=False,
        )
        assert result["dimensions"] == 256
        assert "user" not in result

    def test_validate_environment_with_api_key(self):
        """Test environment validation with explicit API key."""
        headers = self.config.validate_environment(
            headers={},
            model=self.model,
            messages=[],
            optional_params={},
            litellm_params={},
            api_key="pplx-test-key",
        )
        assert headers["Authorization"] == "Bearer pplx-test-key"
        assert headers["Content-Type"] == "application/json"

    def test_transform_embedding_request_string_input(self):
        """Test request transformation with string input."""
        result = self.config.transform_embedding_request(
            model=self.model,
            input="Hello world",
            optional_params={},
            headers={},
        )
        assert result["model"] == self.model
        assert result["input"] == "Hello world"

    def test_transform_embedding_request_list_input(self):
        """Test request transformation with list input."""
        input_data = ["Hello world", "Testing embeddings"]
        result = self.config.transform_embedding_request(
            model=self.model,
            input=input_data,
            optional_params={},
            headers={},
        )
        assert result["model"] == self.model
        assert result["input"] == input_data

    def test_transform_embedding_request_with_params(self):
        """Test request transformation with optional params."""
        result = self.config.transform_embedding_request(
            model=self.model,
            input=["Test"],
            optional_params={"dimensions": 256},
            headers={},
        )
        assert result["model"] == self.model
        assert result["input"] == ["Test"]
        assert result["dimensions"] == 256

    def test_transform_embedding_response_float_passthrough(self):
        """Test response transformation when embeddings are already float arrays."""
        mock_response_data = {
            "object": "list",
            "model": "pplx-embed-v1-0.6b",
            "data": [
                {
                    "object": "embedding",
                    "index": 0,
                    "embedding": [0.1, 0.2, 0.3],
                }
            ],
            "usage": {
                "prompt_tokens": 5,
                "total_tokens": 5,
            },
        }
        mock_response = MagicMock(spec=httpx.Response)
        mock_response.json.return_value = mock_response_data
        mock_response.status_code = 200

        model_response = EmbeddingResponse()
        result = self.config.transform_embedding_response(
            model=self.model,
            raw_response=mock_response,
            model_response=model_response,
            logging_obj=self.logging_obj,
        )

        assert result.model == "pplx-embed-v1-0.6b"
        assert result.object == "list"
        assert len(result.data) == 1
        assert result.data[0]["embedding"] == [0.1, 0.2, 0.3]
        assert result.usage.prompt_tokens == 5
        assert result.usage.total_tokens == 5

    def test_transform_embedding_response_base64_int8(self):
        """Test decoding base64_int8 embeddings to float arrays (Perplexity default)."""
        int8_values = [127, -128, 0, 64, -64]
        b64_encoded = base64.b64encode(
            struct.pack(f"{len(int8_values)}b", *int8_values)
        ).decode()

        mock_response_data = {
            "object": "list",
            "model": "pplx-embed-v1-0.6b",
            "data": [
                {
                    "object": "embedding",
                    "index": 0,
                    "embedding": b64_encoded,
                }
            ],
            "usage": {"prompt_tokens": 3, "total_tokens": 3},
        }
        mock_response = MagicMock(spec=httpx.Response)
        mock_response.json.return_value = mock_response_data
        mock_response.status_code = 200

        model_response = EmbeddingResponse()
        result = self.config.transform_embedding_response(
            model=self.model,
            raw_response=mock_response,
            model_response=model_response,
            logging_obj=self.logging_obj,
        )

        embedding = result.data[0]["embedding"]
        assert isinstance(embedding, list)
        assert len(embedding) == 5
        assert all(isinstance(v, float) for v in embedding)
        assert abs(embedding[0] - 1.0) < 0.01
        assert abs(embedding[1] - (-128.0 / 127.0)) < 0.01
        assert embedding[2] == 0.0

    def test_decode_base64_embedding_static(self):
        """Test the static decode helper directly."""
        int8_values = [10, -10, 50, -50]
        b64_str = base64.b64encode(struct.pack("4b", *int8_values)).decode()
        result = PerplexityEmbeddingConfig._decode_base64_embedding(b64_str)
        assert len(result) == 4
        assert abs(result[0] - 10.0 / 127.0) < 1e-6
        assert abs(result[1] - (-10.0 / 127.0)) < 1e-6

    def test_decode_base64_embedding_list_passthrough(self):
        """Test that float lists pass through unchanged."""
        floats = [0.5, -0.3, 0.8]
        result = PerplexityEmbeddingConfig._decode_base64_embedding(floats)
        assert result == floats

    def test_transform_embedding_response_error(self):
        """Test that malformed response raises PerplexityEmbeddingError."""
        mock_response = MagicMock(spec=httpx.Response)
        mock_response.json.side_effect = Exception("Invalid JSON")
        mock_response.text = "Server error"
        mock_response.status_code = 500

        model_response = EmbeddingResponse()
        with pytest.raises(PerplexityEmbeddingError) as exc_info:
            self.config.transform_embedding_response(
                model=self.model,
                raw_response=mock_response,
                model_response=model_response,
                logging_obj=self.logging_obj,
            )
        e = exc_info.value
        assert e.status_code == 500
        assert "Server error" in e.message

    def test_get_error_class(self):
        """Test that get_error_class returns the correct error type."""
        error = self.config.get_error_class(
            error_message="Not found",
            status_code=404,
            headers={},
        )
        assert isinstance(error, PerplexityEmbeddingError)
        assert error.status_code == 404
        assert error.message == "Not found"

    def test_transform_embedding_request_4b_model(self):
        """Test request transformation with the 4b model."""
        model = "pplx-embed-v1-4b"
        result = self.config.transform_embedding_request(
            model=model,
            input=["Test text"],
            optional_params={"dimensions": 2560},
            headers={},
        )
        assert result["model"] == model
        assert result["dimensions"] == 2560


class TestPerplexityEmbeddingProviderConfig:
    """Test that Perplexity is correctly registered in ProviderConfigManager."""

    def test_provider_config_returns_perplexity_embedding(self):
        import litellm
        from litellm.utils import ProviderConfigManager

        config = ProviderConfigManager.get_provider_embedding_config(
            model="pplx-embed-v1-0.6b",
            provider=litellm.LlmProviders.PERPLEXITY,
        )
        assert config is not None
        assert isinstance(config, PerplexityEmbeddingConfig)

    def test_provider_config_returns_perplexity_embedding_4b(self):
        import litellm
        from litellm.utils import ProviderConfigManager

        config = ProviderConfigManager.get_provider_embedding_config(
            model="pplx-embed-v1-4b",
            provider=litellm.LlmProviders.PERPLEXITY,
        )
        assert config is not None
        assert isinstance(config, PerplexityEmbeddingConfig)


FLOAT_ROW = {"object": "embedding", "index": 0, "embedding": [0.1, 0.2, 0.3]}


def _transform(payload: object) -> EmbeddingResponse:
    logging_obj = Logging(
        model="perplexity/pplx-embed-v1-0.6b",
        messages=[],
        stream=False,
        call_type="embedding",
        start_time=datetime.datetime(2025, 1, 1, tzinfo=datetime.timezone.utc),
        litellm_call_id="call-id",
        function_id="function-id",
    )
    return PerplexityEmbeddingConfig().transform_embedding_response(
        model="pplx-embed-v1-0.6b",
        raw_response=httpx.Response(200, json=payload),
        model_response=EmbeddingResponse(),
        logging_obj=logging_obj,
    )


def _token_counts(response: EmbeddingResponse) -> tuple[int, int, int]:
    assert response.usage is not None
    return (response.usage.prompt_tokens, response.usage.completion_tokens, response.usage.total_tokens)


@pytest.mark.parametrize(
    ("usage", "expected"),
    [
        ({"prompt_tokens": 4, "total_tokens": 6}, (4, 0, 6)),
        ({"total_tokens": 6}, (6, 0, 6)),
        ({"prompt_tokens": 0, "total_tokens": 6}, (6, 0, 6)),
        ({"prompt_tokens": None, "total_tokens": 6}, (6, 0, 6)),
        ({"prompt_tokens": 4}, (4, 0, 0)),
        ({}, (0, 0, 0)),
        ({"prompt_tokens": None, "total_tokens": None}, (0, 0, 0)),
        ({"prompt_tokens": "", "total_tokens": []}, (0, 0, 0)),
        ({"prompt_tokens": "12", "total_tokens": 12.0}, (12, 0, 12)),
    ],
)
def test_perplexity_embedding_usage_falls_back_to_total_tokens_and_tolerates_loose_counts(usage, expected):
    response = _transform({"data": [FLOAT_ROW], "usage": usage})

    assert response.data == [FLOAT_ROW]
    assert _token_counts(response) == expected


def test_perplexity_embedding_response_without_usage_reports_zero_tokens():
    assert _token_counts(_transform({"data": [FLOAT_ROW]})) == (0, 0, 0)


def test_perplexity_embedding_rows_keep_their_fields_in_order_around_the_decoded_vector():
    encoded = base64.b64encode(struct.pack("3b", 127, 0, -127)).decode()

    response = _transform(
        {"data": [{"z": 1, "embedding": encoded, "index": 0}, {"index": 1, "embedding": [0.5]}, {"index": 2}]}
    )

    assert [list(row.items()) for row in response.data] == [
        [("z", 1), ("embedding", [1.0, 0.0, -1.0]), ("index", 0)],
        [("index", 1), ("embedding", [0.5])],
        [("index", 2), ("embedding", None)],
    ]


@pytest.mark.parametrize("payload", [{}, {"data": []}, {"data": ""}, {"data": {}}])
def test_perplexity_embedding_response_without_rows_has_no_data(payload):
    assert _transform(payload).data == []


@pytest.mark.parametrize("row", [None, 3, "ab", [], [["embedding", [1.0]]]])
def test_perplexity_embedding_row_that_is_not_an_object_is_rejected(row):
    with pytest.raises(ValidationError):
        _transform({"data": [FLOAT_ROW, row]})


@pytest.mark.parametrize("usage", [None, [], "tokens", 3])
def test_perplexity_embedding_usage_that_is_not_an_object_is_rejected(usage):
    with pytest.raises(ValidationError):
        _transform({"data": [FLOAT_ROW], "usage": usage})


@pytest.mark.parametrize(
    "usage",
    [
        {"prompt_tokens": "many"},
        {"total_tokens": 1.5},
        {"prompt_tokens": [1]},
        {"prompt_tokens": 4, "total_tokens": 1.5},
        {"prompt_tokens": 4, "total_tokens": "many"},
    ],
)
def test_perplexity_embedding_token_count_that_is_not_an_integer_is_rejected(usage):
    with pytest.raises(ValidationError):
        _transform({"data": [FLOAT_ROW], "usage": usage})


@pytest.mark.parametrize(
    "api_base",
    [
        "https://gateway.example.com/perplexity",
        "https://gateway.example.com/perplexity/",
        "https://gateway.example.com/perplexity/v1/embeddings/",
    ],
)
def test_get_complete_url_ignores_a_trailing_slash_on_api_base(api_base: str):
    assert (
        PerplexityEmbeddingConfig().get_complete_url(
            api_base=api_base, api_key=None, model="pplx-embed-v1-0.6b", optional_params={}, litellm_params={}
        )
        == "https://gateway.example.com/perplexity/v1/embeddings"
    )