feat: df for extra info and pydantic validator

app/assets/config/config_checkbox_behavior.json

@@ -1,5 +1,5 @@
 {
-    "Abnormal breating":
+    "Abnormal breathing":
     {
         "Description": "Problems breathing, breathing sounds"
     },

app/assets/config/config_dropdown_circumstances.json

@@ -3,12 +3,10 @@
     {
         "road vehicle": 
         {
-            
             "Options": {
-                "road_type" : ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other", "unknown"]
+                "road_type" : ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other road", "unknown road"]
             },
             "Open": "Infrastructure number"
-            
         },
         "train": 
         {
@@ -16,7 +14,7 @@
         },
         "aircraft": {},
         "boat": {},
-        "other": {},
+        "other transport collision": {},
         "unknown": {}
     },
     "Destruction / Deliberatly removed" : 
@@ -24,27 +22,33 @@
         "hunting": 
         {
             "Options": {
-                "method" : ["shooting", "bow", "falconry", "hounds hunting", "digging up", "other", "unknown"]
+                "method" : ["shooting", "bow", "falconry", 
+                "hounds hunting", "digging up", "other hunting", "unknow hunting"]
             }
         },
         "trap": 
         {
             "Options": {
-                "method": ["killing trap", "pole trap", "trap cage", "corvids nasse", "net", "cage trap", "fall-trap", "glue trap", "insect trap", "other", "unknown"]
+                "method": ["killing trap", "pole trap", 
+                "trap cage", "corvids nasse", "net", "cage trap", 
+                "fall-trap", "glue trap", "insect trap", "other trap", "unknown trap"]
             }
         },
         "poisoning": {},
         "removal or direct capture": 
         {
-            "Options": {"method": ["gassing", "raptor captured at nest", "brood destruction", "traffic/trade", "capture accident", "scientific sample", "other", "unknown"]
+            "Options": {"method": ["gassing", "raptor captured at nest", 
+            "brood destruction", "traffic/trade", "capture accident", 
+            "scientific sample", "other removal", "unknown removal"]
         }
         },
         "fishing": 
         {
-            "Options": {"method" : ["drowned/tangled", "beached with capture indications", "other", "unknown"]
+            "Options": {"method" : ["drowned/tangled", "beached with capture indications", 
+            "other fishing", "unknown fishing"]
         }
         },
-        "other": {},
+        "other destruction": {},
         "unknown": {}
     },
    "Indirect destruction":
@@ -53,46 +57,48 @@
          {
   
             "Options": {
-                "infrastructure" : ["electric line", "pole/pylon", "other", "unknown"]
+                "infrastructure" : ["electric line", "pole/pylon", "other structure", "unknown structure"]
             },
             "Extra":
             {
-                "Cause": ["collision", "electrocution", "unknown"]
+                "Cause": ["collision", "electrocution"]
             }
          },
          "windfarm": {},
          "other collision": 
          {
             "Options": {
-                "object": ["window", "building", "lighthouse", "cable", "wire fence/barbed wire", "other crash", "unknown"]
+                "object": ["window", "building", "lighthouse", "cable", "wire fence/barbed wire", "other crash", "unknown crash"]
             }
          },
          "fall": 
          {
             "Options": {
-                "location": ["chimney", "empty pole", "hole/well", "other", "unknown"]
+                "location": ["chimney", "empty pole", "hole/well", "other fall", "unknown fall"]
             }
          },
          "development work": 
          {
             "Options": {
-                "work_type" : ["transport infrastructure", "building", "other", "unknown"]
+                "work_type" : ["transport infrastructure", "building", "other work", "unknown work"]
             }
          },
          "pollution / contamination": 
          {
             "Options": {
-                "pollution_type" : ["oil pollution", "chemical pollution", "heavy metals", "light", "noise", "plastic ingestion", "other", "unknown"]
+                "pollution_type" : ["oil pollution", "chemical pollution", "heavy metals", 
+                "light", "noise", "plastic ingestion", "other pollution", "unknown pollution"]
          },
          "agricultural net protection": {},
          "vegetal / forest work": 
          {
             "Options": {
-                "work_type" : ["clearing/mowing/plowing", "tree felling/pruning", "other", "unknown"]
+                "work_type" : ["clearing/mowing/plowing", "tree felling/pruning", 
+                "other forest work", "unknown forest work"]
             }
          }
          },
-         "other": {},
+         "other indirect destruction": {},
          "unknown": {}
     },
     "Natural cause": 
@@ -100,19 +106,20 @@
         "predation": 
         {
             "Options": {
-                "predator" : ["cat", "dog", "rooster/hen", "other domestic animal", "wild birds", "wild mammal", "other", "unknown"]
+                "predator" : ["cat", "dog", "rooster/hen", "other domestic animal", "wild birds",
+                "wild mammal", "other predator", "unknown predator"]
             }
         },
         "weather": 
         {
             "Options": {
-                "condition" : ["cold wave", "drought", "hail", "lightening", "storm", "other", "unknown"]
+                "condition" : ["cold wave", "drought", "hail", "lightening", "storm", "other weather", "unknown weather"]
             }
         },
         "natural disaster": 
         {
             "Options": {
-                "disaster" : ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other", "unknown"]
+                "disaster" : ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other natural disaster", "unknown natural disaster"]
             }
         },
         "nest fall": {},
@@ -121,10 +128,10 @@
         "accidental drowing": 
         {
             "Options": {
-                "drowning_location" : ["drinking trough", "pool", "storm pool", "irrigation pool", "natural pool", "flood", "other container", "unknown"]
+                "drowning_location" : ["drinking trough", "pool", "storm pool", "irrigation pool", "natural pool", "flood", "other location", "unknown location"]
             }
         },
-        "other": {},
+        "other natural cause": {},
         "unknown": {}
     },
     "Unknown": {}

app/assets/config/config_fields.json

@@ -1,20 +0,0 @@
-{
-    "fields": [
-        "latitude",
-        "longitude",
-        "wounded", 
-        "dead", 
-        "circumstance",
-        "circumstance_dropdown_level1",
-        "circumstance_dropdown_level2",
-        "circumstance_openfield_level2",
-        "circumstance_dropdown_extra_level2",
-        "behavior",
-        "physical_changes_beak", 
-        "physical_changes_body",
-        "physical_changes_head", 
-        "physical_changes_feathers", 
-        "physical_changes_legs",
-        "image"
-    ]
-}

app/behavior/behavior_checkbox.py

@@ -5,6 +5,7 @@ from utils.utils_visible import set_visible
 from validation_submission.add_json import add_data_tmp
 
 def on_select_behavior(behavior_checkbox): 
+    behavior_checkbox = [behavior.lower() for behavior in behavior_checkbox]
     add_data_tmp("wounded_dead", "behaviors_type", behavior_checkbox)
 
 def retrieve_behavior_options_description():

