Merge pull request #21 from sdsc-ordes/feat-multi-animal-reporting

.gitignore

@@ -7,6 +7,8 @@ __pycache__/
 
 #Data 
 test/data/**
+data/**
+app/assets/tmp_json/** 
 
 # C extensions
 *.so

app/.env.dist

@@ -0,0 +1 @@
+PATH_ASSETS="YOUR_PATH_HERE"

app/assets/config/config_checkbox_behavior.json

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

app/assets/config/config_checkbox_physical.json

@@ -11,7 +11,7 @@
             "Description": "Obvious bone fracture"},
         "Injury": {
             "Description": "Visible skin injury"},
-        "Parasites": {
+        "Parasite": {
             "Description": "Maggots, fleas, lice, louseflies"},
         "Swelling": {
             "Description": "Marked swelling without injury"},

app/assets/config/{config_dropdown_conditions.json → config_dropdown_circumstances.json}

@@ -3,40 +3,52 @@
     {
         "road vehicle": 
         {
-            
-            "Options": ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other", "unknown"],
-            "Open": "Infrastructure number"
-            
+            "Options": {
+                "road_type" : ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other road", "unknown road"]
+            },
+            "Open": "Infrastructure_number"
         },
         "train": 
         {
-            "Open": "Infrastructure number"
+            "Open": "Infrastructure_number"
         },
         "aircraft": {},
         "boat": {},
-        "other": {},
+        "other transport collision": {},
         "unknown": {}
     },
     "Destruction / Deliberatly removed" : 
     {
         "hunting": 
         {
-            "Options": ["shooting", "bow", "falconry", "hounds hunting", "digging up", "other", "unknown"]
+            "Options": {
+                "method" : ["shooting", "bow", "falconry", 
+                "hounds hunting", "digging up", "other hunting", "unknow hunting"]
+            }
         },
         "trap": 
         {
-            "Options": ["killing trap", "pole trap", "trap cage", "corvids nasse", "net", "cage trap", "fall-trap", "glue trap", "insect trap", "other", "unknown"]
+            "Options": {
+                "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": ["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": ["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":
@@ -44,59 +56,82 @@
          "pylone and electric grid":
          {
   
-            "Options": ["electric line", "pole/pylon", "other", "unknown"],
+            "Options": {
+                "infrastructure" : ["electric line", "pole/pylon", "other structure", "unknown structure"]
+            },
             "Extra":
             {
-                "Cause": ["collision", "electrocution", "unknown"]
+                "Cause": ["collision", "electrocution"]
             }
          },
          "windfarm": {},
          "other collision": 
          {
-            "Options": ["window", "building", "lighthouse", "cable", "wire fence/barbed wire", "other crash", "unknown"]
+            "Options": {
+                "object": ["window", "building", "lighthouse", "cable", "wire fence/barbed wire", "other crash", "unknown crash"]
+            }
          },
          "fall": 
          {
-            "Options": ["chimney", "empty pole", "hole/well", "other", "unknown"]
+            "Options": {
+                "location": ["chimney", "empty pole", "hole/well", "other fall", "unknown fall"]
+            }
          },
          "development work": 
          {
-            "Options": ["transport infrastructure", "building", "other", "unknown"]
+            "Options": {
+                "work_type" : ["transport infrastructure", "building", "other work", "unknown work"]
+            }
          },
          "pollution / contamination": 
          {
-            "Options": ["oil pollution", "chemical pollution", "heavy metals", "light", "noise", "plastic ingestion", "other", "unknown"]
+            "Options": {
+                "pollution_type" : ["oil pollution", "chemical pollution", "heavy metals", 
+                "light", "noise", "plastic ingestion", "other pollution", "unknown pollution"]
          },
          "agricultural net protection": {},
          "vegetal / forest work": 
          {
-            "Options": ["clearing/mowing/plowing", "tree felling/pruning", "other", "unknown"]
+            "Options": {
+                "work_type" : ["clearing/mowing/plowing", "tree felling/pruning", 
+                "other forest work", "unknown forest work"]
+            }
+         }
          },
-         "other": {},
+         "other indirect destruction": {},
          "unknown": {}
     },
     "Natural cause": 
     {
         "predation": 
         {
-            "Options": ["cat", "dog", "rooster/hen", "other domestic animal", "wild birds", "wild mammal", "other", "unknown"]
+            "Options": {
+                "predator" : ["cat", "dog", "rooster/hen", "other domestic animal", "wild birds",
+                "wild mammal", "other predator", "unknown predator"]
+            }
         },
         "weather": 
         {
-            "Options": ["cold wave", "drought", "hail", "lightening", "storm", "other", "unknown"]
+            "Options": {
+                "condition" : ["cold wave", "drought", "hail", "lightening", "storm", "other weather", "unknown weather"]
+            }
         },
         "natural disaster": 
         {
-            "Options": ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other", "unknown"]
+            "Options": {
+                "disaster" : ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other natural disaster", "unknown natural disaster"]
+            }
         },
         "nest fall": {},
         "stranding due to exhaustion": {},
         "disease/parasite": {},
         "accidental drowing": 
         {
-            "Options": ["drinking trough", "pool", "storm pool", "irrigation pool", "natural pool", "flood", "other container", "unknown"]
+            "Options": {
+                "drowning_location" : ["drinking trough", "pool", "storm pool", "irrigation pool", "natural pool", "flood", "other location", "unknown location"]
+            }
         },
-        "other": {},
+        "other natural cause": {},
         "unknown": {}
     },
     "Unknown": {}

app/{behavior_checkbox.py → behavior/behavior_checkbox.py}

@@ -1,9 +1,15 @@
-from utils_config import get_custom_config_dropdowns
-from utils_checkbox import create_checkbox
-from utils_visible import set_visible
+import gradio as gr
+from utils.utils_config import get_custom_config_dropdowns
+from utils.utils_checkbox import create_checkbox
+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():
-    dropdown_config = get_custom_config_dropdowns("/assets/config/config_checkbox_behavior.json")
+    dropdown_config = get_custom_config_dropdowns("config_checkbox_behavior.json")
     options = list(dropdown_config.keys())
     options = [option.title() for option in options]
     descriptions =[]
@@ -20,4 +26,5 @@ def create_behavior_checkbox(section: str, visible):
 def show_behavior(choice, section: str): 
     visible = set_visible(choice)
     checkbox, text = create_behavior_checkbox(section, visible)
+    add_data_tmp("wounded_dead", "behaviors_radio", choice)
     return checkbox, text

app/behavior/class_behavior.py

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

app/{circumstances.py → circumstances/circumstances.py}

@@ -1,49 +1,59 @@
 import gradio as gr
 import os
-from utils_visible import set_visible
+from dotenv import load_dotenv
+
+from utils.utils_visible import set_visible
+from validation_submission.add_json import add_data_tmp
+
+load_dotenv()
+PATH = os.getcwd() + "/"
+PATH_ASSETS = os.getenv('PATH_ASSETS')
+LOGO_PATH = PATH + PATH_ASSETS + "logos"
 
-PATH = os.getcwd()
 CAUSE_COL_WIDTH = "50px"
 
-def show_causes(choice): 
+
+def show_circumstances(choice): 
     visible = set_visible(choice)
-    button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_causes(visible)
+    add_data_tmp("wounded_dead", 
+                    "circumstance_radio", 
+                    choice)
+    button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_circumstances(visible)
     return button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2
 
-def create_causes(visible):
-    button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause = create_causes_buttons(visible)      
-    dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_causes_dropdown(visible)
+def create_circumstances(visible):
+    button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause = create_circumstances_buttons(visible)      
+    dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_circumstances_dropdown(visible)
     return button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2
 
-
-def create_causes_buttons(visible): 
+def create_circumstances_buttons(visible): 
     with gr.Row() as image_row:
             with gr.Column(scale=1, min_width=CAUSE_COL_WIDTH):
                 button_collision = gr.Button("Collision with a means of transport", 
                                              visible=visible,
-                                             icon=PATH + '/assets/logos/van.png',
+                                             icon=LOGO_PATH +  '/van.png',
                                              elem_id="buttons-conditions")
                 
             with gr.Column(scale=1, min_width=CAUSE_COL_WIDTH):
                 button_deliberate_destruction = gr.Button("Destruction / Deliberatly removed", 
-                                                          icon=PATH + '/assets/logos/destruction.png',
+                                                          icon=LOGO_PATH +  '/destruction.png',
                                                           visible=visible,
                                                           elem_id="buttons-conditions")
  
             with gr.Column(scale=1, min_width=CAUSE_COL_WIDTH):
                 button_indirect_destruction = gr.Button("Indirect destruction", 
-                                                        icon=PATH + '/assets/logos/indirect.png',
+                                                        icon=LOGO_PATH +  '/indirect.png',
                                                         visible=visible,
                                                         elem_id="buttons-conditions")
 
             with gr.Column(scale=1, min_width=CAUSE_COL_WIDTH):
                 button_natural_cause = gr.Button("Natural cause", 
-                                                 icon=PATH + '/assets/logos/natural.png', 
+                                                 icon=LOGO_PATH +  '/natural.png', 
                                                  visible=visible,
                                                  elem_id="buttons-conditions")
     return button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause
 
-def create_causes_dropdown(visible):
+def create_circumstances_dropdown(visible):
     with gr.Row() as dropdown_row:
         dropdown = gr.Dropdown(choices=[], 
                                label="Choices will appear here...",

app/{circumstances_dropdowns.py → circumstances/circumstances_dropdowns.py}

@@ -1,6 +1,6 @@
 import gradio as gr
-from utils_config import get_custom_config_dropdowns
-
+from utils.utils_config import get_custom_config_dropdowns
+from validation_submission.add_json import add_data_tmp
 
 #--------------------------------------------------------- LEVEL 1 DROPDOWNS
 def retrieve_config_options(label, dropdown_config):
@@ -15,7 +15,7 @@ def reinitialise_level2():
     return dropdown_level2, openfield_level2, dropdown_extra_level2
 
 def create_dropdown_level1(label): 
-    dropdown_config = get_custom_config_dropdowns("/assets/config/config_dropdown_conditions.json")
+    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()
@@ -23,34 +23,41 @@ def create_dropdown_level1(label):
     
 def dropdown_collision():
     label = "Collision with a means of transport"
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label)
 
 def dropdown_deliberate_destruction():
     label = "Destruction / Deliberatly removed"
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label)     
 
 def dropdown_indirect_destruction(): 
     label = "Indirect destruction"
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label) 
 
 def dropdown_natural_cause(): 
     label = "Natural cause"
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label)         
 
 
 #--------------------------------------------------------- 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("/assets/config/config_dropdown_conditions.json")
+        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_dropdown = nested_dict["Options"]
+                    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"]
@@ -60,10 +67,18 @@ def get_options(value):
                         extras_label = key
                         extras = val
                         extras = [extra.title() for extra in extras]
-        return options_dropdown, open_field, extras, extras_label
-            
+        return options_label, options_dropdown, open_field, extras, extras_label
+
+       
 def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
-    options_dropdown, open_field, extras, extras_label = get_options(evt.value)
+    options_label, options_dropdown, open_field, extras, extras_label = get_options(evt.value)
+    add_data_tmp("wounded_dead", 
+                    "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'
+                    })
     if options_dropdown is not None:
         dropdown_level2 = gr.Dropdown(choices=options_dropdown, label=evt.value, interactive=True, visible=True)
     else: 
@@ -78,4 +93,20 @@ def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
         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
+    return dropdown_level2, openfield_level2, dropdown_extra_level2
+
+def on_select_dropdown_level2(evt: gr.SelectData): 
+    add_data_tmp("wounded_dead", 
+                "circumstance_option_dropdown", 
+                evt.value.lower())
+
+def on_select_dropdown_extra_level2(evt: gr.SelectData):  
+    add_data_tmp("wounded_dead", 
+                 "circumstance_extra", 
+                 evt.value.lower())
+    
+def on_change_openfield_level2(openfield_level2_dead): 
+    print("Saving open field")
+    add_data_tmp("wounded_dead", 
+                "circumstance_open_field", 
+                str(openfield_level2_dead).lower())

app/circumstances/class_circumstance.py

@@ -0,0 +1,205 @@
+from pydantic import BaseModel, Field
+from typing import Literal, List, Union, Optional
+
+# Base class for CircumstanceType with a discriminator field 'type'
+class CircumstanceTypeBase(BaseModel):
+    type: str
+
+# Collision with means of transport
+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']
+
+class TrainCollision(CircumstanceTypeBase):
+    type: Literal['train']
+    infrastructure_number: str
+
+class AircraftCollision(CircumstanceTypeBase):
+    type: Literal['aircraft']
+
+class BoatCollision(CircumstanceTypeBase):
+    type: Literal['boat']
+
+class OtherTransportCollision(CircumstanceTypeBase):
+    type: Literal['other transport collision']
+
+class UnknownTransportCollision(CircumstanceTypeBase):
+    type: Literal['unknown transport collision']
+
+# Destruction / Deliberately removed
+class HuntingDestruction(CircumstanceTypeBase):
+    type: Literal['hunting']
+    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 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 removal", "unknown removal"]
+
+class FishingDestruction(CircumstanceTypeBase):
+    type: Literal['fishing']
+    method: Literal['drowned/tangled', 'beached with capture indications', "other fishing", "unknown fishing"]
+
+class OtherDestruction(CircumstanceTypeBase):
+    type: Literal['other destruction']
+
+class UnknownDestruction(CircumstanceTypeBase):
+    type: Literal['unknown destruction']
+
+# Indirect destruction
+class PylonElectricGridDestruction(CircumstanceTypeBase):
+    type: Literal['pylone and electric grid']
+    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 crash']
+
+class FallDestruction(CircumstanceTypeBase):
+    type: Literal['fall']
+    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 work', 'unknown work']
+
+class PollutionContaminationDestruction(CircumstanceTypeBase):
+    type: Literal['pollution / contamination']
+    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 forest work', 'unknown forest work']
+
+class OtherIndirectDestruction(CircumstanceTypeBase):
+    type: Literal['other indirect desctruction']
+
+class UnknownIndirectDestruction(CircumstanceTypeBase):
+    type: Literal['unknown indirect desctruction']
+
+# Natural cause
+class Predation(CircumstanceTypeBase):
+    type: Literal['predation']
+    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 weather', 'unknown weather']
+
+class NaturalDisaster(CircumstanceTypeBase):
+    type: Literal['natural disaster']
+    disaster: Literal['fire', 'avalanche', 'rock fall', 
+                      'mudslide', 'volcanic eruption/ashes', 
+                      'other natural disaster', 'unknown natural disaster']
+
+class NestFall(CircumstanceTypeBase):
+    type: Literal['nest fall']
+
+class StrandingExhaustion(CircumstanceTypeBase):
+    type: Literal['stranding due to exhaustion']
+
+class DiseaseParasite(CircumstanceTypeBase):
+    type: Literal['disease/parasite']
+
+class AccidentalDrowning(CircumstanceTypeBase):
+    type: Literal['accidental drowning']
+    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']
+
+class UnknownNaturalCause(CircumstanceTypeBase):
+    type: Literal['unknown natural cause']
+
+# Unknown cause
+class UnknownCircumstance(CircumstanceTypeBase):
+    type: Literal['unknown']
+
+# Union of all possible CircumstanceTypes with 'type' as the discriminator
+CircumstanceType = Union[
+    RoadVehicleCollision,
+    TrainCollision,
+    AircraftCollision,
+    BoatCollision,
+    OtherTransportCollision,
+    UnknownTransportCollision,
+    HuntingDestruction,
+    TrapDestruction,
+    PoisoningDestruction,
+    RemovalDestruction,
+    FishingDestruction,
+    OtherDestruction,
+    UnknownDestruction,
+    PylonElectricGridDestruction,
+    WindfarmDestruction,
+    OtherCollisionDestruction,
+    FallDestruction,
+    DevelopmentWorkDestruction,
+    PollutionContaminationDestruction,
+    AgriculturalNetProtectionDestruction,
+    VegetalForestWorkDestruction,
+    OtherIndirectDestruction,
+    UnknownIndirectDestruction,
+    Predation,
+    Weather,
+    NaturalDisaster,
+    NestFall,
+    StrandingExhaustion,
+    DiseaseParasite,
+    AccidentalDrowning,
+    OtherNaturalCause,
+    UnknownNaturalCause,
+    UnknownCircumstance
+]
+
+# Main Circumstance class
+class Circumstances(BaseModel):
+    circumstance_radio: str  # e.g., "Yes"
+    circumstance: Optional[str] = None  # e.g., "COLLISION"
+    circumstance_type: Optional[CircumstanceType] = Field(None, discriminator='type')
+
+
+# Example usage
+# json_data = {
+#     "circumstance": "COLLISION",
+#     "circumstance_radio": "Yes",
+#     "circumstance_type": {
+#         "type": "Train",
+#         "infrastructure_number": "56"
+#     }
+# }
+# circumstance_instance = Circumstance(**json_data)
+# circumstance_schema = Circumstance.schema_json(indent=2)

app/classes.py

@@ -0,0 +1,46 @@
+from pydantic import BaseModel, Field
+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
+from physical.class_physical import PhysicalAnomalies
+from follow_up.class_follow_up import FollowUpEvents
+from geolocalisation.class_geolocalisation import Geolocalisation
+
+class Wounded(BaseModel):
+    circumstances: Circumstances
+    behaviors: Behaviors
+    physical_anomalies: PhysicalAnomalies
+    follow_up_events: FollowUpEvents
+
+class Dead(BaseModel):
+    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):
+    identifier: str
+    image: ImageBase64
+    geolocalisation: Geolocalisation
+    wounded_state: str
+    wounded: Optional[Wounded] = None  
+    dead_state: str
+    dead: Optional[Dead] = None 

app/dead.py

@@ -1,15 +1,40 @@
 import gradio as gr
-from circumstances import create_causes
-from followup_events import create_followup_section
-
+from circumstances.circumstances import create_circumstances
+from physical.physical_select_animal import create_bird_anatomy
+from physical.physical_checkbox import process_body_parts
+from follow_up.followup_events import create_followup_dropdowns, create_followup_open
+from validation_submission.add_json import add_data_to_individual
 
 def show_section_dead(visible):
+    if visible==True: 
+        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")
-        gr.Markdown("## Please describe the cause of death", label="description")
         
-        button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_causes(visible)      
+        gr.Markdown("## Do you know what conditions caused this?", label="description")
+        radio_cause = gr.Radio(["Yes", "No"], value=None, show_label=False, interactive=True)
+        button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_circumstances(visible=False)      
         
-        create_followup_section()
+        gr.Markdown("## Are there physical changes on the bird?" , label="description")
+        radio_physical = gr.Radio(["Yes", "No"], value=None, show_label=False, interactive=True)
+        with gr.Row():
+            physical_boxes = create_bird_anatomy(False, "dead")
+            with gr.Column():
+                checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs = process_body_parts("dead", "None")
+
+        gr.Markdown("## Follow-Up Events", label="Title")
+        gr.Markdown("Please tell us what you did with the animal.", label="description")
+        with gr.Row(): 
+            fe_collection_dropdown, fe_recepient_dropdown, fe_radio_dropdown, fe_answer_dropdown = create_followup_dropdowns(visible, "dead")
+        with gr.Row(): 
+            fe_name_recipient, fe_collection_ref = create_followup_open(visible, "dead")
+
 
-    return section_dead, button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2
+    return section_dead, radio_cause, radio_physical,\
+         button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, \
+          dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2, \
+          physical_boxes, \
+          checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs, \
+          fe_collection_dropdown, fe_recepient_dropdown, fe_radio_dropdown, fe_answer_dropdown, fe_name_recipient, fe_collection_ref

app/display.py

@@ -0,0 +1,120 @@
+import gradio as gr
+import pandas as pd
+from gradio_modal import Modal
+from PIL import Image
+from io import BytesIO
+import base64
+
+from validation_submission.submission import validate_save_individual
+from validation_submission.get_json import get_json_all_individuals
+
+HEADERS = ["Identifier", "Location", "Wounded", "Dead"]
+
+
+def save_display_individual(gallery, df, error_box):
+    individual, error_box = validate_save_individual(error_box)
+    if 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, error_box
+
+# ---------------------------------- 
+# GALLERY 
+
+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: 
+        num_cols=5
+        num_rows=2
+    else: 
+        num_cols = len_animals/2
+        num_rows = len_animals/(num_cols)
+    return num_cols, num_rows
+
+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=gallery_animals,
+        object_fit="contain", height="auto", interactive=False)
+    return gallery
+
+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
+
+# ---------------------------------- 
+# DATAFRAME 
+
+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(**{
+    'min-width': '25px',
+    'max-width': '50px',  # 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=styled_df,
+                         headers=HEADERS, interactive=False)
+    return df_gradio
+

app/follow_up/class_follow_up.py

@@ -0,0 +1,50 @@
+from pydantic import BaseModel, Field
+from typing import Literal, Union, Optional, List
+
+# --- Event follow-up classes ---
+
+class AnimalCollectedEvent(BaseModel):
+    type: Literal['animal collected']
+    collected: Literal['yes', 'no']
+
+class RecipientEvent(BaseModel):
+    type: Literal['recipient']
+    recipient: Literal['veterinary', 'care center', 
+                                'local museum', 'national museum', 
+                                'other']
+
+class RadiographyEvent(BaseModel):
+    type: Literal['radiography']
+    radiography: Literal['yes', 'no', 'unknown']
+
+class GivenAnswerEvent(BaseModel):
+    type: Literal['given answer']
+    answer: Literal[
+        'nothing', 
+        'complaint against x', 
+        'complaint', 
+        'police call', 
+        'discussion with the speaker', 
+        'press release', 
+        'unknown'
+    ]
+
+class NameOfRecipientEvent(BaseModel):
+    type: Literal['recipient name']
+    name: str
+
+class CollectionReferenceEvent(BaseModel):
+    type: Literal['collection reference']
+    reference: str
+
+FollowUpEventType = Union[
+    AnimalCollectedEvent,
+    RecipientEvent,
+    RadiographyEvent,
+    GivenAnswerEvent,
+    NameOfRecipientEvent,
+    CollectionReferenceEvent
+]
+
+class FollowUpEvents(BaseModel):
+    follow_up_events: Optional[List[FollowUpEventType]] = None

app/follow_up/followup_events.py

@@ -0,0 +1,46 @@
+import gradio as gr
+from utils.utils_config import get_custom_config_dropdowns
+from validation_submission.add_json import add_data_tmp
+
+def create_followup_dropdowns(visible, elem_id): 
+    followup_config = get_custom_config_dropdowns("config_followup.json")
+    followup_config = followup_config["Event follow-up"]
+    fe_collection_dropdown = create_fe_collection_dropdown(followup_config, visible, elem_id)
+    fe_recipient_dropdown = create_fe_recipient_dropdown(followup_config, visible, elem_id)
+    fe_radio_dropdown = create_fe_radio_dropdown(followup_config, visible, elem_id)
+    fe_answer_dropdown = create_fe_answer_dropdown(followup_config, visible, elem_id)
+    return fe_collection_dropdown, fe_recipient_dropdown, fe_radio_dropdown, fe_answer_dropdown
+
+def create_followup_open(visible, elem_id): 
+    fe_name_recipient = gr.Textbox(label="Name of recipient / museum", visible=visible, 
+                                   elem_id=elem_id, interactive=True)
+    fe_collection_ref = gr.Textbox(label="Collection reference", visible=visible, 
+                                   elem_id=elem_id, interactive=True)
+    return fe_name_recipient, fe_collection_ref
+
+
+def create_fe_collection_dropdown(followup_config, visible, elem_id):
+    fe_collection_dropdown = gr.Dropdown(choices=followup_config["Animal collected"]["Options"], label="Animal collected", 
+                                         visible=visible, elem_id=elem_id, interactive=True)
+    return fe_collection_dropdown
+
+def create_fe_recipient_dropdown(followup_config, visible, elem_id):
+    fe_recipient_dropdown = gr.Dropdown(choices=followup_config["Recipient"]["Options"], label="Recipient", 
+                                        visible=visible, elem_id=elem_id, interactive=True)
+    return fe_recipient_dropdown
+
+def create_fe_radio_dropdown(followup_config, visible, elem_id): 
+    fe_radio_dropdown = gr.Dropdown(choices=followup_config["Radiography"]["Options"], label="Radiography", 
+                                        visible=visible, elem_id=elem_id, interactive=True)
+    return fe_radio_dropdown
+
+def create_fe_answer_dropdown(followup_config, visible, elem_id): 
+    fe_answer_dropdown = gr.Dropdown(choices=followup_config["Given answer"]["Options"], label="Given answer", 
+                                        visible=visible, elem_id=elem_id, interactive=True)
+    return fe_answer_dropdown
+
+def save_fe(value, key): 
+    add_data_tmp("wounded_dead", "followup " + key.lower(), value.lower())
+
+
+    

app/followup_events.py

@@ -1,17 +0,0 @@
-import gradio as gr
-from utils_config import get_custom_config_dropdowns
-
-def create_followup_section():
-    followup_config = get_custom_config_dropdowns("/assets/config/config_followup.json")
-    followup_config = followup_config["Event follow-up"]
-    gr.Markdown("Please tell us what you did with the animal.", label="description")
-    with gr.Row(): 
-        for key, val in followup_config.items():
-            followup_label = key
-            if "Options" in val.keys(): 
-                gr.Dropdown(choices=val["Options"], label=followup_label, visible=True, elem_id="followup")
-    with gr.Row(): 
-        for key, val in followup_config.items():
-            followup_label = key
-            if "Open" in val.keys(): 
-                gr.Textbox(label=followup_label, visible=True, elem_id="followup")

app/geolocalisation/class_geolocalisation.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+from typing import Literal, List, Union
+
+class Longitude(BaseModel):
+    type: Literal['longitude']
+    value: float
+
+class Latitude(BaseModel):
+    type: Literal['latitude']
+    value: float
+
+class Geolocalisation(BaseModel):
+    longitude: Longitude
+    latitude: Latitude
+    name: str
+

app/{maps.py → geolocalisation/maps.py}

@@ -1,6 +1,24 @@
 from geopy.geocoders import Nominatim
 import gradio as gr
- 
+from validation_submission.add_json import add_data_to_individual
+from geolocalisation.class_geolocalisation import Geolocalisation
+
+
+def create_geolocalisation_object(lat, long, name): 
+    try: 
+        geolocalisation = Geolocalisation(
+        longitude={"type": "longitude", "value": long},
+        latitude={"type": "latitude", "value": lat},
+        name=name
+        )
+    except: 
+        print("Pydantic Error for Geolocalisation")
+    return geolocalisation
+
+def save_geolocalisation_to_json(geolocalisation): 
+    geo_dict = geolocalisation.dict()
+    add_data_to_individual("geolocalisation", geo_dict)
+
 def get_location(address):
     try: 
         # calling the Nominatim tool
@@ -12,6 +30,11 @@ def get_location(address):
         # latitude and longitude
         lat = getLoc.latitude
         lon = getLoc.longitude
+
+        # Save values
+        geolocalisation = create_geolocalisation_object(lat, lon, address)
+        save_geolocalisation_to_json(geolocalisation)
+
         #display location processing
         value = "Latitude = " + str(lat) + "\n" + "Longitude = " + str(lon)
         identified_location= gr.Textbox(visible=True, interactive=False, 

app/gradio_test/test_selectdata_event.py

@@ -0,0 +1,16 @@
+import gradio as gr
+
+with gr.Blocks() as demo:
+    table = gr.Dataframe([[1, 2, 3], [4, 5, 6]])
+    #gallery = gr.Gallery([("cat.jpg", "Cat"), ("dog.jpg", "Dog")])
+    textbox = gr.Textbox("Hello World!")
+    statement = gr.Textbox()
+
+    def on_select(evt: gr.SelectData):
+        return gr.Textbox(f"You selected {evt.value} at {evt.index} from {evt.target}")
+
+    table.select(on_select, inputs=[table], outputs=[statement])
+    #gallery.select(on_select, gallery, statement)
+    textbox.select(on_select, inputs=[textbox], outputs=[statement])
+
+demo.launch(server_name="0.0.0.0", server_port=3131)

app/gradio_test/tests_delete_gallery.py

@@ -0,0 +1,25 @@
+import gradio as gr
+
+# Example initial image list
+images = [
+    "https://via.placeholder.com/150/0000FF",
+    "https://via.placeholder.com/150/FF0000",
+    "https://via.placeholder.com/150/00FF00"
+]
+
+# Function to remove a selected image from the gallery
+def delete_image(selected_image, image_list):
+    if selected_image in image_list:
+        image_list.remove(selected_image)  # Remove the selected image
+    return image_list  # Return the updated image list
+
+# Gradio app
+with gr.Blocks() as demo:
+    gallery = gr.Gallery(value=images, label="Gallery")  # Gallery of images
+    selected_image = gr.Dropdown(choices=images, label="Select Image to Delete")  # Dropdown for selection
+    delete_button = gr.Button("Delete Selected Image")  # Button to delete
+    
+    # When button is clicked, delete the selected image and update gallery
+    delete_button.click(fn=delete_image, inputs=[selected_image, gallery], outputs=gallery)
+    
+demo.launch(server_name="0.0.0.0", server_port=3232)

app/main.py

@@ -1,164 +1,337 @@
 import gradio as gr
+from gradio_modal import Modal
+
+from validation_submission.create_json import create_json_all_individuals, create_json_one_individual, create_tmp, reset_json
+from validation_submission.add_json import add_data_to_individual
+from validation_submission.validation import reset_error_box
+from display import save_display_individual
+from geolocalisation.maps import get_location
 from functools import partial
 from dead import show_section_dead
 from wounded import show_section_wounded
-from circumstances import show_causes
-from circumstances_dropdowns import *
-from physical_select_animal import show_physical, find_bounding_box
-from behavior_checkbox import show_behavior
-from maps import get_location
-from style import *
-from theme import theme, css
-
-with gr.Blocks(theme=theme, css=css) as demo:
+from circumstances.circumstances import show_circumstances
+from circumstances.circumstances_dropdowns import *
+from physical.physical_select_animal import show_physical, find_bounding_box
+from physical.physical_checkbox import on_select_body_part, hide_physical
+from behavior.behavior_checkbox import show_behavior, on_select_behavior
+from follow_up.followup_events import save_fe
+from styling.style import *
+from styling.theme import css
+
+# with gr.Blocks(theme=theme, css=css) as demo:
+with gr.Blocks(css=css) as demo:
+    create_json_all_individuals()
     # ---------------------------------------------------------
     # Intro Text
     with gr.Row():
         with gr.Column(scale=1):
             title = gr.Markdown("# Welcome to Digiwild", label="Title")
             description = gr.Markdown("Please record your wildlife observations here !", label="description")
+    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=["Identifier", "Location", "Wounded", "Dead"], visible=False, interactive=False)
+    gallery = gr.Gallery(
+        label="Gallery of Records", elem_id="gallery", 
+        columns=[1], rows=[1],
+        object_fit="contain", height="auto", interactive=False)
 
-    # ---------------------------------------------------------
-    # Camera
-    with gr.Row():
-        #with gr.Column(scale=1):
-        camera = gr.Image(elem_id="image")
-            
-    # ---------------------------------------------------------
-    # Location
-    #with gr.Row():
-        with gr.Column(scale=1):
-            location = gr.Textbox(visible=True, interactive=True, label="Location of Sighting")
-            #display location processing
-            identified_location= gr.Textbox(visible=False, interactive=False, 
-                                            label="Identified GPS Location")
-            with gr.Row():
-                #to clear it
-                clear_location = gr.ClearButton(components=[location], visible=True, interactive=True, scale=1
-                                                )
-                clear_location.click()
-                #to submit it
-                submit_location = gr.Button("Get GPS Coordinates", visible=True, interactive=True, scale=3)
-                submit_location.click(get_location, inputs=[location], outputs=[identified_location])
+    with Modal(visible=False) as modal:
+        # ---------------------------------------------------------
+        # Intro Text
+        with gr.Row():
+            with gr.Column(scale=1):
+                title = gr.Markdown("# Animal Report", label="Title")
+                description = gr.Markdown("Please record your observation here.", label="description")
 
-    # ---------------------------------------------------------
-    # Dead and Wounded Buttons
-    gr.Markdown("## The State of the Animal", label="Title")
-    gr.Markdown("Please tell us if the animal was wounded or dead.", label="description")
-    with gr.Row() as block_form:
-        with gr.Column(scale=1):
-            butt_wounded = gr.Button("Wounded", elem_id="wounded")
-        with gr.Column(scale=1):
-            butt_dead = gr.Button("Dead", elem_id="dead")
+        # ---------------------------------------------------------
+        # Camera
+        with gr.Row():
+            def save_image(camera):
+                add_data_to_individual("image", camera.tolist())
 
-    # ---------------------------------------------------------
-    # Initiate sections
-    section_dead, \
-        button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, \
-            dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead \
-                = show_section_dead(False)
-    section_wounded, radio_cause_wounded, radio_behavior_wounded, radio_physical_wounded, \
-        button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, \
-            dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded, \
-                behavior_checkbox, behavior_text, \
-                    physical_boxes_wounded, \
-                        checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs \
-                        = show_section_wounded(False)
+            camera = gr.Image(elem_id="image")
+            camera.input(save_image, inputs=[camera])
+        # ---------------------------------------------------------
+        # Location
+        #with gr.Row():
+            with gr.Column(scale=1):
+                location = gr.Textbox(visible=True, interactive=True, label="Location of Sighting")
+                #display location processing
+                identified_location= gr.Textbox(visible=False, interactive=False, 
+                                                label="Identified GPS Location")
+                with gr.Row():
+                    #to submit it
+                    submit_location = gr.Button("Get GPS Coordinates", 
+                                                visible=True, interactive=True, scale=3)
+                    submit_location.click(get_location, inputs=[location], outputs=[identified_location])
+                    #to clear it
+                    clear_location = gr.ClearButton(components=[location, identified_location], 
+                                                    visible=True, interactive=True, scale=1
+                                                    )
+                    clear_location.click()
+        
+        # ---------------------------------------------------------
+         # ---------------------------------------------------------
+        # Dead and Wounded Buttons
+        gr.Markdown("## The State of the Animal", label="Title")
+        gr.Markdown("Please tell us if the animal was wounded or dead.", label="description")
+        with gr.Row() as block_form:
+            with gr.Column(scale=1):
+                butt_wounded = gr.Button("Wounded", elem_id="wounded")
+            with gr.Column(scale=1):
+                butt_dead = gr.Button("Dead", elem_id="dead")
 
-    # ---------------------------------------------------------
-    # Dead Button Logic
-    partial_show_section_dead = partial(show_section_dead, True)
-    partial_hide_section_wounded = partial(show_section_wounded, False)
-    butt_dead.click(partial_show_section_dead, 
-                    inputs=None, 
-                    outputs=[section_dead, 
-                            button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
-                            dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead
-                            ])
-    butt_dead.click(partial_hide_section_wounded, 
-                    inputs=None, 
-                    outputs=[section_wounded, 
-                            radio_cause_wounded, radio_behavior_wounded, radio_physical_wounded,
-                            button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
-                            dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded,
-                            behavior_checkbox, behavior_text, 
-                            physical_boxes_wounded, 
-                            checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
-
-                            ])
-    # ---------------------------------------------------------
-    # Wounded Button Logic
-    partial_show_section_wounded = partial(show_section_wounded, True)
-    partial_hide_section_dead = partial(show_section_dead, False)
-
-    butt_wounded.click(partial_show_section_wounded, 
-                       inputs=None, 
-                       outputs=[section_wounded, 
-                                radio_cause_wounded, radio_behavior_wounded, radio_physical_wounded,
+        # ---------------------------------------------------------
+        # Initiate sections
+        section_dead, radio_circumstance_dead, radio_physical_dead,\
+            button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, \
+                dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead, \
+                    physical_boxes_dead, \
+                    checkbox_beak_dead, text_beak_dead, checkbox_body_dead, text_body_dead, checkbox_feathers_dead, text_feathers_dead, checkbox_head_dead, text_head_dead, checkbox_legs_dead, text_legs_dead, \
+                    fe_collection_dropdown_dead, fe_recepient_dropdown_dead, fe_radio_dropdown_dead, fe_answer_dropdown_dead, \
+                    fe_name_recipient_dead, fe_collection_ref_dead \
+                    = show_section_dead(False)
+        section_wounded, radio_circumstance_wounded, radio_behavior_wounded, radio_physical_wounded, \
+            button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, \
+                dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded, \
+                    behavior_checkbox, behavior_text, \
+                        physical_boxes_wounded, \
+                            checkbox_beak_wounded, text_beak_wounded, checkbox_body_wounded, text_body_wounded, checkbox_feathers_wounded, text_feathers_wounded, checkbox_head_wounded, text_head_wounded, checkbox_legs_wounded, text_legs_wounded, \
+                            fe_collection_dropdown_wounded, fe_recepient_dropdown_wounded, fe_radio_dropdown_wounded, fe_answer_dropdown_wounded, \
+                                fe_name_recipient_wounded, fe_collection_ref_wounded \
+                                = show_section_wounded(False)
+    
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # Dead Button Logic
+        partial_show_section_dead = partial(show_section_dead, True)
+        partial_hide_section_wounded = partial(show_section_wounded, False)
+        butt_dead.click(partial_show_section_dead, 
+                        inputs=None, 
+                        outputs=[section_dead, 
+                                radio_circumstance_dead, radio_physical_dead,
+                                button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
+                                dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead, \
+                                physical_boxes_dead, \
+                                checkbox_beak_dead, text_beak_dead, checkbox_body_dead, text_body_dead, checkbox_feathers_dead, text_feathers_dead, checkbox_head_dead, text_head_dead, checkbox_legs_dead, text_legs_dead, \
+                                fe_collection_dropdown_dead, fe_recepient_dropdown_dead, fe_radio_dropdown_dead, fe_answer_dropdown_dead, \
+                                fe_name_recipient_dead, fe_collection_ref_dead \
+                                ])
+        butt_dead.click(partial_hide_section_wounded, 
+                        inputs=None, 
+                        outputs=[section_wounded, 
+                                radio_circumstance_wounded, radio_behavior_wounded, radio_physical_wounded,
                                 button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
                                 dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded,
                                 behavior_checkbox, behavior_text, 
-                                physical_boxes_wounded, 
-                                checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
+                                physical_boxes_wounded, \
+                                checkbox_beak_wounded, text_beak_wounded, checkbox_body_wounded, text_body_wounded, checkbox_feathers_wounded, text_feathers_wounded, checkbox_head_wounded, text_head_wounded, checkbox_legs_wounded, text_legs_wounded, \
+                                fe_collection_dropdown_wounded, fe_recepient_dropdown_wounded, fe_radio_dropdown_wounded, fe_answer_dropdown_wounded, \
+                                fe_name_recipient_wounded, fe_collection_ref_wounded \
                                 ])
-    butt_wounded.click(partial_hide_section_dead, inputs=None, outputs=[section_dead, 
-                                                                        button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
-                                                                        dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead
-                                                                        ])
-    # ---------------------------------------------------------
-    # Dropdowns Dead
-    button_collision_dead.click(dropdown_collision,  
-                                outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
-    button_deliberate_destruction_dead.click(dropdown_deliberate_destruction, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
-    button_indirect_destruction_dead.click(dropdown_indirect_destruction, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
-    button_natural_cause_dead.click(dropdown_natural_cause, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
+        
+        # ---------------------------------------------------------
+        # Wounded Button Logic
+        partial_show_section_wounded = partial(show_section_wounded, True)
+        partial_hide_section_dead = partial(show_section_dead, False)
 
-    dropdown_dead.select(on_select, None, [dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
+        butt_wounded.click(partial_show_section_wounded, 
+                        inputs=None, 
+                        outputs=[section_wounded, 
+                                    radio_circumstance_wounded, radio_behavior_wounded, radio_physical_wounded,
+                                    button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
+                                    dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded,
+                                    behavior_checkbox, behavior_text, 
+                                    physical_boxes_wounded, \
+                                    checkbox_beak_wounded, text_beak_wounded, checkbox_body_wounded, text_body_wounded, checkbox_feathers_wounded, text_feathers_wounded, checkbox_head_wounded, text_head_wounded, checkbox_legs_wounded, text_legs_wounded, \
+                                    fe_collection_dropdown_wounded, fe_recepient_dropdown_wounded, fe_radio_dropdown_wounded, fe_answer_dropdown_wounded, \
+                                    fe_name_recipient_wounded, fe_collection_ref_wounded \
+                                    ])
+        butt_wounded.click(partial_hide_section_dead, inputs=None, outputs=[section_dead, 
+                                                                            radio_circumstance_dead, radio_physical_dead,
+                                                                            button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
+                                                                            dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead, \
+                                                                            physical_boxes_dead, \
+                                                                            checkbox_beak_dead, text_beak_dead, checkbox_body_dead, text_body_dead, checkbox_feathers_dead, text_feathers_dead, checkbox_head_dead, text_head_dead, checkbox_legs_dead, text_legs_dead, \
+                                                                            fe_collection_dropdown_dead, fe_recepient_dropdown_dead, fe_radio_dropdown_dead, fe_answer_dropdown_dead, \
+                                                                            fe_name_recipient_dead, fe_collection_ref_dead \
+                                                                            ])
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # DEAD
+        # ---------------------------------------------------------
+        # Radio Circumstance Dead
+        radio_circumstance_dead.change(fn=show_circumstances,
+                                inputs=[radio_circumstance_dead],
+                                outputs=[button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
+                                            dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead]
+                                )
+        
+        # Dropdowns Dead
+        button_collision_dead.click(dropdown_collision,  
+                                    outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
+        button_deliberate_destruction_dead.click(dropdown_deliberate_destruction, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
+        button_indirect_destruction_dead.click(dropdown_indirect_destruction, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
+        button_natural_cause_dead.click(dropdown_natural_cause, outputs=[dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead])
 
-    # ---------------------------------------------------------
-    # Radio Cause Wounded
-    radio_cause_wounded.change(fn=show_causes,
-                              inputs=[radio_cause_wounded],
-                              outputs=[button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
-                                        dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded]
-                              )
-    
-    # Dropdowns Cause Wounded
-    button_collision_wounded.click(dropdown_collision,  
-                                outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
-    button_deliberate_destruction_wounded.click(dropdown_deliberate_destruction, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
-    button_indirect_destruction_wounded.click(dropdown_indirect_destruction, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
-    button_natural_cause_wounded.click(dropdown_natural_cause, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
-    
-    dropdown_wounded.select(on_select, None, [dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
+        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.change(on_change_openfield_level2, inputs=[openfield_level2_dead])
+        dropdown_extra_level2_dead.select(on_select_dropdown_extra_level2)
+        # ---------------------------------------------------------
+        # Radio Physical Dead
+        radio_physical_dead.change(fn=show_physical,
+                                    inputs=[radio_physical_dead, gr.Text("dead", visible=False)],
+                                    outputs=[physical_boxes_dead])
 
-    # ---------------------------------------------------------
-    # Radio Behavior Wounded
-    radio_behavior_wounded.change(fn=show_behavior,
-                                  inputs=[radio_behavior_wounded, gr.Text("wounded", visible=False)],
-                                  outputs=[behavior_checkbox, behavior_text])
+        # Checkbox Physical Dead
+        physical_boxes_dead.select(find_bounding_box, 
+                        inputs=[physical_boxes_dead, gr.Textbox(value="dead", visible=False)], 
+                        outputs=[checkbox_beak_dead, text_beak_dead, 
+                                 checkbox_body_dead, text_body_dead, 
+                                 checkbox_feathers_dead, text_feathers_dead, 
+                                 checkbox_head_dead, text_head_dead, 
+                                 checkbox_legs_dead, text_legs_dead
+                                    ])
+        checkbox_beak_dead.select(on_select_body_part, inputs=[checkbox_beak_dead, gr.Text("beak", visible=False)])
+        checkbox_body_dead.select(on_select_body_part, inputs=[checkbox_body_dead, gr.Text("body", visible=False)])
+        checkbox_feathers_dead.select(on_select_body_part, inputs=[checkbox_feathers_dead, gr.Text("feathers", visible=False)])
+        checkbox_head_dead.select(on_select_body_part, inputs=[checkbox_head_dead, gr.Text("head", visible=False)])
+        checkbox_legs_dead.select(on_select_body_part, inputs=[checkbox_legs_dead, gr.Text("legs", visible=False)])
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # ---------------------------------------------------------
+        # WOUNDED
+        # ---------------------------------------------------------
+        # Radio Circumstance Wounded
+        radio_circumstance_wounded.change(fn=show_circumstances,
+                                inputs=[radio_circumstance_wounded],
+                                outputs=[button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
+                                            dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded]
+                                )
+        
+        # Dropdowns Circumstance Wounded
+        button_collision_wounded.click(dropdown_collision,  
+                                    outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
+        button_deliberate_destruction_wounded.click(dropdown_deliberate_destruction, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
+        button_indirect_destruction_wounded.click(dropdown_indirect_destruction, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
+        button_natural_cause_wounded.click(dropdown_natural_cause, outputs=[dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded])
+        
+        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.change(on_change_openfield_level2, inputs=[openfield_level2_wounded])
+        dropdown_extra_level2_wounded.select(on_select_dropdown_extra_level2)
+        # ---------------------------------------------------------
+        # Radio Behavior Wounded
+        radio_behavior_wounded.change(fn=show_behavior,
+                                    inputs=[radio_behavior_wounded, gr.Text("wounded", visible=False)],
+                                    outputs=[behavior_checkbox, behavior_text])
+        behavior_checkbox.select(on_select_behavior, 
+                                 inputs=[behavior_checkbox])
+        # ---------------------------------------------------------
+        # Radio Physical Wounded
+        radio_physical_wounded.change(fn=show_physical,
+                                    inputs=[radio_physical_wounded, gr.Text("wounded", visible=False)],
+                                    outputs=[physical_boxes_wounded])
 
-    # ---------------------------------------------------------
-    # Radio Physical Wounded
-    radio_physical_wounded.change(fn=show_physical,
-                                  inputs=[radio_physical_wounded, gr.Text("wounded", visible=False)],
-                                  outputs=[physical_boxes_wounded])
-
-    # Checkbox Physical Wounded
-    physical_boxes_wounded.select(find_bounding_box, 
-                     inputs=[physical_boxes_wounded, gr.Textbox(value="wounded", visible=False)], 
-                     outputs=[checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
-                                ])
+        # Checkbox Physical Wounded
+        physical_boxes_wounded.select(find_bounding_box, 
+                        inputs=[physical_boxes_wounded, gr.Textbox(value="wounded", visible=False)], 
+                        outputs=[checkbox_beak_wounded, text_beak_wounded, 
+                                 checkbox_body_wounded, text_body_wounded, 
+                                 checkbox_feathers_wounded, text_feathers_wounded, 
+                                 checkbox_head_wounded, text_head_wounded, 
+                                 checkbox_legs_wounded, text_legs_wounded
+                                    ])
+        checkbox_beak_wounded.select(on_select_body_part, inputs=[checkbox_beak_wounded, gr.Text("beak", visible=False)])
+        checkbox_body_wounded.select(on_select_body_part, inputs=[checkbox_body_wounded, gr.Text("body", visible=False)])
+        checkbox_feathers_wounded.select(on_select_body_part, inputs=[checkbox_feathers_wounded, gr.Text("feathers", visible=False)])
+        checkbox_head_wounded.select(on_select_body_part, inputs=[checkbox_head_wounded, gr.Text("head", visible=False)])
+        checkbox_legs_wounded.select(on_select_body_part, inputs=[checkbox_legs_wounded, gr.Text("legs", visible=False)])
+        
+        # ---------------------------------------------------------
+        # Follow Up Events Wounded 
+        fe_collection_dropdown_wounded.select(save_fe, inputs=[fe_collection_dropdown_wounded, gr.Textbox("animal collected", visible=False)])
+        fe_recepient_dropdown_wounded.select(save_fe, inputs=[fe_recepient_dropdown_wounded, gr.Textbox("recipient", visible=False)])
+        fe_radio_dropdown_wounded.select(save_fe, inputs=[fe_radio_dropdown_wounded, gr.Textbox("radiography", visible=False)]) 
+        fe_answer_dropdown_wounded.select(save_fe, inputs=[fe_answer_dropdown_wounded, gr.Textbox("given answer", visible=False)])
+        fe_name_recipient_wounded.input(save_fe, inputs=[fe_name_recipient_wounded, gr.Textbox("recipient name", visible=False)])
+        fe_collection_ref_wounded.input(save_fe, inputs=[fe_collection_ref_wounded, gr.Textbox("collection reference", visible=False)])
+
+        # ---------------------------------------------------------
+        # Follow Up Events Dead 
+        fe_collection_dropdown_dead.select(save_fe, inputs=[fe_collection_dropdown_dead, gr.Textbox("animal collected", visible=False)])
+        fe_recepient_dropdown_dead.select(save_fe, inputs=[fe_recepient_dropdown_dead, gr.Textbox("recipient", visible=False)])
+        fe_radio_dropdown_dead.select(save_fe, inputs=[fe_radio_dropdown_dead, gr.Textbox("radiography", visible=False)]) 
+        fe_answer_dropdown_dead.select(save_fe, inputs=[fe_answer_dropdown_dead, gr.Textbox("given answer", visible=False)])
+        fe_name_recipient_dead.input(save_fe, inputs=[fe_name_recipient_dead, gr.Textbox("recipient name", visible=False)])
+        fe_collection_ref_dead.input(save_fe, inputs=[fe_collection_ref_dead, gr.Textbox("collection reference", visible=False)])
+
+        # ---------------------------------------------------------
+        # Error Box
+        error_box = gr.Text(value=None, visible=False)
+
+        # ---------------------------------------------------------
+        # Add One Individual's Data to the Dataframe
+        # And Allow clearing of all previous output
+        with gr.Row(): 
+            button_df = gr.Button("Submit Animal Report", scale = 3)
+            button_clear = gr.ClearButton(scale = 1, 
+                                          components=[
+                camera,
+                location, identified_location, 
+                #dead reset
+                radio_circumstance_dead, radio_physical_dead,
+                button_collision_dead, button_deliberate_destruction_dead, button_indirect_destruction_dead, button_natural_cause_dead, 
+                dropdown_dead, dropdown_level2_dead, openfield_level2_dead, dropdown_extra_level2_dead,
+                physical_boxes_dead,
+                checkbox_beak_dead, text_beak_dead, checkbox_body_dead, text_body_dead, checkbox_feathers_dead, text_feathers_dead, checkbox_head_dead, text_head_dead, checkbox_legs_dead, text_legs_dead, 
+                fe_collection_dropdown_dead, fe_recepient_dropdown_dead, fe_radio_dropdown_dead, fe_answer_dropdown_dead, 
+                fe_name_recipient_dead, fe_collection_ref_dead,
+                #wounded reset
+                radio_circumstance_wounded, radio_behavior_wounded, radio_physical_wounded,
+                button_collision_wounded, button_deliberate_destruction_wounded, button_indirect_destruction_wounded, button_natural_cause_wounded, 
+                dropdown_wounded, dropdown_level2_wounded, openfield_level2_wounded, dropdown_extra_level2_wounded,
+                behavior_checkbox, behavior_text, 
+                physical_boxes_wounded, 
+                checkbox_beak_wounded, text_beak_wounded, checkbox_body_wounded, text_body_wounded, checkbox_feathers_wounded, text_feathers_wounded, checkbox_head_wounded, text_head_wounded, checkbox_legs_wounded, text_legs_wounded,
+                fe_collection_dropdown_wounded, fe_recepient_dropdown_wounded, fe_radio_dropdown_wounded, fe_answer_dropdown_wounded, 
+                fe_name_recipient_wounded, fe_collection_ref_wounded,
+                error_box
+                ])
+            button_close = gr.Button("Back to Display", scale = 1)
+            
+
+        # ---------------------------------------------------------
+        # Button Click Logic
+        button_clear.click()
+        button_clear.click(hide_physical,
+                           outputs=[checkbox_beak_wounded, text_beak_wounded, checkbox_body_wounded, text_body_wounded, checkbox_feathers_wounded, text_feathers_wounded, checkbox_head_wounded, text_head_wounded, checkbox_legs_wounded, text_legs_wounded])
+        button_clear.click(hide_physical,
+                           outputs=[checkbox_beak_dead, text_beak_dead, checkbox_body_dead, text_body_dead, checkbox_feathers_dead, text_feathers_dead, checkbox_head_dead, text_head_dead, checkbox_legs_dead, text_legs_dead])
+                
+        button_clear.click(reset_error_box, inputs=[error_box], outputs=[error_box])
+        button_clear.click(reset_json)
+
+        button_df.click(save_display_individual, 
+                        inputs=[gallery, df, error_box],
+                        outputs=[gallery, df, error_box]
+                        )
+        button_close.click(lambda: Modal(visible=False), None, modal)
     
     # ---------------------------------------------------------
-    #Submit Button
-    with gr.Column(scale=1):
-        subbutt = gr.Button("SUBMIT YOUR OBSERVATION TO ORNITHO", 
-                            elem_id="submit", 
-                            icon="https://cdn.iconscout.com/icon/free/png-256/free-send-2451554-2082560.png",
-                            scale=1)
-        output_message = gr.Markdown("Thank you, you are a champion of biodiversity conservation !")
+    # Event Functions of the landing page buttons
+    show_modal.click(lambda: Modal(visible=True), None, modal)
+    show_modal.click(create_json_one_individual)
+    show_modal.click(create_tmp)
+    #submit_button.click(save_and_rest_df, inputs=[df], outputs=[df])
 
-    
 
-demo.launch(server_name="0.0.0.0")
+     
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=3333)

app/main_test.py

@@ -1,68 +0,0 @@
-import gradio as gr
-
-# Function that processes the Textbox input and generates new CheckboxGroups
-def generate_checkbox_groups(textbox_input):
-    try:
-        num_groups = int(textbox_input)
-    except ValueError:
-        return "Please enter a valid number."
-
-    # Dynamically create a list of CheckboxGroups
-    checkbox_groups = []
-    for i in range(num_groups):
-        checkbox_groups.append(gr.CheckboxGroup(
-            choices=["Option 1", "Option 2", "Option 3"], 
-            label=f"Checkbox Group {i + 1}",
-            interactive=True
-        ))
-    
-    return checkbox_groups
-
-# Function to process the selections of the dynamically created CheckboxGroups
-def process_selections(*checkbox_values):
-    results = []
-    for i, selections in enumerate(checkbox_values):
-        selected_options = ', '.join(selections) if selections else 'None'
-        results.append(f"Selected options for group {i + 1}: {selected_options}")
-    
-    return "\n".join(results)
-
-with gr.Blocks() as demo:
-    # Textbox for user input to specify the number of CheckboxGroups
-    textbox = gr.Textbox(label="Enter the number of Checkbox Groups to create")
-    
-    # Button to trigger the generation of CheckboxGroups
-    generate_button = gr.Button("Generate Checkbox Groups")
-    
-    # A placeholder for the dynamically generated CheckboxGroups
-    dynamic_checkbox_groups = gr.Column()
-    
-    # Output Textbox to display the results
-    output = gr.Textbox(label="Output")
-
-    # Generate CheckboxGroups based on Textbox input
-    def update_dynamic_groups(textbox_value):
-        groups = generate_checkbox_groups(textbox_value)
-        dynamic_checkbox_groups.children = groups
-        return dynamic_checkbox_groups
-
-    generate_button.click(
-        fn=update_dynamic_groups,
-        inputs=textbox,
-        outputs=dynamic_checkbox_groups
-    )
-
-    # Button to process selections from the dynamically generated CheckboxGroups
-    process_button = gr.Button("Submit Selections")
-    
-    # Process the selections when the second button is clicked
-    def process_dynamic_groups(*checkbox_groups):
-        return process_selections(*checkbox_groups)
-    
-    process_button.click(
-        fn=process_dynamic_groups,
-        inputs=dynamic_checkbox_groups.children,  # Unpack the dynamically generated groups
-        outputs=output
-    )
-
-demo.launch(server_name="0.0.0.0")

app/physical/class_physical.py

@@ -0,0 +1,79 @@
+from pydantic import BaseModel, Field
+from typing import Literal, List, Union, Optional
+
+# Define common anomalies as a Literal type
+CommonAnomalies = Literal[
+    'blackened/burnt skin',
+    'blood',
+    'foreign body',
+    'fracture',
+    'injury',
+    'parasite',
+    'swelling',
+    'warty or tumor-like growth, crusts'
+]
+
+# --- Beak-related Anomalies ---
+class BeakAnomaly(BaseModel):
+    type: Literal['beak']
+    anomaly_type: List[Literal[
+        'adhesion',
+        'deformation',
+        CommonAnomalies
+    ]]
+
+# --- Body-related Anomalies ---
+class BodyAnomaly(BaseModel):
+    type: Literal['body']
+    anomaly_type: List[Literal[
+        'emaciation',
+        'fluffed up',
+        'stained feathers',
+        CommonAnomalies
+    ]]
+
+# --- Legs-related Anomalies ---
+class LegAnomaly(BaseModel):
+    type: Literal['legs']
+    anomaly_type: List[Literal[
+        'missing limb',
+        'deformation',
+        CommonAnomalies
+    ]]
+
+# --- Feathers/Wings/Tail-related Anomalies ---
+class FeathersWingsTailAnomaly(BaseModel):
+    type: Literal['feathers/wings/tail']
+    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 incl. eyes']
+    anomaly_type: List[Literal[
+        'ear changes',
+        'eye changes',
+        'tilted head',
+        CommonAnomalies
+    ]]
+
+
+# Union of all possible anomaly types for specific body parts
+AnomalyType = Union[
+    BeakAnomaly,
+    BodyAnomaly,
+    LegAnomaly,
+    FeathersWingsTailAnomaly,
+    HeadAnomaly
+]
+
+# Main PhysicalAnomaly class that logs anomalies across different body parts
+class PhysicalAnomalies(BaseModel):
+    physical_radio: str
+    physical_anomalies_type: Optional[List[AnomalyType]] = None

app/{physical_boxes_map.py → physical/physical_boxes_map.py}

@@ -2,6 +2,11 @@ from PIL import Image, ImageDraw, ImageFont
 
 from physical_boxes_define import gdf
 
+from dotenv import load_dotenv
+import os
+load_dotenv()
+PATH_ASSETS = os.getenv('PATH_ASSETS')
+
 # Function to draw the bounding boxes on the image
 def draw_bounding_boxes(image_path, gdf):
     image = Image.open(image_path+'bird.png').convert("RGB")
@@ -10,7 +15,7 @@ def draw_bounding_boxes(image_path, gdf):
 
     # Optional: Load a font (requires a TTF file)
     # try:
-    font = ImageFont.truetype("assets/fonts/LiberationSans-Regular.ttf", 
+    font = ImageFont.truetype(PATH_ASSETS + "fonts/LiberationSans-Regular.ttf", 
                               20)
     # except IOError:
     #     print("default")
@@ -25,4 +30,4 @@ def draw_bounding_boxes(image_path, gdf):
     image.save(image_path+'bird_boxed.png', "PNG")
 
 if __name__ == "__main__":
-    draw_bounding_boxes('assets/images/', gdf)
+    draw_bounding_boxes(PATH_ASSETS + 'images/', gdf)

app/{physical_checkbox.py → physical/physical_checkbox.py}

@@ -1,9 +1,10 @@
 import gradio as gr
-from utils_config import get_custom_config_dropdowns
-from utils_checkbox import create_checkbox
+from utils.utils_config import get_custom_config_dropdowns
+from utils.utils_checkbox import create_checkbox
+from validation_submission.add_json import add_data_tmp 
 #--------------------------------------------------------- 
 def get_body_parts():
-    dropdown_config = get_custom_config_dropdowns("/assets/config/config_checkbox_physical.json")
+    dropdown_config = get_custom_config_dropdowns("config_checkbox_physical.json")
     return list(dropdown_config.keys())
 
 def retrieve_config_options(label, dropdown_config):
@@ -12,7 +13,7 @@ def retrieve_config_options(label, dropdown_config):
     return options
 
 def get_options_description(value):
-        dropdown_config = get_custom_config_dropdowns("/assets/config/config_checkbox_physical.json")
+        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)
@@ -68,4 +69,16 @@ def process_body_parts(section, matched_box):
     checkbox_legs, text_legs = create_checkbox_legs(section, 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): 
+    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)
+
+#--------------------------------------------------------- 
+
+def hide_physical():
+    checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs = process_body_parts("wounded", "None")
+    return checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs
      

app/{physical_select_animal.py → physical/physical_select_animal.py}

@@ -1,11 +1,15 @@
 import gradio as gr
-# from gradio_image_prompter import ImagePrompter
+from dotenv import load_dotenv
+import os
 from typing import List
 from shapely.geometry import Point
-from physical_checkbox import *
-from physical_boxes_define import gdf
-from utils_visible import set_visible
 
+from physical.physical_checkbox import *
+from physical.physical_boxes_define import gdf
+from utils.utils_visible import set_visible
+
+load_dotenv()
+PATH_ASSETS = os.getenv('PATH_ASSETS')
 
 # Function to find the matching bounding box for a given point and return the image with boxes
 def find_bounding_box(evt: gr.SelectData, img, section: str):
@@ -25,7 +29,8 @@ def find_bounding_box(evt: gr.SelectData, img, section: str):
 # Gradio app
 def create_bird_anatomy(visible, section: str):
     # Draw bounding boxes on the image
-    img_with_boxes = gr.Image(value='assets/images/bird_boxed.png', 
+    print
+    img_with_boxes = gr.Image(value=PATH_ASSETS+'images/bird_boxed.png', 
                             show_label=False, 
                             height="600px",
                             elem_id=section,
@@ -35,6 +40,7 @@ def create_bird_anatomy(visible, section: str):
 def show_physical(choice, section: str): 
     visible = set_visible(choice)
     physical_boxes = create_bird_anatomy(visible, section)
+    add_data_tmp("wounded_dead", "physical_radio", choice)
     return physical_boxes
 
 

app/{style.py → styling/style.py}

@@ -3,7 +3,7 @@ import gradio as gr
 gr.HTML('''
     <style>
     .custom-button {
-        background-color: #4CAF50; /* Green */
+        background-color: #3B4C54;
         border: none;
         color: white;
         padding: 15px 32px;
