bug: Expanded Pydantic class to make it compatible with simple and advance mode

README.md

@@ -13,7 +13,7 @@ short_description: Digiwild
 ## Docker
 
 ``` bash
-docker build -t ordes/digiwild . 
+docker build -t ordes/digiwild .
 ```
 
 
@@ -29,18 +29,17 @@ python3 main.py
 ### How to develop on docker
 
 ``` bash
-docker run -it -p 7860:7860 -v $(pwd):/home/user/digiwild/ ordes/digiwild
+docker run -it -p 7860:7860 -v $(pwd):/home/user/digiwild/ --entrypoint bash ordes/digiwild
 ```
 
 ## TODO
 
 - [x] Change `wounded` to `wounded / sick`
 - [x] Info formatting
-- [ ] Use in memory object instead of files to avoid writting / reading problems.
+- [x] Use in memory object instead of files to avoid writting / reading problems.
 - [ ] Connection to a database? Maybe an open MongoDB
 - [x] GPS Compatibility
 - [x] New fields suggested: Number individuals, Species, Comments
-- [ ] Save new fields values into the JSON. Perform validation too.
 - [ ] Add info and placeholder information to the different components.
 
 ## Needs
@@ -50,5 +49,3 @@ docker run -it -p 7860:7860 -v $(pwd):/home/user/digiwild/ ordes/digiwild
 - GPS location
 - Comments
 - Symptomps selection (Dropdown)
-
-## PR Updates

app/behavior/behavior_checkbox.py

@@ -4,33 +4,41 @@ from utils.utils_checkbox import create_checkbox
 from utils.utils_visible import set_visible
 from validation_submission.utils_individual import add_data_to_individual
 
-def on_select_behavior(behavior_checkbox, individual): 
+
+def on_select_behavior(behavior_checkbox, individual):
     behavior_checkbox = [behavior.lower() for behavior in behavior_checkbox]
     individual = add_data_to_individual("behaviors_type", behavior_checkbox, individual)
     return individual
 
-def retrieve_behavior_options_description(mode:str):
-    print(mode)
-    if mode =="simple": 
-        dropdown_config = get_custom_config_dropdowns("config_checkbox_behavior_simple.json")
-    elif mode=="advanced": 
+
+def retrieve_behavior_options_description(mode: str):
+    # print(f"Retrieve Behavior Option Description: {mode}")
+    if mode == "simple":
+        dropdown_config = get_custom_config_dropdowns(
+            "config_checkbox_behavior_simple.json"
+        )
+    elif mode == "advanced":
         dropdown_config = get_custom_config_dropdowns("config_checkbox_behavior.json")
     options = list(dropdown_config.keys())
     options = [option.title() for option in options]
-    descriptions =[]
-    for _,subdict in dropdown_config.items():
+    descriptions = []
+    for _, subdict in dropdown_config.items():
         descriptions.append(subdict["Description"])
     return options, descriptions
 
+
 def create_behavior_checkbox(section: str, mode: str, visible):
     options, descriptions = retrieve_behavior_options_description(mode)
     label_checkbox = "Behavior changes observed"
-    checkbox, text = create_checkbox("", section, label_checkbox, visible, options, descriptions)
+    checkbox, text = create_checkbox(
+        "", section, label_checkbox, visible, options, descriptions
+    )
     return checkbox, text
 
-def show_behavior(choice, section: str, mode: str, individual): 
-    print(mode)
+
+def show_behavior(choice, section: str, mode: str, individual):
+    # print(f"Show Behavior: {mode}")
     visible = set_visible(choice)
     checkbox, text = create_behavior_checkbox(section, mode, visible)
     individual = add_data_to_individual("behaviors_radio", choice, individual)
-    return checkbox, text, individual
+    return checkbox, text, individual

app/behavior/class_behavior_simple.py

@@ -1,34 +1,42 @@
 from pydantic import BaseModel, Field
 from typing import Literal, List, Union, Optional
 
+
 class BehaviorSimple(BaseModel):
     type: str
     description: Optional[str] = None  # Making the description field optional
 
+
 # --- Specific BehaviorSimple classes ---
 class GeneralWeakness(BehaviorSimple):
