orca-sdk 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

orca_sdk/datasource_test.py

@@ -19,9 +19,10 @@ def test_create_datasource(datasource, hf_dataset):
     assert datasource.length == len(hf_dataset)
 
 
-def test_create_datasource_unauthenticated(unauthenticated, hf_dataset):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        Datasource.from_hf_dataset("test_datasource", hf_dataset)
+def test_create_datasource_unauthenticated(unauthenticated_client, hf_dataset):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            Datasource.from_hf_dataset("test_datasource", hf_dataset)
 
 
 def test_create_datasource_already_exists_error(hf_dataset, datasource):
@@ -43,9 +44,10 @@ def test_open_datasource(datasource):
     assert fetched_datasource.length == len(datasource)
 
 
-def test_open_datasource_unauthenticated(datasource, unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        Datasource.open("test_datasource")
+def test_open_datasource_unauthenticated(unauthenticated_client, datasource):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            Datasource.open("test_datasource")
 
 
 def test_open_datasource_invalid_input():
@@ -58,9 +60,10 @@ def test_open_datasource_not_found():
         Datasource.open(str(uuid4()))
 
 
-def test_open_datasource_unauthorized(datasource, unauthorized):
-    with pytest.raises(LookupError):
-        Datasource.open(datasource.id)
+def test_open_datasource_unauthorized(unauthorized_client, datasource):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            Datasource.open(datasource.id)
 
 
 def test_all_datasources(datasource):
@@ -69,9 +72,10 @@ def test_all_datasources(datasource):
     assert any(datasource.name == datasource.name for datasource in datasources)
 
 
-def test_all_datasources_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        Datasource.all()
+def test_all_datasources_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            Datasource.all()
 
 
 def test_drop_datasource(hf_dataset):
@@ -81,9 +85,10 @@ def test_drop_datasource(hf_dataset):
     assert not Datasource.exists("datasource_to_delete")
 
 
-def test_drop_datasource_unauthenticated(datasource, unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        Datasource.drop(datasource.id)
+def test_drop_datasource_unauthenticated(datasource, unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            Datasource.drop(datasource.id)
 
 
 def test_drop_datasource_not_found():
@@ -93,9 +98,10 @@ def test_drop_datasource_not_found():
     Datasource.drop(str(uuid4()), if_not_exists="ignore")
 
 
-def test_drop_datasource_unauthorized(datasource, unauthorized):
-    with pytest.raises(LookupError):
-        Datasource.drop(datasource.id)
+def test_drop_datasource_unauthorized(datasource, unauthorized_client):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            Datasource.drop(datasource.id)
 
 
 def test_drop_datasource_invalid_input():
@@ -295,6 +301,126 @@ def test_from_disk_already_exists():
             os.unlink(f.name)
 
 
+def test_query_datasource_rows():
+    """Test querying rows from a datasource with pagination and shuffle."""
+    # Create a new dataset with 5 entries for testing
+    test_data = [{"id": i, "name": f"item_{i}"} for i in range(5)]
+    datasource = Datasource.from_list(name="test_query_datasource", data=test_data)
+
+    # Test basic query
+    rows = datasource.query(limit=3)
+    assert len(rows) == 3
+    assert all(isinstance(row, dict) for row in rows)
+
+    # Test offset
+    offset_rows = datasource.query(offset=2, limit=2)
+    assert len(offset_rows) == 2
+    assert offset_rows[0]["id"] == 2
+
+    # Test shuffle
+    shuffled_rows = datasource.query(limit=5, shuffle=True)
+    assert len(shuffled_rows) == 5
+    assert not all(row["id"] == i for i, row in enumerate(shuffled_rows))
+
+    # Test shuffle with seed
+    assert datasource.query(limit=5, shuffle=True, shuffle_seed=42) == datasource.query(
+        limit=5, shuffle=True, shuffle_seed=42
+    )
+
+
+def test_query_datasource_with_filters():
+    """Test querying datasource rows with various filter operators."""
+    # Create a datasource with test data
+    test_data = [
+        {"name": "Alice", "age": 25, "city": "New York", "score": 85.5},
+        {"name": "Bob", "age": 30, "city": "San Francisco", "score": 90.0},
+        {"name": "Charlie", "age": 35, "city": "Chicago", "score": 75.5},
+        {"name": "Diana", "age": 28, "city": "Boston", "score": 88.0},
+        {"name": "Eve", "age": 32, "city": "New York", "score": 92.0},
+    ]
+    datasource = Datasource.from_list(name=f"test_filter_datasource_{uuid4()}", data=test_data)
+
+    # Test == operator
+    rows = datasource.query(filters=[("city", "==", "New York")])
+    assert len(rows) == 2
+    assert all(row["city"] == "New York" for row in rows)
+
+    # Test > operator
+    rows = datasource.query(filters=[("age", ">", 30)])
+    assert len(rows) == 2
+    assert all(row["age"] > 30 for row in rows)
+
+    # Test >= operator
+    rows = datasource.query(filters=[("score", ">=", 88.0)])
+    assert len(rows) == 3
+    assert all(row["score"] >= 88.0 for row in rows)
+
+    # Test < operator
+    rows = datasource.query(filters=[("age", "<", 30)])
+    assert len(rows) == 2
+    assert all(row["age"] < 30 for row in rows)
+
+    # Test in operator
+    rows = datasource.query(filters=[("city", "in", ["New York", "Boston"])])
+    assert len(rows) == 3
+    assert all(row["city"] in ["New York", "Boston"] for row in rows)
+
+    # Test not in operator
+    rows = datasource.query(filters=[("city", "not in", ["New York", "Boston"])])
+    assert len(rows) == 2
+    assert all(row["city"] not in ["New York", "Boston"] for row in rows)
+
+    # Test like operator
+    rows = datasource.query(filters=[("name", "like", "li")])
+    assert len(rows) == 2
+    assert all("li" in row["name"].lower() for row in rows)
+
+    # Test multiple filters (AND logic)
+    rows = datasource.query(filters=[("city", "==", "New York"), ("age", ">", 26)])
+    assert len(rows) == 1
+    assert rows[0]["name"] == "Eve"
+
+    # Test filter with pagination
+    rows = datasource.query(filters=[("age", ">=", 28)], limit=2, offset=1)
+    assert len(rows) == 2
+
+
+def test_query_datasource_with_none_filters():
+    """Test filtering for None values."""
+    test_data = [
+        {"name": "Alice", "age": 25, "label": "A"},
+        {"name": "Bob", "age": 30, "label": None},
+        {"name": "Charlie", "age": 35, "label": "C"},
+        {"name": "Diana", "age": None, "label": "D"},
+        {"name": "Eve", "age": 32, "label": None},
+    ]
+    datasource = Datasource.from_list(name=f"test_none_filter_{uuid4()}", data=test_data)
+
+    # Test == None
+    rows = datasource.query(filters=[("label", "==", None)])
+    assert len(rows) == 2
+    assert all(row["label"] is None for row in rows)
+
+    # Test != None
+    rows = datasource.query(filters=[("label", "!=", None)])
+    assert len(rows) == 3
+    assert all(row["label"] is not None for row in rows)
+
+    # Test that None values are excluded from comparison operators
+    rows = datasource.query(filters=[("age", ">", 25)])
+    assert len(rows) == 3
+    assert all(row["age"] is not None and row["age"] > 25 for row in rows)
+
+
+def test_query_datasource_filter_invalid_column():
+    """Test that querying with an invalid column raises an error."""
+    test_data = [{"name": "Alice", "age": 25}]
+    datasource = Datasource.from_list(name=f"test_invalid_filter_{uuid4()}", data=test_data)
+
+    with pytest.raises(ValueError):
+        datasource.query(filters=[("invalid_column", "==", "test")])
+
+
 def test_to_list(hf_dataset, datasource):
     assert datasource.to_list() == hf_dataset.to_list()
 

orca_sdk/embedding_model.py

@@ -12,15 +12,15 @@ from .client import (
     EmbedRequest,
     FinetunedEmbeddingModelMetadata,
     FinetuneEmbeddingModelRequest,
+    OrcaClient,
     PretrainedEmbeddingModelMetadata,
     PretrainedEmbeddingModelName,
-    orca_api,
 )
 from .datasource import Datasource
 from .job import Job, Status
 
 if TYPE_CHECKING:
-    from .memoryset import LabeledMemoryset
+    from .memoryset import LabeledMemoryset, ScoredMemoryset
 
 
 class EmbeddingModelBase(ABC):
@@ -82,15 +82,16 @@ class EmbeddingModelBase(ABC):
             "max_seq_length": max_seq_length,
             "prompt": prompt,
         }
+        client = OrcaClient._resolve_client()
         if isinstance(self, PretrainedEmbeddingModel):
-            embeddings = orca_api.POST(
+            embeddings = client.POST(
                 "/gpu/pretrained_embedding_model/{model_name}/embedding",
                 params={"model_name": cast(PretrainedEmbeddingModelName, self.name)},
                 json=payload,
                 timeout=30,  # may be slow in case of cold start
             )
         elif isinstance(self, FinetunedEmbeddingModel):
-            embeddings = orca_api.POST(
+            embeddings = client.POST(
                 "/gpu/finetuned_embedding_model/{name_or_id}/embedding",
                 params={"name_or_id": self.id},
                 json=payload,
@@ -109,7 +110,7 @@ class EmbeddingModelBase(ABC):
         label_column: str,
         score_column: None = None,
         eval_datasource: Datasource | None = None,
-        subsample: int | None = None,
+        subsample: int | float | None = None,
         neighbor_count: int = 5,
         batch_size: int = 32,
         weigh_memories: bool = True,
@@ -126,7 +127,7 @@ class EmbeddingModelBase(ABC):
         label_column: str,
         score_column: None = None,
         eval_datasource: Datasource | None = None,
-        subsample: int | None = None,
+        subsample: int | float | None = None,
         neighbor_count: int = 5,
         batch_size: int = 32,
         weigh_memories: bool = True,
@@ -143,7 +144,7 @@ class EmbeddingModelBase(ABC):
         label_column: None = None,
         score_column: str,
         eval_datasource: Datasource | None = None,
-        subsample: int | None = None,
+        subsample: int | float | None = None,
         neighbor_count: int = 5,
         batch_size: int = 32,
         weigh_memories: bool = True,
@@ -160,7 +161,7 @@ class EmbeddingModelBase(ABC):
         label_column: None = None,
         score_column: str,
         eval_datasource: Datasource | None = None,
-        subsample: int | None = None,
+        subsample: int | float | None = None,
         neighbor_count: int = 5,
         batch_size: int = 32,
         weigh_memories: bool = True,
@@ -176,7 +177,7 @@ class EmbeddingModelBase(ABC):
         label_column: str | None = None,
         score_column: str | None = None,
         eval_datasource: Datasource | None = None,
-        subsample: int | None = None,
+        subsample: int | float | None = None,
         neighbor_count: int = 5,
         batch_size: int = 32,
         weigh_memories: bool = True,
@@ -191,6 +192,7 @@ class EmbeddingModelBase(ABC):
         """
         Evaluate the finetuned embedding model
         """
+
         payload: EmbeddingEvaluationRequest = {
             "datasource_name_or_id": datasource.id,
             "datasource_label_column": label_column,
@@ -202,14 +204,15 @@ class EmbeddingModelBase(ABC):
             "batch_size": batch_size,
             "weigh_memories": weigh_memories,
         }
+        client = OrcaClient._resolve_client()
         if isinstance(self, PretrainedEmbeddingModel):
-            response = orca_api.POST(
+            response = client.POST(
                 "/pretrained_embedding_model/{model_name}/evaluation",
                 params={"model_name": self.name},
                 json=payload,
             )
         elif isinstance(self, FinetunedEmbeddingModel):
-            response = orca_api.POST(
+            response = client.POST(
                 "/finetuned_embedding_model/{name_or_id}/evaluation",
                 params={"name_or_id": self.id},
                 json=payload,
@@ -217,16 +220,17 @@ class EmbeddingModelBase(ABC):
         else:
             raise ValueError("Invalid embedding model")
 
-        def get_result(task_id: str) -> ClassificationMetrics | RegressionMetrics:
+        def get_result(job_id: str) -> ClassificationMetrics | RegressionMetrics:
+            client = OrcaClient._resolve_client()
             if isinstance(self, PretrainedEmbeddingModel):
-                res = orca_api.GET(
-                    "/pretrained_embedding_model/{model_name}/evaluation/{task_id}",
-                    params={"model_name": self.name, "task_id": task_id},
+                res = client.GET(
+                    "/pretrained_embedding_model/{model_name}/evaluation/{job_id}",
+                    params={"model_name": self.name, "job_id": job_id},
                 )["result"]
             elif isinstance(self, FinetunedEmbeddingModel):
-                res = orca_api.GET(
-                    "/finetuned_embedding_model/{name_or_id}/evaluation/{task_id}",
-                    params={"name_or_id": self.id, "task_id": task_id},
+                res = client.GET(
+                    "/finetuned_embedding_model/{name_or_id}/evaluation/{job_id}",
+                    params={"name_or_id": self.id, "job_id": job_id},
                 )["result"]
             else:
                 raise ValueError("Invalid embedding model")
@@ -260,7 +264,7 @@ class EmbeddingModelBase(ABC):
                 )
             )
 
-        job = Job(response["task_id"], lambda: get_result(response["task_id"]))
+        job = Job(response["job_id"], lambda: get_result(response["job_id"]))
         return job if background else job.result()
 
 
@@ -401,7 +405,8 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
         Returns:
             A list of all pretrained embedding models available in the OrcaCloud
         """
-        return [cls(metadata) for metadata in orca_api.GET("/pretrained_embedding_model")]
+        client = OrcaClient._resolve_client()
+        return [cls(metadata) for metadata in client.GET("/pretrained_embedding_model")]
 
     _instances: dict[str, PretrainedEmbeddingModel] = {}
 
@@ -410,7 +415,8 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
         # for internal use only, do not document - we want people to use dot notation to get the model
         cache_key = str(name)
         if cache_key not in cls._instances:
-            metadata = orca_api.GET(
+            client = OrcaClient._resolve_client()
+            metadata = client.GET(
                 "/pretrained_embedding_model/{model_name}",
                 params={"model_name": name},
             )
@@ -457,12 +463,13 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
     def finetune(
         self,
         name: str,
-        train_datasource: Datasource | LabeledMemoryset,
+        train_datasource: Datasource | LabeledMemoryset | ScoredMemoryset,
         *,
         eval_datasource: Datasource | None = None,
         label_column: str = "label",
+        score_column: str = "score",
         value_column: str = "value",
-        training_method: EmbeddingFinetuningMethod = "classification",
+        training_method: EmbeddingFinetuningMethod | None = None,
         training_args: dict | None = None,
         if_exists: CreateMode = "error",
         background: Literal[True],
@@ -473,12 +480,13 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
     def finetune(
         self,
         name: str,
-        train_datasource: Datasource | LabeledMemoryset,
+        train_datasource: Datasource | LabeledMemoryset | ScoredMemoryset,
         *,
         eval_datasource: Datasource | None = None,
         label_column: str = "label",
+        score_column: str = "score",
         value_column: str = "value",
-        training_method: EmbeddingFinetuningMethod = "classification",
+        training_method: EmbeddingFinetuningMethod | None = None,
         training_args: dict | None = None,
         if_exists: CreateMode = "error",
         background: Literal[False] = False,
@@ -488,12 +496,13 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
     def finetune(
         self,
         name: str,
-        train_datasource: Datasource | LabeledMemoryset,
+        train_datasource: Datasource | LabeledMemoryset | ScoredMemoryset,
         *,
         eval_datasource: Datasource | None = None,
         label_column: str = "label",
+        score_column: str = "score",
         value_column: str = "value",
-        training_method: EmbeddingFinetuningMethod = "classification",
+        training_method: EmbeddingFinetuningMethod | None = None,
         training_args: dict | None = None,
         if_exists: CreateMode = "error",
         background: bool = False,
@@ -505,9 +514,10 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
             name: Name of the finetuned embedding model
             train_datasource: Data to train on
             eval_datasource: Optionally provide data to evaluate on
-            label_column: Column name of the label
+            label_column: Column name of the label.
+            score_column: Column name of the score (for regression when training on scored data).
             value_column: Column name of the value
-            training_method: Training method to use
+            training_method: Optional training method override. If omitted, Lighthouse defaults apply.
             training_args: Optional override for Hugging Face [`TrainingArguments`][transformers.TrainingArguments].
                 If not provided, reasonable training arguments will be used for the specified training method
             if_exists: What to do if a finetuned embedding model with the same name already exists, defaults to
@@ -538,29 +548,33 @@ class PretrainedEmbeddingModel(EmbeddingModelBase):
 
             return existing
 
-        from .memoryset import LabeledMemoryset
+        from .memoryset import LabeledMemoryset, ScoredMemoryset
 
         payload: FinetuneEmbeddingModelRequest = {
             "name": name,
             "base_model": self.name,
             "label_column": label_column,
+            "score_column": score_column,
             "value_column": value_column,
-            "training_method": training_method,
             "training_args": training_args or {},
         }
+        if training_method is not None:
+            payload["training_method"] = training_method
+
         if isinstance(train_datasource, Datasource):
             payload["train_datasource_name_or_id"] = train_datasource.id
-        elif isinstance(train_datasource, LabeledMemoryset):
+        elif isinstance(train_datasource, (LabeledMemoryset, ScoredMemoryset)):
             payload["train_memoryset_name_or_id"] = train_datasource.id
         if eval_datasource is not None:
             payload["eval_datasource_name_or_id"] = eval_datasource.id
 
-        res = orca_api.POST(
+        client = OrcaClient._resolve_client()
+        res = client.POST(
             "/finetuned_embedding_model",
             json=payload,
         )
         job = Job(
-            res["finetuning_task_id"],
+            res["finetuning_job_id"],
             lambda: FinetunedEmbeddingModel.open(res["id"]),
         )
         return job if background else job.result()
@@ -630,7 +644,8 @@ class FinetunedEmbeddingModel(EmbeddingModelBase):
         Returns:
             A list of all finetuned embedding model handles in the OrcaCloud
         """
-        return [cls(metadata) for metadata in orca_api.GET("/finetuned_embedding_model")]
+        client = OrcaClient._resolve_client()
+        return [cls(metadata) for metadata in client.GET("/finetuned_embedding_model")]
 
     @classmethod
     def open(cls, name: str) -> FinetunedEmbeddingModel:
@@ -646,7 +661,8 @@ class FinetunedEmbeddingModel(EmbeddingModelBase):
         Raises:
             LookupError: If the finetuned embedding model does not exist
         """
-        metadata = orca_api.GET(
+        client = OrcaClient._resolve_client()
+        metadata = client.GET(
             "/finetuned_embedding_model/{name_or_id}",
             params={"name_or_id": name},
         )
@@ -681,7 +697,8 @@ class FinetunedEmbeddingModel(EmbeddingModelBase):
             LookupError: If the finetuned embedding model does not exist and `if_not_exists` is `"error"`
         """
         try:
-            orca_api.DELETE(
+            client = OrcaClient._resolve_client()
+            client.DELETE(
                 "/finetuned_embedding_model/{name_or_id}",
                 params={"name_or_id": name_or_id},
             )

orca_sdk/embedding_model_test.py

@@ -25,9 +25,10 @@ def test_open_pretrained_model():
     assert model is PretrainedEmbeddingModel.GTE_BASE
 
 
-def test_open_pretrained_model_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        PretrainedEmbeddingModel.GTE_BASE.embed("I love this airline")
+def test_open_pretrained_model_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            PretrainedEmbeddingModel.GTE_BASE.embed("I love this airline")
 
 
 def test_open_pretrained_model_not_found():
@@ -52,9 +53,10 @@ def test_embed_text():
     assert isinstance(embedding[0], float)
 
 
-def test_embed_text_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        PretrainedEmbeddingModel.GTE_BASE.embed("I love this airline", max_seq_length=32)
+def test_embed_text_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            PretrainedEmbeddingModel.GTE_BASE.embed("I love this airline", max_seq_length=32)
 
 
 def test_evaluate_pretrained_model(datasource: Datasource):
@@ -108,9 +110,10 @@ def test_finetune_model_already_exists_return(datasource: Datasource, finetuned_
     assert new_model._status == Status.COMPLETED
 
 
-def test_finetune_model_unauthenticated(unauthenticated, datasource: Datasource):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        PretrainedEmbeddingModel.DISTILBERT.finetune("test_finetuned_model_unauthenticated", datasource)
+def test_finetune_model_unauthenticated(unauthenticated_client, datasource: Datasource):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            PretrainedEmbeddingModel.DISTILBERT.finetune("test_finetuned_model_unauthenticated", datasource)
 
 
 def test_use_finetuned_model_in_memoryset(datasource: Datasource, finetuned_model: FinetunedEmbeddingModel):
@@ -150,13 +153,15 @@ def test_all_finetuned_models(finetuned_model: FinetunedEmbeddingModel):
     assert any(model.name == finetuned_model.name for model in models)
 
 
-def test_all_finetuned_models_unauthenticated(unauthenticated):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        FinetunedEmbeddingModel.all()
+def test_all_finetuned_models_unauthenticated(unauthenticated_client):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            FinetunedEmbeddingModel.all()
 
 
-def test_all_finetuned_models_unauthorized(unauthorized, finetuned_model: FinetunedEmbeddingModel):
-    assert finetuned_model not in FinetunedEmbeddingModel.all()
+def test_all_finetuned_models_unauthorized(unauthorized_client, finetuned_model: FinetunedEmbeddingModel):
+    with unauthorized_client.use():
+        assert finetuned_model not in FinetunedEmbeddingModel.all()
 
 
 def test_drop_finetuned_model(datasource: Datasource):
@@ -167,9 +172,10 @@ def test_drop_finetuned_model(datasource: Datasource):
         FinetunedEmbeddingModel.open("finetuned_model_to_delete")
 
 
-def test_drop_finetuned_model_unauthenticated(unauthenticated, datasource: Datasource):
-    with pytest.raises(ValueError, match="Invalid API key"):
-        PretrainedEmbeddingModel.DISTILBERT.finetune("finetuned_model_to_delete", datasource)
+def test_drop_finetuned_model_unauthenticated(unauthenticated_client, datasource: Datasource):
+    with unauthenticated_client.use():
+        with pytest.raises(ValueError, match="Invalid API key"):
+            PretrainedEmbeddingModel.DISTILBERT.finetune("finetuned_model_to_delete", datasource)
 
 
 def test_drop_finetuned_model_not_found():
@@ -179,9 +185,10 @@ def test_drop_finetuned_model_not_found():
     FinetunedEmbeddingModel.drop(str(uuid4()), if_not_exists="ignore")
 
 
-def test_drop_finetuned_model_unauthorized(unauthorized, finetuned_model: FinetunedEmbeddingModel):
-    with pytest.raises(LookupError):
-        FinetunedEmbeddingModel.drop(finetuned_model.id)
+def test_drop_finetuned_model_unauthorized(unauthorized_client, finetuned_model: FinetunedEmbeddingModel):
+    with unauthorized_client.use():
+        with pytest.raises(LookupError):
+            FinetunedEmbeddingModel.drop(finetuned_model.id)
 
 
 def test_supports_instructions():