@@ -16,4 +16,22 @@ gr.HTML('''
         border-radius: 8px;
     }
     </style>
-    ''')
+    ''')
+
+# gr.HTML('''
+#     <style>
+#     .custom-button {
+#         background-color: #4CAF50; /* Green */
+#         border: none;
+#         color: white;
+#         padding: 15px 32px;
+#         text-align: center;
+#         text-decoration: none;
+#         display: inline-block;
+#         font-size: 16px;
+#         margin: 4px 2px;
+#         cursor: pointer;
+#         border-radius: 8px;
+#     }
+#     </style>
+#     ''')

app/styling/theme.py

@@ -0,0 +1,104 @@
+import gradio as gr
+
+css = """
+.gradio-container {background: url(https://openclipart.org/image/2000px/279687)}
+
+/* Main background */
+body {
+    background-color: #3B4C54;
+    color: #ffffff; /* Set default text color for contrast */
+}
+
+/* Secondary color for headers and panels */
+.gradio-container .card, 
+.gradio-container h1, 
+.gradio-container h2, 
+.gradio-container h3, 
+.gradio-container h4 {
+    background-color: #3F543B;
+    color: #ffffff; /* Ensuring text is readable */
+}
+
+
+
+
+/* Background color for the wounded section */
+#wounded {
+    background-color: #503B54;
+    color: #ffffff; /* Ensures text is readable */
+}
+
+/* Olive green color for headers within the wounded section */
+#wounded h1, 
+#wounded h2, 
+#wounded h3, 
+#wounded h4, 
+#wounded h5, 
+#wounded h6 {
+    color: #ffffff; /* Olive green color for header text */
+    background-color: #503B54; /* No background color for headers */
+}
+
+/* Styling dropdowns within the wounded section */
+#wounded select {
+    background-color: #3F543B; /* Olive green background */
+    color: #ffffff; /* Ensures text is readable */
+    border: 1px solid #3B4C54; /* Optional border for consistency */
+}
+
+/* Styling checkboxes within the wounded section */
+#wounded input[type="checkbox"] {
+    accent-color: #3F543B; /* Olive green color for the checkbox */
+}
+
+/* Additional checkbox label styling if needed */
+#wounded label {
+    color: #ffffff; /* Ensures labels are readable */
+}
+
+
+
+
+
+/* Background color for the dead section */
+#dead {
+    background-color: #54433B;
+    color: #ffffff; /* Ensures text is readable */
+}
+
+/* Brown color for headers within the dead section */
+#dead h1, 
+#dead h2, 
+#dead h3, 
+#dead h4, 
+#dead h5, 
+#dead h6 {
+    color: #ffffff; /* Olive green color for header text */
+    background-color: #54433B; /* No background color for headers */
+}
+
+
+#bird-boxes {background-color: #3B4C54}
+#submit {background-color: #abb2bf}
+#error {background-color: #e82323}
+#valid {background-color: #07e63f}
+"""
+
+# OLD THEME: 
+
+# css = """
+# .gradio-container {background: url(https://openclipart.org/image/2000px/279687)}
+# #image {background-color: #73b9ae}
+# #dead {background-color: #333333}
+# #wounded {background-color: #5e0724}
+# #bird-boxes {background-color: #f2f3f3}
+# #buttons-conditions {background-color: #b3b3b3}
+# #dropdown-conditions {background-color: #b3b3b3}
+# #followup {background-color: #38241c} 
+# #submit {background-color: #abb2bf}
+# #error {background-color: #e82323}
+# #valid {background-color: #07e63f}
+# """
+
+# theme = gr.themes.Soft(primary_hue="teal", secondary_hue="teal", neutral_hue="emerald",
+#                          font=[gr.themes.GoogleFont("Inconsolata"), "Arial", "sans-serif"])