-    type: Literal['general weakness']
-    description: Optional[Literal["Abnormal breathing (dyspnoea), sudden crash, apathy, lethargy, unable to fly but responsive"]] = None
+    type: Literal["general weakness"]
+    description: Optional[
+        Literal[
+            "Abnormal breathing (dyspnoea), sudden crash, apathy, lethargy, unable to fly but responsive"
+        ]
+    ] = None
+
 
 class Vomiting(BehaviorSimple):
-    type: Literal['vomiting']
+    type: Literal["vomiting"]
     description: Optional[Literal["Throwing up undigested food, regurgitating"]] = None
 
+
 class AtypicalBehavior(BehaviorSimple):
-    type: Literal['atypical behavior']
-    description: Optional[Literal["Circling, incoordination, tremors, convulsions"]] = None
+    type: Literal["atypical behavior"]
+    description: Optional[
+        Literal["Circling, incoordination, tremors, convulsions"]
+    ] = None
+
 
 class NoChanges(BehaviorSimple):
-    type: Literal['no changes']
+    type: Literal["no changes"]
     description: Optional[Literal["Animal is acting normally"]] = None
 
+
 # Union of all possible behaviors
-BehaviorSimpleType = Union[
-    GeneralWeakness,
-    Vomiting,
-    AtypicalBehavior,
-    NoChanges
-]
+BehaviorSimpleType = Union[GeneralWeakness, Vomiting, AtypicalBehavior, NoChanges]
+
 
 # Main class that logs multiple behaviors
 class BehaviorsSimple(BaseModel):

app/circumstances/circumstances_dropdowns.py

@@ -2,114 +2,141 @@ import gradio as gr
 from utils.utils_config import get_custom_config_dropdowns
 from validation_submission.utils_individual import add_data_to_individual
 
-#--------------------------------------------------------- LEVEL 1 DROPDOWNS
+
+# --------------------------------------------------------- LEVEL 1 DROPDOWNS
 def retrieve_config_options(label, dropdown_config):
     options = list(dropdown_config[label].keys())
     options = [option.title() for option in options]
     return options
 
-def reinitialise_level2(): 
+
+def reinitialise_level2():
     dropdown_level2 = gr.Dropdown(choices=[], visible=False)
     openfield_level2 = gr.Textbox(visible=False)
     dropdown_extra_level2 = gr.Dropdown(choices=[], visible=False)
     return dropdown_level2, openfield_level2, dropdown_extra_level2
 
-def create_dropdown_level1(label, individual): 
+
+def create_dropdown_level1(label, individual):
     dropdown_config = get_custom_config_dropdowns("config_dropdown_circumstances.json")
     options = retrieve_config_options(label, dropdown_config)
     dropdown = gr.Dropdown(choices=options, label=label, interactive=True, visible=True)
     dropdown_level2, openfield_level2, dropdown_extra_level2 = reinitialise_level2()
-    return dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2, individual
-    
+    return (
+        dropdown,
+        dropdown_level2,
+        openfield_level2,
+        dropdown_extra_level2,
+        individual,
+    )
+
+
 def dropdown_collision(individual):
     label = "Collision with a means of transport"
     individual = add_data_to_individual("circumstance", label.lower(), individual)
     return create_dropdown_level1(label, individual)
 
+
 def dropdown_deliberate_destruction(individual):
     label = "Destruction / Deliberatly removed"
     individual = add_data_to_individual("circumstance", label.lower(), individual)
-    return create_dropdown_level1(label, individual)     
+    return create_dropdown_level1(label, individual)
+
 
-def dropdown_indirect_destruction(individual): 
+def dropdown_indirect_destruction(individual):
     label = "Indirect destruction"
     individual = add_data_to_individual("circumstance", label.lower(), individual)
-    return create_dropdown_level1(label, individual) 
+    return create_dropdown_level1(label, individual)
 
-def dropdown_natural_cause(individual): 
+
+def dropdown_natural_cause(individual):
     label = "Natural cause"
-    individual = add_data_to_individual( "circumstance", label.lower(), individual)
-    return create_dropdown_level1(label, individual)         
+    individual = add_data_to_individual("circumstance", label.lower(), individual)
+    return create_dropdown_level1(label, individual)
 
 
-#--------------------------------------------------------- LEVEL 2 DROPDOWNS
+# --------------------------------------------------------- LEVEL 2 DROPDOWNS
 def get_options(value):
