retab 0.0.42__py3-none-any.whl → 0.0.44__py3-none-any.whl

retab/resources/evaluations/client.py

@@ -1,38 +1,38 @@
 from typing import Any, Dict, List
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
-from ...types.evaluations import Evaluation, PatchEvaluationRequest, ListEvaluationParams, CreateEvaluation
+from ...types.projects import Project, PatchProjectRequest, ListProjectParams, BaseProject
 from ...types.inference_settings import InferenceSettings
 from ...types.standards import PreparedRequest, DeleteResponse, FieldUnset
 from .documents import Documents, AsyncDocuments
 from .iterations import Iterations, AsyncIterations
 
 
-class EvaluationsMixin:
+class ProjectsMixin:
     def prepare_create(
         self,
         name: str,
         json_schema: dict[str, Any],
-        project_id: str = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
     ) -> PreparedRequest:
-        # Use CreateEvaluation model
-        eval_data = CreateEvaluation(
-            name=name,
-            json_schema=json_schema,
-            project_id=project_id,
-            default_inference_settings=default_inference_settings,
-        )
-        return PreparedRequest(method="POST", url="/v1/evaluations", data=eval_data.model_dump(exclude_none=True, mode="json"))
+        # Use BaseProject model
+        eval_dict = {
+            "name": name,
+            "json_schema": json_schema,
+        }
+        if default_inference_settings is not FieldUnset:
+            eval_dict["default_inference_settings"] = default_inference_settings
+
+        eval_data = BaseProject(**eval_dict)
+        return PreparedRequest(method="POST", url="/v1/evaluations", data=eval_data.model_dump(exclude_unset=True, mode="json"))
 
     def prepare_get(self, evaluation_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}")
 
     def prepare_update(
         self,
         evaluation_id: str,
         name: str = FieldUnset,
-        project_id: str = FieldUnset,
         json_schema: dict[str, Any] = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
     ) -> PreparedRequest:
@@ -42,41 +42,39 @@ class EvaluationsMixin:
         Only the provided fields will be updated. Fields set to None will be excluded from the update.
         """
         # Build a dictionary with only the provided fields
-        data = PatchEvaluationRequest(
-            name=name,
-            project_id=project_id,
-            json_schema=json_schema,
-            default_inference_settings=default_inference_settings,
-        ).model_dump(exclude_unset=True, mode="json")
+        update_dict = {}
+        if name is not FieldUnset:
+            update_dict["name"] = name
+        if json_schema is not FieldUnset:
+            update_dict["json_schema"] = json_schema
+        if default_inference_settings is not FieldUnset:
+            update_dict["default_inference_settings"] = default_inference_settings
 
-        return PreparedRequest(method="PATCH", url=f"/v1/evaluations/{evaluation_id}", data=data)
+        data = PatchProjectRequest(**update_dict).model_dump(exclude_unset=True, mode="json")
 
-    def prepare_list(self, project_id: str = FieldUnset) -> PreparedRequest:
+        return PreparedRequest(method="PATCH", url=f"/v1/projects/{evaluation_id}", data=data)
+
+    def prepare_list(self) -> PreparedRequest:
         """
         Prepare a request to list evaluations.
 
         Usage:
-        >>> client.evals.list(project_id="project_id")   # List all evaluations for a project
-        >>> client.evals.list()                          # List all evaluations (no project_id)
-
-        This does not work:
-        >>> client.evals.list(project_id=None)
-
-        Args:
-            project_id: The project ID to list evaluations for
+        >>> client.evaluations.list()                          # List all evaluations
 
         Returns:
             PreparedRequest: The prepared request
         """
-        params = ListEvaluationParams(project_id=project_id).model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
+        params_dict = {}
+
+        params = ListProjectParams(**params_dict).model_dump(exclude_unset=True, exclude_defaults=True, mode="json")
         return PreparedRequest(method="GET", url="/v1/evaluations", params=params)
 
     def prepare_delete(self, id: str) -> PreparedRequest:
-        return PreparedRequest(method="DELETE", url=f"/v1/evaluations/{id}")
+        return PreparedRequest(method="DELETE", url=f"/v1/projects/{id}")
 
 
-class Evaluations(SyncAPIResource, EvaluationsMixin):
-    """Evaluations API wrapper"""
+class Projects(SyncAPIResource, ProjectsMixin):
+    """Projects API wrapper"""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -87,29 +85,27 @@ class Evaluations(SyncAPIResource, EvaluationsMixin):
         self,
         name: str,
         json_schema: dict[str, Any],
-        project_id: str = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
-    ) -> Evaluation:
+    ) -> Project:
         """
         Create a new evaluation.
 
         Args:
             name: The name of the evaluation
             json_schema: The JSON schema for the evaluation
-            project_id: The project ID to associate with the evaluation
             documents: The documents to associate with the evaluation
             default_inference_settings: The default inference settings to associate with the evaluation
 
         Returns:
-            Evaluation: The created evaluation
+            Project: The created evaluation
         Raises:
             HTTPException if the request fails
         """
-        request = self.prepare_create(name, json_schema, project_id, default_inference_settings=default_inference_settings)
+        request = self.prepare_create(name, json_schema, default_inference_settings=default_inference_settings)
         response = self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
-    def get(self, evaluation_id: str) -> Evaluation:
+    def get(self, evaluation_id: str) -> Project:
         """
         Get an evaluation by ID.
 
@@ -117,64 +113,59 @@ class Evaluations(SyncAPIResource, EvaluationsMixin):
             evaluation_id: The ID of the evaluation to retrieve
 
         Returns:
-            Evaluation: The evaluation
+            Project: The evaluation
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_get(evaluation_id)
         response = self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
     def update(
         self,
         evaluation_id: str,
         name: str = FieldUnset,
-        project_id: str = FieldUnset,
         json_schema: dict[str, Any] = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
-    ) -> Evaluation:
+    ) -> Project:
         """
         Update an evaluation with partial updates.
 
         Args:
             evaluation_id: The ID of the evaluation to update
             name: Optional new name for the evaluation
-            project_id: Optional new project ID
             json_schema: Optional new JSON schema
             documents: Optional list of documents to update
             iterations: Optional list of iterations to update
             default_inference_settings: Optional annotation properties
 
         Returns:
-            Evaluation: The updated evaluation
+            Project: The updated evaluation
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_update(
             evaluation_id=evaluation_id,
             name=name,
-            project_id=project_id,
             json_schema=json_schema,
             default_inference_settings=default_inference_settings,
         )
         response = self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
-    def list(self, project_id: str = FieldUnset) -> List[Evaluation]:
+    def list(self) -> List[Project]:
         """
         List evaluations for a project.
 
         Args:
-            project_id: The project ID to list evaluations for
-
         Returns:
-            List[Evaluation]: List of evaluations
+            List[Project]: List of evaluations
         Raises:
             HTTPException if the request fails
         """
-        request = self.prepare_list(project_id)
+        request = self.prepare_list()
         response = self._client._prepared_request(request)
-        return [Evaluation(**item) for item in response.get("data", [])]
+        return [Project(**item) for item in response.get("data", [])]
 
     def delete(self, evaluation_id: str) -> DeleteResponse:
         """
@@ -192,33 +183,32 @@ class Evaluations(SyncAPIResource, EvaluationsMixin):
         return self._client._prepared_request(request)
 
 
-class AsyncEvaluations(AsyncAPIResource, EvaluationsMixin):
-    """Async Evaluations API wrapper"""
+class AsyncProjects(AsyncAPIResource, ProjectsMixin):
+    """Async Projects API wrapper"""
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.documents = AsyncDocuments(self._client)
         self.iterations = AsyncIterations(self._client)
 
