lsst-daf-butler 29.2025.2600__tar.gz → 29.2025.2800__tar.gz

{lsst_daf_butler-29.2025.2600/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.2800}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.2600
+Version: 29.2025.2800
 Summary: An abstraction layer for reading and writing astronomical data to datastores.
 Author-email: Rubin Observatory Data Management <dm-admin@lists.lsst.org>
 License: BSD 3-Clause License

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/doc/lsst.daf.butler/queries.rst

@@ -327,6 +327,12 @@ where ``ra`` and ``dec`` are specified as an ICRS sky position in degrees.
 
     visit.region OVERLAPS POINT(53.6, -32.7)
 
+All types of regions supported by the language will work with ``OVERLAP`` as well.
+
+.. code-block:: sql
+
+    visit.region OVERLAPS BOX(53.6, -32.7, 1, 1)
+
 You can check overlaps with arbitrary sky regions by binding values (see
 :ref:`daf_butler_dimension_expressions_identifiers`).  Bound region values may
 be specified as the following object types:
@@ -364,16 +370,37 @@ consists of an identifier followed by zero or more comma-separated arguments
 enclosed in parentheses (e.g. ``func(1, 2, 3)``). An argument to a function
 can be any expression. Names of the functions are not case-sensitive.
 
-Presently the following functions are implemented in the query language:
+A small set of functions is implemented in the query language presently.
+
+Functions supporting operations on strings:
 
-- ``POINT(ra, dec)`` - function which declares (or returns) sky coordinates
-  similarly to ADQL syntax.
 - ``GLOB(expression, pattern)`` - performs case-sensitive match of a string
   ``expression`` against ``pattern``. Pattern can include ``*`` and ``?``
   meta-characters, matching any number of characters or a single character
   respectfully. All other characters in pattern are matched literally, and
   whole expression string has to match for ``GLOB()`` to return ``True``.
 
+Functions for defining sky coordinates or regions. All these functions accept
+either numeric literals or bind identifiers (``:name`` syntax):
+
+- ``POINT(ra, dec)`` - function which declares (or returns) sky coordinates
+  similarly to ADQL syntax, arguments are in degrees.
+- ``CIRCLE(ra, dec, radius)`` - function which returns circular sky region,
+  all arguments are in degrees.
+- ``BOX(center_ra, center_dec, width, height)`` - function which returns box
+  sky region, all arguments are in degrees.
+- ``POLYGON(ra1, dec1, ra2, dec2, ...)`` - function which returns polygonal
+  sky region, all arguments are in degrees, at least three pairs of coordinates
+  have to be provided. Note that implementation for this function is based on
+  ``lsst.sphgeom.ConvexPolygon`` class which builds a convex hull out of all
+  vertices, thus ignoring their order. This is not strictly consistent with
+  ADQL definition that relies on ordering of the vertices and allows non-convex
+  polygons.
+- ``REGION('string')`` - function returning sky region, string argument uses
+  `IVOA SIAv2 POS`_ syntax. Same caveat applies as for ``POLYGON`` function.
+
+.. _IVOA SIAv2 POS: https://ivoa.net/documents/SIA/20151223/REC-SIA-2.0-20151223.html#toc12
+
 
 .. _time-literals-syntax:
 

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/doc/lsst.daf.butler/writing-subcommands.rst

@@ -433,6 +433,8 @@ An example implementation is:
 
 Which should be sufficient for most implementations where the commands are already stored in ``__all__``.
 
+.. _Manifest:
+
 Manifest (Deprecated)
 ---------------------
 

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/_butler.py

@@ -1828,7 +1828,7 @@ class Butler(LimitedButler):  # numpydoc ignore=PR02
             provided, the default collections are used. Can be a wildcard if
             ``find_first`` is `False` (if find first is requested the order
             of collections matters and wildcards make the order indeterminate).
-             See :ref:`daf_butler_collection_expressions` for more information.
+            See :ref:`daf_butler_collection_expressions` for more information.
         find_first : `bool`, optional
             If `True` (default), for each result data ID, only yield one
             `DatasetRef` of each `DatasetType`, from the first collection in

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/datastore/_transfer.py