-        value = value.lower()
-        options_label = None
-        options_dropdown= None
-        open_field = None
-        extras = None
-        extras_label = None
-        dropdown_config = get_custom_config_dropdowns("config_dropdown_circumstances.json")
-        for _, sub_dict in dropdown_config.items():
-            nested_dict = sub_dict.get(value)
-            if nested_dict is not None: 
-                if "Options" in nested_dict.keys():
-                    options_dict = nested_dict["Options"]
-                    options_label = list(options_dict.keys())[0]
-                    options_dropdown = list(options_dict.values())[0]
-                    options_dropdown = [option.title() for option in options_dropdown]
-                if "Open" in nested_dict.keys():
-                    open_field = nested_dict["Open"]
-                    open_field = open_field.title()
-                if "Extra" in nested_dict.keys():
-                    for key, val in nested_dict["Extra"].items():
-                        extras_label = key
-                        extras = val
-                        extras = [extra.title() for extra in extras]
-        return options_label, options_dropdown, open_field, extras, extras_label
-
-       
+    value = value.lower()
+    options_label = None
+    options_dropdown = None
+    open_field = None
+    extras = None
+    extras_label = None
+    dropdown_config = get_custom_config_dropdowns("config_dropdown_circumstances.json")
+    for _, sub_dict in dropdown_config.items():
+        nested_dict = sub_dict.get(value)
+        if nested_dict is not None:
+            if "Options" in nested_dict.keys():
+                options_dict = nested_dict["Options"]
+                options_label = list(options_dict.keys())[0]
+                options_dropdown = list(options_dict.values())[0]
+                options_dropdown = [option.title() for option in options_dropdown]
+            if "Open" in nested_dict.keys():
+                open_field = nested_dict["Open"]
+                open_field = open_field.title()
+            if "Extra" in nested_dict.keys():
+                for key, val in nested_dict["Extra"].items():
+                    extras_label = key
+                    extras = val
+                    extras = [extra.title() for extra in extras]
+    return options_label, options_dropdown, open_field, extras, extras_label
+
+
 def on_select(evt: gr.SelectData, individual):  # SelectData is a subclass of EventData
-    options_label, options_dropdown, open_field, extras, extras_label = get_options(evt.value)
+    options_label, options_dropdown, open_field, extras, extras_label = get_options(
+        evt.value
+    )
     individual = add_data_to_individual(
-                    "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',
-                     "extra_label": extras_label.lower() if extras_label is not None else 'NA'
-                    }, individual)
+        "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",
+            "extra_label": extras_label.lower() if extras_label is not None else "NA",
+        },
+        individual,
+    )
     if options_dropdown is not None:
-        dropdown_level2 = gr.Dropdown(choices=options_dropdown, label=evt.value, interactive=True, visible=True)
-    else: 
+        dropdown_level2 = gr.Dropdown(
+            choices=options_dropdown, label=evt.value, interactive=True, visible=True
+        )
+    else:
         dropdown_level2 = gr.Dropdown(choices=[], visible=False)
 
     if open_field is not None:
         openfield_level2 = gr.Textbox(label=open_field, interactive=True, visible=True)
-    else: 
+    else:
         openfield_level2 = gr.Textbox(visible=False)
 
-    if extras is not None: 
-        dropdown_extra_level2 = gr.Dropdown(choices=extras, label=extras_label, interactive=True, visible=True)
-    else: 
+    if extras is not None:
+        dropdown_extra_level2 = gr.Dropdown(
+            choices=extras, label=extras_label, interactive=True, visible=True
+        )
+    else:
         dropdown_extra_level2 = gr.Dropdown(choices=[], visible=False)
     return dropdown_level2, openfield_level2, dropdown_extra_level2, individual
 
-def on_select_dropdown_level2(evt: gr.SelectData, individual): 
-    individual = add_data_to_individual( 
-                "circumstance_option_dropdown", 
-                evt.value.lower(), individual)
+
+def on_select_dropdown_level2(evt: gr.SelectData, individual):
+    individual = add_data_to_individual(
+        "circumstance_option_dropdown", evt.value.lower(), individual
+    )
     return individual
 
-def on_select_dropdown_extra_level2(evt: gr.SelectData, individual):  
-    individual = add_data_to_individual( 
-                 "circumstance_extra", 
-                 evt.value.lower(), individual)
+
+def on_select_dropdown_extra_level2(evt: gr.SelectData, individual):
+    individual = add_data_to_individual(
+        "circumstance_extra", evt.value.lower(), individual
+    )
     return individual
