moved code

shared/mongodb/src/classes/__init__.py

@@ -0,0 +1,13 @@
+from .angle import AngleData
+from .contact import ContactData
+from .distance import DistanceData
+from .framing import FramingData
+from .information_value import InformationValueData
+from .modality_color import ModalityColorData
+from .modality_depth import ModalityDepthData
+from .modality_lighting import ModalityLightingData
+from .model_data import ModelData
+from .point_of_view import PointOfViewData
+from .salience import SalienceData
+from .visual_communication import VisualCommunication
+from .visual_syntax import VisualSyntaxData

shared/mongodb/src/classes/angle.py

@@ -0,0 +1,13 @@
+"""Definition of Angle data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class AngleData(DataModel):
+    """Angle data model."""
+
+    high: float
+    eye_level: float
+    low: float

shared/mongodb/src/classes/contact.py

@@ -0,0 +1,12 @@
+"""Definition of ContactData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class ContactData(DataModel):
+    """ContactData data model."""
+
+    offer: float
+    demand: float

shared/mongodb/src/classes/data_model.py

@@ -0,0 +1,67 @@
+"""Definition of DataModel base class."""
+
+import random
+
+from pydantic import BaseModel, ValidationError
+from torch import Tensor
+
+
+class DataModel(BaseModel):
+    """DataModel base class."""
+
+    @classmethod
+    def classname(cls) -> str:
+        """Return classname."""
+        return cls.__name__
+
+    @classmethod
+    def list_fields(cls) -> list[str]:
+        """List options that are stored as attributes."""
+        return list(cls.model_fields.keys())
+
+    @classmethod
+    def from_random(cls):
+        """Instantiate with random numbers."""
+        kwargs = {field: random.random() for field in cls.list_fields()}
+        return cls(**kwargs)
+
+    @classmethod
+    def from_choice(cls, option: str):
+        """Instantiate from choice."""
+        if option is None:
+            raise ValidationError()
+        assert isinstance(option, str), 'option is not a string'
+        allowed_options_list = cls.list_fields()
+        assert (
+            option in allowed_options_list
+        ), f"{option} is not among allowed fields {allowed_options_list}"
+        kwargs = {field: 0 for field in cls.list_fields()}
+        kwargs[option] = 1
+        return cls(**kwargs)
+
+    @classmethod
+    def from_tensor(cls, tensor: Tensor):
+        """Instantiate from list of values."""
+        assert tensor.size(dim=0) == 1, f'tensor batch larger than 1: {tensor}'
+        data_list = [float(t.item()) for t in tensor[0]]
+        kwargs = dict(zip(cls.list_fields(), data_list))
+        return cls(**kwargs)
+
+    def __repr__(self) -> str:
+        model_dict = self.model_dump()
+        model_repr_str = f'{self.classname()}('
+        model_repr_str += ', '.join(
+            [f'{field}={value:.3f}' for field, value in model_dict.items()],
+        )
+        model_repr_str += ')'
+        return model_repr_str
+
+    def highest_score_field(self) -> str:
+        """Return name of field with highest score."""
+        model_dict = self.model_dump()
+        return max(model_dict, key=lambda k: model_dict[k])
+
+    def highest_score_value(self) -> float:
+        """Return value of field with highest score."""
+        model_dict = self.model_dump()
+        return max(model_dict.values())

shared/mongodb/src/classes/distance.py

@@ -0,0 +1,13 @@
+"""Definition of DistanceData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class DistanceData(DataModel):
+    """DistanceData data model."""
+
+    long: float
+    medium: float
+    close: float

shared/mongodb/src/classes/framing.py

@@ -0,0 +1,14 @@
+"""Definition of FramingData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class FramingData(DataModel):
+    """FramingData data model."""
+
+    frame_lines: float
+    empty_space: float
+    colour_contrast: float
+    form_contrast: float

shared/mongodb/src/classes/information_value.py

@@ -0,0 +1,13 @@
+"""Definition of InformationValueData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class InformationValueData(DataModel):
+    """InformationValueData data model."""
+
+    given_new: float
+    ideal_real: float
+    central_marginal: float

shared/mongodb/src/classes/modality_color.py

@@ -0,0 +1,13 @@
+"""Definition of ModalityColorData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class ModalityColorData(DataModel):
+    """ModalityColorData data model."""
+
+    high: float
+    medium: float
+    low: float

shared/mongodb/src/classes/modality_depth.py

@@ -0,0 +1,13 @@
+"""Definition of ModalityDepthData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class ModalityDepthData(DataModel):
+    """ModalityDepthData data model."""
+
+    high: float
+    medium: float
+    low: float

shared/mongodb/src/classes/modality_lighting.py

@@ -0,0 +1,13 @@
+"""Definition of ModalityLightingData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class ModalityLightingData(DataModel):
+    """ModalityLightingData data model."""
+
+    high: float
+    medium: float
+    low: float