app/behavior/class_behavior.py

@@ -1,51 +1,50 @@
 from pydantic import BaseModel, Field
-from typing import Literal, List, Union
-
+from typing import Literal, List, Union, Optional
 
 class Behavior(BaseModel):
     type: str
-    description: str
+    description: Optional[str] = None  # Making the description field optional
 
 # --- Specific Behavior classes ---
 class AbnormalBreathing(Behavior):
     type: Literal['abnormal breathing']
-    description: Literal["Problems breathing, breathing sounds"]
+    description: Optional[Literal["Problems breathing, breathing sounds"]] = None
 
 class CrashFalling(Behavior):
     type: Literal['crash, falling from the sky']
-    description: Literal["Suddenly falling from the sky"]
+    description: Optional[Literal["Suddenly falling from the sky"]] = None
 
 class Diarrhea(Behavior):
     type: Literal['diarrhea']
-    description: Literal["Observed diarrhea"]
+    description: Optional[Literal["Observed diarrhea"]] = None
 
 class Lameness(Behavior):
     type: Literal['lameness']
-    description: Literal["Apparent limping or not able to walk properly"]
+    description: Optional[Literal["Apparent limping or not able to walk properly"]] = None
 
 class Neurological(Behavior):
     type: Literal['neurological']
-    description: Literal["Circling, incoordination, tremors, convulsions, fast eye movements"]
+    description: Optional[Literal["Circling, incoordination, tremors, convulsions, fast eye movements"]] = None
 
 class OtherAbnormalBehavior(Behavior):
     type: Literal['other abnormal behavior']
-    description: Literal["Other than weakness, other than neurologic"]
+    description: Optional[Literal["Other than weakness, other than neurologic"]] = None
 
 class UnableToFly(Behavior):
     type: Literal['unable to fly']
-    description: Literal["Animal alert and tries to fly but can not take off"]
+    description: Optional[Literal["Animal alert and tries to fly but can not take off"]] = None
 
 class Vomiting(Behavior):
     type: Literal['vomiting']
-    description: Literal["Throwing up undigested food, regurgitating"]
+    description: Optional[Literal["Throwing up undigested food, regurgitating"]] = None
 
 class Weakness(Behavior):
     type: Literal['weakness']
-    description: Literal["Non responsive, does not fly away when approached, lethargy"]
+    description: Optional[Literal["Non responsive, does not fly away when approached, lethargy"]] = None
 
 class NoChanges(Behavior):
     type: Literal['no changes']