app/theme.py

@@ -1,18 +0,0 @@
-import gradio as gr
-
-css = """
-.gradio-container {background: url(https://openclipart.org/image/2000px/279687)}
-#image {background-color: #73b9ae}
-#dead {background-color: #333333}
-#wounded {background-color: #5e0724}
-#bird-boxes {background-color: #f2f3f3}
-#buttons-conditions {background-color: #b3b3b3}
-#dropdown-conditions {background-color: #b3b3b3}
-#followup {background-color: #38241c} 
-#submit {background-color: #abb2bf}
-"""
-
-#followup 2nd option: #13422f
-
-theme = gr.themes.Soft(primary_hue="teal", secondary_hue="teal", neutral_hue="emerald",
-                         font=[gr.themes.GoogleFont("Inconsolata"), "Arial", "sans-serif"])

app/{utils_config.py → utils/utils_config.py}

@@ -1,5 +1,11 @@
 import json
 import os
+from dotenv import load_dotenv
+import os
+load_dotenv()
+PATH = os.getcwd() + "/"
+PATH_ASSETS = os.getenv('PATH_ASSETS')
+PATH_CONFIG = PATH + PATH_ASSETS + "config/"
 
 def load_config(file_path):
     with open(file_path) as f:
@@ -7,8 +13,7 @@ def load_config(file_path):
     return config
 
 def get_custom_config_dropdowns(config_path):