-    
-def on_change_openfield_level2(openfield_level2_dead, individual): 
-    print("Saving open field")
+
+
+def on_change_openfield_level2(openfield_level2_dead, individual):
+    # print("Saving open field")
     individual = add_data_to_individual(
-                "circumstance_open_field", 
-                str(openfield_level2_dead).lower(), individual)
-    return individual
+        "circumstance_open_field", str(openfield_level2_dead).lower(), individual
+    )
+    return individual

app/classes.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel, Field
-from typing import Optional
+from typing import Optional, Union
 import numpy as np
 from PIL import Image
 import io
@@ -7,24 +7,30 @@ import base64
 import uuid
 
 from behavior.class_behavior import Behaviors
+from behavior.class_behavior_simple import BehaviorsSimple
 from circumstances.class_circumstance import Circumstances
 from physical.class_physical import PhysicalAnomalies
+from physical.class_physical_simple import PhysicalAnomaliesSimple
 from follow_up.class_follow_up import FollowUpEvents
 from geolocalisation.class_geolocalisation import Geolocalisation
 
+
 class Wounded(BaseModel):
     circumstances: Circumstances
-    behaviors: Behaviors
-    physical_anomalies: PhysicalAnomalies
+    behaviors: Union[Behaviors, BehaviorsSimple]
+    physical_anomalies: Union[PhysicalAnomalies, PhysicalAnomaliesSimple]
     follow_up_events: FollowUpEvents
 
+
 class Dead(BaseModel):
     circumstances: Circumstances
-    physical_anomalies: PhysicalAnomalies
+    physical_anomalies: Union[PhysicalAnomalies, PhysicalAnomaliesSimple]
     follow_up_events: FollowUpEvents
 
+
 class ImageBase64(BaseModel):
-    image: str  
+    image: str
+
     @classmethod
     def to_base64(cls, pixel_data: list):
         img_array = np.array(pixel_data, dtype=np.uint8)
@@ -33,15 +39,16 @@ class ImageBase64(BaseModel):
         buffer = io.BytesIO()
         img.save(buffer, format="PNG")
         buffer.seek(0)
-        base64_str = base64.b64encode(buffer.read()).decode('utf-8')
+        base64_str = base64.b64encode(buffer.read()).decode("utf-8")
         return cls(image=base64_str)
-    
+
+
 class Report(BaseModel):
     identifier: str
     image: ImageBase64
     image_md5: str
     geolocalisation: Geolocalisation
     wounded_state: str
-    wounded: Optional[Wounded] = None  
+    wounded: Optional[Wounded] = None
     dead_state: str
-    dead: Optional[Dead] = None 
+    dead: Optional[Dead] = None

app/physical/physical_checkbox.py

@@ -1,92 +1,168 @@
 import gradio as gr
 from utils.utils_config import get_custom_config_dropdowns
 from utils.utils_checkbox import create_checkbox
-from validation_submission.utils_individual import add_data_to_individual 
-#--------------------------------------------------------- 
+from validation_submission.utils_individual import add_data_to_individual
+
+
+# ---------------------------------------------------------
 def get_body_parts(mode):
-    if mode=="simple":
-        dropdown_config = get_custom_config_dropdowns("config_checkbox_physical_simple.json")
+    if mode == "simple":
+        dropdown_config = get_custom_config_dropdowns(
+            "config_checkbox_physical_simple.json"
+        )
     elif mode == "advanced":
         dropdown_config = get_custom_config_dropdowns("config_checkbox_physical.json")
     return list(dropdown_config.keys())
 
+
 def retrieve_config_options(label, dropdown_config):
     options = list(dropdown_config[label].keys())
     options = [option.title() for option in options]
     return options
 
+
 def get_options_description(value, mode):
