retab 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

{uiform → retab}/client.py

@@ -1,16 +1,16 @@
 import json
 import os
 from types import TracebackType
-from typing import Any, AsyncIterator, BinaryIO, Iterator, List, Optional
+from typing import Any, AsyncIterator, Iterator, Optional
 
 import backoff
 import backoff.types
 import httpx
+import truststore
 from pydantic_core import PydanticUndefined
 
-from .resources import processors, consensus, documents, evals, files, finetuning, models, schemas, secrets, usage
+from .resources import consensus, documents, evals, files, finetuning, models, processors, schemas, secrets, usage, evaluations
 from .types.standards import PreparedRequest
-import truststore
 
 
 class MaxRetriesExceeded(Exception):
@@ -70,7 +70,6 @@ class BaseUiForm:
         if base_url is None:
             base_url = os.environ.get("UIFORM_API_BASE_URL", "https://api.uiform.com")
 
-
         truststore.inject_into_ssl()
         self.api_key = api_key
         self.base_url = base_url.rstrip("/")
@@ -84,26 +83,26 @@ class BaseUiForm:
         # Only check environment variables if the value is PydanticUndefined
         if openai_api_key is PydanticUndefined:
             openai_api_key = os.environ.get("OPENAI_API_KEY")
-        
+
         # if claude_api_key is PydanticUndefined:
         #    claude_api_key = os.environ.get("CLAUDE_API_KEY")
-        
+
         # if xai_api_key is PydanticUndefined:
         #    xai_api_key = os.environ.get("XAI_API_KEY")
-        
+
         if gemini_api_key is PydanticUndefined:
             gemini_api_key = os.environ.get("GEMINI_API_KEY")
 
         # Only add headers if the values are actual strings (not None or PydanticUndefined)
         if openai_api_key and openai_api_key is not PydanticUndefined:
             self.headers["OpenAI-Api-Key"] = openai_api_key
-        
+
         # if claude_api_key and claude_api_key is not PydanticUndefined:
         #    self.headers["Anthropic-Api-Key"] = claude_api_key
-        
+
         if xai_api_key and xai_api_key is not PydanticUndefined:
             self.headers["XAI-Api-Key"] = xai_api_key
-        
+
         if gemini_api_key and gemini_api_key is not PydanticUndefined:
             self.headers["Gemini-Api-Key"] = gemini_api_key
 
@@ -126,12 +125,12 @@ class BaseUiForm:
 
     def _parse_response(self, response: httpx.Response) -> Any:
         """Parse response based on content-type.
-        
+
         Returns:
             Any: Parsed JSON object for JSON responses, raw text string for text responses
         """
         content_type = response.headers.get("content-type", "")
-        
+
         # Check if it's a JSON response
         if "application/json" in content_type or "application/stream+json" in content_type:
             return response.json()
@@ -198,6 +197,7 @@ class UiForm(BaseUiForm):
 
         self.client = httpx.Client(timeout=self.timeout)
         self.evals = evals.Evals(client=self)
+        self.evaluations = evaluations.Evaluations(client=self)
         self.files = files.Files(client=self)
         self.fine_tuning = finetuning.FineTuning(client=self)
         # self.prompt_optimization = prompt_optimization.PromptOptimization(client=self)
@@ -247,7 +247,7 @@ class UiForm(BaseUiForm):
                 "params": params,
                 "headers": self._get_headers(idempotency_key),
             }
-            
+
             # Handle different content types
             if files or form_data:
                 # For multipart/form-data requests
@@ -262,7 +262,7 @@ class UiForm(BaseUiForm):
             elif data:
                 # For JSON requests
                 request_kwargs["json"] = data
-            
+
             response = self.client.request(**request_kwargs)
             self._validate_response(response)
             return self._parse_response(response)
@@ -314,7 +314,7 @@ class UiForm(BaseUiForm):
                 "params": params,
                 "headers": self._get_headers(idempotency_key),
             }
-            
+
             # Handle different content types
             if files or form_data:
                 # For multipart/form-data requests
@@ -329,10 +329,10 @@ class UiForm(BaseUiForm):
             elif data:
                 # For JSON requests
                 stream_kwargs["json"] = data
-            
+
             with self.client.stream(**stream_kwargs) as response_ctx_manager:
                 self._validate_response(response_ctx_manager)
-                
+
                 content_type = response_ctx_manager.headers.get("content-type", "")
                 is_json_stream = "application/json" in content_type or "application/stream+json" in content_type
                 is_text_stream = "text/plain" in content_type or ("text/" in content_type and not is_json_stream)