-    description: Literal["Animal is acting normally"]
+    description: Optional[Literal["Animal is acting normally"]] = None
 
 # Union of all possible behaviors
 BehaviorType = Union[
@@ -64,4 +63,4 @@ BehaviorType = Union[
 # Main class that logs multiple behaviors
 class Behaviors(BaseModel):
     behaviors_radio: str  # e.g., "Yes"
-    behaviors_type: List[BehaviorType] = Field(..., discriminator='type')
+    behaviors_type: Optional[List[BehaviorType]] = None

app/circumstances/circumstances_dropdowns.py

@@ -73,7 +73,7 @@ def get_options(value):
 def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
     options_label, options_dropdown, open_field, extras, extras_label = get_options(evt.value)
     add_data_tmp("wounded_dead", 
-                    "cirumstance_type", 
+                    "circumstance_type", 
                     {"type": (evt.value).lower(),
                      "option_dropdown_label" : options_label.lower() if options_label is not None else 'NA',
                      "open_field_label" : open_field.lower() if open_field is not None else 'NA',
@@ -98,14 +98,15 @@ def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
 def on_select_dropdown_level2(evt: gr.SelectData): 
     add_data_tmp("wounded_dead", 
                 "circumstance_option_dropdown", 
-                evt.value)
+                evt.value.lower())
 
-def on_select_openfield_level2(evt: gr.SelectData): 
+def on_change_openfield_level2(evt: gr.EventData): 
+    print("Saving open field")
     add_data_tmp("wounded_dead", 
                 "circumstance_open_field", 
-                evt.value)
+                evt.value.lower())
 
 def on_select_dropdown_extra_level2(evt: gr.SelectData):  
     add_data_tmp("wounded_dead", 
                  "circumstance_extra", 
-                 evt.value)
+                 evt.value.lower())

app/circumstances/class_circumstance.py

@@ -9,7 +9,9 @@ class CircumstanceTypeBase(BaseModel):
 class RoadVehicleCollision(CircumstanceTypeBase):
     type: Literal['road_vehicle']
     infrastructure_number: Optional[str] = None
-    road_type: Literal['highway', 'main road', 'secondary road', 'local road/path/trail', 'parking lot', 'other', 'unknown']
+    road_type: Literal['highway', 'main road', 
+                       'secondary road', 'local road/path/trail', 
+                       'parking lot']
 
 class TrainCollision(CircumstanceTypeBase):
     type: Literal['train']
@@ -30,22 +32,28 @@ class UnknownTransportCollision(CircumstanceTypeBase):
 # Destruction / Deliberately removed
 class HuntingDestruction(CircumstanceTypeBase):
     type: Literal['hunting']
-    method: Literal['shooting', 'bow', 'falconry', 'hounds hunting', 'digging up', 'other', 'unknown']
+    method: Literal['shooting', 'bow', 'falconry', 
+                    'hounds hunting', 'digging up', 
+                    "other hunting", "unknow hunting"]
 
 class TrapDestruction(CircumstanceTypeBase):
     type: Literal['trap']
-    method: Literal['killing trap', 'pole trap', 'trap cage', 'corvids nasse', 'net', 'cage trap', 'fall-trap', 'glue trap', 'insect trap', 'other', 'unknown']
+    method: Literal['killing trap', 'pole trap', 'trap cage', 'corvids nasse', 
+                    'net', 'cage trap', 'fall-trap', 'glue trap', 'insect trap', 
+                    "other trap", "unknown trap"]
 
 class PoisoningDestruction(CircumstanceTypeBase):
     type: Literal['poisoning']
 
 class RemovalDestruction(CircumstanceTypeBase):
     type: Literal['removal or direct capture']
-    method: Literal['gassing', 'raptor captured at nest', 'brood destruction', 'traffic/trade', 'capture accident', 'scientific sample', 'other', 'unknown']
+    method: Literal['gassing', 'raptor captured at nest', 'brood destruction', 
+                    'traffic/trade', 'capture accident', 'scientific sample',
+                    "other removal", "unknown removal"]
 
 class FishingDestruction(CircumstanceTypeBase):
     type: Literal['fishing']
-    method: Literal['drowned/tangled', 'beached with capture indications', 'other', 'unknown']
+    method: Literal['drowned/tangled', 'beached with capture indications', "other fishing", "unknown fishing"]
 
 class OtherDestruction(CircumstanceTypeBase):
     type: Literal['other destruction']
@@ -56,34 +64,38 @@ class UnknownDestruction(CircumstanceTypeBase):
 # Indirect destruction
 class PylonElectricGridDestruction(CircumstanceTypeBase):
     type: Literal['pylone and electric grid']
-    infrastructure: Literal['electric line', 'pole/pylon', 'other', 'unknown']
-    cause: Literal['collision', 'electrocution', 'unknown']
+    infrastructure: Literal['electric line', 'pole/pylon', "other structure", "unknown structure"]
+    cause: Literal['collision', 'electrocution']
 
 class WindfarmDestruction(CircumstanceTypeBase):
     type: Literal['windfarm']
 
 class OtherCollisionDestruction(CircumstanceTypeBase):
     type: Literal['other collision']
-    object: Literal['window', 'building', 'lighthouse', 'cable', 'wire fence/barbed wire', 'other crash', 'unknown']
+    object: Literal['window', 'building', 'lighthouse', 
+                    'cable', 'wire fence/barbed wire', 'other crash', 'unknown crash']
 
 class FallDestruction(CircumstanceTypeBase):
     type: Literal['fall']
-    location: Literal['chimney', 'empty pole', 'hole/well', 'other', 'unknown']
+    location: Literal['chimney', 'empty pole', 'hole/well', 'other fall', 'unknown fall']
 
 class DevelopmentWorkDestruction(CircumstanceTypeBase):
     type: Literal['development work']
-    work_type: Literal['transport infrastructure', 'building', 'other', 'unknown']
+    work_type: Literal['transport infrastructure', 'building', 'other work', 'unknown work']
 
 class PollutionContaminationDestruction(CircumstanceTypeBase):
     type: Literal['pollution / contamination']
-    pollution_type: Literal['oil pollution', 'chemical pollution', 'heavy metals', 'light', 'noise', 'plastic ingestion', 'other', 'unknown']
+    pollution_type: Literal['oil pollution', 'chemical pollution', 'heavy metals', 
+                            'light', 'noise', 
+                            'plastic ingestion', 'other pollution', 'unknown pollution']
 
 class AgriculturalNetProtectionDestruction(CircumstanceTypeBase):
     type: Literal['agricultural net protection']
 
 class VegetalForestWorkDestruction(CircumstanceTypeBase):
     type: Literal['vegetal / forest work']
-    work_type: Literal['clearing/mowing/plowing', 'tree felling/pruning', 'other', 'unknown']
+    work_type: Literal['clearing/mowing/plowing', 'tree felling/pruning', 
+                       'other forest work', 'unknown forest work']
 
 class OtherIndirectDestruction(CircumstanceTypeBase):
     type: Literal['other indirect desctruction']
@@ -94,15 +106,21 @@ class UnknownIndirectDestruction(CircumstanceTypeBase):
 # Natural cause
 class Predation(CircumstanceTypeBase):
     type: Literal['predation']
-    predator: Literal['cat', 'dog', 'rooster/hen', 'other domestic animal', 'wild birds', 'wild mammal', 'other', 'unknown']
+    predator: Literal['cat', 'dog', 'rooster/hen', 
+                      'other domestic animal', 'wild birds', 
+                      'wild mammal', 'other predator', 'unknown predator']
 
 class Weather(CircumstanceTypeBase):
     type: Literal['weather']
-    condition: Literal['cold wave', 'drought', 'hail', 'lightening', 'storm', 'other', 'unknown']
+    condition: Literal['cold wave', 'drought', 'hail', 
+                       'lightening', 'storm', 
+                       'other weather', 'unknown weather']
 
 class NaturalDisaster(CircumstanceTypeBase):
     type: Literal['natural disaster']
-    disaster: Literal['fire', 'avalanche', 'rock fall', 'mudslide', 'volcanic eruption/ashes', 'other', 'unknown']
+    disaster: Literal['fire', 'avalanche', 'rock fall', 
+                      'mudslide', 'volcanic eruption/ashes', 
+                      'other natural disaster', 'unknown natural disaster']
 
 class NestFall(CircumstanceTypeBase):
     type: Literal['nest fall']
@@ -115,7 +133,10 @@ class DiseaseParasite(CircumstanceTypeBase):
 
 class AccidentalDrowning(CircumstanceTypeBase):
     type: Literal['accidental drowning']
-    drowning_location: Literal['drinking trough', 'pool', 'storm pool', 'irrigation pool', 'natural pool', 'flood', 'other container', 'unknown']
+    drowning_location: Literal['drinking trough', 'pool', 
+                               'storm pool', 'irrigation pool', 
+                               'natural pool', 'flood', 
+                               'other location', 'unknown location']
 
 class OtherNaturalCause(CircumstanceTypeBase):
     type: Literal['other natural cause']
@@ -166,9 +187,9 @@ CircumstanceType = Union[
 
 # Main Circumstance class
 class Circumstances(BaseModel):
-    circumstance: str  # e.g., "COLLISION"
     circumstance_radio: str  # e.g., "Yes"
-    circumstance_type: CircumstanceType = Field(..., discriminator='type')
+    circumstance: Optional[str] = None  # e.g., "COLLISION"
+    circumstance_type: Optional[CircumstanceType] = Field(None, discriminator='type')
 
 
 # Example usage

app/classes.py

@@ -1,5 +1,10 @@
 from pydantic import BaseModel, Field
-from typing import Literal, List, Union, Optional
+from typing import Optional
+import numpy as np
+from PIL import Image
+import io
+import base64
+import uuid
 
 from behavior.class_behavior import Behaviors
 from circumstances.class_circumstance import Circumstances
@@ -9,22 +14,33 @@ from geolocalisation.class_geolocalisation import Geolocalisation
 
 class Wounded(BaseModel):
     circumstances: Circumstances
-    behaviors: List[Behaviors]
-    physical_anomalies: List[PhysicalAnomalies]
-    follow_up_events: List[FollowUpEvents]
+    behaviors: Behaviors
+    physical_anomalies: PhysicalAnomalies
+    follow_up_events: FollowUpEvents
 
 class Dead(BaseModel):
-    circumstances: List[Circumstances] 
-    physical_anomalies: List[PhysicalAnomalies]
-    follow_up_events: List[FollowUpEvents]
-
-class Image(BaseModel):
-    image: List[float]
+    circumstances: Circumstances
+    physical_anomalies: PhysicalAnomalies
+    follow_up_events: FollowUpEvents
 
+class ImageBase64(BaseModel):
+    image: str  
+    @classmethod
+    def to_base64(cls, pixel_data: list):
+        img_array = np.array(pixel_data, dtype=np.uint8)
+        img = Image.fromarray(img_array)
+        # Save the image to a bytes buffer
+        buffer = io.BytesIO()
+        img.save(buffer, format="PNG")
+        buffer.seek(0)
+        base64_str = base64.b64encode(buffer.read()).decode('utf-8')
+        return cls(image=base64_str)
+    
 class Report(BaseModel):
-    image: Image
+    identifier: str
+    image: ImageBase64
     geolocalisation: Geolocalisation
-    wounded_state: bool
+    wounded_state: str
     wounded: Optional[Wounded] = None  
-    dead_state: bool
+    dead_state: str
     dead: Optional[Dead] = None 

app/dead.py

@@ -1,12 +1,12 @@
 import gradio as gr
 from circumstances.circumstances import create_circumstances
 from follow_up.followup_events import create_followup_dropdowns, create_followup_open
-from validation_submission.add_json import add_data_to_individual  
+from validation_submission.add_json import add_data_to_individual
 
 def show_section_dead(visible):
     if visible==True: 
-        add_data_to_individual("dead_bool", "True")
-        add_data_to_individual("wounded_bool", "False")
+        add_data_to_individual("wounded_state", "No")
+        add_data_to_individual("dead_state", "Yes")
         
     with gr.Column(visible=visible, elem_id="dead") as section_dead:
         gr.Markdown("# Dead Animal")

app/follow_up/class_follow_up.py

@@ -3,45 +3,40 @@ from typing import Literal, Union, Optional, List
 
 # --- Event follow-up classes ---
 
-# Animal collected event
 class AnimalCollectedEvent(BaseModel):
     type: Literal['animal collected']
-    collected: Literal['Yes', 'No']
+    collected: Literal['yes', 'no']
 
-# Recipient event
 class RecipientEvent(BaseModel):
     type: Literal['recipient']
-    recipient: Literal['Veterinary', 'Care center', 'Local Museum', 'National Museum', 'Other']
-    
-# Radiography event
+    recipient: Literal['veterinary', 'care center', 
+                                'local museum', 'national museum', 
+                                'other']
+
 class RadiographyEvent(BaseModel):
     type: Literal['radiography']
-    radiography: Literal['Yes', 'No', 'Unknown']
+    radiography: Literal['yes', 'no', 'unknown']
 
-# Given answer event
 class GivenAnswerEvent(BaseModel):
     type: Literal['given answer']
     answer: Literal[
-        'Nothing', 
-        'Complaint against X', 
-        'Complaint', 
-        'Police call', 
-        'Discussion with the speaker', 
-        'Press release', 
-        'Unknown'
+        'nothing', 
+        'complaint against x', 
+        'complaint', 
+        'police call', 
+        'discussion with the speaker', 
+        'press release', 
+        'unknown'
     ]
 
-# Name of recipient/museum (open text field)
 class NameOfRecipientEvent(BaseModel):
     type: Literal['recipient name']
-    name: str  # Open text field for entering the name
+    name: str
 
-# Collection reference (open text field)
 class CollectionReferenceEvent(BaseModel):
     type: Literal['collection reference']
-    reference: str  # Open text field for entering the reference
+    reference: str
 
-# Union of all possible follow-up event types
 FollowUpEventType = Union[
     AnimalCollectedEvent,
     RecipientEvent,
@@ -51,7 +46,5 @@ FollowUpEventType = Union[
     CollectionReferenceEvent
 ]
 
-# Main class that logs multiple follow-up events
 class FollowUpEvents(BaseModel):
-    follow_up_events: List[FollowUpEventType]
-
+    follow_up_events: Optional[List[FollowUpEventType]] = None

app/gallery.py

@@ -1,84 +1,18 @@
 import gradio as gr
 import pandas as pd
-import numpy as np
-from dotenv import load_dotenv
-import os
 
-from utils.utils_config import load_config
-from validation_submission.get_json import get_json_one_individual
-from validation_submission.submission import save_to_all_individuals
-from validation_submission.validation import validate_individual
+from validation_submission.submission import validate_save_individual
+from validation_submission.get_json import get_json_all_individuals
 
+HEADERS = ["Identifier", "Location", "Wounded", "Dead"]
 
-load_dotenv()
-PATH = os.getcwd() + "/"
-PATH_ASSETS = os.getenv('PATH_ASSETS')
-PATH_CONFIG = PATH + PATH_ASSETS + "config/"
 
-def get_headers(): 
-    headers_config = load_config(PATH_CONFIG + "config_headers.json")
-    headers = headers_config["headers"]
-    return headers
-
-def get_fields(): 
-    fields_config = load_config(PATH_CONFIG + "config_fields.json")
-    fields = fields_config["fields"]
-    return fields
-
-def match_data_to_fields(fields, one_individual): 
-    new_row = {}
-    for key in fields:
-        if key in one_individual:
-            if key=="image": 
-                new_row[key] = one_individual[key]
-            elif type(one_individual[key])==list:
-                new_row[key] = ' , '.join(one_individual[key])
-            else:
-                new_row[key] = one_individual[key]
-        else:
-            new_row[key] = "NA"
-    return new_row
-
-
-
-def process_animals(all_animals): 
-    processed_animals = []
-    for _, animal in all_animals.items(): 
-        image = np.array(animal["image"])
-        caption = []
-        for key, val in animal.items(): 
-            if key!="image": 
-                if key=="latitude": 
-                    caption.extend([
-                        " | Latitude: " + str(animal["latitude"])])
-                elif key=="longitude": 
-                    caption.extend([
-                        " | Longitude: " + str(animal["longitude"])])
-                elif key=="wounded" and val=="True": 
-                    caption.extend([" | Wounded: " + animal["wounded"]])
-                elif key=="dead" and val=="True":
-                    caption.extend([" | Dead: " + animal["dead"]])
-                # elif key=="circumstance": 
-                #     caption.extend([" | Circumstances: " , 
-                #                     animal["circumstance"],
-                #                     animal["circumstance_dropdown_level1"], 
-                #                     animal["circumstance_dropdown_level2"],
-                #                     animal["circumstance_openfield_level2"], 
-                #                     animal["circumstance_dropdown_extra_level2"]])
-                # elif key=="behavior": 
-                #     caption.extend([" | Behavior: ", animal[key]])
-                # elif "physical_changes" in key:
-                #     if not(" | Physical Changes: " in caption) :
-                #         caption.extend([" | Physical Changes: ",
-                #                         "Beak: " + animal["physical_changes_beak"],
-                #                         "Body: " + animal["physical_changes_body"], 
-                #                         "Head: " + animal["physical_changes_head"],
-                #                         "Feathers: " + animal["physical_changes_feathers"], 
-                #                         "Legs: " + animal["physical_changes_legs"]])
-        caption_str = " ".join(caption)
-        animal = (image, caption_str)
-        processed_animals.append(animal)
-    return processed_animals
+from PIL import Image
+from io import BytesIO
+import base64
+def convert_image(image_base64_str): 
+    im = Image.open(BytesIO(base64.b64decode(image_base64_str)))
+    return im
 
 def set_gallery_size(len_animals): 
     if len_animals < 10: 
@@ -89,62 +23,92 @@ def set_gallery_size(len_animals):
         num_rows = len_animals/(num_cols)
     return num_cols, num_rows
 
-def save_individual_to_gallery(gallery):
-    validate_individual()
-    one_individual = get_json_one_individual()
-    fields = get_fields()
-    one_individual_matched = match_data_to_fields(fields, one_individual)
-    all_animals = save_to_all_individuals(one_individual_matched)
-    num_cols, num_rows = set_gallery_size(len(all_animals))
-    processed_animals = process_animals(all_animals)
+def save_individual_to_gallery(gallery, df):
+    validate_save_individual()
+    all_animals = get_json_all_individuals()
+    gallery_animals = process_animals_for_gallery(all_animals)
+    gallery = make_gallery(gallery_animals)
+    df_animals = process_animals_for_df(all_animals)
+    df = make_df(df_animals)
+    return gallery, df
+
+def process_animals_for_gallery(all_animals): 
+    gallery_animals = []
+    for _, animal in all_animals.items(): 
+        image = convert_image(animal["image"]["image"])
+        caption = animal["identifier"]
+        animal = (image, caption)
+        gallery_animals.append(animal)
+    return gallery_animals
+
+def make_gallery(gallery_animals):
+    num_cols, num_rows = set_gallery_size(len(gallery_animals))
     gallery = gr.Gallery(
         label="Gallery of Records", elem_id="gallery", 
         columns=[num_cols], rows=[num_rows],
-        value=processed_animals,
+        value=gallery_animals,
         object_fit="contain", height="auto", interactive=False)
     return gallery
-    
-# def save_individual_to_df(df): 
-#     fields = get_fields()
-#     one_individual = get_json_one_individual()
-#     headers = get_headers()
-#     new_row = match_data_to_fields(fields, one_individual)
-#     new_row = format_row(new_row, headers)
-#     new_row_df = pd.DataFrame([new_row], columns=headers)  
-#     df_new = pd.concat([df, new_row_df], ignore_index=True)
-#     df_gr = gr.DataFrame(visible=True,
-#                          value=df_new,
-#                          headers=headers)
-#     return df_gr
 
-# def save_and_rest_df(df):
-#     save_all_animals(df)
-#     df = gr.Dataframe(fields=get_fields(),
-#                       visible=False)
-#     return df
+def keep_only_values(dict_to_filter): 
+    info_text = ""
+    values_to_ignore = ["Yes", "No", "NA"]
+    if dict_to_filter:
+        for key, val in dict_to_filter.items(): 
+            if type(val) is dict: 
+                subset_text = keep_only_values(val)
+                info_text += f"{subset_text}"
+            elif type(val) is list:
+                for item in val: 
+                    if type(item) is dict: 
+                        subset_text = keep_only_values(item)
+                        info_text += f"{subset_text}"
+            elif (val is not None) and (type(val) is not bool) and (val not in values_to_ignore): 
+                info_text += f" {key} : {val} |"
+            else:
+                print("Ignoring value: ", val)
+                print("Associated key: ", key)
+    else: 
+        info_text = "NaN"
+    return info_text
+
+
+def process_animals_for_df(all_animals):
+    df_animals = {}
+    identifiers =[]
+    geo =[]
+    wounded =[]
+    dead =[]
+    for _, animal in all_animals.items(): 
+        identifier_value = animal["identifier"]
+        identifiers.append(identifier_value)
+        geo_dict = animal["geolocalisation"]
+        geo_values = keep_only_values(geo_dict)
+        geo.append(geo_values)
+        wounded_dict = animal["wounded"]
+        wounded_values = keep_only_values(wounded_dict)
+        wounded.append(wounded_values)
+        dead_dict = animal["dead"]
+        dead_values = keep_only_values(dead_dict)
+        dead.append(dead_values)
+    df_animals["Identifier"] = identifiers
+    df_animals["Location"] = geo
+    df_animals["Wounded"] = wounded
+    df_animals["Dead"] = dead
+    return df_animals
+
+
+def make_df(df_animals):
+    df = pd.DataFrame.from_dict(df_animals)
+    styled_df = df.style.set_properties(**{
+    'max-width': '100px',  # Adjust width as needed
+    'white-space': 'normal',  # Allows text to wrap to the next line
+    'word-wrap': 'break-word'  # Breaks long words to fit within the width
+    })
+    df_gradio = gr.DataFrame(visible=True,
+                         value=df,
+                         headers=HEADERS, interactive=False)
+    # df = gr.DataFrame(visible=True,    
+    #                     headers=HEADERS)
+    return df_gradio
 
-# def format_row(new_row, headers):
-#     formatted_row = {}
-#     #formatted_row["image"] = new_row["image"]
-#     for header in headers: 
-#         if header=="location": 
-#             formatted_row[header] = " | ".join(["Latitude: " + str(new_row["latitude"]), 
-#                                                 "Longitude: " + str(new_row["longitude"])])
-#         elif header=="state": 
-#             formatted_row[header] = " | ".join(["Wounded: " + new_row["wounded"], 
-#                                                 "Dead: " + new_row["dead"]])
-#         elif header=="circumstance": 
-#             formatted_row[header] = " | ".join([new_row["circumstance"],
-#                                                 new_row["circumstance_dropdown_level1"], 
-#                                                 new_row["circumstance_dropdown_level2"],
-#                                                 new_row["circumstance_openfield_level2"], 
-#                                                 new_row["circumstance_dropdown_extra_level2"]])
-#         elif header=="behavior": 
-#             formatted_row[header] = new_row[header]
-#         elif header=="physical_changes":
-#             formatted_row[header] = " | ".join([new_row["physical_changes_beak"],
-#                                                 new_row["physical_changes_body"], 
-#                                                 new_row["physical_changes_head"],
-#                                                 new_row["physical_changes_feathers"], 
-#                                                 new_row["physical_changes_legs"]])
-#     return list(formatted_row.values())

app/main_multianimal.py

@@ -29,8 +29,7 @@ with gr.Blocks(theme=theme, css=css) as demo:
     with gr.Row(): 
         show_modal = gr.Button("Add an Animal", scale=3)
         submit_button = gr.Button("Submit All Animals", scale=1)
-    # df = gr.Dataframe(headers=get_headers(),
-    #                   visible=False)
+    df = gr.Dataframe(headers=["Identifier", "Location", "Wounded", "Dead"], visible=False, interactive=False)
     gallery = gr.Gallery(
         label="Gallery of Records", elem_id="gallery", 
         columns=[1], rows=[1],
@@ -126,6 +125,7 @@ with gr.Blocks(theme=theme, css=css) as demo:
                                 fe_collection_dropdown_wounded, fe_recepient_dropdown_wounded, fe_radio_dropdown_wounded, fe_answer_dropdown_wounded, \
                                 fe_name_recipient_wounded, fe_collection_ref_wounded \
                                 ])
+        
         # ---------------------------------------------------------
         # Wounded Button Logic
         partial_show_section_wounded = partial(show_section_wounded, True)
@@ -149,6 +149,9 @@ with gr.Blocks(theme=theme, css=css) as demo:
                                                                             fe_collection_dropdown_dead, fe_recepient_dropdown_dead, fe_radio_dropdown_dead, fe_answer_dropdown_dead, \
                                                                             fe_name_recipient_dead, fe_collection_ref_dead \
                                                                             ])