-        print(mode)
-        if mode=="simple":
-            dropdown_config = get_custom_config_dropdowns("config_checkbox_physical_simple.json")
-        elif mode == "advanced": 
-            dropdown_config = get_custom_config_dropdowns("config_checkbox_physical.json")
-        # get options
-        options_common = retrieve_config_options("Common", dropdown_config)
-        options_for_value = retrieve_config_options(value, dropdown_config)
-        options_common.extend(options_for_value)
-        options = options_common
-        # get descriptions
-        descriptions = []
-        for key, sub_dict in dropdown_config.items():
-            if key==value or key=="Common":
-                for _, option_dict in sub_dict.items():
-                    for description_tag, description in option_dict.items():
-                        if "Description"==description_tag:
-                            descriptions.append(description)
-        return options, descriptions
-
-#--------------------------------------------------------- 
+    # print(f"Get options description: {mode}")
+    if mode == "simple":
+        dropdown_config = get_custom_config_dropdowns(
+            "config_checkbox_physical_simple.json"
+        )
+    elif mode == "advanced":
+        dropdown_config = get_custom_config_dropdowns("config_checkbox_physical.json")
+    # get options
+    options_common = retrieve_config_options("Common", dropdown_config)
+    options_for_value = retrieve_config_options(value, dropdown_config)
+    options_common.extend(options_for_value)
+    options = options_common
+    # get descriptions
+    descriptions = []
+    for key, sub_dict in dropdown_config.items():
+        if key == value or key == "Common":
+            for _, option_dict in sub_dict.items():
+                for description_tag, description in option_dict.items():
+                    if "Description" == description_tag:
+                        descriptions.append(description)
+    return options, descriptions
+
+
+# ---------------------------------------------------------
 def create_checkbox_beak(section, mode, label_checkbox, visible):
-    body_part="Beak"
+    body_part = "Beak"
     options, descriptions = get_options_description(body_part, mode)
-    return create_checkbox(body_part, section, label_checkbox, visible, options, descriptions)
+    return create_checkbox(
+        body_part, section, label_checkbox, visible, options, descriptions
+    )
+
 
 def create_checkbox_body(section, mode, label_checkbox, visible):
-    body_part="Body"
+    body_part = "Body"
     options, descriptions = get_options_description(body_part, mode)
-    return create_checkbox(body_part, section, label_checkbox, visible, options, descriptions)
+    return create_checkbox(
+        body_part, section, label_checkbox, visible, options, descriptions
+    )
+
 
 def create_checkbox_feathers(section, mode, label_checkbox, visible):
-    body_part="Feathers/Wings/Tail"
+    body_part = "Feathers/Wings/Tail"
     options, descriptions = get_options_description(body_part, mode)
-    return create_checkbox(body_part, section, label_checkbox, visible, options, descriptions)
+    return create_checkbox(
+        body_part, section, label_checkbox, visible, options, descriptions
+    )
+
 
 def create_checkbox_head(section, mode, label_checkbox, visible):
-    body_part="Head incl. eyes"
+    body_part = "Head incl. eyes"
     options, descriptions = get_options_description(body_part, mode)
-    return create_checkbox(body_part, section, label_checkbox, visible, options, descriptions)
+    return create_checkbox(
+        body_part, section, label_checkbox, visible, options, descriptions
+    )
+
 
 def create_checkbox_legs(section, mode, label_checkbox, visible):
-    body_part="Legs"
+    body_part = "Legs"
     options, descriptions = get_options_description(body_part, mode)
-    return create_checkbox(body_part, section, label_checkbox, visible, options, descriptions)
+    return create_checkbox(
+        body_part, section, label_checkbox, visible, options, descriptions
+    )
+
 
-#---------------------------------------------------------
+# ---------------------------------------------------------
 def process_body_parts(section, mode, matched_box):
-    #take all except "Common"
+    # take all except "Common"
     body_parts = get_body_parts(mode)
     body_parts = body_parts[1:]
     label_checkbox = "Physical changes to "
