release: 🔖 version 0.6.5

Author: kikkomep

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "roc-validator"
-version = "0.6.4"
+version = "0.6.5"
 description = "A Python package to validate RO-Crates"
 authors = [
     "Marco Enrico Piras <[email protected]>",

rocrate_validator/cli/commands/validate.py

@@ -558,6 +558,11 @@ def update(self, event: Event):
                     else:
                         self._stats["failed_checks"].append(event.requirement_check)
                     self.layout.update(self._stats)
+                else:
+                    logger.debug("Requirement check validation result is None: %s",
+                                 event.requirement_check.identifier)
+            else:
+                logger.debug("Skipping requirement check validation: %s", event.requirement_check.identifier)
         elif event.event_type == EventType.REQUIREMENT_VALIDATION_END:
             if not event.requirement.hidden:
                 self.progress.update(task_id=self.requirement_validation, advance=1)

rocrate_validator/events.py

@@ -19,6 +19,11 @@
 
 import enum_tools
 
+import rocrate_validator.log as logging
+
+# Set up logging
+logger = logging.getLogger(__name__)
+
 
 @enum.unique
 @enum_tools.documentation.document_enum
@@ -67,6 +72,59 @@ def __init__(self, event_type: EventType, message: Optional[str] = None):
         self.event_type = event_type
         self.message = message
 
+    def __str__(self):
+        """
+        String representation of the event.
+
+        :return: the string representation
+        :rtype: str
+        """
+        return f"{self.event_type.name}: {self.message}" if self.message else self.event_type.name
+
+    def __repr__(self):
+        """
+        String representation of the event.
+
+        :return: the string representation
+        :rtype: str
+        """
+        return f"{self.event_type.name}: {self.message}" if self.message else self.event_type.name
+
+    def __eq__(self, other):
+        """
+        Compare two events.
+
+        :param other: the other event
+        :type other: Event
+
+        :return: True if the events are equal, False otherwise
+        :rtype: bool
+        """
+        if self.__class__ is other.__class__:
+            return self.event_type == other.event_type and self.message == other.message
+        return NotImplemented
+
+    def __hash__(self):
+        """
+        Hash the event.
+
+        :return: the hash
+        :rtype: int
+        """
+        return hash((self.event_type, self.message))
+
+    def __ne__(self, other):
+        """
+        Compare two events.
+        :param other: the other event
+        :type other: Event
+        :return: True if the events are not equal, False otherwise
+        :rtype: bool
+        """
+        if self.__class__ is other.__class__:
+            return not self.__eq__(other)
+        return NotImplemented
+
 
 class Subscriber(ABC):
 
@@ -91,8 +149,10 @@ def update(self, event: Event):
 
 
 class Publisher:
-    def __init__(self):
+    def __init__(self, avoid_duplicate_notifications: bool = False):
         self.__subscribers = set()
+        self.__notified_events = set()
+        self.__avoid_duplicate_notifications = avoid_duplicate_notifications
 
     @property
     def subscribers(self):
@@ -107,5 +167,15 @@ def remove_subscriber(self, subscriber):
     def notify(self, event: Union[Event, EventType]):
         if isinstance(event, EventType):
             event = Event(event)
+        # Check if the event has already been notified
+        # This is to avoid notifying the same event multiple times
+        if self.__avoid_duplicate_notifications:
+            if event in self.__notified_events:
+                logger.warning(f"Event {event} already notified")
+                return
+        # Add the event to the notified events
+        self.__notified_events.add(event)
+        logger.debug(f"Notifying event {event}")
+        # Notify all subscribers
         for subscriber in self.subscribers:
             subscriber.update(event)

rocrate_validator/models.py

@@ -897,9 +897,7 @@ def _do_validate_(self, context: ValidationContext) -> bool:
                       or _.identifier not in context.settings.skip_checks]:
 
             try:
-                logger.debug("Running check '%s' - Desc: %s - overridden: %s",
-                             check.name, check.description, [_.identifier for _ in check.overridden_by])
-                if check.overridden:
+                if check.overridden and not check.requirement.profile.identifier == context.profile_identifier:
                     logger.debug("Skipping check '%s' because overridden by '%r'",
                                  check.identifier, [_.identifier for _ in check.overridden_by])
                     continue
