django-gisserver 1.2.7__py3-none-any.whl → 1.4.0__py3-none-any.whl

gisserver/output/results.py

@@ -3,18 +3,19 @@
 The "SimpleFeatureCollection" and "FeatureCollection" and their
 properties match the WFS 2.0 spec closely.
 """
+
 from __future__ import annotations
 
 import math
 import operator
-from functools import reduce
-from typing import Iterable
+from collections.abc import Iterable
+from datetime import timezone
+from functools import cached_property, reduce
 
-import django
 from django.db import models
-from django.utils.functional import cached_property
-from django.utils.timezone import now, utc
+from django.utils.timezone import now
 
+from gisserver import conf
 from gisserver.features import FeatureType
 from gisserver.geometries import BoundingBox
 
@@ -41,6 +42,7 @@ class SimpleFeatureCollection:
         self.stop = stop
         self._result_cache = None
         self._result_iterator = None
+        self._has_more = None
 
     def __iter__(self) -> Iterable[models.Model]:
         """Iterate through all results.
@@ -78,8 +80,14 @@ class SimpleFeatureCollection:
             # resulttype=hits
             return iter([])
         else:
-            model_iter = self._paginated_queryset().iterator()
-            self._result_iterator = CountingIterator(model_iter)
+            if self._use_sentinel_record:
+                model_iter = self._paginated_queryset(add_sentinel=True).iterator()
+                self._result_iterator = CountingIterator(
+                    model_iter, max_results=(self.stop - self.start)
+                )
+            else:
+                model_iter = self._paginated_queryset().iterator()
+                self._result_iterator = CountingIterator(model_iter)
             return iter(self._result_iterator)
 
     def _chunked_iterator(self):
@@ -88,7 +96,7 @@ class SimpleFeatureCollection:
         self._result_iterator = ChunkedQuerySetIterator(self._paginated_queryset())
         return iter(self._result_iterator)
 
-    def _paginated_queryset(self) -> models.QuerySet:
+    def _paginated_queryset(self, add_sentinel=True) -> models.QuerySet:
         """Apply the pagination to the queryset."""
         if self.stop == math.inf:
             # Infinite page requested
@@ -97,7 +105,7 @@ class SimpleFeatureCollection:
             else:
                 return self.queryset
         else:
-            return self.queryset[self.start : self.stop]
+            return self.queryset[self.start : self.stop + (1 if add_sentinel else 0)]
 
     def first(self):
         try:
@@ -121,15 +129,37 @@ class SimpleFeatureCollection:
             # This still allows prefetch_related() to work,
             # since QuerySet.iterator() is avoided.
             if self.stop == math.inf:
-                # Infinite page requested
-                if self.start:
-                    qs = self.queryset[self.start :]
-                else:
-                    qs = self.queryset.all()
+                # Infinite page requested, see if start is still requested
+                qs = self.queryset[self.start :] if self.start else self.queryset.all()
+                self._result_cache = list(qs)
+            elif self._use_sentinel_record:
+                # No counting, but instead fetch an extra item as sentinel to see if there are more results.
+                qs = self.queryset[self.start : self.stop + 1]
+                page_results = list(qs)
+
+                # The stop + 1 sentinel allows checking if there is a next page.
+                # This means no COUNT() is needed to detect that.
+                page_size = self.stop - self.start
+                self._has_more = len(page_results) > page_size
+                if self._has_more:
+                    # remove extra element
+                    page_results.pop()
+
+                self._result_cache = page_results
             else:
+                # Fetch exactly the page size, no more is needed.
+                # Will use a COUNT on the total table, so it can be used to see if there are more pages.
                 qs = self.queryset[self.start : self.stop]
+                self._result_cache = list(qs)
 
-            self._result_cache = list(qs)
+    @cached_property
+    def _use_sentinel_record(self) -> bool:
+        """Tell whether a sentinel record should be included in the result set.
+        This is used to determine whether there are more results, without having to perform a COUNT query
+        """
+        return conf.GISSERVER_COUNT_NUMBER_MATCHED == 0 or (
+            conf.GISSERVER_COUNT_NUMBER_MATCHED == 2 and self.start
+        )
 
     @cached_property
     def number_returned(self) -> int:
@@ -149,8 +179,7 @@ class SimpleFeatureCollection:
     @cached_property
     def number_matched(self) -> int:
         """Return the total number of matches across all pages."""