-    path = os.getcwd()
-    dropdown_config_path = path + config_path
+    dropdown_config_path = PATH_CONFIG + config_path
     dropdown_config = load_config(dropdown_config_path)
     return dropdown_config
 

app/validation_submission/add_json.py

@@ -0,0 +1,15 @@
+from validation_submission.create_json import create_json_one_individual, create_tmp
+import json 
+
+def add_data_to_individual(key, value): 
+    with open("data/one_individual.json", 'r') as openfile:
+        one_individual = json.load(openfile)
+    one_individual[key] = value
+    create_json_one_individual(one_individual)
+
+def add_data_tmp(tmp_name, key, value): 
+    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

@@ -0,0 +1,20 @@
+import json 
+
+def create_json_one_individual(one_individual={}):
+    one_individual = json.dumps(one_individual)
+    with open("data/one_individual.json", "w") as outfile:
+        outfile.write(one_individual)
+
+def create_json_all_individuals(all_individuals={}):
+    all_individuals = json.dumps(all_individuals)
+    with open("data/all_individuals.json", "w") as outfile:
+        outfile.write(all_individuals)
+
+def create_tmp(tmp_name="wounded_dead", tmp={}):
+    tmp = json.dumps(tmp)
+    with open(f"app/assets/tmp_json/tmp_{tmp_name}.json", "w") as outfile:
+        outfile.write(tmp)
+
+def reset_json(): 
+    create_json_one_individual()
+    create_tmp()