@@ -910,7 +908,7 @@ def _do_validate_(self, context: ValidationContext) -> bool:
                 context.result._add_executed_check(check, check_result)
                 context.validator.notify(RequirementCheckValidationEvent(
                     EventType.REQUIREMENT_CHECK_VALIDATION_END, check, validation_result=check_result))
-                logger.debug("Ran check '%s'. Got result %s", check.name, check_result)
+                logger.debug("Ran check '%s'. Got result %s", check.identifier, check_result)
                 if not isinstance(check_result, bool):
                     logger.warning("Ignoring the check %s as it returned the value %r instead of a boolean", check.name)
                     raise RuntimeError(f"Ignoring invalid result from check {check.name}")
@@ -1659,6 +1657,23 @@ def __init__(self, event_type: EventType, profile: Profile, message: Optional[st
     def profile(self) -> Profile:
         return self._profile
 
+    def __str__(self) -> str:
+        return f"ProfileValidationEvent({self.event_type}, {self.profile})"
+
+    def __repr__(self) -> str:
+        return f"ProfileValidationEvent(event_type={self.event_type}, profile={self.profile})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ProfileValidationEvent):
+            raise TypeError(f"Cannot compare {type(self)} with {type(other)}")
+        return self.event_type == other.event_type and self.profile == other.profile
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.event_type, self.profile))
+
 
 class RequirementValidationEvent(Event):
     def __init__(self,
@@ -1679,6 +1694,23 @@ def requirement(self) -> Requirement:
     def validation_result(self) -> Optional[bool]:
         return self._validation_result
 
+    def __str__(self) -> str:
+        return f"RequirementValidationEvent({self.event_type}, {self.requirement})"
+
+    def __repr__(self) -> str:
+        return f"RequirementValidationEvent(event_type={self.event_type}, requirement={self.requirement})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RequirementValidationEvent):
+            raise TypeError(f"Cannot compare {type(self)} with {type(other)}")
+        return self.event_type == other.event_type and self.requirement == other.requirement
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.event_type, self.requirement))
+
 
 class RequirementCheckValidationEvent(Event):
     def __init__(self, event_type: EventType,
@@ -1697,6 +1729,24 @@ def requirement_check(self) -> RequirementCheck:
     def validation_result(self) -> Optional[bool]:
         return self._validation_result
 
+    def __str__(self) -> str:
+        return f"RequirementCheckValidationEvent({self.event_type}, {self.requirement_check})"
+
+    def __repr__(self) -> str:
+        return f"RequirementCheckValidationEvent(event_type={self.event_type}, " \
+               f"requirement_check={self.requirement_check})"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RequirementCheckValidationEvent):
+            raise TypeError(f"Cannot compare {type(self)} with {type(other)}")
+        return self.event_type == other.event_type and self.requirement_check == other.requirement_check
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.event_type, self.requirement_check))
+
 
 class Validator(Publisher):
     """
@@ -1809,7 +1859,7 @@ def __do_validate__(self,
                     self.notify(RequirementValidationEvent(
                         EventType.REQUIREMENT_VALIDATION_START, requirement=requirement))
                 passed = requirement._do_validate_(context)
-                logger.debug("Requirement %s passed: %s", requirement, passed)
+                logger.debug("Requirement %s passed: %s", requirement.identifier, passed)
                 if not requirement.overridden:
                     self.notify(RequirementValidationEvent(
                         EventType.REQUIREMENT_VALIDATION_END, requirement=requirement, validation_result=passed))

rocrate_validator/requirements/shacl/checks.py

@@ -111,16 +111,19 @@ def execute_check(self, context: ValidationContext):
                          self.requirement.profile.identifier, self.identifier)
             with SHACLValidationContextManager(self, context) as ctx:
                 # The check is executed only if the profile is the most specific one
-                logger.debug("SHACL Validation of profile %s requirement %s started",
+                logger.debug("SHACL Validation of requirement check %s (profile: %s) started",
                              self.requirement.profile.identifier, self.identifier)
                 result = self.__do_execute_check__(ctx)
-                ctx.current_validation_result = self not in result
+                ctx.current_validation_result = self.identifier not in result
+                logger.debug("SHACL Validation of requirement check %s (profile: %s) finished with result %s",
+                             self.requirement.profile.identifier, self.identifier, ctx.current_validation_result)
                 return ctx.current_validation_result
         except SHACLValidationAlreadyProcessed:
-            logger.debug("SHACL Validation of profile %s already processed", self.requirement.profile.identifier)
+            logger.debug("SHACL Validation of requirement check %s (profile: %s) already processed",
+                         self.requirement.identifier, self.requirement.profile.identifier)
             # The check belongs to a profile which has already been processed
             # so we can skip the validation and return the specific result for the check
-            return self not in [i.check for i in context.result.get_issues()]
+            return self.identifier not in [i.check.identifier for i in context.result.get_issues()]
         except SHACLValidationSkip as e:
             logger.debug("SHACL Validation of profile %s requirement %s skipped",
                          self.requirement.profile.identifier, self.identifier)
@@ -187,7 +190,9 @@ def __do_execute_check__(self, shacl_context: SHACLValidationContext):
         # if the validation fails, process the failed checks
         failed_requirements_checks = set()
         failed_requirements_checks_violations: dict[str, SHACLViolation] = {}
-        failed_requirement_checks_notified = []
+        failed_requirement_checks_notified = [_.check.identifier for _ in shacl_context.result.get_issues(
+            min_severity=shacl_context.settings.requirement_severity)]
+
         logger.debug("Parsing Validation with result: %s", shacl_result)
         # process the failed checks to extract the requirement checks involved
         for violation in shacl_result.violations:
@@ -215,13 +220,18 @@ def __do_execute_check__(self, shacl_context: SHACLValidationContext):
                 violation_message = violation.get_result_message(shacl_context.rocrate_uri)
                 registered_check_issues = shacl_context.result.get_issues_by_check(requirementCheck)
                 skip_requirement_check = False
+                # check if the violation is already registered
+                # and skip the requirement check if it is
                 for check_issue in registered_check_issues:
                     if check_issue.message == violation_message and \
                             check_issue.violatingProperty == violating_property and \
                             check_issue.violatingEntity == violating_entity and \
                             check_issue.violatingPropertyValue == violation.value:
                         skip_requirement_check = True
+                        logger.debug("Skipping requirement check %s: %s", requirementCheck.identifier,
+                                     violation_message)
                         break
+                # if the check is not to be skipped, add the issue to the context
                 if not skip_requirement_check:
                     c = shacl_context.result.add_issue(
                         message=violation.get_result_message(shacl_context.rocrate_uri),
@@ -240,11 +250,13 @@ def __do_execute_check__(self, shacl_context: SHACLValidationContext):
             # all together and not profile by profile
             if requirementCheck.identifier not in failed_requirement_checks_notified:
                 shacl_context.result._add_executed_check(requirementCheck, False)
-                shacl_context.validator.notify(RequirementCheckValidationEvent(
-                    EventType.REQUIREMENT_CHECK_VALIDATION_END,
-                    requirementCheck, validation_result=False))
-                # failed_requirement_checks_notified.append(requirementCheck.identifier)
-                logger.debug("Added validation issue to the context: %s", c)
+                if requirementCheck.identifier not in failed_requirement_checks_notified and \
+                        requirementCheck.requirement.profile != shacl_context.current_validation_profile:
+                    failed_requirement_checks_notified.append(requirementCheck.identifier)
+                    shacl_context.validator.notify(RequirementCheckValidationEvent(
+                        EventType.REQUIREMENT_CHECK_VALIDATION_END,
+                        requirementCheck, validation_result=False))
+                    logger.debug("Added validation issue to the context: %s", c)
 
             # if the fail fast mode is enabled, stop the validation after the first failed check
             if shacl_context.fail_fast:
@@ -257,7 +269,7 @@ def __do_execute_check__(self, shacl_context: SHACLValidationContext):
             if not isinstance(requirementCheck, SHACLCheck):
                 logger.debug("Skipped check is not a SHACLCheck: %s", requirementCheck.identifier)
                 continue
-            # if requirementCheck.requirement.profile != shacl_context.current_validation_profile and \
+            # if requirementCheck.requirement.profile != shacl_context.current_validation_profile and
             if requirementCheck.identifier not in failed_requirement_checks_notified:
                 failed_requirement_checks_notified.append(requirementCheck.identifier)
                 shacl_context.result._add_executed_check(requirementCheck, True)