Spaces:
Runtime error
Runtime error
Claude Opus 5.5
feat(embeddings): voyage-4-large remplace EmbeddingGemma (API Voyage, halfvec 1024)
57c8117 Download tests/test_services/test_embedding_providers.py from rahim237cm/jurix-api: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/tests/test_services/test_embedding_providers.py
- Command line
-
hf download hf://spaces/rahim237cm/jurix-api/tests/test_services/test_embedding_providers.py
-
curl -L -o test_embedding_providers.py https://huggingface.co/spaces/rahim237cm/jurix-api/resolve/main/tests/test_services/test_embedding_providers.py
10.7 kB
| """ | |
| Tests du contrat de fournisseur d'embeddings. | |
| Le service delegue la production des vecteurs a un fournisseur interchangeable | |
| et garde tout le reste. Ces tests verrouillent les quatre garanties qui | |
| rendent l'echange sur : | |
| - deux fournisseurs ne se servent JAMAIS leurs vecteurs par le cache, meme a | |
| dimension egale — c'est le cas que la garde de dimension ne voit pas ; | |
| - une dimension que le fournisseur ne sait pas produire est refusee a la | |
| construction, pas au premier appel apres trois tentatives ; | |
| - ce qu'un nouvel essai reproduirait n'est jamais rejoue, et une question | |
| n'a droit qu'a un essai ; | |
| - le service normalise et verifie, quel que soit ce que rend le fournisseur. | |
| Aucun vrai modele, aucun appel reseau : les fournisseurs sont des doublures. | |
| """ | |
| import numpy as np | |
| import pytest | |
| from app.services import embedding_service as module | |
| from app.services.embedding_service import ( | |
| EmbeddingDefinitiveError, | |
| EmbeddingService, | |
| EmbeddingServiceError, | |
| GeminiProvider, | |
| ) | |
| class _Fournisseur: | |
| """Fournisseur factice, configurable, qui compte ses appels.""" | |
| label = "Fournisseur de test" | |
| model = "modele-de-test" | |
| retryable = True | |
| inter_batch_delay_s = 0.0 | |
| def __init__(self, name="test", native_dim=None, echec=None, norme=7.0): | |
| self.name = name | |
| self.native_dim = native_dim or EmbeddingService.EMBEDDING_DIM | |
| self.echec = echec | |
| self.norme = norme | |
| self.appels = 0 | |
| def fingerprint(self): | |
| return f"{self.name}|{self.model}" | |
| def embed(self, texts, task_type, dim): | |
| self.appels += 1 | |
| if self.echec: | |
| raise self.echec | |
| rng = np.random.default_rng(3) | |
| # Vecteurs NON unitaires : c'est au service de normaliser. | |
| return [(rng.random(dim) * self.norme).astype(np.float32) for _ in texts] | |
| def _service(fournisseur): | |
| return EmbeddingService(use_cache=False, provider=fournisseur) | |
| class TestEmpreinteDansLaCle: | |
| def test_deux_fournisseurs_a_dimension_egale_ont_des_cles_distinctes(self): | |
| """ | |
| Le cas que la garde de dimension ne voit pas : meme texte, meme | |
| dimension, meme tache, deux modeles. Sans l'empreinte dans la cle, le | |
| vecteur de l'un serait resservi a l'autre pendant sept jours. | |
| """ | |
| a = _service(_Fournisseur(name="a")) | |
| b = _service(_Fournisseur(name="b")) | |
| cle_a = a._cache_key("Article premier", EmbeddingService.TASK_DOCUMENT) | |
| cle_b = b._cache_key("Article premier", EmbeddingService.TASK_DOCUMENT) | |
| assert cle_a != cle_b | |
| def test_meme_fournisseur_meme_cle(self): | |
| a = _service(_Fournisseur(name="a")) | |
| a2 = _service(_Fournisseur(name="a")) | |
| assert a._cache_key("x", EmbeddingService.TASK_DOCUMENT) == a2._cache_key( | |
| "x", EmbeddingService.TASK_DOCUMENT | |
| ) | |
| def test_la_cle_lit_l_empreinte_de_l_instance(self): | |
| """Pas une constante de classe figee a l'import.""" | |
| f = _Fournisseur(name="avant") | |
| s = _service(f) | |
| avant = s._cache_key("x", EmbeddingService.TASK_DOCUMENT) | |
| f.name = "apres" | |
| assert s._cache_key("x", EmbeddingService.TASK_DOCUMENT) != avant | |
| def test_empreinte_gemini_porte_le_modele(self, monkeypatch): | |
| monkeypatch.setattr(module.genai, "Client", lambda *a, **k: object()) | |
| assert GeminiProvider(api_key="factice").fingerprint == ( | |
| f"gemini|{module.settings.GEMINI_EMBEDDING_MODEL}" | |
| ) | |
| class TestDimensionNative: | |
| def test_dimension_trop_grande_refusee_a_la_construction(self): | |
| """ | |
| Sans ce controle, l'erreur n'apparait qu'au premier appel, apres trois | |
| tentatives, et la recherche hybride l'avale sans bruit. | |
| """ | |
| trop_petit = _Fournisseur(native_dim=EmbeddingService.EMBEDDING_DIM - 1) | |
| with pytest.raises(EmbeddingServiceError, match="dimension native"): | |
| _service(trop_petit) | |
| def test_dimension_egale_a_la_native_acceptee(self): | |
| _service(_Fournisseur(native_dim=EmbeddingService.EMBEDDING_DIM)) | |
| def test_dimension_hors_des_dimensions_permises_refusee(self): | |
| """ | |
| Voyage n'accepte que 256, 512, 1024 et 2048 : une dimension sous la | |
| native mais hors liste n'echouerait qu'au premier appel, en HTTP 400, | |
| que la recherche hybride avalerait. | |
| """ | |
| f = _Fournisseur(native_dim=2048) | |
| f.dimensions_permises = (256, 512, 2048) | |
| with pytest.raises(EmbeddingServiceError, match="permises"): | |
| _service(f) | |
| def test_dimension_permise_acceptee(self): | |
| f = _Fournisseur(native_dim=2048) | |
| f.dimensions_permises = (EmbeddingService.EMBEDDING_DIM,) | |
| _service(f) | |
| class TestLimiteDeTexte: | |
| def test_la_limite_du_fournisseur_s_impose_a_l_instance(self): | |
| f = _Fournisseur() | |
| f.max_caracteres = 50 | |
| s = _service(f) | |
| assert s.MAX_TEXT_LENGTH == 50 | |
| with pytest.raises(ValueError, match="trop long"): | |
| s.generate_embedding("x" * 51) | |
| def test_sans_limite_declaree_le_defaut_du_service(self): | |
| assert _service(_Fournisseur()).MAX_TEXT_LENGTH == EmbeddingService.MAX_TEXT_LENGTH | |
| def test_gemini_garde_sa_limite(self): | |
| """2 048 jetons de contexte chez gemini-embedding-001.""" | |
| assert GeminiProvider.max_caracteres == 10_000 | |
| class TestReprises: | |
| def test_fournisseur_non_rejouable_echoue_au_premier_appel(self, monkeypatch): | |
| """ | |
| Un modele local qui echoue echouera pareil a la tentative suivante : | |
| rejouer ne ferait que dormir avant d'echouer quand meme. | |
| """ | |
| dodos = [] | |
| monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s)) | |
| f = _Fournisseur(echec=RuntimeError("modele indisponible")) | |
| f.retryable = False | |
| with pytest.raises(EmbeddingServiceError): | |
| _service(f).generate_embedding("Article premier") | |
| assert f.appels == 1 | |
| assert dodos == [] | |
| def test_fournisseur_rejouable_est_rejoue(self, monkeypatch): | |
| monkeypatch.setattr(module.time, "sleep", lambda s: None) | |
| f = _Fournisseur(echec=RuntimeError("503 passager")) | |
| with pytest.raises(EmbeddingServiceError): | |
| _service(f).generate_embedding("Article premier") | |
| assert f.appels == EmbeddingService.MAX_RETRIES | |
| def test_une_erreur_definitive_n_est_pas_rejouee(self, monkeypatch): | |
| """Une cle refusee le sera encore : la relancer telle quelle.""" | |
| dodos = [] | |
| monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s)) | |
| f = _Fournisseur(echec=EmbeddingDefinitiveError("HTTP 401 : cle refusee")) | |
| with pytest.raises(EmbeddingDefinitiveError): | |
| _service(f).generate_embedding("Article premier") | |
| with pytest.raises(EmbeddingDefinitiveError): | |
| _service(f).generate_batch_embeddings(["a", "b"]) | |
| assert f.appels == 2 | |
| assert dodos == [] | |
| def test_une_question_n_a_qu_un_essai(self, monkeypatch): | |
| """ | |
| Pendant ce temps, l'utilisateur attend : un echec passager ne lui | |
| coute que le volet semantique de sa recherche. | |
| """ | |
| dodos = [] | |
| monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s)) | |
| f = _Fournisseur(echec=RuntimeError("503 passager")) | |
| with pytest.raises(EmbeddingServiceError): | |
| _service(f).generate_embedding("Une question", task_type=EmbeddingService.TASK_QUERY) | |
| assert f.appels == 1 | |
| assert dodos == [] | |
| def test_pas_de_pause_entre_lots_si_le_fournisseur_n_en_veut_pas(self, monkeypatch): | |
| dodos = [] | |
| monkeypatch.setattr(module.time, "sleep", lambda s: dodos.append(s)) | |
| f = _Fournisseur() # inter_batch_delay_s = 0.0 | |
| _service(f).generate_batch_embeddings(["a", "b", "c"], batch_size=1) | |
| assert dodos == [] | |
| class TestLeServiceGardeSesControles: | |
| def test_le_service_normalise_quel_que_soit_le_fournisseur(self): | |
| vecteur = _service(_Fournisseur(norme=9.0)).generate_embedding("Article premier") | |
| assert vecteur.shape == (EmbeddingService.EMBEDDING_DIM,) | |
| assert abs(float(np.linalg.norm(vecteur)) - 1.0) < 1e-5 | |
| def test_reponse_incomplete_detectee_par_le_service(self): | |
| class _Court(_Fournisseur): | |
| def embed(self, texts, task_type, dim): | |
| return super().embed(texts[:-1], task_type, dim) | |
| with pytest.raises(EmbeddingServiceError, match="incomplète"): | |
| _service(_Court()).generate_batch_embeddings(["a", "b", "c"]) | |
| def test_le_fournisseur_injecte_est_celui_qui_sert(self): | |
| f = _Fournisseur() | |
| s = _service(f) | |
| s.generate_embedding("Article premier") | |
| assert s.provider is f | |
| assert f.appels == 1 | |
| def test_health_check_decrit_le_fournisseur(self): | |
| sante = _service(_Fournisseur()).health_check() | |
| assert sante["provider"] == "Fournisseur de test" | |
| assert sante["model"] == "modele-de-test" | |
| class TestGeminiRefus: | |
| """ | |
| Une cle Gemini invalide arrive en 400 (API_KEY_INVALID) : elle doit | |
| arreter un traitement par lots, pas faire sauter chaque lot apres trois | |
| essais. | |
| """ | |
| def _fournisseur(monkeypatch, erreur): | |
| class _Modeles: | |
| def embed_content(self, **kwargs): | |
| raise erreur | |
| class _Client: | |
| def __init__(self, *a, **k): | |
| self.models = _Modeles() | |
| monkeypatch.setattr(module.genai, "Client", _Client) | |
| return GeminiProvider(api_key="factice") | |
| def test_une_cle_invalide_vise_la_configuration(self, monkeypatch): | |
| from google.genai import errors | |
| erreur = errors.ClientError(400, {"error": { | |
| "code": 400, "message": "API key not valid.", "status": "INVALID_ARGUMENT", | |
| "details": [{"reason": "API_KEY_INVALID"}], | |
| }}) | |
| with pytest.raises(EmbeddingDefinitiveError) as refus: | |
| self._fournisseur(monkeypatch, erreur).embed(["a"], EmbeddingService.TASK_DOCUMENT, 1024) | |
| assert refus.value.code == 401 | |
| assert refus.value.vise_la_configuration | |
| def test_un_429_reste_rejouable(self, monkeypatch): | |
| """Le quota par minute se rejoue ; _is_daily_quota_error lit son message.""" | |
| from google.genai import errors | |
| erreur = errors.ClientError(429, {"error": { | |
| "code": 429, "message": "Resource has been exhausted", "status": "RESOURCE_EXHAUSTED", | |
| }}) | |
| with pytest.raises(errors.ClientError): | |
| self._fournisseur(monkeypatch, erreur).embed(["a"], EmbeddingService.TASK_DOCUMENT, 1024) | |