feature: image procesing modeling

* chore(image_processing): move image processing to its own app

* chore(image_processing): wrap image_processing and divide into domains

* chore(image_processing): move applied transformation handling to the client layer

* chore(image_processing_api): move get_local_transformer to utils

* feature(image_processing): create image processing models

* feature(image_processing): persist local processing procedures

* chore(places): update local image task with user

Author: jazzify

.pre-commit-config.yaml

@@ -26,6 +26,7 @@ repos:
       - id: mypy
         args: [--strict, --disable-error-code=misc]
         additional_dependencies: [
+          Pillow,
           django-stubs,
           django,
           whitenoise,

apps/images/__init__.py apps/image_processing/__init__.pyapps/images/__init__.py renamed to apps/image_processing/__init__.py

@@ -5,13 +5,13 @@
 from PIL import Image as PImage
 from PIL import ImageFilter
 
-from apps.images.constants import (
+from apps.image_processing.api.constants import (
     ImageTransformations,
     TransformationFilterBlurFilter,
     TransformationFilterDither,
     TransformationFilterThumbnailResampling,
 )
-from apps.images.processing.data_models import (
+from apps.image_processing.src.data_models import (
     InternalImageTransformationFilters,
     InternalTransformationFiltersBlackAndWhite,
     InternalTransformationFiltersBlur,

apps/images/processing/__init__.py apps/image_processing/api/__init__.pyapps/images/processing/__init__.py renamed to apps/image_processing/api/__init__.py

@@ -0,0 +1,120 @@
+import logging
+from dataclasses import asdict
+from io import BytesIO
+
+from django.core.files import File
+
+from apps.image_processing.api.data_models import ImageTransformationDefinition
+from apps.image_processing.api.utils import (
+    get_local_transformer,
+    get_transformation_dataclasses,
+)
+from apps.image_processing.models import (
+    Image,
+    ImageTransformation,
+    ProcessedImage,
+    TransformationBatch,
+)
+from apps.image_processing.src.data_models import (
+    InternalImageTransformationResult,
+    InternalTransformationManagerSaveResult,
+)
+from apps.image_processing.src.managers import ImageLocalManager
+
+logger = logging.getLogger(__name__)
+
+
+def image_processing_save_procedure(
+    user_id: int,
+    image_file: File[bytes],
+    transformer: str,
+    transformations: list[ImageTransformationDefinition],
+    transformations_applied: list[InternalImageTransformationResult],
+) -> None:
+    image = Image.objects.create(user_id=user_id, file=image_file)
+    transformation_batch = TransformationBatch(
+        input_image=image,
+        transformer=transformer,
+    )
+    transformation_batch.full_clean()
+    transformation_batch.save()
+
+    image_transformations = []
+    for transformation in transformations:
+        filters = asdict(transformation.filters) if transformation.filters else None
+        image_transformations.append(
+            ImageTransformation(
+                identifier=transformation.identifier,
+                transformation=transformation.transformation,
+                filters=filters,
+                batch=transformation_batch,
+            )
+        )
+    ImageTransformation.objects.bulk_create(image_transformations)
+
+    image_transformations_dict = {
+        transformation.identifier: transformation
+        for transformation in image_transformations
+    }
+    processed_images = []
+    for transformation_applied in transformations_applied:
+        bytes_image = BytesIO(transformation_applied.image.tobytes())
+        bytes_image.seek(0)
+        processed_images.append(
+            ProcessedImage(
+                identifier=transformation_applied.identifier,
+                file=File(bytes_image, name=f"{transformation_applied.identifier}.png"),
+                transformation=image_transformations_dict[
+                    transformation_applied.identifier
+                ],
+            )
+        )
+    ProcessedImage.objects.bulk_create(processed_images)
+
+
+def image_local_transform(
+    user_id: int,
+    image_path: str,
+    transformations: list[ImageTransformationDefinition],
+    parent_folder: str,
+    is_chain: bool = False,
+) -> list[InternalTransformationManagerSaveResult]:
+    """
+    Transforms a local image using specified transformations and saves the results.
+
+    This function processes an image located at the specified path using a list of
+    image transformations. The transformed images are saved under the specified
+    parent folder. The function returns a list of results indicating the paths
+    where the transformed images were saved.
+
+    Args:
+        user_id (int): The user_id who is performing the transformation.
+        image_path (str): The path to the local image file to be transformed.
+        transformations (list[ImageTransformationDefinition]): A list of
+            transformation definitions to apply to the image.
+        parent_folder (str): The name of the parent folder where transformed
+            images will be saved.
+        is_chain (bool, optional): A flag indicating whether to use a chain
+            transformer. Defaults to False.
+
+    Returns:
+        list[InternalTransformationManagerSaveResult]: A list containing the
+        results of the transformation, including the paths of the saved images.
+    """
+    transformations_data = get_transformation_dataclasses(transformations)
+    transformer = get_local_transformer(
+        transformations=transformations_data, is_chain=is_chain
+    )
+    image_manager = ImageLocalManager(image_path, transformer=transformer)
+    transformations_applied = image_manager.apply_transformations()
+    images_save = image_manager.save(
+        parent_folder=parent_folder, transformations=transformations_applied
+    )
+    image_processing_save_procedure(
+        user_id=user_id,
+        image_file=image_manager.get_file(),
+        transformer=transformer.name,
+        transformations=transformations,
+        transformations_applied=transformations_applied,
+    )
+    return images_save

apps/images/constants.py apps/image_processing/api/constants.pyapps/images/constants.py renamed to apps/image_processing/api/constants.py

@@ -0,0 +1,183 @@
+from unittest.mock import MagicMock, patch
+
+import pytest
+from django.contrib.auth import get_user_model
+
+from apps.image_processing.api.constants import ImageTransformations
+from apps.image_processing.api.data_models import (
+    ImageTransformationDefinition,
+    TransformationFiltersThumbnail,
+)
+from apps.image_processing.api.services import (
+    image_local_transform,
+    image_processing_save_procedure,
+)
+from apps.image_processing.models import (
+    Image,
+    ImageTransformation,
+    ProcessedImage,
+    TransformationBatch,
+)
+from apps.image_processing.src.data_models import InternalImageTransformationResult
+from apps.image_processing.src.managers import ImageLocalManager
+
+User = get_user_model()
+
+
+@pytest.fixture
+def mock_get_transformation_dataclasses():
+    with patch(
+        "apps.image_processing.api.services.get_transformation_dataclasses"
+    ) as mock:
+        mock.return_value = [MagicMock(), MagicMock()]
+        yield mock
+
+
+@pytest.fixture
+def mock_get_local_transformer():
+    with patch("apps.image_processing.api.services.get_local_transformer") as mock:
+        mock_transformer_instance = MagicMock()
+        mock.return_value = mock_transformer_instance
+        yield mock
+
+
+@pytest.fixture
+def mock_image_local_manager():
+    with patch("apps.image_processing.api.services.ImageLocalManager") as mock:
+        mock_manager_instance = MagicMock()
+        mock_manager_instance.apply_transformations = MagicMock()
+        mock_manager_instance.get_file.return_value = 1
+        mock_manager_instance.save.return_value = {
+            "transformed_image.png": "/path/to/transformed_image.png"
+        }
+        mock.return_value = mock_manager_instance
+        yield mock
+
+
+@patch("apps.image_processing.api.services.image_processing_save_procedure")
+def test_image_local_transform(
+    mock_image_processing_save_procedure,
+    mock_get_transformation_dataclasses,
+    mock_get_local_transformer,
+    mock_image_local_manager,
+):
+    user_id = 1
+    image_path = "/fake/image.jpg"
+    transformations = [
+        ImageTransformationDefinition(
+            identifier="test_thumb",
+            transformation=ImageTransformations.THUMBNAIL,
+            filters=TransformationFiltersThumbnail(size=(100, 100)),
+        )
+    ]
+    parent_folder = "test_parent"
+
+    expected_save_result = {"transformed_image.png": "/path/to/transformed_image.png"}
+
+    result = image_local_transform(user_id, image_path, transformations, parent_folder)
+
+    mock_get_transformation_dataclasses.assert_called_once_with(transformations)
+    mock_get_local_transformer.assert_called_once_with(
+        transformations=mock_get_transformation_dataclasses.return_value, is_chain=False
+    )
+
+    mock_image_local_manager.assert_called_once_with(
+        image_path, transformer=mock_get_local_transformer.return_value
+    )
+
+    mock_instance = mock_image_local_manager.return_value
+    mock_instance.apply_transformations.assert_called_once()
+    mock_instance.save.assert_called_once_with(
+        parent_folder=parent_folder,
+        transformations=mock_instance.apply_transformations.return_value,
+    )
+
+    mock_image_processing_save_procedure.assert_called_once_with(
+        user_id=user_id,
+        image_file=1,
+        transformer=mock_get_local_transformer().name,
+        transformations=transformations,
+        transformations_applied=mock_instance.apply_transformations.return_value,
+    )
+    assert result == expected_save_result
+
+
+@pytest.mark.django_db
+def test_image_processing_save_procedure_integration(user, temp_image_file):
+    user_id = user.id
+
+    transformer_name = "chain"
+    transformations_defs = [
+        ImageTransformationDefinition(
+            identifier="thumb_integration",
+            transformation=ImageTransformations.THUMBNAIL,
+            filters=TransformationFiltersThumbnail(size=(100, 100)),
+        ),
+        ImageTransformationDefinition(
+            identifier="resize_integration",
+            transformation=ImageTransformations.BLUR,
+        ),
+    ]
+    mock_applied_image_data = MagicMock()
+    mock_applied_image_data.tobytes.return_value = b"transformedimagedata"
+    transformations_applied_results = [
+        InternalImageTransformationResult(
+            identifier="thumb_integration", image=mock_applied_image_data
+        ),
+        InternalImageTransformationResult(
+            identifier="resize_integration", image=mock_applied_image_data
+        ),
+    ]
+
+    local_manage = ImageLocalManager(image_path=temp_image_file)
+    mock_image_file = local_manage.get_file()
+
+    image_processing_save_procedure(
+        user_id=user_id,
+        image_file=mock_image_file,
+        transformer=transformer_name,
+        transformations=transformations_defs,
+        transformations_applied=transformations_applied_results,
+    )
+
+    assert Image.objects.count() == 1
+    saved_image = Image.objects.first()
+    assert saved_image.user_id == user_id
+    assert saved_image.file.name == "image_processing/api/test_image.png"
+
+    assert TransformationBatch.objects.count() == 1
+    saved_batch = TransformationBatch.objects.first()
+    assert saved_batch.input_image == saved_image
+    assert saved_batch.transformer == transformer_name
+
+    assert ImageTransformation.objects.count() == 2
+    db_transformations = ImageTransformation.objects.order_by("identifier")
+    assert db_transformations[0].identifier == "resize_integration"
+    assert db_transformations[0].transformation == ImageTransformations.BLUR
+    assert db_transformations[0].filters == None
+    assert db_transformations[0].batch == saved_batch
+
+    assert db_transformations[1].identifier == "thumb_integration"
+    assert db_transformations[1].transformation == ImageTransformations.THUMBNAIL
+    assert db_transformations[1].filters == {
+        "size": [100, 100],
+        "reducing_gap": 2,
+        "resample": "bicubic",
+    }
+    assert db_transformations[1].batch == saved_batch
+
+    assert ProcessedImage.objects.count() == 2
+    db_processed_images = ProcessedImage.objects.order_by("identifier")
+    assert db_processed_images[0].identifier == "resize_integration"
+    assert (
+        db_processed_images[0].file.name
+        == "image_processing/processed/resize_integration.png"
+    )
+    assert db_processed_images[0].transformation == db_transformations[0]
+
+    assert db_processed_images[1].identifier == "thumb_integration"
+    assert (
+        db_processed_images[1].file.name
+        == "image_processing/processed/thumb_integration.png"
+    )
+    assert db_processed_images[1].transformation == db_transformations[1]