app/validation_submission/get_json.py

@@ -0,0 +1,16 @@
+import json
+
+def get_json_one_individual():
+    with open("data/one_individual.json", 'r') as openfile:
+        one_individual = json.load(openfile)
+    return one_individual
+
+def get_json_all_individuals():
+    with open("data/all_individuals.json", "r") as openfile:
+        all_individuals = json.load(openfile)
+    return all_individuals
+
+def get_json_tmp(tmp_name):
+    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,55 @@
+#### 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")
+    return data
+
+def process_behaviors(data):
+    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):
+    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):
+    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

@@ -0,0 +1,17 @@
+import json 
+from validation_submission.get_json import get_json_all_individuals
+from validation_submission.validation import validate_individual
+
+def validate_save_individual(error_box):
+    individual, error_box = validate_individual(error_box)
+    if individual:
+        save_to_all_individuals(individual.model_dump())
+    return individual, error_box
+
+def save_to_all_individuals(one_individual):
+    all_individuals = get_json_all_individuals()
+    all_individuals[str(len(all_individuals))] = one_individual
+    all_individuals_for_json = json.dumps(all_individuals)
+    with open("data/all_individuals.json", "w") as outfile:
+        outfile.write(all_individuals_for_json)
+    return all_individuals

app/validation_submission/validation.py