-    async def create(self, name: str, json_schema: Dict[str, Any], project_id: str = FieldUnset) -> Evaluation:
+    async def create(self, name: str, json_schema: Dict[str, Any]) -> Project:
         """
         Create a new evaluation.
 
         Args:
             name: The name of the evaluation
             json_schema: The JSON schema for the evaluation
-            project_id: The project ID to associate with the evaluation
 
         Returns:
-            Evaluation: The created evaluation
+            Project: The created evaluation
         Raises:
             HTTPException if the request fails
         """
-        request = self.prepare_create(name, json_schema, project_id=project_id)
+        request = self.prepare_create(name, json_schema)
         response = await self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
-    async def get(self, evaluation_id: str) -> Evaluation:
+    async def get(self, evaluation_id: str) -> Project:
         """
         Get an evaluation by ID.
 
@@ -226,64 +216,58 @@ class AsyncEvaluations(AsyncAPIResource, EvaluationsMixin):
             evaluation_id: The ID of the evaluation to retrieve
 
         Returns:
-            Evaluation: The evaluation
+            Project: The evaluation
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_get(evaluation_id)
         response = await self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
     async def update(
         self,
         evaluation_id: str,
         name: str = FieldUnset,
-        project_id: str = FieldUnset,
         json_schema: dict[str, Any] = FieldUnset,
         default_inference_settings: InferenceSettings = FieldUnset,
-    ) -> Evaluation:
+    ) -> Project:
         """
         Update an evaluation with partial updates.
 
         Args:
             id: The ID of the evaluation to update
             name: Optional new name for the evaluation
-            project_id: Optional new project ID
             json_schema: Optional new JSON schema
             documents: Optional list of documents to update
             iterations: Optional list of iterations to update
             default_inference_settings: Optional annotation properties
 
         Returns:
-            Evaluation: The updated evaluation
+            Project: The updated evaluation
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_update(
             evaluation_id=evaluation_id,
             name=name,
-            project_id=project_id,
             json_schema=json_schema,
             default_inference_settings=default_inference_settings,
         )
         response = await self._client._prepared_request(request)
-        return Evaluation(**response)
+        return Project(**response)
 
-    async def list(self, project_id: str = FieldUnset) -> List[Evaluation]:
+    async def list(self) -> List[Project]:
         """
         List evaluations for a project.
 
-        Args:
-            project_id: The project ID to list evaluations for
-
         Returns:
-            List[Evaluation]: List of evaluations
+            List[Project]: List of evaluations
         Raises:
             HTTPException if the request fails
         """
-        request = self.prepare_list(project_id)
+        request = self.prepare_list()
         response = await self._client._prepared_request(request)