@@ -56,8 +56,8 @@ class FileTransferSource(Protocol):
         dataset_ids : `~collections.abc.Iterable` [ `DatasetId` ]
             List of dataset IDs for which we will retrieve file information.
 
-        Return
-        ------
+        Returns
+        -------
         transfer_map : `FileTransferMap`
             Dictionary from `DatasetId` to a list of files found for that
             dataset.  If information about any  given dataset IDs could not
@@ -78,8 +78,8 @@ class FileTransferSource(Protocol):
             Optional mapping of datastore artifact to existence. Updated by
             this method with details of all artifacts tested.
 
-        Return
-        ------
+        Returns
+        -------
         transfer_map : `FileTransferMap`
             Dictionary from `DatasetId` to a list of files found for that
             dataset.  If information about any  given dataset IDs could not

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/dimensions/_group.py

@@ -414,12 +414,37 @@ class DimensionGroup:  # numpydoc ignore=PR02
         names = set(self.names).intersection(*[other.names for other in others])
         return DimensionGroup(self.universe, names=names)
 
+    def difference(self, other: DimensionGroup) -> DimensionGroup:
+        """Construct a new group with dimensions that are in ``self`` but not
+        ``other`` OR dependencies of those in ``self`` but not in ``other``.
+
+        Parameters
+        ----------
+        other : `DimensionGroup`
+            Other group to compare with.
+
+        Returns
+        -------
+        diff : `DimensionGroup`
+            Difference of the two groups.
+
+        Notes
+        -----
+        This is not exactly equivalent to a true `set` difference, because the
+        result must be expanded to include required and implied dependencies,
+        and those may be common to ``self`` and ``other``.
+        """
+        return DimensionGroup(self.universe, names=self.names - other.names)
+
     def __or__(self, other: DimensionGroup) -> DimensionGroup:
         return self.union(other)
 
     def __and__(self, other: DimensionGroup) -> DimensionGroup:
         return self.intersection(other)
 
+    def __sub__(self, other: DimensionGroup) -> DimensionGroup:
+        return self.difference(other)
+
     @property
     def data_coordinate_keys(self) -> Set[str]:
         """A set of dimensions ordered like `DataCoordinate.mapping`.

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/dimensions/_record_set.py

@@ -809,8 +809,7 @@ class DimensionDataAttacher:
             been referenced in at least one of the constructor arguments.
         data_ids : `~collections.abc.Iterable` [ `DataCoordinate` ]
             Data IDs to attach dimension records to (not in place; data
-            coordinates are immutable).  Must have full values (i.e. implied
-            as well as required dimensions).
+            coordinates are immutable).
         query : `.queries.Query`, optional
             A butler query that can be used to look up missing dimension
             records.  Records fetched via query are cached in the `records`
@@ -822,49 +821,41 @@ class DimensionDataAttacher:
             Data IDs with dimension records attached, in the same order as the
             original iterable.
         """
-        incomplete: list[_InProgressRecordDicts] = []
         lookup_helpers = [
             _DimensionRecordLookupHelper.build(dimensions, element_name, self)
-            for element_name in dimensions.elements
+            for element_name in dimensions.lookup_order
         ]