shared/mongodb/src/classes/model_data.py

@@ -0,0 +1,115 @@
+"""Definition of ModelData data model."""
+
+from __future__ import annotations
+
+from .angle import AngleData
+from .contact import ContactData
+from .data_model import DataModel
+from .distance import DistanceData
+from .framing import FramingData
+from .information_value import InformationValueData
+from .modality_color import ModalityColorData
+from .modality_depth import ModalityDepthData
+from .modality_lighting import ModalityLightingData
+from .point_of_view import PointOfViewData
+from .salience import SalienceData
+from .visual_syntax import VisualSyntaxData
+
+
+class ModelData(DataModel):
+    """ModelData model for data IO with combined ML model."""
+
+    visual_syntax: VisualSyntaxData
+    contact: ContactData
+    angle: AngleData
+    point_of_view: PointOfViewData
+    distance: DistanceData
+    modality_lighting: ModalityLightingData
+    modality_color: ModalityColorData
+    modality_depth: ModalityDepthData
+    information_value: InformationValueData
+    framing: FramingData
+    salience: SalienceData
+
+    @classmethod
+    def from_random(cls) -> ModelData:
+        """Instantiate with random numbers."""
+        kwargs = {
+            field: field_info.annotation.from_random()  # type: ignore
+            for field, field_info in cls.model_fields.items()
+        }
+        return cls(**kwargs)
+
+    @classmethod
+    def from_prediction_dict(
+        cls,
+        prediction_dict: dict,
+    ) -> ModelData:
+        """Instantiate from prediction dictionary."""
+        kwargs = {
+            'visual_syntax': VisualSyntaxData.from_tensor(
+                prediction_dict['visual_syntax'],
+            ),
+            'contact': ContactData.from_tensor(
+                prediction_dict['contact'],
+            ),
+            'angle': AngleData.from_tensor(
+                prediction_dict['angle'],
+            ),
+            'point_of_view': PointOfViewData.from_tensor(
+                prediction_dict['point_of_view'],
+            ),
+            'distance': DistanceData.from_tensor(
+                prediction_dict['distance'],
+            ),
+            'modality_lighting': ModalityLightingData.from_tensor(
+                prediction_dict['modality_lighting'],
+            ),
+            'modality_color': ModalityColorData.from_tensor(
+                prediction_dict['modality_color'],
+            ),
+            'modality_depth': ModalityDepthData.from_tensor(
+                prediction_dict['modality_depth'],
+            ),
+            'information_value': InformationValueData.from_tensor(
+                prediction_dict['information_value'],
+            ),
+            'framing': FramingData.from_tensor(
+                prediction_dict['framing'],
+            ),
+            'salience': SalienceData.from_tensor(
+                prediction_dict['salience'],
+            ),
+        }
+        return cls(**kwargs)
+
+    @classmethod
+    def from_annotations(
+        cls,
+        visual_syntax: str,
+        contact: str,
+        angle: str,
+        point_of_view: str,
+        distance: str,
+        modality_lighting: str,
+        modality_color: str,
+        modality_depth: str,
+        information_value: str,
+        framing: str,
+        salience: str,
+    ) -> ModelData:
+        """Instantiate from annotation."""
+        kwargs = {
+            'visual_syntax': VisualSyntaxData.from_choice(visual_syntax),
+            'contact': ContactData.from_choice(contact),
+            'angle': AngleData.from_choice(angle),
+            'point_of_view': PointOfViewData.from_choice(point_of_view),
+            'distance': DistanceData.from_choice(distance),
+            'modality_lighting': ModalityLightingData.from_choice(modality_lighting),
+            'modality_color': ModalityColorData.from_choice(modality_color),
+            'modality_depth': ModalityDepthData.from_choice(modality_depth),
+            'information_value': InformationValueData.from_choice(information_value),
+            'framing': FramingData.from_choice(framing),
+            'salience': SalienceData.from_choice(salience),
+        }
+        return cls(**kwargs)

shared/mongodb/src/classes/point_of_view.py

@@ -0,0 +1,12 @@
+"""Definition of PointOfViewData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class PointOfViewData(DataModel):
+    """PointOfViewData data model."""
+
+    frontal: float
+    oblique: float

shared/mongodb/src/classes/salience.py

@@ -0,0 +1,15 @@
+"""Definition of SalienceData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class SalienceData(DataModel):
+    """SalienceData data model."""
+
+    size: float
+    colour: float
+    tone: float
+    form: float
+    positioning: float

shared/mongodb/src/classes/visual_communication.py