@@ -0,0 +1,173 @@
+import uuid
+from pydantic import ValidationError
+import gradio as gr
+
+from validation_submission.get_json import get_json_tmp, get_json_one_individual
+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 = {} 
+    for key, val in data_dict.items():
+        if keyword in key:
+            extract[key] = val
+    return extract
+
+def validate_individual(error_box):
+    error_box = reset_error_box(error_box)
+    data = get_json_one_individual()
+    data["identifier"] = str(uuid.uuid4())
+    if "image" in data.keys():
+        img = ImageBase64.to_base64(data["image"])
+    else: 
+        img = None
+    if "geolocalisation" in data.keys():
+        geolocalisation = data["geolocalisation"]
+    else:
+        geolocalisation = None
+
+    error_behavior = 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 = get_json_tmp("wounded_dead")
+        circumstance, error_circumstance = validate_circumstance(data_wounded_dead)
+        physical, error_physical = validate_physical(data_wounded_dead)
+        followup, error_followup = validate_follow_up(data_wounded_dead)
+
+        if data["wounded_state"]=="Yes":
+            print(physical)
+            behavior, error_behavior = validate_behavior(data_wounded_dead)
+            try : 
+                individual = Report(identifier = data["identifier"],
+                                    image = img,
+                                    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)
+                error_individual = e
+
+        elif data["dead_state"]=="Yes":
+            try: 
+                individual = Report(identifier = data["identifier"],
+                                    image = img,
+                                    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)
+                error_individual = e
+    else:
+        try: 
+            individual = Report(identifier = data["identifier"],
+                                    image = img,
+                                    geolocalisation = geolocalisation,
+                                    wounded_state = data["wounded_state"],
+                                    dead_state = data["dead_state"])
+        except ValidationError as e:
+            print(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)
+        individual = None
+    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):
+    error_text = ""
+    if error_circumstance:
+        error_text += f"Error in circumstance: {error_circumstance}\n"
+    if error_behavior:
+        error_text += f"Error in behavior: {error_behavior}\n"
+    if error_physical:
+        error_text += f"Error in physical: {error_physical}\n"
+    if error_followup:
+        error_text += f"Error in follow-up: {error_followup}\n"
+    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")
+    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): 
+    circumstance_raw = get_fields(data, "circumstance")
+    circumstance_formatted = process_circumstance(circumstance_raw)
+    try: 
+        Circumstances.model_validate(circumstance_formatted)
+        circumstances = Circumstances(**circumstance_formatted)
+        error = None
+    except ValidationError as e:
+        error = e
+        print(e)
+        circumstances = None
+    return circumstances, error
+        
+
+def validate_behavior(data): 
+    behaviors_raw = get_fields(data, "behaviors")
+    behaviors_formatted = process_behaviors(behaviors_raw)
+    try:
+        Behaviors.model_validate(behaviors_formatted)
+        behavior = Behaviors(**behaviors_formatted)
+        error = None
+    except ValidationError as e:
+        print(e)
+        print("Validation failed for the behaviors.")
+        behavior = None
+        error = e
+    return behavior, error
+        
+
+def validate_physical(data): 
+    physical_raw = get_fields(data, "physical")
+    physical_formatted = process_physical(physical_raw)
+    try: 
+        PhysicalAnomalies.model_validate(physical_formatted)
+        physical = PhysicalAnomalies(**physical_formatted)
+        error = None
+    except ValidationError as e:
+        print(e)
+        print("Validation failed for the physical anomalies.")
+        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: 
+        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.")
+        followup = None
+    return followup, error
+    
+        
+ 