@@ -340,7 +340,7 @@ class UiForm(BaseUiForm):
                 for chunk in response_ctx_manager.iter_lines():
                     if not chunk:
                         continue
-                    
+
                     if is_json_stream:
                         try:
                             yield json.loads(chunk)
@@ -375,7 +375,7 @@ class UiForm(BaseUiForm):
             form_data=request.form_data,
             files=request.files,
             idempotency_key=request.idempotency_key,
-            raise_for_status=request.raise_for_status
+            raise_for_status=request.raise_for_status,
         )
 
     def _prepared_request_stream(self, request: PreparedRequest) -> Iterator[Any]:
@@ -387,7 +387,7 @@ class UiForm(BaseUiForm):
             form_data=request.form_data,
             files=request.files,
             idempotency_key=request.idempotency_key,
-            raise_for_status=request.raise_for_status
+            raise_for_status=request.raise_for_status,
         ):
             yield item
 
@@ -466,6 +466,7 @@ class AsyncUiForm(BaseUiForm):
         self.client = httpx.AsyncClient(timeout=self.timeout)
 
         self.evals = evals.AsyncEvals(client=self)
+        self.evaluations = evaluations.AsyncEvaluations(client=self)
         self.files = files.AsyncFiles(client=self)
         self.fine_tuning = finetuning.AsyncFineTuning(client=self)
         # self.prompt_optimization = prompt_optimization.AsyncPromptOptimization(client=self)
@@ -479,12 +480,12 @@ class AsyncUiForm(BaseUiForm):
 
     def _parse_response(self, response: httpx.Response) -> Any:
         """Parse response based on content-type.
-        
+
         Returns:
             Any: Parsed JSON object for JSON responses, raw text string for text responses
         """
         content_type = response.headers.get("content-type", "")
-        
+
         # Check if it's a JSON response
         if "application/json" in content_type or "application/stream+json" in content_type:
             return response.json()
@@ -536,7 +537,7 @@ class AsyncUiForm(BaseUiForm):
                 "params": params,
                 "headers": self._get_headers(idempotency_key),
             }
-            
+
             # Handle different content types
             if files or form_data:
                 # For multipart/form-data requests
@@ -551,7 +552,7 @@ class AsyncUiForm(BaseUiForm):
             elif data:
                 # For JSON requests
                 request_kwargs["json"] = data
-            
+
             response = await self.client.request(**request_kwargs)
             self._validate_response(response)
             return self._parse_response(response)
@@ -602,7 +603,7 @@ class AsyncUiForm(BaseUiForm):
                 "params": params,
                 "headers": self._get_headers(idempotency_key),
             }
-            
+
             # Handle different content types
             if files or form_data:
                 # For multipart/form-data requests
@@ -617,18 +618,18 @@ class AsyncUiForm(BaseUiForm):
             elif data:
                 # For JSON requests
                 stream_kwargs["json"] = data
-            
+
             async with self.client.stream(**stream_kwargs) as response_ctx_manager:
                 self._validate_response(response_ctx_manager)
-                
+
                 content_type = response_ctx_manager.headers.get("content-type", "")
                 is_json_stream = "application/json" in content_type or "application/stream+json" in content_type
                 is_text_stream = "text/plain" in content_type or ("text/" in content_type and not is_json_stream)
-                
+
                 async for chunk in response_ctx_manager.aiter_lines():
                     if not chunk:
                         continue
-                    
+
                     if is_json_stream:
                         try:
                             yield json.loads(chunk)
@@ -662,7 +663,7 @@ class AsyncUiForm(BaseUiForm):
             form_data=request.form_data,
             files=request.files,
             idempotency_key=request.idempotency_key,
-            raise_for_status=request.raise_for_status
+            raise_for_status=request.raise_for_status,
         )
 
     async def _prepared_request_stream(self, request: PreparedRequest) -> AsyncIterator[Any]:
@@ -674,7 +675,7 @@ class AsyncUiForm(BaseUiForm):
             form_data=request.form_data,
             files=request.files,
             idempotency_key=request.idempotency_key,
-            raise_for_status=request.raise_for_status
+            raise_for_status=request.raise_for_status,
         ):
             yield item
 

{uiform → retab}/resources/consensus/client.py

@@ -1,15 +1,13 @@
 from typing import Any, Dict, List, Literal, Optional
 
-from pydantic import BaseModel, Field
-
 from ..._resource import AsyncAPIResource, SyncAPIResource
+from ...types.consensus import ReconciliationResponse, ReconciliationRequest
 from ...types.standards import PreparedRequest
 from .completions import AsyncCompletions, Completions
 from .responses import AsyncResponses, Responses
