feat: json schema set-up

app/assets/config/config_dropdown_circumstances.json

@@ -4,7 +4,9 @@
         "road vehicle": 
         {
             
-            "Options": ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other", "unknown"],
+            "Options": {
+                "road_type" : ["highway", "main road", "secondary road", "local road/path/trail", "parking lot", "other", "unknown"]
+            },
             "Open": "Infrastructure number"
             
         },
@@ -21,20 +23,26 @@
     {
         "hunting": 
         {
-            "Options": ["shooting", "bow", "falconry", "hounds hunting", "digging up", "other", "unknown"]
+            "Options": {
+                "method" : ["shooting", "bow", "falconry", "hounds hunting", "digging up", "other", "unknown"]
+            }
         },
         "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", "unknown"]
+            }
         },
         "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", "unknown"]
+        }
         },
         "fishing": 
         {
-            "Options": ["drowned/tangled", "beached with capture indications", "other", "unknown"]
+            "Options": {"method" : ["drowned/tangled", "beached with capture indications", "other", "unknown"]
+        }
         },
         "other": {},
         "unknown": {}
@@ -44,7 +52,9 @@
          "pylone and electric grid":
          {
   
-            "Options": ["electric line", "pole/pylon", "other", "unknown"],
+            "Options": {
+                "infrastructure" : ["electric line", "pole/pylon", "other", "unknown"]
+            },
             "Extra":
             {
                 "Cause": ["collision", "electrocution", "unknown"]
@@ -53,24 +63,34 @@
          "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"]
+            }
          },
          "fall": 
          {
-            "Options": ["chimney", "empty pole", "hole/well", "other", "unknown"]
+            "Options": {
+                "location": ["chimney", "empty pole", "hole/well", "other", "unknown"]
+            }
          },
          "development work": 
          {
-            "Options": ["transport infrastructure", "building", "other", "unknown"]
+            "Options": {
+                "work_type" : ["transport infrastructure", "building", "other", "unknown"]
+            }
          },
          "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", "unknown"]
          },
          "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", "unknown"]
+            }
+         }
          },
          "other": {},
          "unknown": {}
@@ -79,22 +99,30 @@
     {
         "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", "unknown"]
+            }
         },
         "weather": 
         {
-            "Options": ["cold wave", "drought", "hail", "lightening", "storm", "other", "unknown"]
+            "Options": {
+                "condition" : ["cold wave", "drought", "hail", "lightening", "storm", "other", "unknown"]
+            }
         },
         "natural disaster": 
         {
-            "Options": ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other", "unknown"]
+            "Options": {
+                "disaster" : ["fire", "avalanche", "rock fall", "mudslide", "volcanic eruption/ashes", "other", "unknown"]
+            }
         },
         "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 container", "unknown"]
+            }
         },
         "other": {},
         "unknown": {}

app/assets/json_tmp/tmp_wounded_dead.json

@@ -0,0 +1 @@
+{}

app/behavior/behavior_checkbox.py

@@ -2,7 +2,7 @@ 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 utils.utils_json import add_data_to_individual 
+from validation_submission.add_json import add_data_to_individual 
 
 def on_select_behavior(behavior_checkbox): 
     add_data_to_individual("behavior", behavior_checkbox)

app/behavior/class_behavior.py

@@ -63,4 +63,4 @@ BehaviorType = Union[
 
 # Main class that logs multiple behaviors
 class Behaviors(BaseModel):
-    observed_behaviors: List[BehaviorType]
+    observed_behaviors: List[BehaviorType] = Field(..., discriminator='type')

app/circumstances/circumstances.py

@@ -1,8 +1,10 @@
 import gradio as gr
 import os
-from utils.utils_visible import set_visible
 from dotenv import load_dotenv
-import os
+
+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')
@@ -13,6 +15,9 @@ CAUSE_COL_WIDTH = "50px"
 
 def show_circumstances(choice): 
     visible = set_visible(choice)
+    add_data_tmp("wounded_dead", 
+                    "circumstance_radio", 
+                    True)
     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
 

app/circumstances/circumstances_dropdowns.py

@@ -1,6 +1,6 @@
 import gradio as gr
 from utils.utils_config import get_custom_config_dropdowns
-from utils.utils_json import add_data_to_individual  
+from validation_submission.add_json import add_data_tmp
 
 #--------------------------------------------------------- LEVEL 1 DROPDOWNS
 def retrieve_config_options(label, dropdown_config):
@@ -23,28 +23,29 @@ def create_dropdown_level1(label):
     
 def dropdown_collision():
     label = "Collision with a means of transport"
-    add_data_to_individual("circumstance", label)
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label)
 
 def dropdown_deliberate_destruction():
     label = "Destruction / Deliberatly removed"