app/wounded.py

@@ -1,17 +1,22 @@
 import gradio as gr
-from circumstances import create_causes
-from physical_select_animal import create_bird_anatomy
-from physical_checkbox import process_body_parts
-from behavior_checkbox import create_behavior_checkbox
-from followup_events import create_followup_section
+from circumstances.circumstances import create_circumstances
+from physical.physical_select_animal import create_bird_anatomy
+from physical.physical_checkbox import process_body_parts
+from behavior.behavior_checkbox import create_behavior_checkbox
+from follow_up.followup_events import create_followup_dropdowns, create_followup_open
+from validation_submission.add_json import add_data_to_individual  
 
 def show_section_wounded(visible):
+    if visible==True: 
+        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")
         
         gr.Markdown("## Do you know what conditions caused this?", label="description")
         radio_cause = gr.Radio(["Yes", "No"], value=None, show_label=False, interactive=True)
-        button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_causes(visible=False)
+        button_collision, button_deliberate_destruction, button_indirect_destruction, button_natural_cause, dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2 = create_circumstances(visible=False)
 
         gr.Markdown("## Is the bird displaying behavioural changes?" , label="description")
         radio_behaviour = gr.Radio(["Yes", "No"], value=None, show_label=False, interactive=True)
@@ -25,9 +30,14 @@ def show_section_wounded(visible):
             with gr.Column():
                 checkbox_beak, text_beak, checkbox_body, text_body, checkbox_feathers, text_feathers, checkbox_head, text_head, checkbox_legs, text_legs = process_body_parts("wounded", "None")
 
-
+            
         gr.Markdown("## Follow-Up Events", label="Title")
-        create_followup_section()
+        gr.Markdown("Please tell us what you did with the animal.", label="description")
+        with gr.Row(): 
+            fe_collection_dropdown, fe_recepient_dropdown, fe_radio_dropdown, fe_answer_dropdown = create_followup_dropdowns(visible, "wounded")
+        with gr.Row(): 
+            fe_name_recipient, fe_collection_ref = create_followup_open(visible, "wounded")
+
 
     # Change variables and names
     return wounded_section, radio_cause, radio_behaviour, radio_physical, \
@@ -35,4 +45,5 @@ def show_section_wounded(visible):
         dropdown, dropdown_level2, openfield_level2, dropdown_extra_level2, \
         behavior_checkbox, behavior_text, \
         physical_boxes, \
-        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, \
+        fe_collection_dropdown, fe_recepient_dropdown, fe_radio_dropdown, fe_answer_dropdown, fe_name_recipient, fe_collection_ref

requirements.txt

@@ -1,4 +1,6 @@
 gradio
+gradio_modal
 geopy
 geopandas
-pillow
+pillow
+dotenv