assertions-mate 0.1.0__py3-none-any.whl

assertions_mate/__about__.py

@@ -0,0 +1,15 @@
+# Copyright 2025 Terradue
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "0.1.0"

assertions_mate/__init__.py

@@ -0,0 +1,170 @@
+# Copyright 2025 Terradue
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .error_models import ProblemDetails
+from abc import (
+    ABC,
+    abstractmethod
+)
+from cwl2ogc import BaseCWLtypes2OGCConverter
+from loguru import logger
+from pydantic import (
+    BaseModel,
+    computed_field,
+    model_serializer
+)
+from typing import (
+    Any,
+    List,
+    Mapping,
+    Optional
+)
+
+class BaseValidator(ABC):
+
+    @abstractmethod
+    def validate_inputs(
+        self,
+        data: Mapping[str, Any]
+    ) -> ProblemDetails | None:
+        pass
+
+class AssertionHint(BaseModel):
+    parent_workflow: Optional[Any] = None
+
+    @property
+    @computed_field
+    @abstractmethod
+    def annotation(self) -> str:
+        pass
+
+    @abstractmethod
+    def validator(self) -> BaseValidator:
+        pass
+
+class JSONSchemaHint(AssertionHint):
+    json_schema: Mapping[str, Any] = {}
+
+    @staticmethod
+    def get_annotation_name() -> str:
+        return 'eoap.ogc.org/inputs-json-schema'
+
+    @property
+    def annotation(self) -> str:
+        return JSONSchemaHint.get_annotation_name()
+
+    @model_serializer
+    def ser_model(self) -> Mapping[str, Any]:
+        return BaseCWLtypes2OGCConverter(self.parent_workflow).get_inputs_json_schema() if self.parent_workflow is not None else self.json_schema
+ 
+    def validator(self) -> BaseValidator:
+        from .jsonschema_validator import JSONSchemaValidator
+        schema = BaseCWLtypes2OGCConverter(self.parent_workflow).get_inputs_json_schema() if self.parent_workflow is not None else self.json_schema
+        return JSONSchemaValidator(schema=schema)
+
+class RegoPolicyHint(AssertionHint):
+
+    @staticmethod
+    def get_annotation_name() -> str:
+        return 'eoap.ogc.org/inputs-rego-policy'
+
+    module: str
+    queries: List[str]
+
+    @property
+    def annotation(self) -> str:
+        return RegoPolicyHint.get_annotation_name()
+
+    @model_serializer
+    def ser_model(self) -> Mapping[str, Any]:
+        return {
+            'queries': self.queries,
+            'module': self.module
+        }
+
+    def validator(self) -> BaseValidator:
+        from .rego_validator import RegoValidator
+        return RegoValidator(
+            queries=self.queries,
+            module=self.module
+        )
+
+class Cql2Query(BaseModel):
+    id: str
+    cql2: str | Mapping[str, Any]
+    message: str
+
+class Cql2FilterHint(AssertionHint):
+
+    @staticmethod
+    def get_annotation_name() -> str:
+        return 'eoap.ogc.org/inputs-cql2-filter'
+
+    queries: List[Cql2Query]
+
+    @property
+    def annotation(self) -> str:
+        return Cql2FilterHint.get_annotation_name()
+
+    @model_serializer
+    def ser_model(self) -> Mapping[str, Any]:
+        return {
+            'queries': self.queries
+        }
+
+    def validator(self) -> BaseValidator:
+        from .cql2_validator import Cql2Validator
+        return Cql2Validator(
+            queries=self.queries
+        )
+
+def _get_assertion_hint_by_name(
+    parent_workflow: Any,
+    hint: Mapping[str, Any]
+) -> AssertionHint | None:
+    fqn_hint_kind = hint['class']
+
+    logger.debug(f"Analysing hint: {fqn_hint_kind}")
+
+    if 'eoap:' in fqn_hint_kind:
+        hint_kind_name = fqn_hint_kind.split(':')[-1]
+
+        logger.debug(f"Mapping {fqn_hint_kind} to {AssertionHint.__name__}:")
+
+        try:
+            hint_kind = globals()[hint_kind_name]
+            return hint_kind(parent_workflow=parent_workflow, **hint)
+        except Exception as e:
+            logger.error(f"An error occurred while mapping {fqn_hint_kind} to {AssertionHint.__name__}: {e}")
+            return None
+
+    return None
+
+def extract_assertion_hints(
+    workflow: Any
+) -> List[AssertionHint]:
+    assertion_hints = []
+
+    if workflow.hints:
+        for hint in workflow.hints:
+            if isinstance(hint, dict):
+                hint_instance = _get_assertion_hint_by_name(parent_workflow=workflow, hint=hint)
+
+                if hint_instance:
+                    assertion_hints.append(hint_instance)
+    else:
+        logger.debug(f"No hints defined in current #{workflow.id.split('#')[-1]} {workflow.class_} ({workflow.cwlVersion})")
+
+    return assertion_hints
+

assertions_mate/cli.py