@@ -0,0 +1,126 @@
+"""Definition of VisualCommunication model."""
+
+from __future__ import annotations
+
+import logging
+from base64 import b64decode, b64encode
+from io import BytesIO
+from pathlib import Path
+
+from minio import Minio
+from PIL import Image
+from pydantic import BaseModel, ConfigDict
+from pymongo.collection import Collection
+
+from shared.data_store import get, put
+from shared.mongodb.classes import ModelData
+
+
+class VisualCommunication(BaseModel):
+    """Visual communication model."""
+
+    name: str
+    object_name: str
+    annotation: ModelData | None = None
+    prediction: ModelData | None = None
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @classmethod
+    def classname(cls) -> str:
+        """Return classname."""
+        return cls.__name__
+
+    @classmethod
+    def upload_image_to_minio(
+        cls,
+        image: Image.Image,
+        minio_client: Minio,
+    ) -> str:
+        """Upload image to MinIO and return MD5 checksum of hashed image."""
+        assert isinstance(image, Image.Image)
+        assert isinstance(minio_client, Minio)
+        buffer = BytesIO()
+        image.save(buffer, 'png')
+        object_name = put(
+            client=minio_client,
+            buffer=buffer,
+        )
+        return object_name
+
+    @classmethod
+    def from_name_and_image(
+        cls,
+        name: str,
+        image: Image.Image,
+        minio_client: Minio,
+    ) -> VisualCommunication:
+        """Instantiate from filename and image that is automatically uploaded
+        to MinIO."""
+        assert isinstance(name, str)
+        assert isinstance(image, Image.Image)
+        assert isinstance(minio_client, Minio)
+        # upload file to minio
+        object_name = VisualCommunication.upload_image_to_minio(
+            image=image,
+            minio_client=minio_client,
+        )
+        return VisualCommunication(name=name, object_name=object_name)
+
+    @classmethod
+    def from_file(cls, path: Path, minio_client: Minio) -> VisualCommunication:
+        """Instantiate from file."""
+        assert isinstance(path, Path)
+        assert isinstance(minio_client, Minio)
+        # determine name
+        name = path.stem
+        # open image
+        image = Image.open(path)
+        image.load()
+        # instantiate object
+        return VisualCommunication.from_name_and_image(
+            name=name,
+            image=image,
+            minio_client=minio_client,
+        )
+
+    @classmethod
+    def decode_image(cls, content: str) -> Image.Image:
+        """Extract image from webencoded content."""
+        _, content_data = content.split(',')
+        return Image.open(BytesIO(b64decode(content_data)))
+
+    def get_image(self, minio_client: Minio) -> Image.Image:
+        """Load image data from minio."""
+        assert isinstance(minio_client, Minio)
+        # get buffer from minio
+        buffer = get(
+            client=minio_client,
+            object_name=self.object_name,
+        )
+        # convert data to image
+        im = Image.open(buffer)
+        return im
+
+    def save_to_mongo(self, collection: Collection) -> None:
+        """Save self as document in MongoDB."""
+        res = collection.insert_one(
+            document=self.model_dump(),
+        )
+        assert res.acknowledged
+
+    def webencoded_image(self, minio_client: Minio) -> str:
+        """Convert image to be displayed on webpage."""
+        assert isinstance(minio_client, Minio)
+        # get image from minio
+        image = self.get_image(minio_client)
+        # convert images to bytes string
+        buffer = BytesIO()
+        image.save(buffer, format='png')
+        img_enc = b64encode(buffer.getvalue()).decode('utf-8')
+        return f"data:image/png;base64, {img_enc}"
+
+    def generate_random_prediction(self, force: bool = False) -> None:
+        """Generate random prediction values."""
+        if not force and self.prediction is not None:
+            logging.warning('set force=True to overwrite existing values.')
+        self.prediction = ModelData.from_random()

shared/mongodb/src/classes/visual_syntax.py

@@ -0,0 +1,28 @@
+"""Definition of VisualSyntaxData data model."""
+
+from __future__ import annotations
+
+from .data_model import DataModel
+
+
+class VisualSyntaxData(DataModel):
+    """VisualSyntaxData data model."""
+
+    non_transactional_action: float
+    non_transactional_reaction: float
+    unidirectional_transactional_action: float
+    unidirectional_transactional_reaction: float
+    bidirectional_transactional_action: float
+    bidirectional_transactional_reaction: float
+    conversion: float
+    speech_process: float
+    classification_overt_taxonomy: float
+    analytical_exhaustive: float
+    analytical_disarranged: float
+    analytical_temporal: float
+    analytical_distributed: float
+    analytical_topological: float
+    analytical_exploded: float
+    analytical_inclusive: float
+    symbolic_suggestive: float
+    symbolic_attributive: float