-from ...types.consensus import ReconciliationResponse
 
-class BaseConsensusMixin:
 
+class BaseConsensusMixin:
     def _prepare_reconcile(
         self,
         list_dicts: List[Dict[str, Any]],
@@ -17,21 +15,15 @@ class BaseConsensusMixin:
         mode: Literal["direct", "aligned"] = "direct",
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
-        data = {
-            "list_dicts": list_dicts,
-            "mode": mode,
-        }
-        
-        if reference_schema is not None:
-            data["reference_schema"] = reference_schema
-            
-        return PreparedRequest(
-            method="POST", 
-            url="/v1/consensus/reconcile", 
-            data=data, 
-            idempotency_key=idempotency_key
+        request = ReconciliationRequest(
+            list_dicts=list_dicts,
+            reference_schema=reference_schema,
+            mode=mode,
         )
 
+        return PreparedRequest(method="POST", url="/v1/consensus/reconcile", data=request.model_dump(), idempotency_key=idempotency_key)
+
+
 class Consensus(SyncAPIResource, BaseConsensusMixin):
     """Consensus API wrapper for synchronous operations"""
 
@@ -49,25 +41,20 @@ class Consensus(SyncAPIResource, BaseConsensusMixin):
     ) -> ReconciliationResponse:
         """
         Reconcile multiple dictionaries to produce a single unified consensus dictionary.
-        
+
         Args:
             list_dicts: List of dictionaries to reconcile
             reference_schema: Optional schema to validate dictionaries against
             mode: Mode for consensus computation ("direct" or "aligned")
             idempotency_key: Optional idempotency key for the request
-            
+
         Returns:
             Dict containing the consensus dictionary and consensus likelihoods
-            
+
         Raises:
             UiformAPIError: If the API request fails
         """
-        request = self._prepare_reconcile(
-            list_dicts, 
-            reference_schema, 
-            mode, 
-            idempotency_key
-        )
+        request = self._prepare_reconcile(list_dicts, reference_schema, mode, idempotency_key)
         response = self._client._prepared_request(request)
         return ReconciliationResponse.model_validate(response)
 
@@ -80,7 +67,6 @@ class AsyncConsensus(AsyncAPIResource, BaseConsensusMixin):
         self.completions = AsyncCompletions(client=client)
         self.responses = AsyncResponses(client=client)
 
-    
     async def reconcile(
         self,
         list_dicts: List[Dict[str, Any]],
@@ -90,25 +76,20 @@ class AsyncConsensus(AsyncAPIResource, BaseConsensusMixin):
     ) -> ReconciliationResponse:
         """
         Reconcile multiple dictionaries to produce a single unified consensus dictionary asynchronously.
-        
+
         Args:
             list_dicts: List of dictionaries to reconcile
             reference_schema: Optional schema to validate dictionaries against
             mode: Mode for consensus computation ("direct" or "aligned")
             idempotency_key: Optional idempotency key for the request
-            
+
         Returns:
             Dict containing the consensus dictionary and consensus likelihoods
-            
+
         Raises:
             UiformAPIError: If the API request fails
         """
-        request = self._prepare_reconcile(
-            list_dicts, 
-            reference_schema, 
-            mode, 
-            idempotency_key
-        )
+        request = self._prepare_reconcile(list_dicts, reference_schema, mode, idempotency_key)
         response = await self._client._prepared_request(request)
 
         return ReconciliationResponse.model_validate(response)

{uiform → retab}/resources/consensus/completions.py

@@ -1,28 +1,19 @@
-import json
-from pathlib import Path
-from typing import Any, AsyncGenerator, Generator
-
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
-from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
-#from openai.lib._parsing import ResponseFormatT
-from pydantic import BaseModel as ResponseFormatT
 
+# from openai.lib._parsing import ResponseFormatT
+from pydantic import BaseModel as ResponseFormatT
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ..._utils.json_schema import load_json_schema, unflatten_dict
-from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
 from ...types.chat import ChatCompletionUiformMessage
 from ...types.completions import UiChatCompletionsRequest
-from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
-from ...types.standards import PreparedRequest
+from ...types.documents.extractions import UiParsedChatCompletion
 from ...types.schemas.object import Schema
-
+from ...types.standards import PreparedRequest
 
 
 class BaseCompletionsMixin:
-
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
@@ -40,9 +31,10 @@ class BaseCompletionsMixin:
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -50,18 +42,12 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
-
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
     def prepare_create(
         self,
@@ -74,16 +60,16 @@ class BaseCompletionsMixin:
         n_consensus: int,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
-        
         json_schema = response_format["json_schema"].get("schema")
 
         assert isinstance(json_schema, dict), f"json_schema must be a dictionary, got {type(json_schema)}"
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -91,17 +77,12 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
 
 class Completions(SyncAPIResource, BaseCompletionsMixin):
@@ -137,7 +118,6 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 
         return UiParsedChatCompletion.model_validate(response)
 
-
     def parse(
         self,
         response_format: type[ResponseFormatT],
@@ -210,9 +190,6 @@ class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
         response = await self._client._prepared_request(request)
         return UiParsedChatCompletion.model_validate(response)
 
-
-
-
     async def parse(
         self,
         response_format: type[ResponseFormatT],

{uiform → retab}/resources/consensus/completions_stream.py

@@ -1,28 +1,25 @@
 import json
-from pathlib import Path
-from typing import Any, AsyncGenerator, Generator
+from typing import AsyncGenerator, Generator
 
 from openai.types.chat.chat_completion_reasoning_effort import ChatCompletionReasoningEffort
 from openai.types.chat.parsed_chat_completion import ParsedChatCompletionMessage
 from openai.types.shared_params.response_format_json_schema import ResponseFormatJSONSchema
-#from openai.lib._parsing import ResponseFormatT
-from pydantic import BaseModel as ResponseFormatT
 
+# from openai.lib._parsing import ResponseFormatT
+from pydantic import BaseModel as ResponseFormatT
 
 from ..._resource import AsyncAPIResource, SyncAPIResource
 from ..._utils.ai_models import assert_valid_model_extraction
-from ..._utils.json_schema import load_json_schema, unflatten_dict
+from ..._utils.json_schema import unflatten_dict
 from ..._utils.stream_context_managers import as_async_context_manager, as_context_manager
 from ...types.chat import ChatCompletionUiformMessage
 from ...types.completions import UiChatCompletionsRequest
 from ...types.documents.extractions import UiParsedChatCompletion, UiParsedChatCompletionChunk, UiParsedChoice
-from ...types.standards import PreparedRequest
 from ...types.schemas.object import Schema
-
+from ...types.standards import PreparedRequest
 
 
 class BaseCompletionsMixin:
-
     def prepare_parse(
         self,
         response_format: type[ResponseFormatT],
@@ -37,12 +34,11 @@ class BaseCompletionsMixin:
         assert_valid_model_extraction(model)
 
         json_schema = response_format.model_json_schema()
-
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        request = UiChatCompletionsRequest(
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -50,18 +46,14 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
-
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+            model=model,
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
 
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
     def prepare_create(
         self,
@@ -74,16 +66,17 @@ class BaseCompletionsMixin:
         n_consensus: int,
         idempotency_key: str | None = None,
     ) -> PreparedRequest:
-        
         json_schema = response_format["json_schema"].get("schema")
 
         assert isinstance(json_schema, dict), f"json_schema must be a dictionary, got {type(json_schema)}"
 
         schema_obj = Schema(json_schema=json_schema)
 
-        data = {
-            "messages": messages,
-            "response_format": {
+        # Validate DocumentAPIRequest data (raises exception if invalid)
+        request = UiChatCompletionsRequest(
+            model=model,
+            messages=messages,
+            response_format={
                 "type": "json_schema",
                 "json_schema": {
                     "name": schema_obj.id,
@@ -91,17 +84,13 @@ class BaseCompletionsMixin:
                     "strict": True,
                 },
             },
-            "model": model,
-            "temperature": temperature,
-            "stream": stream,
-            "reasoning_effort": reasoning_effort,
-            "n_consensus": n_consensus,
-        }
-
-        # Validate DocumentAPIRequest data (raises exception if invalid)
-        ui_chat_completions_request = UiChatCompletionsRequest.model_validate(data)
+            temperature=temperature,
+            stream=stream,
+            reasoning_effort=reasoning_effort,
+            n_consensus=n_consensus,
+        )
 
-        return PreparedRequest(method="POST", url="/v1/completions", data=ui_chat_completions_request.model_dump(), idempotency_key=idempotency_key)
+        return PreparedRequest(method="POST", url="/v1/completions", data=request.model_dump(), idempotency_key=idempotency_key)
 
 
 class Completions(SyncAPIResource, BaseCompletionsMixin):
@@ -193,7 +182,6 @@ class Completions(SyncAPIResource, BaseCompletionsMixin):
 class AsyncCompletions(AsyncAPIResource, BaseCompletionsMixin):
     """Multi-provider Completions API wrapper for asynchronous usage."""
 
-   
     @as_async_context_manager
     async def stream(
         self,