-    visibles = [True if matched_box==body_part else False for body_part in body_parts ]
-    checkbox_beak, text_beak = create_checkbox_beak(section, mode,  label_checkbox, visibles[0])
-    checkbox_body, text_body = create_checkbox_body(section, mode, label_checkbox, visibles[1])
-    checkbox_feathers, text_feathers = create_checkbox_feathers(section, mode, label_checkbox, visibles[2])
-    checkbox_head, text_head = create_checkbox_head(section, mode, label_checkbox, visibles[3])
-    checkbox_legs, text_legs = create_checkbox_legs(section, mode, label_checkbox, visibles[4])
-    return checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
-          
-#--------------------------------------------------------- 
-
-def on_select_body_part(body_part_checkbox, body_part, individual): 
-    individual = add_data_to_individual("physical_type_"+body_part.lower(), body_part.lower(), individual)
-    body_part_checkbox = [body_part_check.lower() for body_part_check in body_part_checkbox]
-    individual = add_data_to_individual("physical_anomaly_"+body_part.lower(), body_part_checkbox, individual)
+    visibles = [True if matched_box == body_part else False for body_part in body_parts]
+    checkbox_beak, text_beak = create_checkbox_beak(
+        section, mode, label_checkbox, visibles[0]
+    )
+    checkbox_body, text_body = create_checkbox_body(
+        section, mode, label_checkbox, visibles[1]
+    )
+    checkbox_feathers, text_feathers = create_checkbox_feathers(
+        section, mode, label_checkbox, visibles[2]
+    )
+    checkbox_head, text_head = create_checkbox_head(
+        section, mode, label_checkbox, visibles[3]
+    )
+    checkbox_legs, text_legs = create_checkbox_legs(
+        section, mode, label_checkbox, visibles[4]
+    )
+    return (
+        checkbox_beak,
+        text_beak,
+        checkbox_body,
+        text_body,
+        checkbox_feathers,
+        text_feathers,
+        checkbox_head,
+        text_head,
+        checkbox_legs,
+        text_legs,
+    )
+
+
+# ---------------------------------------------------------
+
+
+def on_select_body_part(body_part_checkbox, body_part, individual):
+    individual = add_data_to_individual(
+        "physical_type_" + body_part.lower(), body_part.lower(), individual
+    )
+    body_part_checkbox = [
+        body_part_check.lower() for body_part_check in body_part_checkbox
+    ]
+    individual = add_data_to_individual(
+        "physical_anomaly_" + body_part.lower(), body_part_checkbox, individual
+    )
     return individual
 
-#--------------------------------------------------------- 
+
+# ---------------------------------------------------------
+
 
 def hide_physical(mode):
-    checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs = process_body_parts("wounded", mode, "None")
-    return checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
-     
+    (
+        checkbox_beak,
+        text_beak,
+        checkbox_body,
+        text_body,
+        checkbox_feathers,
+        text_feathers,
+        checkbox_head,
+        text_head,
+        checkbox_legs,
+        text_legs,
+    ) = process_body_parts("wounded", mode, "None")
+    return (
+        checkbox_beak,
+        text_beak,
+        checkbox_body,
+        text_body,
+        checkbox_feathers,
+        text_feathers,
+        checkbox_head,
+        text_head,
+        checkbox_legs,
+        text_legs,
+    )

app/validation_submission/submission.py

@@ -1,28 +1,31 @@
-import json 
+import json
 from validation_submission.validation import validate_individual
 
 from huggingface_hub import HfApi
 import os
 
+
 def validate_save_individual(data, error_box, mode):
     individual, error_box = validate_individual(data, error_box, mode)
     if individual:
         push_to_dataset_hf(individual.model_dump())
     return error_box
-    
+
+
 def push_to_dataset_hf(individual):
     token = os.environ.get("HF_TOKEN", None)
     api = HfApi(token=token)
     import tempfile
+
     f = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
     json.dump(individual, f)
     f.flush()
     f.close()
-    path_in_repo= f"data/{individual['image_md5']}.json"
-    print(path_in_repo)
+    path_in_repo = f"data/{individual['image_md5']}.json"
+    # print(path_in_repo)
     # api.upload_file(
     #     path_or_fileobj=f.name,
     #     path_in_repo=path_in_repo,
     #     repo_id="SDSC/digiwild-dataset",
     #     repo_type="dataset",
-    # )
+    # )

app/validation_submission/validation.py

@@ -10,22 +10,29 @@ from physical.class_physical import PhysicalAnomalies
 from physical.class_physical_simple import PhysicalAnomaliesSimple
 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
+from validation_submission.processing import (
+    process_circumstance,
+    process_behaviors,
+    process_physical,
+    process_followup,
+)
+
 
 def get_fields(data_dict, keyword):
-    extract = {} 
+    extract = {}
     for key, val in data_dict.items():
         if keyword in key:
             extract[key] = val
     return extract
 
-def validate_individual(data, error_box, mode:str):
+
+def validate_individual(data, error_box, mode: str):
     error_box = reset_error_box(error_box)
-    #data = get_json_one_individual() # TODO: This should change
+    # data = get_json_one_individual() # TODO: This should change
     data["identifier"] = str(uuid.uuid4())
     if "image" in data.keys():
         img = ImageBase64.to_base64(data["image"])