+        def save_wounded_state():
+            add_data_tmp("wounded_dead", "wounded", "Yes")
+        butt_wounded.click(save_wounded_state())
         # ---------------------------------------------------------
         # Dropdowns Dead
         button_collision_dead.click(dropdown_collision,  
@@ -159,7 +162,7 @@ with gr.Blocks(theme=theme, css=css) as demo:
 
         dropdown_dead.select(on_select, None, [dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
         dropdown_level2_dead.select(on_select_dropdown_level2)
-        openfield_level2_dead.select(on_select_openfield_level2)
+        openfield_level2_dead.input(on_change_openfield_level2)
         dropdown_extra_level2_dead.select(on_select_dropdown_extra_level2)
         # ---------------------------------------------------------
         # Radio Cause Wounded
@@ -178,7 +181,7 @@ with gr.Blocks(theme=theme, css=css) as demo:
         
         dropdown_wounded.select(on_select, None, [dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
         dropdown_level2_wounded.select(on_select_dropdown_level2)
-        openfield_level2_wounded.select(on_select_openfield_level2)
+        openfield_level2_wounded.select(on_change_openfield_level2)
         dropdown_extra_level2_wounded.select(on_select_dropdown_extra_level2)
         # ---------------------------------------------------------
         # Radio Behavior Wounded
@@ -255,8 +258,8 @@ with gr.Blocks(theme=theme, css=css) as demo:
         #                 inputs=[df],
         #                 outputs=[df])
         button_df.click(save_individual_to_gallery, 
-                        inputs=[gallery],
-                        outputs=[gallery]
+                        inputs=[gallery, df],
+                        outputs=[gallery, df]
                         )
         button_df.click(lambda: Modal(visible=False), None, modal)
     
@@ -266,7 +269,6 @@ with gr.Blocks(theme=theme, css=css) as demo:
     show_modal.click(create_json_one_individual)
     show_modal.click(create_tmp)
     #submit_button.click(save_and_rest_df, inputs=[df], outputs=[df])
-    submit_button.click(save_individual_to_gallery)
 
 
      

app/physical/class_physical.py

@@ -16,52 +16,52 @@ CommonAnomalies = Literal[
 # --- Beak-related Anomalies ---
 class BeakAnomaly(BaseModel):
     type: Literal['beak']
-    anomaly_type: Literal[
+    anomaly_type: List[Literal[
         'adhesion',
         'deformation',
         CommonAnomalies
-    ]
+    ]]
 
 # --- Body-related Anomalies ---
 class BodyAnomaly(BaseModel):
     type: Literal['body']
-    anomaly_type: Literal[
+    anomaly_type: List[Literal[
         'emaciation',
         'fluffed up',
         'stained feathers',
         CommonAnomalies
-    ]
+    ]]
 
 # --- Legs-related Anomalies ---
 class LegAnomaly(BaseModel):
     type: Literal['legs']
-    anomaly_type: Literal[
+    anomaly_type: List[Literal[
         'missing limb',
         'deformation',
         CommonAnomalies
-    ]
+    ]]
 
 # --- Feathers/Wings/Tail-related Anomalies ---
 class FeathersWingsTailAnomaly(BaseModel):
     type: Literal['feathers/wings/tail']
-    anomaly_type: Literal[
+    anomaly_type: List[Literal[
         'fluffed up',
         'feather abnormalities',
         'stained feathers',
         'abnormal wing posture',
         'missing limb',
         CommonAnomalies
-    ]
+    ]]
 
 # --- Head-related Anomalies (including eyes) ---
 class HeadAnomaly(BaseModel):
-    type: Literal['head']
-    anomaly_type: Literal[
+    type: Literal['head incl. eyes']
+    anomaly_type: List[Literal[
         'ear changes',
         'eye changes',
         'tilted head',
         CommonAnomalies
-    ]
+    ]]
 
 
 # Union of all possible anomaly types for specific body parts
@@ -76,4 +76,4 @@ AnomalyType = Union[
 # Main PhysicalAnomaly class that logs anomalies across different body parts
 class PhysicalAnomalies(BaseModel):
     physical_radio: str
-    physical_anomalies_type: List[AnomalyType] = Field(..., discriminator='type')
+    physical_anomalies_type: Optional[List[AnomalyType]] = None

app/physical/physical_checkbox.py

@@ -72,8 +72,9 @@ def process_body_parts(section, matched_box):
 #--------------------------------------------------------- 
 
 def on_select_body_part(body_part_checkbox, body_part): 
-    add_data_tmp("wounded_dead", "physical_type_"+body_part, body_part)
-    add_data_tmp("wounded_dead", "physical_anomaly_type_"+body_part, body_part_checkbox)
+    add_data_tmp("wounded_dead", "physical_type_"+body_part.lower(), body_part.lower())
+    body_part_checkbox = [body_part_check.lower() for body_part_check in body_part_checkbox]
+    add_data_tmp("wounded_dead", "physical_anomaly_"+body_part.lower(), body_part_checkbox)
 
 #--------------------------------------------------------- 
 

app/validation_submission/add_json.py

@@ -8,7 +8,7 @@ def add_data_to_individual(key, value):
     create_json_one_individual(one_individual)
 
 def add_data_tmp(tmp_name, key, value): 
-    with open(f"app/assets/json_tmp/tmp_{tmp_name}.json", 'r') as openfile:
+    with open(f"app/assets/tmp_json/tmp_{tmp_name}.json", 'r') as openfile:
         tmp = json.load(openfile)
     tmp[key] = value
     create_tmp(tmp_name, tmp)

app/validation_submission/create_json.py

@@ -12,5 +12,5 @@ def create_json_all_individuals(all_individuals={}):
 
 def create_tmp(tmp_name="wounded_dead", tmp={}):
     tmp = json.dumps(tmp)
-    with open(f"app/assets/json_tmp/tmp_{tmp_name}.json", "w") as outfile:
+    with open(f"app/assets/tmp_json/tmp_{tmp_name}.json", "w") as outfile:
         outfile.write(tmp)

app/validation_submission/get_json.py

@@ -11,6 +11,6 @@ def get_json_all_individuals():
     return all_individuals
 
 def get_json_tmp(tmp_name):
-    with open(f"app/assets/json_tmp/tmp_{tmp_name}.json", "r") as openfile:
+    with open(f"app/assets/tmp_json/tmp_{tmp_name}.json", "r") as openfile:
         tmp_json = json.load(openfile)
     return tmp_json

app/validation_submission/processing.py

@@ -0,0 +1,110 @@
+#### PROCESS FUNCTIONS 
+
+def process_circumstance(data):
+    fields_to_check = ["option_dropdown", "open_field", "extra"]
+    if data["circumstance_radio"] == "Yes":
+        for field in fields_to_check:
+            if data["circumstance_type"][field+"_label"] == "NA":
+                data["circumstance_type"].pop(field+"_label")
+            else :
+                val = data[f"circumstance_{field}"]
+                key = data["circumstance_type"][field+"_label"]
+                data["circumstance_type"][key] = val
+                data["circumstance_type"].pop(field+"_label")
+    # {"circumstance_radio": true, 
+    #  "circumstance": "destruction / deliberatly removed", 
+    #  "cirumstance_type": {"type": "removal or direct capture", 
+    #                       "option_dropdown_label": "method",
+    #                       "open_field_label": "NA", 
+    #                       "extra_label": "NA"}, 
+    # "circumstance_option_dropdown": "Traffic/Trade"}
+    return data
+
+def process_behaviors(data):
+    # INPUT  : 
+    #"behaviors_radio": true, 
+    # "behaviors_type": ["Crash, Falling From The Sky", "Neurological"]
+    #OUTPUT: 
+#     "behaviors_radio": "Yes",
+#   "behaviors_type": [
+#     {
+#       "type": "abnormal breathing",
+#       "description": "Problems breathing, breathing sounds"
+#     }
+    behaviors =[]
+    if data["behaviors_radio"] == "Yes":
+        for type in data["behaviors_type"]: 
+            new_behavior = {}
+            new_behavior["type"] = type
+            behaviors.append(new_behavior)
+        data["behaviors_type"] = behaviors
+    return data 
+
+def process_physical(data):
+    # INPUT
+    # "physical_type_feathers": "feathers", 
+    # "physical_anomaly_type_feathers": ["Blood", "Swelling"]}
+
+    # OUTPUT
+#     "physical_radio": "Yes",
+#   "physical_anomalies_type": [
+#     {
+#       "type": "beak",
+#       "anomaly_type": "deformation"
+#     },
+#     {
+#       "type": "body",
+#       "anomaly_type": "fluffed up"
+#     },
+    body_parts= ["beak", "body", "legs", "feathers/wings/tail", "head incl. eyes"]
+    anomalies=[]
+    reformatted = {}
+    reformatted["physical_radio"] = data["physical_radio"]
+    if data["physical_radio"] == "Yes":
+        for body_part in body_parts:
+            anomaly = {}
+            for key, val in data.items(): 
+                if "type_"+ body_part in key:
+                    anomaly["type"] = body_part
+                elif "anomaly_"+ body_part in key:
+                    anomaly["anomaly_type"] = val
+            if anomaly: 
+                anomalies.append(anomaly)
+        reformatted["physical_anomalies_type"] = anomalies
+    return reformatted
+
+def process_followup(data):
+    #     "follow_up_events": [
+#     {
+#       "type": "animal collected",
+#       "option": "Yes"
+#     },
+#     {
+#       "type": "recipient",
+#       "option": "Veterinary",
+#       "name_recipient": "Dr. Jane Smith"
+#     },
+#     {
+#       "type": "radiography",
+#       "option": "Unknown"
+#     },
+#     {
+#       "type": "given answer",
+#       "option": "Discussion with the speaker"
+#     },
+#     {
+#       "type": "collection reference",
+#       "reference": "Specimen ID: 12345, Collected on 2023-09-15"
+#     }
+#   ]
+    followup_events = []
+    for key, val in data.items(): 
+        followup_event={}
+        type = key.split("followup")[-1]
+        option = type.split(" ")[-1]
+        followup_event["type"] = type.strip()
+        followup_event[option.strip()] = val 
+        followup_events.append(followup_event)
+    reformatted ={}
+    reformatted["follow_up_events"] = followup_events
+    return reformatted

app/validation_submission/submission.py

@@ -1,5 +1,11 @@
 import json 
 from validation_submission.get_json import get_json_all_individuals
+from validation_submission.validation import validate_individual
+
+def validate_save_individual():
+    individual = validate_individual()
+    save_to_all_individuals(individual.model_dump())
+    return individual
 
 def save_to_all_individuals(one_individual):
     all_individuals = get_json_all_individuals()

app/validation_submission/validation.py

@@ -1,9 +1,12 @@
+import uuid
+
 from validation_submission.get_json import get_json_tmp, get_json_one_individual
-from classes import Report
 from circumstances.class_circumstance import Circumstances
 from behavior.class_behavior import Behaviors
 from physical.class_physical import PhysicalAnomalies
 from follow_up.class_follow_up import FollowUpEvents
+from classes import Report, Wounded, Dead, ImageBase64
+from validation_submission.processing import process_circumstance, process_behaviors, process_physical, process_followup
 
 def get_fields(data_dict, keyword): 
     extract = {} 
@@ -13,154 +16,84 @@ def get_fields(data_dict, keyword):
     return extract
 
 def validate_individual():
-    data = get_json_tmp("wounded_dead")
-    circumstance = validate_circumstance(data)
-    behaviors = validate_behavior(data)
-    validate_physical(data)
-    validate_follow_up(data)
-    validate_individual()
-    pass
-
-#### PROCESS FUNCTIONS 
-
-def process_circumstance(data):
-    fields_to_check = ["option_dropdown", "open_field", "extra"]
-    for field in fields_to_check:
-        if data["circumstance_type"][field+"_label"] == "NA":
-            data["circumstance_type"].pop([field+"_label"])
-        else :
-            key = data[f"circumstance_{field}"]
-            val = data["circumstance_type"][field+"_label"]
-            data["circumstance_type"][key] = val
-            data["circumstance_type"].pop([field+"_label"])
-    # {"circumstance_radio": true, 
-    #  "circumstance": "destruction / deliberatly removed", 
-    #  "cirumstance_type": {"type": "removal or direct capture", 
-    #                       "option_dropdown_label": "method",
-    #                       "open_field_label": "NA", 
-    #                       "extra_label": "NA"}, 
-    # "circumstance_option_dropdown": "Traffic/Trade"}
-    return data
-
-def process_behaviors(data):
-    # INPUT  : 
-    #"behaviors_radio": true, 
-    # "behaviors_type": ["Crash, Falling From The Sky", "Neurological"]
-    #OUTPUT: 
-#     "behaviors_radio": "Yes",
-#   "behaviors_type": [
-#     {
-#       "type": "abnormal breathing",
-#       "description": "Problems breathing, breathing sounds"
-#     }
-    behaviors =[]
-    for type in data["behaviors_type"]: 
-        new_behavior = {}
-        new_behavior["type"] = type
-        behaviors.append(new_behavior)
-    data["behaviors_type"] = behaviors
-    return data 
+    data = get_json_one_individual()
+    data["identifier"] = str(uuid.uuid4())
+    if "wounded_state" not in data or "dead_state" not in data:
+        data["wounded_state"] = "No"
+        data["dead_state"] = "No"
+    if (data["wounded_state"] == "Yes") or (data["dead_state"] == "Yes"):
+        data_wounded_dead = get_json_tmp("wounded_dead")
+        circumstance = validate_circumstance(data_wounded_dead)
+        physical = validate_physical(data_wounded_dead)
+        followup = validate_follow_up(data_wounded_dead)
 
-def process_physical(data):
-    # INPUT
-    # "physical_type_feathers": "feathers", 
-    # "physical_anomaly_type_feathers": ["Blood", "Swelling"]}
+        if data["wounded_state"]=="Yes":
+            behavior = validate_behavior(data_wounded_dead)
+            individual = Report(identifier = data["identifier"],
+                                image = ImageBase64.to_base64(data["image"]),
+                                geolocalisation = data["geolocalisation"],
+                                wounded_state = data["wounded_state"],
+                                wounded = Wounded(circumstances = circumstance,
+                                                    behaviors = behavior,
+                                                    physical_anomalies = physical,
+                                                    follow_up_events = followup),
+                                dead_state = data["dead_state"])
+        elif data["dead_state"]=="Yes":
+            individual = Report(identifier = data["identifier"],
+                                image = ImageBase64.to_base64(data["image"]),
+                                geolocalisation = data["geolocalisation"],
+                                wounded_state = data["wounded_state"],
+                                dead_state = data["dead_state"],
+                                dead = Dead(circumstances = circumstance,
+                                                    physical_anomalies = physical,
+                                                    follow_up_events = followup)
+                                    )
+    else:
+        data["image"] = ImageBase64.to_base64(data["image"])
+        if not Report(**data).validate(): 
+            print("Validation failed for creating the individual report.")
+        else:
+            individual = Report(**data)
+    return individual
 
-    # OUTPUT
-#     "physical_radio": "Yes",
-#   "physical_anomalies_type": [
-#     {
-#       "type": "beak",
-#       "anomaly_type": "deformation"
-#     },
-#     {
-#       "type": "body",
-#       "anomaly_type": "fluffed up"
-#     },
-    body_parts= ["beak", "body", "legs", "feathers", "head"]
-    anomalies=[]
-    reformatted = {}
-    reformatted["physical_radio"] = data["physical_radio"]
-    for body_part in body_parts:
-        anomaly = {}
-        for key, val in data.items(): 
-            if "type_"+ body_part in key:
-                anomaly["type"] = val
-            elif "anomaly_type_"+ body_part in key:
-                anomaly["anomaly_type"] = val
-        anomalies.append(anomaly)
-    reformatted["physical_anomalies_type"] = anomalies
-    return reformatted
 
-def process_followup(data):
-    #     "follow_up_events": [
-#     {
-#       "type": "animal collected",
-#       "option": "Yes"
-#     },
-#     {
-#       "type": "recipient",
-#       "option": "Veterinary",
-#       "name_recipient": "Dr. Jane Smith"
-#     },
-#     {
-#       "type": "radiography",
-#       "option": "Unknown"
-#     },
-#     {
-#       "type": "given answer",
-#       "option": "Discussion with the speaker"
-#     },
-#     {
-#       "type": "collection reference",
-#       "reference": "Specimen ID: 12345, Collected on 2023-09-15"
-#     }
-#   ]
-    followup_events = []
-    for key, val in data.items(): 
-        followup_event={}
-        type = key.split("followup")[-1]
-        option = type.split(" ")[-1]
-        followup_event["type"] = type
-        followup_event[option] = val 
-        followup_events.append(followup_event)
-    return followup_events
 
 #### VALIDATION FUNCTIONS
 def validate_circumstance(data): 
     circumstance_raw = get_fields(data, "circumstance")
     circumstance_formatted = process_circumstance(circumstance_raw)
-    if not Circumstances(**circumstance_formatted).validate(): 
+    if not Circumstances.model_validate(circumstance_formatted): 
         print("Validation failed for the circumstance.")
     else: 
         return Circumstances(**circumstance_formatted)
 
 def validate_behavior(data): 
-    behaviors_raw = get_fields(data, "behaviours")
+    behaviors_raw = get_fields(data, "behaviors")
     behaviors_formatted = process_behaviors(behaviors_raw)
-    if not Behaviors(**behaviors_formatted).validate(): 
-        print("Validation failed for the behaviours.")
-    else: 
+    try:
+        Behaviors.model_validate(behaviors_formatted)
         return Behaviors(**behaviors_formatted)
+    except: 
+        print("Validation failed for the behaviors.")
+        
 
 def validate_physical(data): 
     physical_raw = get_fields(data, "physical")
     physical_formatted = process_physical(physical_raw)
-    if not PhysicalAnomalies(**physical_formatted).validate(): 
-        print("Validation failed for the physical anomalies.")
-    else: 
+    try: 
+        PhysicalAnomalies.model_validate(physical_formatted)
         return PhysicalAnomalies(**physical_formatted)
-
+    except:
+        print("Validation failed for the physical anomalies.")
+        
 def validate_follow_up(data):
     followup_raw = get_fields(data, "followup")
     followup_formatted = process_followup(followup_raw)
-    if not FollowUpEvents(**followup_formatted).validate(): 
-        print("Validation failed for the follow-up events.")
-    else:
+    try: 
+        FollowUpEvents.model_validate(followup_formatted)
         return FollowUpEvents(**followup_formatted)
-
-def validate_individual():
-    individual = get_json_one_individual()
-    if not Report(individual).validate(): 
-        print("Validation failed for creating the individual report.")
-    pass
+    except:
+        print("Validation failed for the follow-up events.")
+    
+        
+ 

app/wounded.py

@@ -8,8 +8,8 @@ from validation_submission.add_json import add_data_to_individual
 
 def show_section_wounded(visible):
     if visible==True: 
-        add_data_to_individual("wounded_bool", "True")
-        add_data_to_individual("dead_bool", "False")
+        add_data_to_individual("wounded_state", "Yes")
+        add_data_to_individual("dead_state", "No")
         
     with gr.Column(visible=visible, elem_id="wounded") as wounded_section:
         gr.Markdown("# Wounded Animal")