-        page_size = self.stop - self.start
-        if page_size and self.number_returned < page_size:
+        if self._is_surely_last_page:
             # For resulttype=results, an expensive COUNT query can be avoided
             # when this is the first and only page or the last page.
             return self.start + self.number_returned
@@ -165,13 +194,46 @@ class SimpleFeatureCollection:
         }
         if clean_annotations != qs.query.annotations:
             qs = self.queryset.all()  # make a clone to allow editing
-            if django.VERSION >= (3, 0):
-                qs.query.annotations = clean_annotations
-            else:
-                qs.query._annotations = clean_annotations
+            qs.query.annotations = clean_annotations
 
         return qs.count()
 
+    @property
+    def _is_surely_last_page(self):
+        """Return true when it's totally clear this is the last page."""
+        # Optimization to avoid making COUNT() queries when we can already know the answer.
+        if self.stop == math.inf:
+            return True  # Infinite page requested
+        elif self._use_sentinel_record:
+            if self._has_more is not None:
+                # did page+1 record check here, answer is known.
+                return not self._has_more
+            elif (
+                isinstance(self._result_iterator, CountingIterator)
+                and self._result_iterator.has_more is not None
+            ):
+                # did page+1 record check via the CountingIterator.
+                return not self._result_iterator.has_more
+
+        # Here different things will happen.
+        # For GeoJSON output, the iterator was read first, and `number_returned` is already filled in.
+        # For GML output, the pagination details are requested first, and will fetch all data.
+        # Hence, reading `number_returned` here can be quite an intensive operation.
+        page_size = self.stop - self.start  # is 0 for resulttype=hits
+        return page_size and (self.number_returned < page_size or self._has_more is False)
+
+    @property
+    def has_next(self):
+        if self.stop == math.inf:
+            return False
+        elif self._has_more is not None:
+            return self._has_more  # did page+1 record check, answer is known.
+        elif self._is_surely_last_page:
+            return False  # Less results then expected, answer is known.
+
+        # This will perform an slow COUNT() query...
+        return self.stop < self.number_matched
+
     def get_bounding_box(self) -> BoundingBox:
         """Determine bounding box of all items."""
         self.fetch_results()  # Avoid querying results twice
@@ -218,7 +280,7 @@ class FeatureCollection:
         self.next = next
         self.previous = previous
         self.date = now()
-        self.timestamp = self.date.astimezone(utc).isoformat()
+        self.timestamp = self.date.astimezone(timezone.utc).isoformat()
 
     def get_bounding_box(self) -> BoundingBox:
         """Determine bounding box of all items."""
@@ -239,10 +301,33 @@ class FeatureCollection:
             # By making the number_matched lazy, the calling method has a chance to
             # decorate the results with extra annotations before they are evaluated.
             # This is needed since SimpleCollection.number_matched already evaluates the queryset.
+            if conf.GISSERVER_COUNT_NUMBER_MATCHED == 0 or (
+                conf.GISSERVER_COUNT_NUMBER_MATCHED == 2 and self.results[0].start > 0
+            ):
+                # Report "unknown" for either all pages, or the second page.
+                # Most clients don't need this metadata and thus we avoid a COUNT query.
+                return None
+
             return sum(c.number_matched for c in self.results)
         else:
             # Evaluate any lazy attributes
             return int(self._number_matched)
 
+    @property
+    def has_next(self) -> bool:
+        """Efficient way to see if a next link needs to be written.
+
+        This method will show up in profiling through
+        as it will be the first moment where queries are executed.
+        """
+        if all(c._is_surely_last_page for c in self.results):
+            return False
+
+        for c in self.results:  # noqa: SIM110
+            # This may perform an COUNT query or read the results and detect the sentinel object:
+            if c.has_next:
+                return True
+        return False
+
     def __iter__(self):
         return iter(self.results)

gisserver/output/utils.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 from collections import defaultdict
+from collections.abc import Iterable
 from itertools import islice
-from typing import Iterable, TypeVar
+from typing import TypeVar
 
 from django.db import models
 from lru import LRU
@@ -15,10 +16,12 @@ DEFAULT_SQL_CHUNK_SIZE = 2000  # allow unit tests to alter this.
 class CountingIterator(Iterable[M]):
     """A simple iterator that counts how many results are given."""
 