-    else: 
+    else:
         img = None
     if "geolocalisation" in data.keys():
         geolocalisation = data["geolocalisation"]
@@ -33,72 +40,109 @@ def validate_individual(data, error_box, mode:str):
         geolocalisation = None
 
     error_behavior = None
-    error_circumstance = None 
-    error_followup = None 
-    error_physical = None 
+    error_circumstance = None
+    error_followup = None
+    error_physical = None
     error_individual = None
     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 = data #get_json_tmp("wounded_dead")
-        print(data_wounded_dead)
+        data_wounded_dead = data  # get_json_tmp("wounded_dead")
+        # print(f"Data Wounded Dead: {data_wounded_dead}")
         circumstance, error_circumstance = validate_circumstance(data_wounded_dead)
         physical, error_physical = validate_physical(data_wounded_dead, mode)
         followup, error_followup = validate_follow_up(data_wounded_dead)
 
-        if data["wounded_state"]=="Yes":
-            print(physical)
+        if data["wounded_state"] == "Yes":
+            # print(f"Physical: {physical}")
             behavior, error_behavior = validate_behavior(data_wounded_dead, mode)
-            try : 
-                individual = Report(identifier = data["identifier"],
-                                    image = img,
-                                    image_md5 = data["image_md5"],
-                                    geolocalisation = geolocalisation,
-                                    wounded_state = data["wounded_state"],
-                                    wounded = Wounded(circumstances = circumstance,
-                                                        behaviors = behavior,
-                                                        physical_anomalies = physical,
-                                                        follow_up_events = followup),
-                                    dead_state = data["dead_state"])
+            try:
+                individual = Report(
+                    identifier=data["identifier"],
+                    image=img,
+                    image_md5=data["image_md5"],
+                    geolocalisation=geolocalisation,
+                    wounded_state=data["wounded_state"],
+                    wounded=Wounded(
+                        circumstances=circumstance,
+                        behaviors=behavior,
+                        physical_anomalies=physical,
+                        follow_up_events=followup,
+                    ),
+                    dead_state=data["dead_state"],
+                )
             except ValidationError as e:
-                print(e)
+                print("Error in wounded_state:")
+                print(e.json())
                 error_individual = e
 
-        elif data["dead_state"]=="Yes":
-            try: 
-                individual = Report(identifier = data["identifier"],
-                                    image = img,
-                                    image_md5 = data["image_md5"],
-                                    geolocalisation = geolocalisation,
-                                    wounded_state = data["wounded_state"],
-                                    dead_state = data["dead_state"],
-                                    dead = Dead(circumstances = circumstance,
-                                                        physical_anomalies = physical,
-                                                        follow_up_events = followup)
-                                        )
+        elif data["dead_state"] == "Yes":
+            try:
+                individual = Report(
+                    identifier=data["identifier"],
+                    image=img,
+                    image_md5=data["image_md5"],
+                    geolocalisation=geolocalisation,
+                    wounded_state=data["wounded_state"],
+                    dead_state=data["dead_state"],
+                    dead=Dead(
+                        circumstances=circumstance,
+                        physical_anomalies=physical,
+                        follow_up_events=followup,
+                    ),
+                )
             except ValidationError as e:
-                print(e)
+                print("Error in dead_state:")
+                print(e.json())
                 error_individual = e
     else:
-        try: 
-            individual = Report(identifier = data["identifier"],
-                                    image = img,
-                                    image_md5 = data["image_md5"],
-                                    geolocalisation = geolocalisation,
-                                    wounded_state = data["wounded_state"],
-                                    dead_state = data["dead_state"])
+        try:
+            individual = Report(
+                identifier=data["identifier"],
+                image=img,
+                image_md5=data["image_md5"],
+                geolocalisation=geolocalisation,
+                wounded_state=data["wounded_state"],
+                dead_state=data["dead_state"],
+            )
         except ValidationError as e:
-            print(e)
+            print(f"""Error in individual else: {e}""")
             error_individual = e
-    if error_behavior or error_circumstance or error_followup or error_physical or error_individual:
-        error_box = show_error(error_box, error_behavior, error_circumstance, error_followup, error_physical, error_individual)
+    if (
+        error_behavior
+        or error_circumstance
+        or error_followup
+        or error_physical
+        or error_individual
+    ):
+        error_box = show_error(
+            error_box,
+            error_behavior,
+            error_circumstance,
+            error_followup,
+            error_physical,
+            error_individual,
+        )
         individual = None