-        return [Evaluation(**item) for item in response.get("data", [])]
+        return [Project(**item) for item in response.get("data", [])]
 
     async def delete(self, evaluation_id: str) -> DeleteResponse:
         """

retab/resources/evaluations/documents.py

@@ -7,7 +7,8 @@ from pydantic import HttpUrl
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ...utils.mime import prepare_mime_document
-from ...types.evaluations import DocumentItem, EvaluationDocument, PatchEvaluationDocumentRequest
+from ...types.projects import DocumentItem, ProjectDocument, PatchProjectDocumentRequest
+from ...types.predictions import PredictionMetadata
 from ...types.mime import MIMEData
 from ...types.standards import PreparedRequest, DeleteResponse, FieldUnset
 from ...types.documents.extractions import RetabParsedChatCompletion
@@ -15,33 +16,37 @@ from ...types.documents.extractions import RetabParsedChatCompletion
 
 class DocumentsMixin:
     def prepare_get(self, evaluation_id: str, document_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/documents/{document_id}")
 
-    def prepare_create(self, evaluation_id: str, document: MIMEData, annotation: dict[str, Any]) -> PreparedRequest:
+    def prepare_create(self, evaluation_id: str, document: MIMEData, annotation: dict[str, Any], annotation_metadata: dict[str, Any] | None = None) -> PreparedRequest:
         # Serialize the MIMEData
-        document_item = DocumentItem(mime_data=document, annotation=annotation, annotation_metadata=None)
-        return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/documents", data=document_item.model_dump(mode="json"))
+        document_item = DocumentItem(mime_data=document, annotation=annotation, annotation_metadata=PredictionMetadata(**annotation_metadata) if annotation_metadata else None)
+        return PreparedRequest(method="POST", url=f"/v1/projects/{evaluation_id}/documents", data=document_item.model_dump(mode="json"))
 
     def prepare_list(self, evaluation_id: str) -> PreparedRequest:
-        return PreparedRequest(method="GET", url=f"/v1/evaluations/{evaluation_id}/documents")
+        return PreparedRequest(method="GET", url=f"/v1/projects/{evaluation_id}/documents")
 
-    def prepare_update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> PreparedRequest:
-        update_request = PatchEvaluationDocumentRequest(annotation=annotation)
-        return PreparedRequest(
-            method="PATCH", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}", data=update_request.model_dump(mode="json", exclude_unset=True, exclude_defaults=True)
-        )
+    def prepare_update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> PreparedRequest:
+        update_request = PatchProjectDocumentRequest(annotation=annotation)
+        return PreparedRequest(method="PATCH", url=f"/v1/projects/{evaluation_id}/documents/{document_id}", data=update_request.model_dump(mode="json", exclude_unset=True))
 
     def prepare_delete(self, evaluation_id: str, document_id: str) -> PreparedRequest:
-        return PreparedRequest(method="DELETE", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}")
+        return PreparedRequest(method="DELETE", url=f"/v1/projects/{evaluation_id}/documents/{document_id}")
 
     def prepare_llm_annotate(self, evaluation_id: str, document_id: str) -> PreparedRequest:
-        return PreparedRequest(method="POST", url=f"/v1/evaluations/{evaluation_id}/documents/{document_id}/llm-annotate", data={"stream": False})
+        return PreparedRequest(method="POST", url=f"/v1/projects/{evaluation_id}/documents/{document_id}/llm-annotate", data={"stream": False})
 
 
 class Documents(SyncAPIResource, DocumentsMixin):
     """Documents API wrapper for evaluations"""
 
-    def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any]) -> EvaluationDocument:
+    def create(
+        self,
+        evaluation_id: str,
+        document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl],
+        annotation: Dict[str, Any],
+        annotation_metadata: Dict[str, Any] | None = None,
+    ) -> ProjectDocument:
         """
         Create a document for an evaluation.
 
@@ -56,7 +61,7 @@ class Documents(SyncAPIResource, DocumentsMixin):
             annotation: The ground truth for the document
 
         Returns:
-            EvaluationDocument: The created document
+            ProjectDocument: The created document
         Raises:
             HTTPException if the request fails
         """
@@ -64,11 +69,11 @@ class Documents(SyncAPIResource, DocumentsMixin):
         mime_document: MIMEData = prepare_mime_document(document)
 
         # Let prepare_create handle the serialization
-        request = self.prepare_create(evaluation_id, mime_document, annotation)
+        request = self.prepare_create(evaluation_id, mime_document, annotation, annotation_metadata)
         response = self._client._prepared_request(request)
-        return EvaluationDocument(**response)
+        return ProjectDocument(**response)
 
-    def list(self, evaluation_id: str) -> List[EvaluationDocument]:
+    def list(self, evaluation_id: str) -> List[ProjectDocument]:
         """
         List documents for an evaluation.
 
@@ -76,15 +81,15 @@ class Documents(SyncAPIResource, DocumentsMixin):
             evaluation_id: The ID of the evaluation
 
         Returns:
-            List[EvaluationDocument]: List of documents
+            List[ProjectDocument]: List of documents
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_list(evaluation_id)
         response = self._client._prepared_request(request)
-        return [EvaluationDocument(**item) for item in response.get("data", [])]
+        return [ProjectDocument(**item) for item in response.get("data", [])]
 
