data-validation-engine 0.8.2__tar.gz → 0.8.4__tar.gz

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-validation-engine
-Version: 0.8.2
+Version: 0.8.4
 Summary: `nhs data validation engine` is a framework used to validate data
 License-Expression: MIT
 License-File: LICENSE
@@ -10,6 +10,7 @@ Requires-Python: >=3.10,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
@@ -25,7 +26,7 @@ Requires-Dist: pandas (==2.3.3)
 Requires-Dist: polars (==0.20.31)
 Requires-Dist: pyarrow (==23.0.1)
 Requires-Dist: pydantic (==1.10.19)
-Requires-Dist: pyspark (>=3.0.0,<=3.5.2)
+Requires-Dist: pyspark (>=3.5.0,<=3.5.5)
 Requires-Dist: typing_extensions (==4.15.0)
 Requires-Dist: urllib3 (==2.7.0)
 Project-URL: Changelog, https://github.com/NHSDigital/data-validation-engine/blob/main/CHANGELOG.md

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/pyproject.toml

@@ -10,6 +10,7 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Libraries",
     "Typing :: Typed",
@@ -24,7 +25,7 @@ Issues = "https://github.com/NHSDigital/data-validation-engine/issues"
 Changelog = "https://github.com/NHSDigital/data-validation-engine/blob/main/CHANGELOG.md"
 
 [tool.poetry]
-version = "0.8.2"
+version = "0.8.4"
 packages = [
     { include = "dve", from = "src" },
 ]
@@ -43,7 +44,7 @@ pandas = "2.3.3"
 polars = "0.20.31"
 pyarrow = "23.0.1"
 pydantic = "1.10.19"
-pyspark = ">=3.0.0,<=3.5.2"
+pyspark = ">=3.5.0,<=3.5.5"
 typing_extensions = "4.15.0"
 urllib3 = "2.7.0"  # dependency of boto3 & botocore
 
@@ -68,7 +69,7 @@ optional = true
 behave = "1.3.3"
 coverage = "7.11.0"
 moto = {extras = ["s3"], version = "4.2.14"}
-cryptography = "48.0.1"  # dependency of `moto`
+cryptography = "50.0.0"  # dependency of `moto`
 requests = "2.33.0"  # dependency of `moto`
 Werkzeug = "3.1.6"
 pytest = "9.0.3"
@@ -105,8 +106,8 @@ click = "8.2.1"
 mkdocs = "1.6.1"
 mkdocstrings = { version = "1.0.3", extras = ["python"] }
 griffelib = "2.0.1"
-pymdown-extensions = "10.21.3"
-zensical = "0.0.31"
+pymdown-extensions = "11.0.1"
+zensical = "0.0.46"
 
 [tool.ruff]
 line-length = 100

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/src/dve/core_engine/backends/implementations/duckdb/duckdb_helpers.py

@@ -21,8 +21,10 @@ from typing_extensions import Annotated, get_args, get_origin, get_type_hints
 
 from dve.common.error_utils import get_feedback_errors_uri
 from dve.core_engine.backends.base.utilities import _get_non_heterogenous_type
+from dve.core_engine.backends.utilities import DEFAULT_ISO_FORMATS, datetime_format_to_regex
 from dve.core_engine.constants import RECORD_INDEX_COLUMN_NAME
 from dve.core_engine.type_hints import URI, EntityName
+from dve.metadata_parser.utilities import resilient_get
 from dve.parser.file_handling.service import LocalFilesystemImplementation, _get_implementation
 
 
@@ -361,7 +363,7 @@ def duckdb_record_index(cls):
 
 def _cast_as_ddb_type(field_expr: str, type_annotation: Any) -> str:
     """Cast to Duck DB type"""
-    return f"""try_cast({field_expr} as {get_duckdb_type_from_annotation(type_annotation)})"""
+    return f"""TRY_CAST({field_expr} as {get_duckdb_type_from_annotation(type_annotation)})"""
 
 
 def _ddb_safely_quote_name(field_name: str) -> str:
@@ -378,9 +380,6 @@ def get_duckdb_cast_statement_from_annotation(
     element_name: str,
     type_annotation: Any,
     parent_element: bool = True,
-    date_regex: str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
-    timestamp_regex: str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}((\+|\-)[0-9]{2}:[0-9]{2})?$",  # pylint: disable=C0301
-    time_regex: str = r"^[0-9]{2}:[0-9]{2}:[0-9]{2}$",
 ) -> str:
     """Generate casting statements for duckdb relations from type annotations"""
     type_origin = get_origin(type_annotation)
@@ -391,19 +390,23 @@ def get_duckdb_cast_statement_from_annotation(
     if type_origin is Union:
         python_type = _get_non_heterogenous_type(get_args(type_annotation))
         return get_duckdb_cast_statement_from_annotation(
-            element_name, python_type, parent_element, date_regex, timestamp_regex
+            element_name,
+            python_type,
+            parent_element,
         )
 
     # Type hint is e.g. `List[str]`, check to ensure non-heterogenity.
     if type_origin is list or (isinstance(type_origin, type) and issubclass(type_origin, list)):
         element_type = _get_non_heterogenous_type(get_args(type_annotation))
-        stmt = f"list_transform({quoted_name}, x -> {get_duckdb_cast_statement_from_annotation('x',element_type, False, date_regex, timestamp_regex)})"  # pylint: disable=C0301
+        stmt = f"LIST_TRANSFORM({quoted_name}, x -> {get_duckdb_cast_statement_from_annotation('x',element_type, False,)})"  # pylint: disable=C0301
         return stmt if not parent_element else _cast_as_ddb_type(stmt, type_annotation)
 
     if type_origin is Annotated:
         python_type, *other_args = get_args(type_annotation)  # pylint: disable=unused-variable
         return get_duckdb_cast_statement_from_annotation(
-            element_name, python_type, parent_element, date_regex, timestamp_regex
+            element_name,
+            python_type,
+            parent_element,
         )  # add other expected params here
     # Ensure that we have a concrete type at this point.
     if not isinstance(type_annotation, type):
@@ -428,7 +431,9 @@ def get_duckdb_cast_statement_from_annotation(
                 continue
 
             fields[field_name] = get_duckdb_cast_statement_from_annotation(
-                f"{element_name}.{field_name}", field_annotation, False, date_regex, timestamp_regex
+                f"{element_name}.{field_name}",
+                field_annotation,
+                False,
             )
 
         if not fields:
@@ -436,7 +441,7 @@ def get_duckdb_cast_statement_from_annotation(
                 f"No type annotations in dict/dataclass type (got {type_annotation!r})"
             )
         cast_exprs = ",".join([f'"{nme}":= {stmt}' for nme, stmt in fields.items()])
-        stmt = f"struct_pack({cast_exprs})"
+        stmt = f"STRUCT_PACK({cast_exprs})"
         return stmt if not parent_element else _cast_as_ddb_type(stmt, type_annotation)
 
     if type_annotation is list:
@@ -447,18 +452,27 @@ def get_duckdb_cast_statement_from_annotation(
         raise ValueError(f"dict must be `typing.TypedDict` subclass, got {type_annotation!r}")
 
     for type_ in type_annotation.mro():
-        # datetime is subclass of date, so needs to be handled first
-        if issubclass(type_, datetime):
-            stmt = rf"CASE WHEN REGEXP_MATCHES(TRIM({quoted_name}), '{timestamp_regex}') THEN TRY_CAST(TRIM({quoted_name}) as TIMESTAMP) ELSE NULL END"  # pylint: disable=C0301
-            return stmt
-        if issubclass(type_, date):
-            stmt = rf"CASE WHEN REGEXP_MATCHES(TRIM({quoted_name}), '{date_regex}') THEN TRY_CAST(TRIM({quoted_name}) as DATE) ELSE NULL END"  # pylint: disable=C0301
-            return stmt
-        if issubclass(type_, time):
-            stmt = rf"CASE WHEN REGEXP_MATCHES(TRIM({quoted_name}), '{time_regex}') THEN TRY_CAST(TRIM({quoted_name}) as TIME) ELSE NULL END"  # pylint: disable=C0301
-            return stmt
-        duck_type = get_duckdb_type_from_annotation(type_)
-        if duck_type:
-            stmt = f"trim({quoted_name})"
-            return _cast_as_ddb_type(stmt, type_) if parent_element else stmt
+        if issubclass(type_, (date, time)):
+            _date_format: str = resilient_get(
+                type_, "DATE_FORMAT", "TIME_FORMAT"
+            ) or DEFAULT_ISO_FORMATS.get(
+                type_, DEFAULT_ISO_FORMATS.get(datetime)
+            )  # type: ignore
+            dt_cast_statement = rf"CASE WHEN REGEXP_FULL_MATCH(TRIM({quoted_name}), '{datetime_format_to_regex(_date_format)}') THEN TRY_STRPTIME(TRIM({quoted_name}), '{_date_format}') ELSE NULL END"  # pylint: disable=C0301
+
+            # datetime is subclass of date, so needs to be handled first
+            if issubclass(type_, datetime):
+                stmt = rf"TRY_CAST({dt_cast_statement} as TIMESTAMP)"
+                return stmt
+            if issubclass(type_, date):
+                stmt = rf"TRY_CAST({dt_cast_statement} as DATE)"
+                return stmt
+            if issubclass(type_, time):
+                stmt = rf"TRY_CAST({dt_cast_statement} as TIME)"
+                return stmt
+        else:
+            duck_type = get_duckdb_type_from_annotation(type_)
+            if duck_type:
+                stmt = f"TRIM({quoted_name})"
+                return _cast_as_ddb_type(stmt, type_) if parent_element else stmt
     raise ValueError(f"No equivalent DuckDB type for {type_annotation!r}")

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/src/dve/core_engine/backends/implementations/spark/contract.py

@@ -7,6 +7,7 @@ from typing import Any, Optional
 from uuid import uuid4
 
 from pydantic import BaseModel
+from pydantic.fields import ModelField
 from pyspark.sql import DataFrame, SparkSession
 from pyspark.sql import functions as sf
 from pyspark.sql.functions import col, lit
@@ -26,6 +27,7 @@ from dve.core_engine.backends.exceptions import (
 )
 from dve.core_engine.backends.implementations.spark.spark_helpers import (
     df_is_empty,
+    get_spark_cast_statement_from_annotation,
     get_type_from_annotation,
     spark_read_parquet,
     spark_record_index,
@@ -86,7 +88,7 @@ class SparkDataContract(BaseDataContract[DataFrame]):
             schema=get_type_from_annotation(schema),
         )
 
-    # pylint: disable=R0915
+    # pylint: disable=R0914,R0915
     def apply_data_contract(
         self,
         working_dir: URI,
@@ -102,6 +104,7 @@ class SparkDataContract(BaseDataContract[DataFrame]):
 
         successful = True
         for entity_name, record_df in entities.items():
+            entity_fields: dict[str, ModelField] = contract_metadata.schemas[entity_name].__fields__
             spark_schema = get_type_from_annotation(contract_metadata.schemas[entity_name])
             spark_schema.add(StructField(RECORD_INDEX_COLUMN_NAME, LongType()))
             if df_is_empty(record_df):
@@ -144,12 +147,21 @@ class SparkDataContract(BaseDataContract[DataFrame]):
                 self.logger.info(f"Data contract found {msg_count} issues in {entity_name}")
 
             try:
+                # TODO: will need to revisit in pydantic v2 bump as model field no longer available
                 record_df = record_df.select(
-                    [
-                        col(column.name).cast(column.dataType)
-                        for column in spark_schema
-                        if column.name in record_df.columns
-                    ]
+                    *[
+                        (
+                            get_spark_cast_statement_from_annotation(
+                                fld, mdl_field.annotation
+                            ).alias(fld)
+                            if fld in record_df.columns
+                            else lit(None).cast(
+                                get_type_from_annotation(mdl_field.annotation).alias(fld)
+                            )
+                        )
+                        for fld, mdl_field in entity_fields.items()
+                    ],
+                    col(RECORD_INDEX_COLUMN_NAME).cast(LongType()).alias(RECORD_INDEX_COLUMN_NAME),
                 )
             except Exception as err:  # pylint: disable=broad-except
                 successful = False

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/src/dve/core_engine/backends/implementations/spark/spark_helpers.py

@@ -28,6 +28,7 @@ from typing_extensions import Annotated, Protocol, TypedDict, get_args, get_orig
 
 from dve.common.error_utils import get_feedback_errors_uri
 from dve.core_engine.backends.base.utilities import _get_non_heterogenous_type
+from dve.core_engine.backends.utilities import DEFAULT_ISO_FORMATS, datetime_format_to_regex
 from dve.core_engine.constants import RECORD_INDEX_COLUMN_NAME
 from dve.core_engine.type_hints import URI, EntityName
 
@@ -99,6 +100,21 @@ PYTHON_TYPE_TO_SPARK_TYPE: dict[type, st.DataType] = {
 }
 """A mapping of Python types to the equivalent Spark types."""
 
+PYTHON_TO_JAVA_DT_FORMAT_MAP: dict[str, str] = {
+    "%Y": "yyyy",
+    "%y": "yy",
+    "%m": "MM",
+    "%d": "dd",
+    "%H": "HH",
+    "%M": "mm",
+    "%S": "ss",
+    "%z": "XX",
+    "%Z": "z",
+}
+"""A mapping of python to java datetime component formats. Not exhaustive but will hopefully support
+   all requirements.
+"""
+
 
 PydanticModel = TypeVar("PydanticModel", bound=BaseModel)
 """An Pydantic model."""
@@ -272,6 +288,13 @@ def create_udf(function: Callable) -> Callable:
     return udf(function, returnType=return_type)
 
 
+def python_to_java_datetime_format(datetime_fmt: str) -> str:
+    "Helper to convert python datetime formats to Java datetime formats"
+    for pt, jt in PYTHON_TO_JAVA_DT_FORMAT_MAP.items():
+        datetime_fmt = datetime_fmt.replace(pt, jt)
+    return datetime_fmt.replace("T", "'T'")
+
+
 SupportedBaseType = Union[str, int, bool, float, Decimal, dt.date, dt.datetime]
 """Supported base types for Spark literals."""
 SparkLiteralType = Union[  # type: ignore
@@ -506,11 +529,7 @@ def _spark_safely_quote_name(field_name: str) -> str:
 
 # pylint: disable=R0801
 def get_spark_cast_statement_from_annotation(
-    element_name: str,
-    type_annotation: Any,
-    parent_element: bool = True,
-    date_regex: str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}$",
-    timestamp_regex: str = r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}((\\+|\\-)[0-9]{2}:[0-9]{2})?$",  # pylint: disable=C0301
+    element_name: str, type_annotation: Any, parent_element: bool = True
 ):
     """Generate casting statements for spark dataframes based on type annotations"""
     type_origin = get_origin(type_annotation)
@@ -520,20 +539,18 @@ def get_spark_cast_statement_from_annotation(
     # An `Optional` or `Union` type, check to ensure non-heterogenity.
     if type_origin is Union:
         python_type = _get_non_heterogenous_type(get_args(type_annotation))
-        return get_spark_cast_statement_from_annotation(
-            element_name, python_type, parent_element, date_regex, timestamp_regex
-        )
+        return get_spark_cast_statement_from_annotation(element_name, python_type, parent_element)
 
     # Type hint is e.g. `List[str]`, check to ensure non-heterogenity.
     if type_origin is list or (isinstance(type_origin, type) and issubclass(type_origin, list)):
         element_type = _get_non_heterogenous_type(get_args(type_annotation))
-        stmt = f"transform({quoted_name}, x -> {get_spark_cast_statement_from_annotation('x',element_type, False, date_regex, timestamp_regex)})"  # pylint: disable=C0301
+        stmt = f"TRANSFORM({quoted_name}, x -> {get_spark_cast_statement_from_annotation('x',element_type, False)})"  # pylint: disable=C0301
         return stmt if not parent_element else _cast_as_spark_type(stmt, type_annotation)
 
     if type_origin is Annotated:
         python_type, *_ = get_args(type_annotation)  # pylint: disable=unused-variable
         return get_spark_cast_statement_from_annotation(
-            element_name, python_type, parent_element, date_regex, timestamp_regex
+            element_name, python_type, parent_element
         )  # add other expected params here
     # Ensure that we have a concrete type at this point.
     if not isinstance(type_annotation, type):
@@ -558,7 +575,7 @@ def get_spark_cast_statement_from_annotation(
                 continue
 
             fields[field_name] = get_spark_cast_statement_from_annotation(
-                f"{element_name}.{field_name}", field_annotation, False, date_regex, timestamp_regex
+                f"{element_name}.{field_name}", field_annotation, False
             )
 
         if not fields:
@@ -566,7 +583,7 @@ def get_spark_cast_statement_from_annotation(
                 f"No type annotations in dict/dataclass type (got {type_annotation!r})"
             )
         cast_exprs = ",".join([f"{stmt} AS `{nme}`" for nme, stmt in fields.items()])
-        stmt = f"struct({cast_exprs})"
+        stmt = f"STRUCT({cast_exprs})"
         return stmt if not parent_element else _cast_as_spark_type(stmt, type_annotation)
     if type_annotation is list:
         raise ValueError(
@@ -576,15 +593,31 @@ def get_spark_cast_statement_from_annotation(
         raise ValueError(f"dict must be `typing.TypedDict` subclass, got {type_annotation!r}")
 
     for type_ in type_annotation.mro():
-        # datetime is subclass of date, so needs to be handled first
-        if issubclass(type_, dt.datetime):
-            stmt = rf"CASE WHEN REGEXP(TRIM({quoted_name}), '{timestamp_regex}') THEN TRIM({quoted_name}) ELSE NULL END"  # pylint: disable=C0301
-            return _cast_as_spark_type(stmt, type_) if parent_element else stmt
         if issubclass(type_, dt.date):
-            stmt = rf"CASE WHEN REGEXP(TRIM({quoted_name}), '{date_regex}') THEN TRIM({quoted_name}) ELSE NULL END"  # pylint: disable=C0301
-            return _cast_as_spark_type(stmt, type_) if parent_element else stmt
-        spark_type = get_type_from_annotation(type_)
-        if spark_type:
-            stmt = f"trim({quoted_name})"
-            return _cast_as_spark_type(stmt, type_) if parent_element else stmt
+            _date_format: str = getattr(  # type: ignore
+                type_,
+                "DATE_FORMAT",
+                DEFAULT_ISO_FORMATS.get(type_, DEFAULT_ISO_FORMATS.get(dt.datetime)),
+            )
+
+            # pylint: disable=C0301
+            dt_cast_statement = f"CASE WHEN REGEXP(TRIM({quoted_name}), '{datetime_format_to_regex(_date_format)}') THEN TRY_TO_TIMESTAMP(TRIM({quoted_name}), \"{python_to_java_datetime_format(_date_format)}\") ELSE NULL END"  # pylint: disable=C0301
+            # datetime is subclass of date, so needs to be handled first
+            if issubclass(type_, dt.datetime):
+                return (
+                    _cast_as_spark_type(dt_cast_statement, type_)
+                    if parent_element
+                    else dt_cast_statement
+                )
+            if issubclass(type_, dt.date):
+                return (
+                    _cast_as_spark_type(dt_cast_statement, type_)
+                    if parent_element
+                    else dt_cast_statement
+                )
+        else:
+            spark_type = get_type_from_annotation(type_)
+            if spark_type:
+                stmt = f"TRIM({quoted_name})"
+                return _cast_as_spark_type(stmt, type_) if parent_element else stmt
     raise ValueError(f"No equivalent Spark type for {type_annotation!r}")

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/src/dve/core_engine/backends/utilities.py

@@ -23,6 +23,49 @@ if sys.version_info[:2] <= (3, 7):
 else:
     from typing import Annotated, get_args, get_origin, get_type_hints
 
+DEFAULT_ISO_FORMATS: dict[type, str] = {
+    date: "%Y-%m-%d",
+    datetime: "%Y-%m-%dT%H:%M:%S",
+    time: "%H:%M:%S",
+}
+"""Mapping of default ISO formats to use when date format not supplied"""
+
+PYTHON_DATE_FORMAT_REGEX_HELPER: dict[str, str] = {
+    "Y": r"[0-9]{4}",
+    "y": r"[0-9]{2}",
+    "m": r"[0-9]{2}",
+    "d": r"[0-9]{2}",
+    "H": r"[0-9]{2}",
+    "M": r"[0-9]{2}",
+    "S": r"[0-9]{2}",
+    "z": r"(\+|\-)?[0-9]+(\.[0-9]*)?",
+    "Z": r"[A-Z]{0,3}",
+}
+
+REGEXP_NEED_ESCAPE_CHARS: tuple[str, str, str] = ("+", "-", ".")
+"""Helper to map python date format to regexp expression. Not exhaustive, but aims to cover
+   all foreseen use cases."""
+
+
+def datetime_format_to_regex(format_str: str) -> str:
+    """
+    Helper function to convert python datetime formats to regexp string checks for casting
+    purposes.
+    """
+
+    tokens = list(format_str.replace("%", ""))
+
+    for idx, tkn in enumerate(tokens):
+        if rpl := PYTHON_DATE_FORMAT_REGEX_HELPER.get(tkn):
+            tokens[idx] = rpl
+        elif tkn in REGEXP_NEED_ESCAPE_CHARS:
+            tokens[idx] = rf"\{tkn}"
+        else:
+            continue
+        tokens = [PYTHON_DATE_FORMAT_REGEX_HELPER.get(tkn, tkn) for tkn in tokens]
+    return "".join(["^", *tokens, "$"])
+
+
 PYTHON_TYPE_TO_POLARS_TYPE: dict[type, PolarsType] = {
     # issue with decimal conversion at the moment...
     str: pl.Utf8,  # type: ignore

{data_validation_engine-0.8.2 → data_validation_engine-0.8.4}/src/dve/metadata_parser/utilities.py

@@ -52,3 +52,23 @@ def chain_get(
         return result
 
     raise exc.TypeNotFoundError(f"Callable or type ({item!r}) not found")
+
+
+def resilient_get(item: object, *attribute_names: str) -> Any:
+    """Given a number of attribute names, try to get attribute value
+    sequentially. Returns the first value found, and if no attributes found
+    returns None.
+
+    Args:
+        item (object): The object to obtain attributes from (where possible)
+        attribute_names (str): The attribute names to search for
+
+    Returns:
+        Any: The first found attribute, otherwise None
+    """
+    for attr in attribute_names:
+        try:
+            return getattr(item, attr)
+        except AttributeError:
+            continue
+    return None