Spaces:
Sleeping
Sleeping
| 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 | |