-        result: list[DataCoordinate] = []
-        for n, data_id in enumerate(data_ids):
-            records = _InProgressRecordDicts(n)
-            for lookup_helper in lookup_helpers:
-                lookup_helper.lookup(data_id.full_values, records)
-            if records.missing:
-                incomplete.append(records)
-            else:
-                data_id = data_id.expanded(records.done)
-            result.append(data_id)
-        if query is not None:
-            for lookup_helper in lookup_helpers:
-                lookup_helper.fetch_missing(query)
-            for records in incomplete:
-                for element, required_values in records.missing.items():
-                    records.done[element] = self.records[element].find_with_required_values(required_values)
-                result[records.index] = result[records.index].expanded(records.done)
-        else:
-            # Other logic branches also raise LookupError internally (e.g. in
-            # find_with_required_values); this one has a better message (i.e.
-            # about all failures, not just the first one) just because we
-            # happen to have any information at hand, while we don't in other
-            # branches.
-            for records in incomplete:
-                raise LookupError(
-                    f"No dimension record for element(s) {list(records.missing.keys())} "
-                    f"for data ID {result[records.index]}.  "
-                    f"{len(incomplete)} data ID{' was' if len(incomplete) == 1 else 's were'} "
-                    "missing at least one record."
-                )
-        return result
+        records = [_InProgressRecordDicts(data_id) for data_id in data_ids]
+        for lookup_helper in lookup_helpers:
+            for r in records:
+                lookup_helper.lookup(r)
+            incomplete = lookup_helper.incomplete_records
+            if incomplete:
+                if query is not None:
+                    lookup_helper.fetch_missing(query)
+                    # We may still be missing records at this point, if they
+                    # were not available in the database.
+                    # This is intentional, because in existing Butler
+                    # repositories dimension records are not always fully
+                    # populated. (For example, it is common for a visit to
+                    # exist without corresponding visit_detector_region
+                    # records, since these are populated at different times
+                    # by different processes.)
+                else:
+                    raise LookupError(
+                        f"No dimension record for element '{lookup_helper.element}' "
+                        f"for data ID {incomplete[0].data_id}.  "
+                        f"{len(incomplete)} data ID{' was' if len(incomplete) == 1 else 's were'} "
+                        "missing at least one record."
+                    )
+
+        return [r.data_id.expanded(r.done) for r in records]
 
 
 @dataclasses.dataclass
 class _InProgressRecordDicts:
-    index: int  # Index of the data ID these are for in the result list.
+    data_id: DataCoordinate
     done: dict[str, DimensionRecord] = dataclasses.field(default_factory=dict)
-    missing: dict[str, tuple[DataIdValue, ...]] = dataclasses.field(default_factory=dict)
 
 
 @dataclasses.dataclass
@@ -873,7 +864,7 @@ class _DimensionRecordLookupHelper:
     # tuple in the to-be-expanded data ID's full-values tuple.
     indices: list[int]
     record_set: DimensionRecordSet
-    missing: set[tuple[DataIdValue, ...]] = dataclasses.field(default_factory=set)
+    incomplete_records: list[_InProgressRecordDicts] = dataclasses.field(default_factory=list)
 
     @property
     def element(self) -> str:
@@ -902,33 +893,62 @@ class _DimensionRecordLookupHelper:
         else:
             return _DimensionRecordLookupHelper(indices, attacher.records[element])
 
-    def lookup(self, full_data_id_values: tuple[DataIdValue, ...], records: _InProgressRecordDicts) -> None:
-        required_values = tuple([full_data_id_values[i] for i in self.indices])
+    def lookup(self, records: _InProgressRecordDicts) -> None:
+        required_values = self._get_required_values(records)
         if (result := self.record_set._by_required_values.get(required_values)) is None:
             result = self.fallback(required_values)
             if result is not None:
                 self.record_set.add(result)
                 records.done[self.element] = result
             else:
-                records.missing[self.element] = required_values
-                self.missing.add(required_values)
+                self.incomplete_records.append(records)
         else:
             records.done[self.element] = result
 
+    def _get_required_values(self, records: _InProgressRecordDicts) -> tuple[DataIdValue, ...]:
+        if records.data_id.hasFull():
+            full_values = records.data_id.full_values
+            return tuple([full_values[i] for i in self.indices])
+        else:
+            values = []
+            dimensions = self.record_set.element.minimal_group.required
+            for dimension in dimensions:
+                value = records.data_id.get(dimension)
+                if value is None:
+                    value = self._find_implied_value(dimension, records)
+                values.append(value)
+            return tuple(values)
+
+    def _find_implied_value(self, implied_dimension: str, records: _InProgressRecordDicts) -> DataIdValue:
+        for rec in records.done.values():
+            if implied_dimension in rec.definition.implied:
+                return rec.get(implied_dimension)
+
+        raise LookupError(
+            f"Implied value for dimension '{implied_dimension}' not found in records for"
+            f" {list(records.done.keys())}"
+        )
+
     def fallback(self, required_values: tuple[DataIdValue, ...]) -> DimensionRecord | None:
         return None
 
     def fetch_missing(self, query: Query) -> None:
-        if self.missing:
+        if self.incomplete_records:
+            missing_values = set(self._get_required_values(r) for r in self.incomplete_records)
             self.record_set.update(
                 query.join_data_coordinates(
                     [
-                        DataCoordinate.from_required_values(self.record_set.element.minimal_group, row)
-                        for row in self.missing
+                        DataCoordinate.from_required_values(self.record_set.element.minimal_group, values)
+                        for values in missing_values
                     ]
                 ).dimension_records(self.record_set.element.name)
             )
 
+        missing = self.incomplete_records
+        self.incomplete_records = list()
+        for record in missing:
+            self.lookup(record)
+
 
 @dataclasses.dataclass
 class _DeserializingDimensionRecordLookupHelper(_DimensionRecordLookupHelper):

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/dimensions/_records.py

@@ -34,15 +34,7 @@ from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, ClassVar, TypeAlias
 
 import pydantic
-from pydantic import (
-    BaseModel,
-    Field,
-    StrictBool,
-    StrictFloat,
-    StrictInt,
-    StrictStr,
-    create_model,
-)
+from pydantic import BaseModel, Field, StrictBool, StrictFloat, StrictInt, StrictStr, create_model
 
 import lsst.sphgeom
 from lsst.utils.classes import immutable
@@ -533,6 +525,29 @@ class DimensionRecord:
                 results["datetime_end"] = timespan.end
         return results
 
+    def get(self, name: str) -> Any:
+        """Return a single metadata value associated with this record.
+
+        Parameters
+        ----------
+        name : `str`
+            Key of the metadata value to be retrieved.
+
+        Returns
+        -------
+        value
+            The metadata value.
+
+        Raises
+        ------
+        KeyError
+            If the given name is not a valid key in this dimension record.
+        """
+        if name not in self.__slots__:
+            raise KeyError(f"'{name}' is not a valid record key for dimension '{self.definition.name}'")
+
+        return getattr(self, name)
+
     def serialize_key_value(self) -> SerializedKeyValueDimensionRecord:
         """Serialize this record to a `list` that can be sliced into a key
         (data ID values) / value (everything else) pair.

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/queries/_expression_strings.py

@@ -40,7 +40,17 @@ from .._timespan import Timespan
 from ..column_spec import ColumnType
 from ..dimensions import DimensionUniverse
 from ..registry.queries.expressions.categorize import ExpressionConstant, categorizeConstant
-from ..registry.queries.expressions.parser import Node, PointNode, RangeLiteral, TreeVisitor, parse_expression
+from ..registry.queries.expressions.parser import (
+    BoxNode,
+    CircleNode,
+    Node,
+    PointNode,
+    PolygonNode,
+    RangeLiteral,
+    RegionNode,
+    TreeVisitor,
+    parse_expression,
+)
 from ._identifiers import IdentifierContext, interpret_identifier
 from .tree import (
     BinaryExpression,
@@ -251,12 +261,67 @@ class _ConversionVisitor(TreeVisitor[_VisitorResult]):
         return expression
 
     def visitPointNode(self, ra: _VisitorResult, dec: _VisitorResult, node: PointNode) -> _VisitorResult:
-        ra_value = _get_float_literal_value(ra, node.ra)
-        dec_value = _get_float_literal_value(dec, node.dec)
+        ra_value = _get_float_literal_value(ra, node.ra, "POINT")
+        dec_value = _get_float_literal_value(dec, node.dec, "POINT")
 
         lon_lat = lsst.sphgeom.LonLat.fromDegrees(ra_value, dec_value)
         return _make_literal(lon_lat)
 
+    def visitCircleNode(
+        self, ra: _VisitorResult, dec: _VisitorResult, radius: _VisitorResult, node: CircleNode
+    ) -> _VisitorResult:
+        ra_value = _get_float_literal_value(ra, node.ra, "CIRCLE")
+        dec_value = _get_float_literal_value(dec, node.dec, "CIRCLE")
+        radius_value = _get_float_literal_value(radius, node.radius, "CIRCLE")
+
+        lon_lat = lsst.sphgeom.LonLat.fromDegrees(ra_value, dec_value)
+        open_angle = lsst.sphgeom.Angle.fromDegrees(radius_value * 2)
+        vec = lsst.sphgeom.UnitVector3d(lon_lat)
+        circle = lsst.sphgeom.Circle(vec, open_angle)
+        return _make_literal(circle)
+
+    def visitBoxNode(
+        self,
+        ra: _VisitorResult,
+        dec: _VisitorResult,
+        width: _VisitorResult,
+        height: _VisitorResult,
+        node: BoxNode,
+    ) -> _VisitorResult:
+        ra_value = _get_float_literal_value(ra, node.ra, "BOX")
+        dec_value = _get_float_literal_value(dec, node.dec, "BOX")
+        width_value = _get_float_literal_value(width, node.width, "BOX")
+        height_value = _get_float_literal_value(height, node.height, "BOX")
+
+        lon_lat = lsst.sphgeom.LonLat.fromDegrees(ra_value, dec_value)
+        half_width = lsst.sphgeom.Angle.fromDegrees(width_value / 2)
+        half_height = lsst.sphgeom.Angle.fromDegrees(height_value / 2)
+        box = lsst.sphgeom.Box(lon_lat, half_width, half_height)
+        return _make_literal(box)
+
+    def visitPolygonNode(
+        self, vertices: list[tuple[_VisitorResult, _VisitorResult]], node: PolygonNode
+    ) -> _VisitorResult:
+        sphgeom_vertices = []
+        for ra, dec in vertices:
+            ra_value = _get_float_literal_value(ra, node, "POLYGON")
+            dec_value = _get_float_literal_value(dec, node, "POLYGON")
+            lon_lat = lsst.sphgeom.LonLat.fromDegrees(ra_value, dec_value)
+            sphgeom_vertices.append(lsst.sphgeom.UnitVector3d(lon_lat))
+
+        polygon = lsst.sphgeom.ConvexPolygon(sphgeom_vertices)
+        return _make_literal(polygon)
+
+    def visitRegionNode(self, pos: _VisitorResult, node: RegionNode) -> _VisitorResult:
+        if isinstance(pos, _ColExpr):
+            expr = pos.value
+            if expr.expression_type == "string":
+                pos_str = expr.value
+                region = lsst.sphgeom.Region.from_ivoa_pos(pos_str)
+                return _make_literal(region)
+
+        raise InvalidQueryError(f"Expression '{node.pos}' in REGION() is not a literal string.")
+
     def visitRangeLiteral(
         self, start: int, stop: int, stride: int | None, node: RangeLiteral
     ) -> _VisitorResult:
@@ -379,7 +444,7 @@ def _get_boolean_column_reference(predicate: Predicate) -> ColumnReference | Non
     return None
 
 
-def _get_float_literal_value(value: _VisitorResult, node: Node) -> float:
+def _get_float_literal_value(value: _VisitorResult, node: Node, name: str) -> float:
     """If the given ``value`` is a literal `float` or `int` expression, return
     it as a float.  Otherwise raise an `InvalidQueryError` identifying a
     problem with the given ``node``.