-    add_data_to_individual("circumstance", label)
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label)     
 
 def dropdown_indirect_destruction(): 
     label = "Indirect destruction"
-    add_data_to_individual("circumstance", label)
+    add_data_tmp("wounded_dead", "circumstance", label.lower())
     return create_dropdown_level1(label) 
 
 def dropdown_natural_cause(): 
     label = "Natural cause"
-    add_data_to_individual("circumstance", label)
+    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
@@ -54,7 +55,9 @@ def get_options(value):
             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"]
@@ -64,12 +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
-    add_data_to_individual("circumstance_dropdown_level1", evt.value)
-    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", 
+                    "cirumstance_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: 
@@ -87,10 +96,16 @@ def on_select(evt: gr.SelectData):  # SelectData is a subclass of EventData
     return dropdown_level2, openfield_level2, dropdown_extra_level2
 
 def on_select_dropdown_level2(evt: gr.SelectData): 
-    add_data_to_individual("circumstance_dropdown_level2", evt.value)
+    add_data_tmp("wounded_dead", 
+                "circumstance_option_dropdown", 
+                evt.value)
 
 def on_select_openfield_level2(evt: gr.SelectData): 
-    add_data_to_individual("circumstance_openfield_level2", evt.value)
+    add_data_tmp("wounded_dead", 
+                "circumstance_open_field", 
+                evt.value)
 
 def on_select_dropdown_extra_level2(evt: gr.SelectData):  
-    add_data_to_individual("circumstance_dropdown_extra_level2", evt.value)
+    add_data_tmp("wounded_dead", 
+                 "circumstance_extra", 
+                 evt.value)

app/circumstances/class_circumstance.py

@@ -22,10 +22,10 @@ class BoatCollision(CircumstanceTypeBase):
     type: Literal['boat']
 
 class OtherTransportCollision(CircumstanceTypeBase):
-    type: Literal['other']
+    type: Literal['other transport collision']
 
 class UnknownTransportCollision(CircumstanceTypeBase):
-    type: Literal['unknown']
+    type: Literal['unknown transport collision']
 
 # Destruction / Deliberately removed
 class HuntingDestruction(CircumstanceTypeBase):
@@ -48,10 +48,10 @@ class FishingDestruction(CircumstanceTypeBase):
     method: Literal['drowned/tangled', 'beached with capture indications', 'other', 'unknown']
 
 class OtherDestruction(CircumstanceTypeBase):
-    type: Literal['other']
+    type: Literal['other destruction']
 
 class UnknownDestruction(CircumstanceTypeBase):
-    type: Literal['unknown']
+    type: Literal['unknown destruction']
 
 # Indirect destruction
 class PylonElectricGridDestruction(CircumstanceTypeBase):
@@ -86,10 +86,10 @@ class VegetalForestWorkDestruction(CircumstanceTypeBase):
     work_type: Literal['clearing/mowing/plowing', 'tree felling/pruning', 'other', 'unknown']
 
 class OtherIndirectDestruction(CircumstanceTypeBase):
-    type: Literal['other']
+    type: Literal['other indirect desctruction']
 
 class UnknownIndirectDestruction(CircumstanceTypeBase):
-    type: Literal['unknown']
+    type: Literal['unknown indirect desctruction']
 
 # Natural cause
 class Predation(CircumstanceTypeBase):
@@ -118,10 +118,10 @@ class AccidentalDrowning(CircumstanceTypeBase):
     drowning_location: Literal['drinking trough', 'pool', 'storm pool', 'irrigation pool', 'natural pool', 'flood', 'other container', 'unknown']
 
 class OtherNaturalCause(CircumstanceTypeBase):
