updated model output definitions

src/model_experiential/__init__.py

@@ -1 +1,24 @@
-from .output import model_labels
+from .classes import ExperientialModelOutput
+
+
+
+# CLASS_NAME_LIST = Literal[
+#     "non transactional action",
+#     "non transactional reaction",
+#     "unidirectional transactional action",
+#     "unidirectional transactional reaction",
+#     "bidirectional transactional action",
+#     "bidirectional transactional reaction",
+#     "conversion",
+#     "speech process",
+#     "classification overt taxonomy",
+#     "analytical exhaustive",
+#     "analytical disarranged",
+#     "analytical temporal",
+#     "analytical distributed",
+#     "anaytical topological",
+#     "analytical exploded",
+#     "analytical inclusive",
+#     "symbolic suggestive",
+#     "symbolic attributive"
+# ]

src/model_experiential/classes.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+from pydantic import BaseModel
+from typing import List
+import random
+
+
+class ExperientialModelOutput(BaseModel):
+    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
+
+    @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) -> ExperientialModelOutput:
+        """Instantiate with random numbers."""
+        kwargs = {field: random.random() for field in cls.list_fields()}
+        return ExperientialModelOutput(**kwargs)
+    
+    def __repr__(self) -> str:
+        model_dict = self.model_dump()
+        model_repr_str = "ExperientialModelOutput("
+        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())
+
+
+if __name__ == '__main__':
+    m = ExperientialModelOutput.from_random()
+    print(m)
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())

src/model_experiential/output.py

@@ -1,5 +1,4 @@
-
+CLASS_NAMES = [
-model_labels = [
     "non transactional action",
     "non transactional reaction",
     "unidirectional transactional action",

src/model_interpersonal/__init__.py

@@ -1 +1,9 @@
-from .output import model_labels
+from .classes import (
+    ContactModelOutput,
+    AngleModelOutput,
+    PointOfViewModelOutput,
+    DistanceModelOutput,
+    ModalityLightingModelOutput,
+    ModalityColorModelOutput,
+    ModalityDepthModelOutput
+)

src/model_interpersonal/classes.py

@@ -0,0 +1,149 @@
+from pydantic import BaseModel
+from typing import List, Dict
+import random
+
+
+class ModelOutput(BaseModel):
+
+    @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)
+
+    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())
+
+
+class ContactModelOutput(ModelOutput):
+    offer: float
+    demand: float
+
+
+class AngleModelOutput(ModelOutput):
+    high: float
+    eye_level: float
+    low: float
+
+
+class PointOfViewModelOutput(ModelOutput):
+    frontal: float
+    oblique: float
+
+
+class DistanceModelOutput(ModelOutput):
+    long: float
+    medium: float
+    close: float
+
+
+class ModalityLightingModelOutput(ModelOutput):
+    high: float
+    medium: float
+    low: float
+
+
+class ModalityColorModelOutput(ModelOutput):
+    high: float
+    medium: float
+    low: float
+
+
+class ModalityDepthModelOutput(ModelOutput):
+    high: float
+    medium: float
+    low: float
+
+
+# class InterpersonalModelOutput(BaseModel):
+#     contact: ContactModelOutput
+#     angle: AngleModelOutput
+#     point_of_view: PointOfViewModelOutput
+#     distance: DistanceModelOutput
+#     modality_lighting: ModalityLightingModelOutput
+#     modality_color: ModalityColorModelOutput
+#     modality_depth: ModalityDepthModelOutput
+
+#     @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) -> InterpersonalModelOutput:
+#         """Instantiate with random numbers."""
+#         print(cls.model_fields)
+#         kwargs = {field: info.annotation.from_random() for field, info in cls.model_fields.items()}
+#         return InterpersonalModelOutput(**kwargs)
+    
+#     def __repr__(self) -> str:
+#         model_dict = self.model_dump()
+#         model_repr_str = "ExperientialModelOutput("
+#         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())
+
+
+if __name__ == '__main__':
+    m = ContactModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = AngleModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = PointOfViewModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = DistanceModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = ModalityLightingModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = ModalityColorModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = ModalityDepthModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())

src/model_interpersonal/output.py

@@ -1,8 +1,8 @@
 
 model_labels = {
     "contact": [
-        "contact offer",
+        "offer",
-        "contact demand"
+        "demand"
     ],
     "angle": [
         "high",

src/model_textual/__init__.py

@@ -1 +1,5 @@
-from .output import model_labels
+from .classes import (
+    InformationValueModelOutput,
+    FramingModelOutput,
+    SalienceModelOutput
+)

src/model_textual/classes.py

@@ -0,0 +1,75 @@
+from pydantic import BaseModel
+from typing import List, Dict
+import random
+
+
+class ModelOutput(BaseModel):
+
+    @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)
+
+    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())
+
+
+class InformationValueModelOutput(ModelOutput):
+    given_new: float
+    ideal_real: float
+    central_marginal: float
+
+
+class FramingModelOutput(ModelOutput):
+    frame_lines: float
+    empty_space: float
+    colour_contrast: float
+    form_contrast: float
+
+
+class SalienceModelOutput(ModelOutput):
+    size: float
+    colour: float
+    tone: float
+    form: float
+    positioning: float
+
+
+if __name__ == '__main__':
+    m = InformationValueModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = FramingModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())
+    m = SalienceModelOutput.from_random()
+    print(repr(m))
+    print(m.highest_score_field())
+    print(m.highest_score_value())