-    def __init__(self, iterator: Iterable[M]):
+    def __init__(self, iterator: Iterable[M], max_results=0):
         self._iterator = iterator
         self._number_returned = 0
         self._in_iterator = False
+        self._max_results = max_results
+        self._has_more = None
 
     def __iter__(self):
         # Count the number of returned items while reading them.
@@ -27,9 +30,14 @@ class CountingIterator(Iterable[M]):
         try:
             self._number_returned = 0
             for instance in self._iterator:
+                if self._max_results and self._number_returned == self._max_results:
+                    self._has_more = True
+                    break
                 self._number_returned += 1
                 yield instance
         finally:
+            if self._max_results and self._has_more is None:
+                self._has_more = False  # ignored the sentinel item
             self._in_iterator = False
 
     @property
@@ -39,6 +47,10 @@ class CountingIterator(Iterable[M]):
             raise RuntimeError("Can't read number of returned results during iteration")
         return self._number_returned
 
+    @property
+    def has_more(self) -> bool | None:
+        return self._has_more
+
 
 class ChunkedQuerySetIterator(Iterable[M]):
     """An optimal strategy to perform ``prefetch_related()`` on large datasets.
@@ -113,9 +125,7 @@ class ChunkedQuerySetIterator(Iterable[M]):
 
         # Reuse the Django machinery for retrieving missing sub objects.
         # and analyse the ForeignKey caches to allow faster prefetches next time
-        models.prefetch_related_objects(
-            instances, *self.queryset._prefetch_related_lookups
-        )
+        models.prefetch_related_objects(instances, *self.queryset._prefetch_related_lookups)
         self._persist_prefetch_cache(instances)
 
     def _persist_prefetch_cache(self, instances):

gisserver/output/xmlschema.py

@@ -1,14 +1,15 @@
 from __future__ import annotations
 
 from collections import deque
-from typing import Iterable, cast
+from collections.abc import Iterable
+from io import StringIO
+from typing import cast
 
 from gisserver.features import FeatureType
 from gisserver.operations.base import WFSMethod
 from gisserver.types import XsdComplexType
 
 from .base import OutputRenderer
-from .buffer import StringBuffer
 
 
 class XMLSchemaRenderer(OutputRenderer):
@@ -30,12 +31,10 @@ class XMLSchemaRenderer(OutputRenderer):
         # the prefixes to be different.
         xmlns_features = "\n   ".join(
             f'xmlns:{p}="{self.app_xml_namespace}"'
-            for p in sorted(
-                {feature_type.xml_prefix for feature_type in self.feature_types}
-            )
+            for p in sorted({feature_type.xml_prefix for feature_type in self.feature_types})
         )
 
-        output = StringBuffer()
+        output = StringIO()
         output.write(
             f"""<?xml version='1.0' encoding="UTF-8" ?>
 <schema
@@ -63,7 +62,7 @@ class XMLSchemaRenderer(OutputRenderer):
         )
 
     def render_feature_type(self, feature_type: FeatureType):
-        output = StringBuffer()
+        output = StringIO()
         xsd_type: XsdComplexType = feature_type.xsd_type
 
         # This declares the that a top-level <app:featureName> is a class of a type.
@@ -83,7 +82,7 @@ class XMLSchemaRenderer(OutputRenderer):
 
     def render_complex_type(self, complex_type: XsdComplexType):
         """Write the definition of a single class."""
