synapse-sdk 1.0.0a46__tar.gz → 1.0.0a47__tar.gz

{synapse_sdk-1.0.0a46/synapse_sdk.egg-info → synapse_sdk-1.0.0a47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a46
+Version: 1.0.0a47
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/synapse_sdk/clients/backend/integration.py

@@ -1,4 +1,4 @@
-from synapse_sdk.clients.backend.models import Storage
+from synapse_sdk.clients.backend.models import Storage, UpdateJob
 from synapse_sdk.clients.base import BaseClient
 from synapse_sdk.utils.file import convert_file_to_base64
 
@@ -43,7 +43,7 @@ class IntegrationClientMixin(BaseClient):
 
     def update_job(self, pk, data):
         path = f'jobs/{pk}/'
-        return self._patch(path, data=data)
+        return self._patch(path, request_model=UpdateJob, data=data)
 
     def list_job_console_logs(self, pk):
         path = f'jobs/{pk}/console_logs/'
@@ -82,4 +82,4 @@ class IntegrationClientMixin(BaseClient):
     def get_storage(self, pk):
         """Get specific storage data from synapse backend."""
         path = f'storages/{pk}/'
-        return self._get(path, pydantic_model=Storage)
+        return self._get(path, response_model=Storage)

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/synapse_sdk/clients/backend/models.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Dict
+from typing import Dict, Optional
 
 from pydantic import BaseModel
 
@@ -42,3 +42,35 @@ class Storage(BaseModel):
     provider: StorageProvider
     configuration: Dict
     is_default: bool
+
+
+class JobStatus(str, Enum):
+    """Synapse Backend Job Status Enum."""
+
+    PENDING = 'pending'
+    RUNNING = 'running'
+    STOPPED = 'stopped'
+    SUCCEEDED = 'succeeded'
+    FAILED = 'failed'
+
+
+class UpdateJob(BaseModel):
+    """Synapse Backend Update Job Request Payload Model.
+
+    Attrs:
+        status (str): The job status. (ex: pending, running, stopped, succeeded, failed)
+        progress_record (Dict): The job progress record.
+        console_logs (Dict): The job console logs.
+        result (Dict): The job result.
+    """
+
+    status: Optional[JobStatus] = None
+    progress_record: Optional[Dict] = None
+    console_logs: Optional[Dict] = None
+    result: Optional[Dict] = None
+
+    def model_dump(self, **kwargs):
+        data = super().model_dump(**kwargs)
+        if data.get('status') is not None:
+            data['status'] = data['status'].value
+        return data

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/synapse_sdk/clients/base.py

@@ -86,14 +86,15 @@ class BaseClient:
         except ValueError:
             return response.text
 
-    def _get(self, path, url_conversion=None, pydantic_model=None, **kwargs):
+    def _get(self, path, url_conversion=None, response_model=None, **kwargs):
         """
         Perform a GET request and optionally convert response to a pydantic model.
 
         Args:
             path (str): URL path to request.
             url_conversion (dict, optional): Configuration for URL to path conversion.
-            pydantic_model (Type, optional): Pydantic model to convert the response to.
+            request_model (pydantic.BaseModel, optional): Pydantic model to validate the request.
+            response_model (pydantic.BaseModel, optional): Pydantic model to validate the response.
             **kwargs: Additional keyword arguments to pass to the request.
 
         Returns:
@@ -107,36 +108,100 @@ class BaseClient:
             else:
                 files_url_to_path_from_objs(response, **url_conversion)
 
-        if pydantic_model:
-            return self._validate_response_with_pydantic_model(response, pydantic_model)
+        if response_model:
+            return self._validate_response_with_pydantic_model(response, response_model)
 
         return response
 
-    def _post(self, path, pydantic_model=None, **kwargs):
+    def _post(self, path, request_model=None, response_model=None, **kwargs):
+        """
+        Perform a POST request and optionally convert response to a pydantic model.
+
+        Args:
+            path (str): URL path to request.
+            request_model (pydantic.BaseModel, optional): Pydantic model to validate the request.
+            response_model (pydantic.BaseModel, optional): Pydantic model to validate the response.
+            **kwargs: Additional keyword arguments to pass to the request.
+
+        Returns:
+            The response data, optionally converted to a pydantic model.
+        """
+        if kwargs.get('data') and request_model:
+            kwargs['data'] = self._validate_request_body_with_pydantic_model(kwargs['data'], request_model)
         response = self._request('post', path, **kwargs)
-        if pydantic_model:
-            return self._validate_response_with_pydantic_model(response, pydantic_model)
+        if response_model:
+            return self._validate_response_with_pydantic_model(response, response_model)
         else:
             return response
 
-    def _put(self, path, pydantic_model=None, **kwargs):
+    def _put(self, path, request_model=None, response_model=None, **kwargs):
+        """
+        Perform a PUT request to the specified path.
+
+        Args:
+            path (str): The URL path for the request.
+            request_model (Optional[Type[BaseModel]]): A Pydantic model class to validate the request body against.
+            response_model (Optional[Type[BaseModel]]): A Pydantic model class to validate and parse the response.
+            **kwargs: Additional arguments to pass to the request method.
+                - data: The request body to be sent. If provided along with request_model, it will be validated.
+
+        Returns:
+            Union[dict, BaseModel]:
+                If response_model is provided, returns an instance of that model populated with the response data.
+        """
+        if kwargs.get('data') and request_model:
+            kwargs['data'] = self._validate_request_body_with_pydantic_model(kwargs['data'], request_model)
         response = self._request('put', path, **kwargs)
-        if pydantic_model:
-            return self._validate_response_with_pydantic_model(response, pydantic_model)
+        if response_model:
+            return self._validate_response_with_pydantic_model(response, response_model)
         else:
             return response
 
-    def _patch(self, path, pydantic_model=None, **kwargs):
+    def _patch(self, path, request_model=None, response_model=None, **kwargs):
+        """
+        Perform a PATCH HTTP request to the specified path.
+
+        Args:
+            path (str): The API endpoint path to make the request to.
+            request_model (Optional[Type[BaseModel]]): A Pydantic model class used to validate the request body.
+            response_model (Optional[Type[BaseModel]]): A Pydantic model class used to validate and parse the response.
+            **kwargs: Additional keyword arguments to pass to the request method.
+                - data: The request body data. If provided along with request_model, it will be validated.
+
+        Returns:
+            Union[dict, BaseModel]: If response_model is provided, returns an instance of that model.
+                Otherwise, returns the raw response data.
+        """
+
+        if kwargs.get('data') and request_model:
+            kwargs['data'] = self._validate_request_body_with_pydantic_model(kwargs['data'], request_model)
         response = self._request('patch', path, **kwargs)
-        if pydantic_model:
-            return self._validate_response_with_pydantic_model(response, pydantic_model)
+        if response_model:
+            return self._validate_response_with_pydantic_model(response, response_model)
         else:
             return response
 
-    def _delete(self, path, pydantic_model=None, **kwargs):
+    def _delete(self, path, request_model=None, response_model=None, **kwargs):
+        """
+        Performs a DELETE request to the specified path.
+
+        Args:
+            path (str): The API endpoint path to send the DELETE request to.
+            request_model (Optional[Type[BaseModel]]): Pydantic model to validate the request data against.
+            response_model (Optional[Type[BaseModel]]): Pydantic model to validate and convert the response data.
+            **kwargs: Additional keyword arguments passed to the request method.
+                - data: Request payload to send. Will be validated against request_model if both are provided.
+
+        Returns:
+            Union[dict, BaseModel]: If response_model is provided, returns an instance of that model.
+                                   Otherwise, returns the raw response data as a dictionary.
+        """
+
+        if kwargs.get('data') and request_model:
+            kwargs['data'] = self._validate_request_body_with_pydantic_model(kwargs['data'], request_model)
         response = self._request('delete', path, **kwargs)
-        if pydantic_model:
-            return self._validate_response_with_pydantic_model(response, pydantic_model)
+        if response_model:
+            return self._validate_response_with_pydantic_model(response, response_model)
         else:
             return response
 
@@ -170,3 +235,19 @@ class BaseClient:
         else:
             # Not a pydantic model
             raise TypeError('The provided model is not a pydantic model')
+
+    def _validate_request_body_with_pydantic_model(self, request_body, pydantic_model):
+        """Validate a request body with a pydantic model."""
+        # Check if model is a pydantic model (has the __pydantic_model__ attribute)
+        if (
+            hasattr(pydantic_model, '__pydantic_model__')
+            or hasattr(pydantic_model, 'model_validate')
+            or hasattr(pydantic_model, 'parse_obj')
+        ):
+            # Validate the request body and convert to model instance
+            model_instance = pydantic_model.model_validate(request_body)
+            # Convert model to dict and remove None values
+            return {k: v for k, v in model_instance.model_dump().items() if v is not None}
+        else:
+            # Not a pydantic model
+            raise TypeError('The provided model is not a pydantic model')

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/synapse_sdk/plugins/categories/export/actions/export.py

@@ -1,4 +1,3 @@
-import json
 from abc import ABC, abstractmethod
 from datetime import datetime
 from typing import Annotated, Any, Literal
@@ -17,12 +16,18 @@ from synapse_sdk.utils.pydantic.validators import non_blank
 from synapse_sdk.utils.storage import get_pathlib
 
 
+class DataFileInfo(BaseModel):
+    """Schema for data_file_info."""
+
+    file_name: str
+
+
 class ExportRun(Run):
     class DataFileLog(BaseModel):
         """Data file log model."""
 
         target_id: int
-        data_file_info: str | None
+        data_file_info: DataFileInfo
         status: ExportStatus
         error: str | None = None
         created: str
@@ -44,7 +49,7 @@ class ExportRun(Run):
             log_type,
             self.DataFileLog(
                 target_id=target_id,
-                data_file_info=json.dumps(data_file_info),
+                data_file_info=data_file_info,
                 status=status.value,
                 error=error,
                 created=now,

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47/synapse_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synapse-sdk
-Version: 1.0.0a46
+Version: 1.0.0a47
 Summary: synapse sdk
 Author-email: datamaker <developer@datamaker.io>
 License: MIT

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/tests/clients/test_backend_models.py

@@ -1,7 +1,7 @@
 import pytest
 from pydantic import ValidationError
 
-from synapse_sdk.clients.backend.models import Storage, StorageCategory, StorageProvider
+from synapse_sdk.clients.backend.models import Storage, StorageCategory, StorageProvider, UpdateJob
 
 
 def test_storage_model_validation_success():
@@ -72,3 +72,28 @@ def test_storage_model_enum_values():
             )
             assert storage.category == category
             assert storage.provider == provider
+
+
+def test_update_job_model_validation_success():
+    job_response = {
+        'status': 'running',
+        'progress_record': {'key': 'value'},
+        'console_logs': {'log': 'log content'},
+        'result': {'result_key': 'result_value'},
+    }
+    update_job = UpdateJob(**job_response)
+    assert update_job.status == 'running'
+    assert update_job.progress_record == {'key': 'value'}
+    assert update_job.console_logs == {'log': 'log content'}
+    assert update_job.result == {'result_key': 'result_value'}
+
+
+def test_update_job_model_validation_with_single_field_success():
+    job_response = {
+        'status': 'running',
+    }
+    update_job = UpdateJob(**job_response)
+    assert update_job.status == 'running'
+    assert update_job.progress_record is None
+    assert update_job.console_logs is None
+    assert update_job.result is None

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/tests/clients/test_base_client.py

@@ -1,7 +1,7 @@
 import pytest
 from pydantic import ValidationError
 
-from synapse_sdk.clients.backend.models import Storage
+from synapse_sdk.clients.backend.models import Storage, UpdateJob
 from synapse_sdk.clients.base import BaseClient
 
 
@@ -44,3 +44,14 @@ def test_validate_response_with_pydantic_model_not_pydantic_model(base_client, v
     with pytest.raises(TypeError) as exc_info:
         base_client._validate_response_with_pydantic_model(valid_storage_response, {})
     assert 'The provided model is not a pydantic model' in str(exc_info.value)
+
+
+def test_validate_update_job_request_body_with_pydantic_model_success(base_client):
+    request_body = {
+        'status': 'running',
+    }
+    validated_request_body = base_client._validate_request_body_with_pydantic_model(
+        request_body,
+        UpdateJob,
+    )
+    assert validated_request_body['status'] == request_body['status']

{synapse_sdk-1.0.0a46 → synapse_sdk-1.0.0a47}/tests/clients/test_collection_validators.py

@@ -25,13 +25,13 @@ def single_image_file_spec_template():
 def single_image_organized_files():
     original_files = []
     for i in range(1, 21):
-        file_name = f'{i:04d}.jpg'
+        image_file_name = f'{i:04d}.jpg'
         original_files.append({
             'files': {
-                'image_1': '',
+                'image_1': f'/path/to/{image_file_name}',
             },
             'meta': {
-                'original_file_name': file_name,
+                'original_file_name': image_file_name,
             },
         })
     return original_files