goodmap 1.1.7__py3-none-any.whl

goodmap/data_models/location.py

@@ -0,0 +1,68 @@
+from typing import Any, Type
+
+from pydantic import (
+    BaseModel,
+    Field,
+    ValidationError,
+    create_model,
+    field_validator,
+    model_validator,
+)
+
+from goodmap.exceptions import LocationValidationError
+
+
+class LocationBase(BaseModel, extra="allow"):
+    position: tuple[float, float]
+    uuid: str
+
+    @field_validator("position")
+    @classmethod
+    def position_must_be_valid(cls, v):
+        if v[0] < -90 or v[0] > 90:
+            raise ValueError("latitude must be in range -90 to 90")
+        if v[1] < -180 or v[1] > 180:
+            raise ValueError("longitude must be in range -180 to 180")
+        return v
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_uuid_exists(cls, data: Any) -> Any:
+        """Ensure UUID is present before validation for better error messages."""
+        if isinstance(data, dict) and "uuid" not in data:
+            raise ValueError("Location data must include 'uuid' field")
+        return data
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def enrich_validation_errors(cls, data, handler):
+        """Wrap validation errors with UUID context for better debugging."""
+        try:
+            return handler(data)
+        except ValidationError as e:
+            uuid = data.get("uuid") if isinstance(data, dict) else None
+            raise LocationValidationError(e, uuid=uuid) from e
+
+    def basic_info(self):
+        return {
+            "uuid": self.uuid,
+            "position": self.position,
+            "remark": bool(getattr(self, "remark", False)),
+        }
+
+
+def create_location_model(obligatory_fields: list[tuple[str, Type[Any]]]) -> Type[BaseModel]:
+    fields = {
+        field_name: (field_type, Field(...)) for (field_name, field_type) in obligatory_fields
+    }
+
+    return create_model(
+        "Location",
+        __config__=None,
+        __doc__=None,
+        __module__="Location",
+        __validators__=None,
+        __base__=LocationBase,
+        __cls_kwargs__=None,
+        **fields,
+    )

goodmap/data_validator.py

@@ -0,0 +1,119 @@
+import json
+from enum import Enum
+from sys import argv, stderr
+
+
+class ViolationType(Enum):
+    INVALID_JSON_FORMAT = 0
+    MISSING_OBLIGATORY_FIELD = 1
+    INVALID_VALUE_IN_CATEGORY = 2
+    NULL_VALUE = 3
+
+    def get_error_message(self):
+        error_message_dict = {
+            0: "invalid json format",
+            1: "missing obligatory field",
+            2: "invalid value in category",
+            3: "attribute has null value",
+        }
+        return error_message_dict[self.value]
+
+
+class DataViolation:
+    def __init__(self, violation_type: ViolationType):
+        self.violation_type = violation_type
+
+
+class FormatViolation(DataViolation):
+    def __init__(self, decoding_error):
+        super().__init__(ViolationType.INVALID_JSON_FORMAT)
+        self.decoding_error = decoding_error
+
+
+class FieldViolation(DataViolation):
+    def __init__(self, violation_type: ViolationType, datapoint, violating_field):
+        super().__init__(violation_type)
+        self.datapoint = datapoint
+        self.violating_field = violating_field
+
+
+def get_missing_obligatory_fields_violations(p, obligatory_fields):
+    violations = []
+    for field in obligatory_fields:
+        if field not in p.keys():
+            violations.append(FieldViolation(ViolationType.MISSING_OBLIGATORY_FIELD, p, field))
+    return violations
+
+
+def get_invalid_value_in_category_violations(p, categories):
+    violations = []
+    for category in categories & p.keys():
+        category_value_in_point = p[category]
+        valid_values_set = categories[category]
+        if isinstance(category_value_in_point, list):
+            for attribute_value in category_value_in_point:
+                if attribute_value not in valid_values_set:
+                    violations.append(
+                        FieldViolation(ViolationType.INVALID_VALUE_IN_CATEGORY, p, category)
+                    )
+        else:
+            if category_value_in_point not in valid_values_set:
+                violations.append(
+                    FieldViolation(ViolationType.INVALID_VALUE_IN_CATEGORY, p, category)
+                )
+    return violations
+
+
+def get_null_values_violations(p):
+    violations = []
+    for attribute, value in p.items():
+        if value is None:
+            violations.append(FieldViolation(ViolationType.NULL_VALUE, p, attribute))
+    return violations
+
+
+def report_data_violations_from_json(json_database):
+    map_data = json_database["map"]
+    datapoints = map_data["data"]
+    categories = map_data["categories"]
+    obligatory_fields = map_data["location_obligatory_fields"]
+
+    data_violations = []
+
+    for p in datapoints:
+        data_violations += get_missing_obligatory_fields_violations(p, obligatory_fields)
+        data_violations += get_invalid_value_in_category_violations(p, categories)
+        data_violations += get_null_values_violations(p)
+
+    return data_violations
+
+
+def report_data_violations_from_json_file(path_to_json_file):
+    with open(path_to_json_file) as json_file:
+        try:
+            return report_data_violations_from_json(json.load(json_file))
+        except json.JSONDecodeError as e:
+            return [FormatViolation(e)]
+
+
+def print_reported_violations(data_violations):  # pragma: no cover
+    for violation in data_violations:
+        violation_type = violation.violation_type
+        if violation_type == ViolationType.INVALID_JSON_FORMAT:
+            print("DATA ERROR: invalid json format", file=stderr)
+            print(violation.decoding_error, file=stderr)
+        else:
+            violating_field = violation.violating_field
+            violation_type_error = violation_type.get_error_message()
+            print(
+                f"DATA ERROR: {violation_type_error} {violating_field} in datapoint:", file=stderr
+            )
+            print(violation.datapoint, file=stderr)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    data_violations = report_data_violations_from_json_file(argv[1])
+    if data_violations == []:
+        print("All data is valid", file=stderr)
+    else:
+        print_reported_violations(data_violations)