@@ -391,6 +456,6 @@ def _get_float_literal_value(value: _VisitorResult, node: Node) -> float:
         elif expr.expression_type == "int":
             return float(expr.value)
         elif expr.expression_type == "unary" and expr.operator == "-":
-            return -1 * _get_float_literal_value(_ColExpr(expr.operand), node)
+            return -1 * _get_float_literal_value(_ColExpr(expr.operand), node, name)
 
-    raise InvalidQueryError(f"Expression '{node}' in POINT() is not a literal number.")
+    raise InvalidQueryError(f"Expression '{node}' in {name}() is not a literal number.")

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/registry/queries/expressions/_predicate.py

@@ -457,6 +457,40 @@ class PredicateConversionVisitor(TreeVisitor[VisitorResult]):
         # do not support actual use just yet.
         raise NotImplementedError("POINT() function is not supported yet")
 
+    def visitCircleNode(
+        self, ra: VisitorResult, dec: VisitorResult, radius: VisitorResult, node: Node
+    ) -> VisitorResult:
+        # Docstring inherited.
+
+        # this is a placeholder for future extension, we enabled syntax but
+        # do not support actual use just yet.
+        raise NotImplementedError("CIRCLE() function is not supported yet")
+
+    def visitBoxNode(
+        self, ra: VisitorResult, dec: VisitorResult, width: VisitorResult, height: VisitorResult, node: Node
+    ) -> VisitorResult:
+        # Docstring inherited.
+
+        # this is a placeholder for future extension, we enabled syntax but
+        # do not support actual use just yet.
+        raise NotImplementedError("BOX() function is not supported yet")
+
+    def visitPolygonNode(
+        self, vertices: list[tuple[VisitorResult, VisitorResult]], node: Node
+    ) -> VisitorResult:
+        # Docstring inherited.
+
+        # this is a placeholder for future extension, we enabled syntax but
+        # do not support actual use just yet.
+        raise NotImplementedError("POLYGON() function is not supported yet")
+
+    def visitRegionNode(self, pos: VisitorResult, node: Node) -> VisitorResult:
+        # Docstring inherited.
+
+        # this is a placeholder for future extension, we enabled syntax but
+        # do not support actual use just yet.
+        raise NotImplementedError("REGION() function is not supported yet")
+
     def visitRangeLiteral(self, start: int, stop: int, stride: int | None, node: Node) -> VisitorResult:
         # Docstring inherited.
         return ColumnContainer.range_literal(range(start, stop + 1, stride or 1))

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/registry/queries/expressions/check.py