@@ -0,0 +1,128 @@
+# Copyright 2025 Terradue
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import (
+    JSONSchemaHint,
+    RegoPolicyHint,
+    Cql2FilterHint,
+    extract_assertion_hints
+)
+from cwl2ogc import BaseCWLtypes2OGCConverter
+from cwl_utils.parser import load_document_by_uri
+from cwl_utils.parser.cwl_v1_2 import Workflow
+from datetime import datetime
+from loguru import logger
+from pathlib import Path
+from typing import (
+    Any,
+    Mapping
+)
+
+import click
+import yaml
+import time
+
+def _scan_workflow(
+    wf: Workflow,
+    inputs: Mapping[str, Any]
+):
+    logger.info('------------------------------------------------------------------------')
+    workflow_id = wf.id.split('#')[-1]
+    logger.info(f"Validating #{workflow_id} {wf.class_} ({wf.cwlVersion}):")
+
+    validators = []
+
+    # prepare
+    for hint_instance in extract_assertion_hints(wf):
+        logger.info(f"Setting up validator for {type(hint_instance).__name__}...")
+
+        try:
+            validators.append(hint_instance.validator())
+        except Exception as e:
+            logger.error(f"An error occurred when setting up {type(hint_instance).__name__}: {e}")
+
+    if validators:
+        logger.info("Setup is over, validating...")
+
+        for validator in validators:
+            logger.info(f"  - Executing {type(validator).__name__}...")
+
+            problem_details = validator.validate_inputs(inputs)
+            if problem_details:
+                logger.error(f"    {type(validator).__name__} detected violations below:")
+
+                for error_detail in problem_details.errors:
+                    logger.error(f"    [{error_detail.pointer}] {error_detail.detail}")
+            else:
+                logger.info(f"    {type(validator).__name__} execution terminated with no violations")
+    else:
+        logger.info(f"No Validators configured in '#{workflow_id}.hints'")
+
+@click.command()
+@click.argument(
+    'workflow',
+    type=click.Path(
+        path_type=Path,
+        exists=True,
+        readable=True,
+        resolve_path=True
+    ),
+    required=True
+)
+@click.option(
+    '--inputs',
+    type=click.Path(
+        path_type=Path,
+        exists=True,
+        readable=True,
+        resolve_path=True
+    ),
+    required=True,
+    help="The Workflow inputs to check against the input Workflow"
+)
+def main(
+    workflow: Path,
+    inputs: Path
+):
+    start_time = time.time()
+
+    logger.info(f"Loading CWL document from {workflow.absolute()}")
+
+    cwl_document = load_document_by_uri(
+        path=workflow,
+        load_all=True
+    )
+
+    end_time = time.time()
+    logger.info(f"{workflow.absolute()} load in {end_time - start_time:.4f} seconds")
+
+    logger.info(f"Loading inputs from {inputs.absolute()}")
+
+    with inputs.open() as input_stream:
+        inputs_mapping = yaml.safe_load(input_stream)
+
+    if isinstance(cwl_document, list):
+        for wf in cwl_document:
+            _scan_workflow(wf, inputs_mapping)                
+    else:
+        _scan_workflow(cwl_document, inputs_mapping)
+
+    end_time = time.time()
+
+    logger.info('------------------------------------------------------------------------')
+    logger.info('VALIDATION COMPLETE')
+    logger.info('------------------------------------------------------------------------')
+
+    logger.info(f"Total time: {end_time - start_time:.4f} seconds")
+    logger.info(f"Finished at: {datetime.fromtimestamp(end_time).isoformat(timespec='milliseconds')}")

assertions_mate/cql2_validator.py

@@ -0,0 +1,116 @@
+# Copyright 2025 Terradue
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import (
+    BaseValidator,
+    Cql2Query
+)
+from .error_models import (
+    BusinessRuleViolation,
+    ErrorDetail,
+    ProblemDetails,
+    ServerError
+)
+from pygeofilter.backends.native.evaluate import NativeEvaluator
+from pygeofilter.parsers.cql2_text import parse as parse_cql2_text
+from pygeofilter.parsers.cql2_json import parse as parse_cql2_json
+from shapely import geometry
+from typing import (
+    Any,
+    List,
+    Mapping,
+    Union
+)
+
+def ensure_bbox(input: Union[Mapping[str, Any], List[float], str]):
+    value = []
+
+    if isinstance(input, dict):
+        value = input['bbox']
+        if not value:
+            raise ValueError(f"Input {input} doesn't have a 'bbox' property")
+    elif isinstance(input, str):
+        value = [float(x) for x in str(input).split(',')]
+    else:
+        value = input
+
+    return geometry.box(*value)
+
+class Cql2Validator(BaseValidator):
+
+    def __init__(
+        self,
+        queries: List[Cql2Query]
+    ):
+        self.evaluator = NativeEvaluator(
+            function_map={
+                'ensure_bbox': ensure_bbox
+            },
+            use_getattr=False
+        )
+
+        self.queries = queries
+
+    def validate_inputs(
+        self,
+        data: Mapping[str, Any]
+    ) -> ProblemDetails | None:
+        errors_list = []
+
+        for filter in self.queries:
+            ast = None
+
+            if isinstance(filter.cql2, str):
+                try:
+                    ast = parse_cql2_text(filter.cql2)
+                except Exception as e:
+                    errors_list.append(
+                        ErrorDetail(
+                            pointer=filter.id,
+                            detail=f"Filter does not look like a valid CQL2 Text encoded sentece: {e}"
+                        )
+                    )
+            elif isinstance(filter.cql2, dict):
+                try:
+                    ast = parse_cql2_json(filter.cql2)
+                except Exception as e:
+                    errors_list.append(
+                        ErrorDetail(
+                            pointer=filter.id,
+                            detail=f"Filter does not look like a valid CQL2 JSON encoded structure: {e}"
+                        )
+                    )
+            else:
+                errors_list.append(
+                    ErrorDetail(
+                        pointer=filter.id,
+                        detail=f"Filter is expressed in an unrecognizible format: {type(filter.cql2)}"
+                    )
+                )
+
+            if ast:
+                predicate = self.evaluator.evaluate(ast)
+
+                if not predicate(data):
+                    errors_list.append(
+                        ErrorDetail(
+                            pointer=filter.id,
+                            detail=filter.message
+                        )
+                    )
+
+        if errors_list:
+            return BusinessRuleViolation(errors=errors_list)
+
+        return None