-    def get(self, evaluation_id: str, document_id: str) -> EvaluationDocument:
+    def get(self, evaluation_id: str, document_id: str) -> ProjectDocument:
         """
         Get a document by ID.
 
@@ -93,15 +98,15 @@ class Documents(SyncAPIResource, DocumentsMixin):
             document_id: The ID of the document
 
         Returns:
-            EvaluationDocument: The document
+            ProjectDocument: The document
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_get(evaluation_id, document_id)
         response = self._client._prepared_request(request)
-        return EvaluationDocument(**response)
+        return ProjectDocument(**response)
 
-    def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> EvaluationDocument:
+    def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> ProjectDocument:
         """
         Update a document.
 
@@ -110,13 +115,13 @@ class Documents(SyncAPIResource, DocumentsMixin):
             document_id: The ID of the document
             annotation: The ground truth for the document
         Returns:
-            EvaluationDocument: The updated document
+            ProjectDocument: The updated document
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_update(evaluation_id, document_id, annotation=annotation)
         response = self._client._prepared_request(request)
-        return EvaluationDocument(**response)
+        return ProjectDocument(**response)
 
     def delete(self, evaluation_id: str, document_id: str) -> DeleteResponse:
         """
@@ -146,7 +151,13 @@ class Documents(SyncAPIResource, DocumentsMixin):
 class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
     """Async Documents API wrapper for evaluations"""
 
-    async def create(self, evaluation_id: str, document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl], annotation: Dict[str, Any]) -> EvaluationDocument:
+    async def create(
+        self,
+        evaluation_id: str,
+        document: Union[Path, str, IOBase, MIMEData, PIL.Image.Image, HttpUrl],
+        annotation: Dict[str, Any],
+        annotation_metadata: Dict[str, Any] | None = None,
+    ) -> ProjectDocument:
         """
         Create a document for an evaluation.
 
@@ -159,9 +170,9 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
                 - A PIL Image object
                 - A URL (HttpUrl)
             annotation: The ground truth for the document
-
+            annotation_metadata: The metadata of the annotation
         Returns:
-            EvaluationDocument: The created document
+            ProjectDocument: The created document
         Raises:
             HTTPException if the request fails
         """
@@ -169,11 +180,11 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
         mime_document: MIMEData = prepare_mime_document(document)
 
         # Let prepare_create handle the serialization
-        request = self.prepare_create(evaluation_id, mime_document, annotation)
+        request = self.prepare_create(evaluation_id, mime_document, annotation, annotation_metadata)
         response = await self._client._prepared_request(request)
-        return EvaluationDocument(**response)
+        return ProjectDocument(**response)
 
-    async def list(self, evaluation_id: str) -> List[EvaluationDocument]:
+    async def list(self, evaluation_id: str) -> List[ProjectDocument]:
         """
         List documents for an evaluation.
 
@@ -181,15 +192,15 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
             evaluation_id: The ID of the evaluation
 
         Returns:
-            List[EvaluationDocument]: List of documents
+            List[ProjectDocument]: List of documents
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_list(evaluation_id)
         response = await self._client._prepared_request(request)
-        return [EvaluationDocument(**item) for item in response.get("data", [])]
+        return [ProjectDocument(**item) for item in response.get("data", [])]
 
-    async def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any] = FieldUnset) -> EvaluationDocument:
+    async def update(self, evaluation_id: str, document_id: str, annotation: dict[str, Any]) -> ProjectDocument:
         """
         Update a document.
 
@@ -199,13 +210,13 @@ class AsyncDocuments(AsyncAPIResource, DocumentsMixin):
             annotation: The ground truth for the document
 
         Returns:
-            EvaluationDocument: The updated document
+            ProjectDocument: The updated document
         Raises:
             HTTPException if the request fails
         """
         request = self.prepare_update(evaluation_id, document_id, annotation)
         response = await self._client._prepared_request(request)
-        return EvaluationDocument(**response)
+        return ProjectDocument(**response)
 
     async def delete(self, evaluation_id: str, document_id: str) -> DeleteResponse:
         """