-        output = StringBuffer()
+        output = StringIO()
         output.write(
             f'  <complexType name="{complex_type.name}">\n'
             "    <complexContent>\n"

gisserver/parsers/base.py

@@ -23,9 +23,7 @@ class TagNameEnum(Enum):
 
     @classmethod
     def _missing_(cls, value):
-        raise NotImplementedError(
-            f"<{value}> is not registered as valid {cls.__name__}"
-        )
+        raise NotImplementedError(f"<{value}> is not registered as valid {cls.__name__}")
 
     def __repr__(self):
         # Make repr(filter) easier to copy-paste
@@ -108,7 +106,7 @@ class TagRegistry:
 
         def _dec(sub_class: type[BaseNode]):
             # Looping over _member_names_ will skip aliased items (like BBOX/Within)
-            for member_name in names.__members__.keys():
+            for member_name in names.__members__:
                 self.register(name=member_name, namespace=namespace)(sub_class)
             return sub_class
 

gisserver/parsers/fes20/expressions.py

@@ -1,12 +1,14 @@
 """These classes map to the FES 2.0 specification for expressions.
 The class names are identical to those in the FES spec.
 """
+
 from __future__ import annotations
 
 import operator
 from dataclasses import dataclass
 from datetime import date, datetime
 from decimal import Decimal as D
+from functools import cached_property
 from typing import Union
 from xml.etree.ElementTree import Element
 
@@ -14,7 +16,6 @@ from django.contrib.gis.geos import GEOSGeometry
 from django.db import models
 from django.db.models import Func, Q, Value
 from django.db.models.expressions import Combinable
-from django.utils.functional import cached_property
 
 from gisserver.exceptions import ExternalParsingError
 from gisserver.parsers.base import BaseNode, TagNameEnum, tag_registry
@@ -31,12 +32,8 @@ from gisserver.parsers.values import auto_cast
 from gisserver.types import FES20, ORMPath, XsdTypes, split_xml_name
 
 NoneType = type(None)
-RhsTypes = Union[
-    Combinable, Func, Q, GEOSGeometry, bool, int, str, date, datetime, tuple
-]
-ParsedValue = Union[
-    int, str, date, D, datetime, GM_Object, GM_Envelope, TM_Object, NoneType
-]
+RhsTypes = Union[Combinable, Func, Q, GEOSGeometry, bool, int, str, date, datetime, tuple]
+ParsedValue = Union[int, str, date, D, datetime, GM_Object, GM_Envelope, TM_Object, NoneType]
 
 OUTPUT_FIELDS = {
     bool: models.BooleanField(),
@@ -148,9 +145,7 @@ class Literal(Expression):
         By aliasing the value using an annotation,
         it can be queried like a regular field name.
         """
-        return compiler.add_annotation(
-            Value(self.value, output_field=self.get_output_field())
-        )
+        return compiler.add_annotation(Value(self.value, output_field=self.get_output_field()))
 
     def get_output_field(self):
         # When the value is used a left-hand-side, Django needs to know the output type.
@@ -169,9 +164,7 @@ class Literal(Expression):
 
 @dataclass(repr=False)
 @tag_registry.register("ValueReference")
-@tag_registry.register(
-    "PropertyName", hidden=True
-)  # FES 1.0 name that old clients still use.
+@tag_registry.register("PropertyName", hidden=True)  # FES 1.0 name that old clients still use.
 class ValueReference(Expression):
     """The <fes:ValueReference> element that holds an XPath string.
     In the fes XSD, this is declared as a subclass of xsd:string.

gisserver/parsers/fes20/filters.py

@@ -42,11 +42,12 @@ class Filter:
         if isinstance(text, str):
             end_first = text.index(">")
             first_tag = text[:end_first].lstrip()
-            if "xmlns" not in first_tag:
-                # Allow KVP requests without a namespace
-                # Both geoserver and mapserver support this.
-                if first_tag == "<Filter" or first_tag.startswith("<Filter "):
-                    text = f'{first_tag} xmlns="{FES20}" xmlns:gml="{GML32}"{text[end_first:]}'
+            # Allow KVP requests without a namespace
+            # Both geoserver and mapserver support this.
+            if "xmlns" not in first_tag and (
+                first_tag == "<Filter" or first_tag.startswith("<Filter ")
+            ):
+                text = f'{first_tag} xmlns="{FES20}" xmlns:gml="{GML32}"{text[end_first:]}'
 
         try:
             root_element = fromstring(text)

gisserver/parsers/fes20/functions.py

@@ -1,8 +1,10 @@
 """Functions to be callable from fes."""
+
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Callable, Union
+from typing import Union
 
 from django.contrib.gis.db.models import functions as gis
 from django.db import models
@@ -40,9 +42,7 @@ class FesFunction:
         """Build the query expression for the function."""
         if len(expressions) != len(self.arguments):
             # Avoid passing extra parameters to the function if those are not defined.
-            raise TypeError(
-                f'Invalid number of arguments for <fes:Function name="{self.name}">'
-            )
+            raise TypeError(f'Invalid number of arguments for <fes:Function name="{self.name}">')
 
         # Keyword arguments are avoided, since some Django SQL functions had
         # SQL-injection issues with those arguments. Only passing expressions for now.

gisserver/parsers/fes20/identifiers.py

@@ -1,6 +1,7 @@
 """These classes map to the FES 2.0 specification for identifiers.
 The class names are identical to those in the FES spec.
 """
+
 from __future__ import annotations
 
 from dataclasses import dataclass

gisserver/parsers/fes20/operators.py

@@ -1,13 +1,14 @@
 """These classes map to the FES 2.0 specification for operators.
 The class names and attributes are identical to those in the FES spec.
 """
+
 from __future__ import annotations
 
 import operator
 from dataclasses import dataclass, field
 from decimal import Decimal
 from enum import Enum
-from functools import reduce
+from functools import cached_property, reduce
 from itertools import groupby
 from typing import Any, Union
 from xml.etree.ElementTree import Element, QName
@@ -15,7 +16,6 @@ from xml.etree.ElementTree import Element, QName
 from django.conf import settings
 from django.contrib.gis import measure
 from django.db.models import Q
-from django.utils.functional import cached_property
 
 from gisserver.exceptions import ExternalParsingError, OperationProcessingFailed
 from gisserver.parsers import gml
@@ -39,8 +39,7 @@ except ImportError:
 else:
 
     class HasBuildRhs(Protocol):
-        def build_rhs(self, compiler) -> RhsTypes:
-            ...
+        def build_rhs(self, compiler) -> RhsTypes: ...
 
 
 if "django.contrib.postgres" in settings.INSTALLED_APPS:
@@ -169,9 +168,7 @@ class Operator(BaseNode):
     xml_ns = FES20
 
     def build_query(self, compiler: CompiledQuery) -> Q | None:
-        raise NotImplementedError(
-            f"Using {self.__class__.__name__} is not supported yet."
-        )
+        raise NotImplementedError(f"Using {self.__class__.__name__} is not supported yet.")
 
 
 @dataclass
@@ -183,9 +180,7 @@ class IdOperator(Operator):
     @property
     def type_names(self) -> list[str]:
         """Provide a list of all type names accessed by this operator"""
-        return [
-            type_name for type_name in self.grouped_ids.keys() if type_name is not None
-        ]
+        return [type_name for type_name in self.grouped_ids if type_name is not None]
 
     @cached_property
     def grouped_ids(self) -> dict[str, list[Id]]:
@@ -209,9 +204,7 @@ class IdOperator(Operator):
             return
 
         for type_name, items in self.grouped_ids.items():
-            ids_subset = reduce(
-                operator.or_, [id.build_query(compiler=None) for id in items]
-            )
+            ids_subset = reduce(operator.or_, [id.build_query(compiler=None) for id in items])
             compiler.add_lookups(ids_subset, type_name=type_name)
 
 
@@ -349,14 +342,10 @@ class DistanceOperator(SpatialOperator):
         if not geometries:
             raise ExternalParsingError(f"Missing gml element in <{element.tag}>")
         elif len(geometries) > 1:
-            raise ExternalParsingError(
-                f"Multiple gml elements found in <{element.tag}>"
-            )
+            raise ExternalParsingError(f"Multiple gml elements found in <{element.tag}>")
 
         return cls(
-            valueReference=ValueReference.from_xml(
-                get_child(element, FES20, "ValueReference")
-            ),
+            valueReference=ValueReference.from_xml(get_child(element, FES20, "ValueReference")),
             operatorType=DistanceOperatorName.from_xml(element),
             geometry=gml.parse_gml_node(geometries[0]),
             distance=Measure.from_xml(get_child(element, FES20, "Distance")),
@@ -470,17 +459,13 @@ class BinaryComparisonOperator(ComparisonOperator):
                 Expression.from_child_xml(element[1]),
             ),
             matchCase=element.get("matchCase", True),
-            matchAction=MatchAction(
-                element.get("matchAction", default=MatchAction.Any)
-            ),
+            matchAction=MatchAction(element.get("matchAction", default=MatchAction.Any)),
             _source=element.tag,
         )
 
     def build_query(self, compiler: CompiledQuery) -> Q:
         lhs, rhs = self.expression
-        return self.build_compare(
-            compiler, lhs=lhs, lookup=self.operatorType.value, rhs=rhs
-        )
+        return self.build_compare(compiler, lhs=lhs, lookup=self.operatorType.value, rhs=rhs)
 
 
 @dataclass
@@ -508,13 +493,9 @@ class BetweenComparisonOperator(ComparisonOperator):
         upper = get_child(element, FES20, "UpperBoundary")
 
         if len(lower) != 1:
-            raise ExternalParsingError(
-                f"{lower.tag} should have 1 expression child node"
-            )
+            raise ExternalParsingError(f"{lower.tag} should have 1 expression child node")
         if len(upper) != 1:
-            raise ExternalParsingError(
-                f"{upper.tag} should have 1 expression child node"
-            )
+            raise ExternalParsingError(f"{upper.tag} should have 1 expression child node")
 
         return cls(
             expression=Expression.from_child_xml(element[0]),
@@ -573,9 +554,7 @@ class LikeOperator(ComparisonOperator):
 
             rhs = Literal(raw_value=value)
         else:
-            raise ExternalParsingError(
-                f"Expected a literal value for the {self.tag} operator."
-            )
+            raise ExternalParsingError(f"Expected a literal value for the {self.tag} operator.")
 
         # Use the FesLike lookup
         return self.build_compare(compiler, lhs=lhs, lookup="fes_like", rhs=rhs)
@@ -603,9 +582,7 @@ class NilOperator(ComparisonOperator):
 
     def build_query(self, compiler: CompiledQuery) -> Q:
         # Any value that evaluates to None is returned as 'xs:nil' in our output.
-        return self.build_compare(
-            compiler, lhs=self.expression, lookup="isnull", rhs=True
-        )
+        return self.build_compare(compiler, lhs=self.expression, lookup="isnull", rhs=True)
 
 
 @dataclass
@@ -621,18 +598,14 @@ class NullOperator(ComparisonOperator):
     @classmethod
     @expect_children(1, Expression)
     def from_xml(cls, element: Element):
-        return cls(
-            expression=Expression.from_child_xml(element[0]), _source=element.tag
-        )
+        return cls(expression=Expression.from_child_xml(element[0]), _source=element.tag)
 
     def build_query(self, compiler: CompiledQuery) -> Q:
         # For now, the implementation is identical to PropertyIsNil.
         # According to the WFS spec, this should only be true when the element
         # is not returned at all (minOccurs=0).
         # TODO: this happens for maxOccurs=unbounded with a null value.
-        return self.build_compare(
-            compiler, lhs=self.expression, lookup="isnull", rhs=True
-        )
+        return self.build_compare(compiler, lhs=self.expression, lookup="isnull", rhs=True)
 
 
 class LogicalOperator(NonIdOperator):

gisserver/parsers/fes20/query.py

@@ -115,9 +115,7 @@ class CompiledQuery:
         """Mark as returning no results."""
         self.is_empty = True
 
-    def filter_queryset(
-        self, queryset: QuerySet, feature_type: FeatureType
-    ) -> QuerySet:
+    def filter_queryset(self, queryset: QuerySet, feature_type: FeatureType) -> QuerySet:
         """Apply the filters and lookups to the queryset.
 
         :param queryset: The queryset to filter.

gisserver/parsers/fes20/sorting.py

@@ -20,9 +20,7 @@ class SortOrder(Enum):
         try:
             return cls[direction]
         except KeyError:
-            raise InvalidParameterValue(
-                "sortby", "Expect ASC/DESC ordering direction"
-            ) from None
+            raise InvalidParameterValue("sortby", "Expect ASC/DESC ordering direction") from None
 
 
 @dataclass

gisserver/parsers/gml/__init__.py

@@ -2,6 +2,7 @@
 
 These functions locate GML objects, and redirect to the proper parser.
 """
+
 from __future__ import annotations
 
 from xml.etree.ElementTree import Element

gisserver/parsers/gml/base.py

@@ -3,6 +3,7 @@
 See "Table D.2" in the GML 3.2.1 spec, showing how the UML names
 map to the GML implementations. These names are referenced by the FES spec.
 """
+
 from gisserver.parsers.base import BaseNode
 
 

gisserver/parsers/values.py

@@ -27,9 +27,7 @@ def auto_cast(value: str):
 def parse_iso_datetime(raw_value: str) -> datetime:
     value = parse_datetime(raw_value)
     if value is None:
-        raise ExternalParsingError(
-            "Date must be in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format."
-        )
+        raise ExternalParsingError("Date must be in YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ] format.")
     return value