-    type: Literal['other']
+    type: Literal['other natural cause']
 
 class UnknownNaturalCause(CircumstanceTypeBase):
-    type: Literal['unknown']
+    type: Literal['unknown natural cause']
 
 # Unknown cause
 class UnknownCircumstance(CircumstanceTypeBase):
@@ -168,4 +168,17 @@ CircumstanceType = Union[
 class Circumstances(BaseModel):
     circumstance: str  # e.g., "COLLISION"
     circumstance_radio: str  # e.g., "Yes"
-    circumstance_type: CircumstanceType = Field(..., discriminator='type')
+    circumstance_type: CircumstanceType = Field(..., 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

@@ -8,7 +8,7 @@ from follow_up.class_follow_up import FollowUpEvents
 from geolocalisation.class_geolocalisation import Geolocalisation
 
 class Wounded(BaseModel):
-    circumstances: List[Circumstances] 
+    circumstances: Circumstances
     behaviors: List[Behaviors]
     physical_anomalies: List[PhysicalAnomaly]
     follow_up_events: List[FollowUpEvents]
@@ -28,15 +28,3 @@ class Report(BaseModel):
     wounded: Optional[Wounded] = None  
     dead_state: bool
     dead: Optional[Dead] = None 
-    
-# 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/dead.py

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

app/follow_up/followup_events.py

@@ -1,6 +1,6 @@
 import gradio as gr
 from utils.utils_config import get_custom_config_dropdowns
-from utils.utils_json import add_data_to_individual
+from validation_submission.add_json import add_data_to_individual
 
 def create_followup_dropdowns(visible, elem_id): 
     followup_config = get_custom_config_dropdowns("config_followup.json")

app/gallery.py

@@ -2,10 +2,13 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 from dotenv import load_dotenv
+import os
 
 from utils.utils_config import load_config
-from utils.utils_json import get_json_one_individual, save_to_all_individuals
-import os
+from validation_submission.get_json import get_json_one_individual
+from validation_submission.submission import save_to_all_individuals
+from validation_submission.validation import validate_individual
+
 
 load_dotenv()
 PATH = os.getcwd() + "/"
@@ -87,6 +90,7 @@ def set_gallery_size(len_animals):
     return num_cols, num_rows
 
 def save_individual_to_gallery(gallery):
+    validate_individual()
     one_individual = get_json_one_individual()
     fields = get_fields()
     one_individual_matched = match_data_to_fields(fields, one_individual)

app/geolocalisation/maps.py

@@ -1,9 +1,26 @@
 from geopy.geocoders import Nominatim
 import gradio as gr
-from utils.utils_json import add_data_to_individual
- 
+from app.validation_submission.utils_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: 
+    try: 
         # calling the Nominatim tool
         loc = Nominatim(user_agent="GetLoc")
         
@@ -15,8 +32,8 @@ def get_location(address):
         lon = getLoc.longitude
 
         # Save values
-        add_data_to_individual("latitude", lat)
-        add_data_to_individual("longitude", lon)
+        geolocalisation = create_geolocalisation_object(lat, lon, address)
+        save_geolocalisation_to_json(geolocalisation)
 
         #display location processing
         value = "Latitude = " + str(lat) + "\n" + "Longitude = " + str(lon)
@@ -25,9 +42,9 @@ def get_location(address):
                                         value=value)
         return identified_location
     
-    # except:
-    #     error = "Please try another less precise location."
-    #     identified_location= gr.Textbox(visible=True, interactive=False, 
-    #                                     label="Identified GPS Location", 
-    #                                     value=error)
-    #     return identified_location
+    except:
+        error = "Please try another less precise location."
+        identified_location= gr.Textbox(visible=True, interactive=False, 
+                                        label="Identified GPS Location", 
+                                        value=error)
+        return identified_location

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/main_multianimal.py

@@ -1,7 +1,8 @@
 import gradio as gr
 from gradio_modal import Modal
 
-from utils.utils_json import *
+from validation_submission.create_json import create_json_all_individuals, create_json_one_individual, create_tmp
+from validation_submission.add_json import add_data_to_individual
 from gallery import save_individual_to_gallery
 from geolocalisation.maps import get_location
 from functools import partial
@@ -15,9 +16,16 @@ 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 theme, css
+from classes import Report
 
 with gr.Blocks(theme=theme, 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)
@@ -33,8 +41,8 @@ with gr.Blocks(theme=theme, css=css) as demo:
         # 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")
+                title = gr.Markdown("# Animal Report", label="Title")
+                description = gr.Markdown("Please record your observation here.", label="description")
 
         # ---------------------------------------------------------
         # Camera
@@ -256,6 +264,7 @@ with gr.Blocks(theme=theme, css=css) as demo:
     # 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])
     submit_button.click(save_individual_to_gallery)
 

app/physical/class_physical.py

@@ -75,4 +75,4 @@ AnomalyType = Union[
 
 # Main PhysicalAnomaly class that logs anomalies across different body parts
 class PhysicalAnomaly(BaseModel):
-    body_part_anomalies: List[AnomalyType]  # List of anomalies across different body parts
+    body_part_anomalies: List[AnomalyType] = Field(..., discriminator='type')

app/physical/physical_checkbox.py

@@ -1,7 +1,7 @@
 import gradio as gr
 from utils.utils_config import get_custom_config_dropdowns
 from utils.utils_checkbox import create_checkbox
-from utils.utils_json import add_data_to_individual 
+from validation_submission.add_json import add_data_to_individual 
 #--------------------------------------------------------- 
 def get_body_parts():
     dropdown_config = get_custom_config_dropdowns("config_checkbox_physical.json")

app/utils/utils_json.py

@@ -1,42 +0,0 @@
-import json
-import gradio as gr
-
-def create_json_one_individual(one_individual={}):
-    # Serializing json
-    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 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 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 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
-
-# def save_all_individuals(df):
-#     all_individuals = df.to_json(orient="records")
-#     with open("data/all_individuals.json", "w") as outfile:
-#         outfile.write(all_individuals)
-    

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/json_tmp/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,16 @@
+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, tmp={}):
+    tmp = json.dumps(tmp)
+    with open(f"app/assets/json_tmp/tmp_{tmp_name}.json", "w") as outfile:
+        outfile.write(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/json_tmp/tmp_{tmp_name}.json", "r") as openfile:
+        tmp_json = json.load(openfile)
+    return tmp_json

app/validation_submission/submission.py

@@ -0,0 +1,10 @@
+import json 
+from validation_submission.get_json import get_json_all_individuals
+
+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,44 @@
+from validation_submission.get_json import get_json_tmp, get_json_one_individual
+from classes import Report
+from circumstances.class_circumstance import Circumstance
+
+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():
+    data = get_json_tmp("wounded_dead")
+    validate_circumstance(data)
+    validate_behavior(data)
+    validate_physical(data)
+    validate_follow_up(data)
+    validate_individual()
+    pass
+
+
+def validate_circumstance(data): 
+    circumstance_raw = get_fields(data, "circumstance")
+    circumstance_formatted = process_circumstance(circumstance_raw)
+    if not Circumstance(circumstance_formatted).validate(): 
+        print("Validation failed for the circumstance.")
+    pass
+def process_circumstance(data):
+    pass
+
+def validate_behavior(data): 
+    pass
+
+def validate_physical(data): 
+    pass
+
+def validate_follow_up(data):
+    pass
+
+def validate_individual():
+    individual = get_json_one_individual()
+    if not Report(individual).validate(): 
+        print("Validation failed for creating the individual report.")
+    pass

app/wounded.py

@@ -4,12 +4,12 @@ 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 utils.utils_json import add_data_to_individual  
+from validation_submission.add_json import add_data_to_individual  
 
 def show_section_wounded(visible):
     if visible==True: 
-        add_data_to_individual("wounded", "True")
-        add_data_to_individual("dead", "False")
+        add_data_to_individual("wounded_bool", "True")
+        add_data_to_individual("dead_bool", "False")
         
     with gr.Column(visible=visible, elem_id="wounded") as wounded_section:
         gr.Markdown("# Wounded Animal")