@@ -285,6 +285,26 @@ class InspectionVisitor(TreeVisitor[TreeSummary]):
         # Docstring inherited from base class
         return TreeSummary()
 
+    def visitCircleNode(
+        self, ra: TreeSummary, dec: TreeSummary, radius: TreeSummary, node: Node
+    ) -> TreeSummary:
+        # Docstring inherited from base class
+        return TreeSummary()
+
+    def visitPolygonNode(self, vertices: list[tuple[TreeSummary, TreeSummary]], node: Node) -> TreeSummary:
+        # Docstring inherited from base class
+        return TreeSummary()
+
+    def visitRegionNode(self, pos: TreeSummary, node: Node) -> TreeSummary:
+        # Docstring inherited from base class
+        return TreeSummary()
+
+    def visitBoxNode(
+        self, ra: TreeSummary, dec: TreeSummary, width: TreeSummary, height: TreeSummary, node: Node
+    ) -> TreeSummary:
+        # Docstring inherited from base class
+        return TreeSummary()
+
     def visitGlobNode(self, expression: TreeSummary, pattern: TreeSummary, node: Node) -> TreeSummary:
         # Docstring inherited from base class
         # pattern is a literal, but expression should refer to a dimension.

{lsst_daf_butler-29.2025.2600 → lsst_daf_butler-29.2025.2800}/python/lsst/daf/butler/registry/queries/expressions/normalForm.py

@@ -1098,6 +1098,33 @@ class TransformationVisitor(TreeVisitor[TransformationWrapper]):
         # Docstring inherited from TreeVisitor.visitPointNode
         raise NotImplementedError("POINT() function is not supported yet")
 
+    def visitCircleNode(
+        self, ra: TransformationWrapper, dec: TransformationWrapper, radius: TransformationWrapper, node: Node
+    ) -> TransformationWrapper:
+        # Docstring inherited from TreeVisitor.visitCircleNode
+        raise NotImplementedError("CIRCLE() function is not supported yet")
+
+    def visitBoxNode(
+        self,
+        ra: TransformationWrapper,
+        dec: TransformationWrapper,
+        width: TransformationWrapper,
+        height: TransformationWrapper,
+        node: Node,
+    ) -> TransformationWrapper:
+        # Docstring inherited from TreeVisitor.visitBoxNode
+        raise NotImplementedError("BOX() function is not supported yet")
+
+    def visitPolygonNode(
+        self, vertices: list[tuple[TransformationWrapper, TransformationWrapper]], node: Node
+    ) -> TransformationWrapper:
+        # Docstring inherited from TreeVisitor.visitPolygonNode
+        raise NotImplementedError("POLYGON() function is not supported yet")
+
+    def visitRegionNode(self, pos: TransformationWrapper, node: Node) -> TransformationWrapper:
+        # Docstring inherited from TreeVisitor.visitRegionNode
+        raise NotImplementedError("REGION() function is not supported yet")
+
     def visitGlobNode(
         self, expression: TransformationWrapper, pattern: TransformationWrapper, node: Node
     ) -> TransformationWrapper: