refactor: soften time validation (#1505)

* refactor: remove time validation from subject and reduce data_description to a warning

* fix: wording

* tests: remove test for validator that was removed

* tests: additional coverage, and removing unnecessary validators

* fix: revert changes to subject validation

Author: dbirman

src/aind_data_schema/core/metadata.py

@@ -351,13 +351,13 @@ def validate_data_description_name_time_consistency(self):
                 if name_creation_time:
                     try:
                         validate_creation_time_after_midnight(name_creation_time, self.acquisition.acquisition_end_time)
-                    except ValueError as e:
-                        # Re-raise with more specific context for data_description.name
-                        raise ValueError(
+                    except ValueError:
+                        # Issue a warning instead of raising an error
+                        warnings.warn(
                             f"Creation time from data_description.name ({name_creation_time}) "
-                            f"must be on or after midnight of the acquisition day "
-                            f"({self.acquisition.acquisition_end_time.date()})"
-                        ) from e
+                            f"should be close to the acquisition end time "
+                            f"({self.acquisition.acquisition_end_time})"
+                        )
 
         return self
 

src/aind_data_schema/utils/validators.py

@@ -90,19 +90,19 @@ def recursive_time_validation_check(data, acquisition_start_time=None, acquisiti
     _time_validation_recurse_helper(data, acquisition_start_time, acquisition_end_time)
 
 
+def _convert_to_comparable(value, reference_datetime):
+    """Convert date to datetime using the timezone from reference, or return as-is if already datetime"""
+    if isinstance(value, date) and not isinstance(value, datetime):
+        # Convert date to datetime at midnight with same timezone as reference
+        return datetime.combine(value, datetime.min.time()).replace(tzinfo=reference_datetime.tzinfo)
+    return value
+
+
 def _validate_time_constraint(field_value, time_validation, start_time, end_time, field_name):
     """Validate a single time field against the specified constraint."""
 
-    # Handle conversion between date and datetime objects for comparison
-    def convert_to_comparable(value, reference_datetime):
-        """Convert date to datetime using the timezone from reference, or return as-is if already datetime"""
-        if isinstance(value, date) and not isinstance(value, datetime):
-            # Convert date to datetime at midnight with same timezone as reference
-            return datetime.combine(value, datetime.min.time()).replace(tzinfo=reference_datetime.tzinfo)
-        return value
-
     # Convert field_value to be comparable with start_time and end_time
-    comparable_field_value = convert_to_comparable(field_value, start_time)
+    comparable_field_value = _convert_to_comparable(field_value, start_time)
 
     if time_validation == TimeValidation.BETWEEN:
         if not (start_time <= comparable_field_value <= end_time):

tests/test_metadata.py

@@ -2,6 +2,7 @@
 
 import json
 import unittest
+import warnings
 from datetime import datetime, timezone
 from pathlib import Path
 
@@ -612,16 +613,21 @@ def test_validate_data_description_name_time_consistency(self):
             project_name="Test Project",
         )
 
-        # This should fail - creation time is before the acquisition day
-        with self.assertRaises(ValidationError) as context:
-            Metadata(
+        # This should issue a warning - creation time is before the acquisition day
+        with warnings.catch_warnings(record=True) as warning_list:
+            warnings.simplefilter("always")
+            metadata_with_warning = Metadata(
                 name="Test Metadata",
                 location="Test Location",
                 data_description=data_description_before,
                 acquisition=acquisition,
             )
-        self.assertIn("Creation time from data_description.name", str(context.exception))
-        self.assertIn("must be on or after midnight of the acquisition day", str(context.exception))
+            # Should have successfully created the metadata object
+            self.assertIsNotNone(metadata_with_warning)
+            # Should have issued a warning
+            self.assertEqual(len(warning_list), 1)
+            self.assertIn("Creation time from data_description.name", str(warning_list[0].message))
+            self.assertIn("should be close to the acquisition end time", str(warning_list[0].message))
 
         # Test case where data_description is None (should pass)
         metadata_no_data_desc = Metadata(

tests/test_utils_validators.py

@@ -1,7 +1,7 @@
 """ Tests for compatibility check utilities """
 
 import unittest
-from datetime import datetime, timezone, timedelta
+from datetime import date, datetime, timezone, timedelta
 from enum import Enum
 from pathlib import Path
 from typing import Annotated
@@ -17,6 +17,7 @@
     CoordinateSystemException,
     SystemNameException,
     TimeValidation,
+    _convert_to_comparable,
     _recurse_helper,
     _system_check_helper,
     _time_validation_recurse_helper,
@@ -683,5 +684,28 @@ def test_invalid_date_object_creation_time(self):
         self.assertIn("must be on or after midnight", str(context.exception))
 
 
+class TestConvertToComparable(unittest.TestCase):
+    """Tests for _convert_to_comparable function"""
+
+    def test_convert_date_to_datetime(self):
+        """Test converting date to datetime with timezone from reference"""
+        reference_time = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        test_date = date(2023, 1, 2)
+
+        result = _convert_to_comparable(test_date, reference_time)
+
+        expected = datetime(2023, 1, 2, 0, 0, 0, tzinfo=timezone.utc)
+        self.assertEqual(result, expected)
+
+    def test_return_datetime_unchanged(self):
+        """Test that datetime objects are returned unchanged"""
+        reference_time = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        test_datetime = datetime(2023, 1, 2, 10, 30, 0, tzinfo=timezone.utc)
+
+        result = _convert_to_comparable(test_datetime, reference_time)
+
+        self.assertEqual(result, test_datetime)
+
+
 if __name__ == "__main__":
     unittest.main()