Whitespace

Author: hoijnet

terminusdb_client/tests/integration_tests/test_woql_interval_duration.py

@@ -52,28 +52,32 @@ def setup_teardown(self, docker_url):
 
     def test_construct_from_datetime_endpoints(self):
         """Construct interval from two xsd:dateTime values."""
-        query = WOQLQuery().interval(dtm("2025-01-01T09:00:00Z"),
-                                     dtm("2025-01-01T17:30:00Z"),
-                                     "v:iv")
+        query = WOQLQuery().interval(
+            dtm("2025-01-01T09:00:00Z"), dtm("2025-01-01T17:30:00Z"), "v:iv"
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
-        assert result["bindings"][0]["iv"]["@value"] == \
-            "2025-01-01T09:00:00Z/2025-01-01T17:30:00Z"
+        assert (
+            result["bindings"][0]["iv"]["@value"]
+            == "2025-01-01T09:00:00Z/2025-01-01T17:30:00Z"
+        )
 
     def test_construct_mixed_date_datetime(self):
         """Construct interval with date start and dateTime end."""
-        query = WOQLQuery().interval(dat("2025-01-01"),
-                                     dtm("2025-04-01T12:00:00Z"),
-                                     "v:iv")
+        query = WOQLQuery().interval(
+            dat("2025-01-01"), dtm("2025-04-01T12:00:00Z"), "v:iv"
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
-        assert result["bindings"][0]["iv"]["@value"] == \
-            "2025-01-01/2025-04-01T12:00:00Z"
+        assert (
+            result["bindings"][0]["iv"]["@value"] == "2025-01-01/2025-04-01T12:00:00Z"
+        )
 
     def test_deconstruct_datetime_interval(self):
         """Deconstruct dateTime interval preserves types."""
-        query = WOQLQuery().interval("v:s", "v:e",
-                                     dti("2025-01-01T09:00:00Z/2025-04-01T17:30:00Z"))
+        query = WOQLQuery().interval(
+            "v:s", "v:e", dti("2025-01-01T09:00:00Z/2025-04-01T17:30:00Z")
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["s"]["@type"] == "xsd:dateTime"
@@ -97,7 +101,8 @@ def setup_teardown(self, docker_url):
     def test_extract_start_and_duration_from_date_interval(self):
         """Extract start + P90D duration from a 90-day interval."""
         query = WOQLQuery().interval_start_duration(
-            "v:s", "v:d", dti("2025-01-01/2025-04-01"))
+            "v:s", "v:d", dti("2025-01-01/2025-04-01")
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["s"]["@value"] == "2025-01-01"
@@ -106,8 +111,8 @@ def test_extract_start_and_duration_from_date_interval(self):
     def test_extract_sub_day_duration_from_datetime_interval(self):
         """Extract PT8H30M duration from a sub-day dateTime interval."""
         query = WOQLQuery().interval_start_duration(
-            "v:s", "v:d",
-            dti("2025-01-01T09:00:00Z/2025-01-01T17:30:00Z"))
+            "v:s", "v:d", dti("2025-01-01T09:00:00Z/2025-01-01T17:30:00Z")
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["s"]["@type"] == "xsd:dateTime"
@@ -116,15 +121,17 @@ def test_extract_sub_day_duration_from_datetime_interval(self):
     def test_construct_interval_from_start_and_duration(self):
         """Construct [Jan 1, Apr 1) from start date + P90D."""
         query = WOQLQuery().interval_start_duration(
-            dat("2025-01-01"), dur("P90D"), "v:iv")
+            dat("2025-01-01"), dur("P90D"), "v:iv"
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["iv"]["@value"] == "2025-01-01/2025-04-01"
 
     def test_construct_full_year_interval(self):
         """Construct a 365-day interval from start + P365D."""
         query = WOQLQuery().interval_start_duration(
-            dat("2025-01-01"), dur("P365D"), "v:iv")
+            dat("2025-01-01"), dur("P365D"), "v:iv"
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["iv"]["@value"] == "2025-01-01/2026-01-01"
@@ -147,7 +154,8 @@ def setup_teardown(self, docker_url):
     def test_extract_duration_and_end_from_interval(self):
         """Extract P90D + end date from a 90-day interval."""
         query = WOQLQuery().interval_duration_end(
-            "v:d", "v:e", dti("2025-01-01/2025-04-01"))
+            "v:d", "v:e", dti("2025-01-01/2025-04-01")
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["e"]["@value"] == "2025-04-01"
@@ -156,7 +164,8 @@ def test_extract_duration_and_end_from_interval(self):
     def test_construct_interval_from_duration_and_end(self):
         """Construct [Jan 1, Apr 1) from P90D + end date."""
         query = WOQLQuery().interval_duration_end(
-            dur("P90D"), dat("2025-04-01"), "v:iv")
+            dur("P90D"), dat("2025-04-01"), "v:iv"
+        )
         result = self.client.query(query)
         assert len(result["bindings"]) == 1
         assert result["bindings"][0]["iv"]["@value"] == "2025-01-01/2025-04-01"

terminusdb_client/tests/test_woql_date_duration.py

@@ -68,17 +68,20 @@ def test_all_ground(self):
     def test_raises_on_none_start(self):
         """Raises ValueError when start is None."""
         import pytest
+
         with pytest.raises(ValueError, match="DateDuration takes three parameters"):
             WOQLQuery().date_duration(None, "v:e", "v:d")
 
     def test_raises_on_none_end(self):
         """Raises ValueError when end is None."""
         import pytest
+
         with pytest.raises(ValueError, match="DateDuration takes three parameters"):
             WOQLQuery().date_duration("v:s", None, "v:d")
 
     def test_raises_on_none_duration(self):
         """Raises ValueError when duration is None."""
         import pytest
+
         with pytest.raises(ValueError, match="DateDuration takes three parameters"):
             WOQLQuery().date_duration("v:s", "v:e", None)

terminusdb_client/tests/test_woql_interval_relation_typed.py

@@ -43,17 +43,26 @@ def test_all_ground(self):
     def test_raises_on_none_relation(self):
         """Raises ValueError when relation is None."""
         import pytest
-        with pytest.raises(ValueError, match="IntervalRelationTyped takes three parameters"):
+
+        with pytest.raises(
+            ValueError, match="IntervalRelationTyped takes three parameters"
+        ):
             WOQLQuery().interval_relation_typed(None, "v:x", "v:y")
 
     def test_raises_on_none_x(self):
         """Raises ValueError when x is None."""
         import pytest
-        with pytest.raises(ValueError, match="IntervalRelationTyped takes three parameters"):
+
+        with pytest.raises(
+            ValueError, match="IntervalRelationTyped takes three parameters"
+        ):
             WOQLQuery().interval_relation_typed("v:rel", None, "v:y")
 
     def test_raises_on_none_y(self):
         """Raises ValueError when y is None."""
         import pytest
-        with pytest.raises(ValueError, match="IntervalRelationTyped takes three parameters"):
+
+        with pytest.raises(
+            ValueError, match="IntervalRelationTyped takes three parameters"
+        ):
             WOQLQuery().interval_relation_typed("v:rel", "v:x", None)

terminusdb_client/woqlquery/woql_query.py

@@ -2425,8 +2425,13 @@ def interval_relation(self, relation, x_start, x_end, y_start, y_end):
         WOQLQuery object
             query object that can be chained and/or execute
         """
-        if (relation is None or x_start is None or x_end is None
-                or y_start is None or y_end is None):
+        if (
+            relation is None
+            or x_start is None
+            or x_end is None
+            or y_start is None
+            or y_end is None
+        ):
             raise ValueError("IntervalRelation takes five parameters")
         if self._cursor.get("@type"):
             self._wrap_cursor_with_and()