-    else: 
-        error_box= gr.Text(label="ALL VALID.", value="Record Registered. You can return to the Display.", visible=True, elem_id="valid")
+    else:
+        error_box = gr.Text(
+            label="ALL VALID.",
+            value="Record Registered. You can return to the Display.",
+            visible=True,
+            elem_id="valid",
+        )
     return individual, error_box
 
-def show_error(error_box, error_behavior, error_circumstance, error_followup, error_physical, error_individual):
+
+def show_error(
+    error_box,
+    error_behavior,
+    error_circumstance,
+    error_followup,
+    error_physical,
+    error_individual,
+):
     error_text = ""
     if error_circumstance:
         error_text += f"Error in circumstance: {error_circumstance}\n"
@@ -111,78 +155,78 @@ def show_error(error_box, error_behavior, error_circumstance, error_followup, er
     if error_individual:
         error_text += f"Error in individual: {error_individual}\n"
     error_text += "PLEASE CORRECT THESE ERRORS BEFORE SUBMITTING."
-    error_box= gr.Text(label="ERROR DETECTED !", value=error_text, visible=True, elem_id="error")
+    error_box = gr.Text(
+        label="ERROR DETECTED !", value=error_text, visible=True, elem_id="error"
+    )
     return error_box
 
+
 def reset_error_box(error_box):
     error_box = gr.Text(value=None, visible=False)
     return error_box
 
+
 #### VALIDATION FUNCTIONS
-def validate_circumstance(data): 
+def validate_circumstance(data):
     circumstance_raw = get_fields(data, "circumstance")
     circumstance_formatted = process_circumstance(circumstance_raw)
-    try: 
+    try:
         Circumstances.model_validate(circumstance_formatted)
         circumstances = Circumstances(**circumstance_formatted)
         error = None
     except ValidationError as e:
         error = e
-        print(e)
+        print(f"""Error in Validate_circumstance: {e}""")
         circumstances = None
     return circumstances, error
-        
 
-def validate_behavior(data, mode): 
+
+def validate_behavior(data, mode):
     behaviors_raw = get_fields(data, "behaviors")
     behaviors_formatted = process_behaviors(behaviors_raw)
     try:
-        if mode=="simple":
+        if mode == "simple":
             BehaviorsSimple.model_validate(behaviors_formatted)
             behavior = BehaviorsSimple(**behaviors_formatted)
-        elif mode=="advanced": 
+        elif mode == "advanced":
             Behaviors.model_validate(behaviors_formatted)
             behavior = Behaviors(**behaviors_formatted)
         error = None
     except ValidationError as e:
-        print(e)
-        print("Validation failed for the behaviors.")
+        print(f"""Error in behaviors validation: {e}""")
         behavior = None
         error = e
     return behavior, error
-        
 
-def validate_physical(data, mode): 
+
+def validate_physical(data, mode):
     physical_raw = get_fields(data, "physical")
     physical_formatted = process_physical(physical_raw)
-    print(physical_formatted)
-    try: 
-        if mode=="simple":
+    # print(physical_formatted)
+    try:
+        if mode == "simple":
             PhysicalAnomaliesSimple.model_validate(physical_formatted)
             physical = PhysicalAnomaliesSimple(**physical_formatted)
-        elif mode=="advanced":
+        elif mode == "advanced":
             PhysicalAnomalies.model_validate(physical_formatted)
             physical = PhysicalAnomalies(**physical_formatted)
         error = None
     except ValidationError as e:
-        print(e)
-        print("Validation failed for the physical anomalies.")
+        print(f"""Error in physical_anomalies validation: {e}""")
         physical = None
         error = e
     return physical, error
-        
+
+
 def validate_follow_up(data):
     followup_raw = get_fields(data, "followup")
     followup_formatted = process_followup(followup_raw)
-    try: 
+    try:
         FollowUpEvents.model_validate(followup_formatted)
         followup = FollowUpEvents(**followup_formatted)
         error = None
     except ValidationError as e:
-        print(e)
-        print("Validation failed for the follow-up events.")
+        print(f"""Error in follow-up events validation: {e}""")
+
         followup = None
     return followup, error
-    
-        
-