lsst-daf-butler 29.2025.2700__tar.gz → 29.2025.2900__tar.gz

{lsst_daf_butler-29.2025.2700/python/lsst_daf_butler.egg-info → lsst_daf_butler-29.2025.2900}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lsst-daf-butler
-Version: 29.2025.2700
+Version: 29.2025.2900
 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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/python/lsst/daf/butler/registry/collections/_base.py

@@ -427,11 +427,13 @@ class DefaultCollectionManager(CollectionManager[K]):
         cache: CollectionRecordCache | None = None
         result: list[CollectionRecord[K]] = []
         done_keys: set[K] = set()
+        explicit_names = list(wildcard.strings)
         if wildcard.patterns:
-            if wildcard.strings:
+            if explicit_names or flatten_chains:
                 # To be efficient in case both patterns and strings are
                 # specified we want to have caching enabled for at least the
-                # duration of this call.
+                # duration of this call. Chains flattening can also produce
+                # additional names to look for.
                 cache = self._caching_context.collection_records or CollectionRecordCache()
             all_records = self._fetch_all(cache)
             for record in filter_types(all_records):
@@ -439,11 +441,17 @@ class DefaultCollectionManager(CollectionManager[K]):
                     if any(p.fullmatch(record.name) for p in wildcard.patterns):
                         result.append(record)
                         done_keys.add(record.key)
-
-        if wildcard.strings:
+            if flatten_chains:
+                # If flattening include children names of all matching chains.
+                for record in all_records:
+                    if isinstance(record, ChainedCollectionRecord):
+                        if any(p.fullmatch(record.name) for p in wildcard.patterns):
+                            explicit_names.extend(record.children)
+
+        if explicit_names:
             # _find_many() returns correctly ordered records, but there may be
             # duplicates.
-            for record in filter_types(self._find_many(wildcard.strings, flatten_chains, cache)):
+            for record in filter_types(self._find_many(explicit_names, flatten_chains, cache)):
                 if record.key not in done_keys:
                     result.append(record)
                     done_keys.add(record.key)

{lsst_daf_butler-29.2025.2700 → lsst_daf_butler-29.2025.2900}/python/lsst/daf/butler/registry/interfaces/_database.py

@@ -561,8 +561,6 @@ class Database(ABC):
             try:
                 yield table
             finally:
-                with self._transaction():
-                    table.drop(connection)
                 self._temp_tables.remove(table.key)
                 self._metadata.remove_table(table.name)
 

{lsst_daf_butler-29.2025.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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.2700 → lsst_daf_butler-29.2025.2900}/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:

{lsst_daf_butler-29.2025.2700 → lsst_daf_butler-29.2025.2900}/python/lsst/daf/butler/registry/queries/expressions/parser/exprTree.py

@@ -39,6 +39,8 @@ from __future__ import annotations
 
 __all__ = [
     "BinaryOp",
+    "BoxNode",
+    "CircleNode",
     "FunctionCall",
     "Identifier",
     "IsIn",
@@ -46,7 +48,9 @@ __all__ = [
     "NumericLiteral",
     "Parens",
     "PointNode",
+    "PolygonNode",
     "RangeLiteral",
+    "RegionNode",
     "StringLiteral",
     "TimeLiteral",
     "TupleNode",
@@ -218,7 +222,7 @@ class TimeLiteral(LiteralNode):
         return visitor.visitTimeLiteral(self.value, self)
 
     def __str__(self) -> str:
-        return "'{value}'".format(**vars(self))
+        return "T'{value}'".format(**vars(self))
 
 
 class NumericLiteral(LiteralNode):
@@ -263,7 +267,7 @@ class UuidLiteral(LiteralNode):
         return visitor.visitUuidLiteral(self.value, self)
 
     def __str__(self) -> str:
-        return str(self.value)
+        return f"UUID('{self.value}')"
 
 
 class Identifier(Node):
@@ -310,7 +314,7 @@ class BindName(Node):
         return visitor.visitBind(self.name, self)
 
     def __str__(self) -> str:
-        return "{name}".format(**vars(self))
+        return ":{name}".format(**vars(self))
 
 
 class RangeLiteral(LiteralNode):
@@ -488,6 +492,115 @@ class PointNode(Node):
         return f"POINT({self.ra}, {self.dec})"
 
 
+class CircleNode(Node):
+    """Node representing a circle, (ra, dec, radius) pair.
+
+    Parameters
+    ----------
+    ra : `Node`
+        Node representing circle center ra value.
+    dec : `Node`
+        Node representing circle center dec value.
+    radius : `Node`
+        Node representing circle radius value.
+    """
+
+    def __init__(self, ra: Node, dec: Node, radius: Node):
+        super().__init__((ra, dec, radius))
+        self.ra = ra
+        self.dec = dec
+        self.radius = radius
+
+    def visit(self, visitor: TreeVisitor) -> Any:
+        # Docstring inherited from Node.visit
+        ra = self.ra.visit(visitor)
+        dec = self.dec.visit(visitor)
+        radius = self.radius.visit(visitor)
+        return visitor.visitCircleNode(ra, dec, radius, self)
+
+    def __str__(self) -> str:
+        return f"CIRCLE({self.ra}, {self.dec}, {self.radius})"
+
+
+class BoxNode(Node):
+    """Node representing box region in ADQL notation (ra, dec, width, height).
+
+    Parameters
+    ----------
+    ra : `Node`
+        Node representing box center ra value.
+    dec : `Node`
+        Node representing box center dec value.
+    width : `Node`
+        Node representing box ra width value.
+    height : `Node`
+        Node representing box dec height value.
+    """
+
+    def __init__(self, ra: Node, dec: Node, width: Node, height: Node):
+        super().__init__((ra, dec, width, height))
+        self.ra = ra
+        self.dec = dec
+        self.width = width
+        self.height = height
+
+    def visit(self, visitor: TreeVisitor) -> Any:
+        # Docstring inherited from Node.visit
+        ra = self.ra.visit(visitor)
+        dec = self.dec.visit(visitor)
+        width = self.width.visit(visitor)
+        height = self.height.visit(visitor)
+        return visitor.visitBoxNode(ra, dec, width, height, self)
+
+    def __str__(self) -> str:
+        return f"BOX({self.ra}, {self.dec}, {self.width}, {self.height})"
+
+
+class PolygonNode(Node):
+    """Node representing polygon region in ADQL notation.
+
+    Parameters
+    ----------
+    vertices : `list`[`tuple`[`Node`, `Node`]]
+        Node representing vertices of polygon.
+    """
+
+    def __init__(self, vertices: list[tuple[Node, Node]]):
+        super().__init__(sum(vertices, start=()))
+        self.vertices = vertices
+
+    def visit(self, visitor: TreeVisitor) -> Any:
+        # Docstring inherited from Node.visit
+        vertices = [(ra.visit(visitor), dec.visit(visitor)) for ra, dec in self.vertices]
+        return visitor.visitPolygonNode(vertices, self)
+
+    def __str__(self) -> str:
+        params = ", ".join(str(param) for param in self.children)
+        return f"POLYGON({params})"
+
+
+class RegionNode(Node):
+    """Node representing region using IVOA SIAv2 POS notation.
+
+    Parameters
+    ----------
+    pos : `Node`
+        IVOA SIAv2 POS string representation of a region.
+    """
+
+    def __init__(self, pos: Node):
+        super().__init__((pos,))
+        self.pos = pos
+
+    def visit(self, visitor: TreeVisitor) -> Any:
+        # Docstring inherited from Node.visit
+        pos = self.pos.visit(visitor)
+        return visitor.visitRegionNode(pos, self)
+
+    def __str__(self) -> str:
+        return f"REGION({self.pos})"
+
+
 class GlobNode(Node):
     """Node representing a call to GLOB(pattern, expression) function.
 
@@ -536,11 +649,45 @@ def function_call(function: str, args: list[Node]) -> Node:
     functions. Tree visitors will most likely raise an error when visiting
     `FunctionCall` nodes.
     """
-    if function.upper() == "POINT":
+    function_name = function.upper()
+    if function_name == "POINT":
         if len(args) != 2:
             raise ValueError("POINT requires two arguments (ra, dec)")
         return PointNode(*args)
-    elif function.upper() == "GLOB":
+    elif function_name == "CIRCLE":
+        if len(args) != 3:
+            raise ValueError("CIRCLE requires three arguments (ra, dec, radius)")
+        # Check types of arguments, we want to support expressions too.
+        for name, arg in zip(("ra", "dec", "radius"), args, strict=True):
+            if not isinstance(arg, NumericLiteral | BindName | Identifier | BinaryOp | UnaryOp):
+                raise ValueError(f"CIRCLE {name} argument must be either numeric expression or bind value.")
+        return CircleNode(*args)
+    elif function_name == "BOX":
+        if len(args) != 4:
+            raise ValueError("CIRCLE requires four arguments (ra, dec, width, height)")
+        # Check types of arguments, we want to support expressions too.
+        for name, arg in zip(("ra", "dec", "width", "height"), args, strict=True):
+            if not isinstance(arg, NumericLiteral | BindName | Identifier | BinaryOp | UnaryOp):
+                raise ValueError(f"BOX {name} argument must be either numeric expression or bind value.")
+        return BoxNode(*args)
+    elif function_name == "POLYGON":
+        if len(args) % 2 != 0:
+            raise ValueError("POLYGON requires even number of arguments")
+        if len(args) < 6:
+            raise ValueError("POLYGON requires at least three vertices")
+        # Check types of arguments, we want to support expressions too.
+        for arg in args:
+            if not isinstance(arg, NumericLiteral | BindName | Identifier | BinaryOp | UnaryOp):
+                raise ValueError("POLYGON argument must be either numeric expression or bind value.")
+        vertices = list(zip(args[::2], args[1::2]))
+        return PolygonNode(vertices)
+    elif function_name == "REGION":
+        if len(args) != 1:
+            raise ValueError("REGION requires a single string argument")
+        if not isinstance(args[0], StringLiteral | BindName | Identifier):
+            raise ValueError("REGION argument must be either a string or a bind value")
+        return RegionNode(args[0])
+    elif function_name == "GLOB":
         if len(args) != 2:
             raise ValueError("GLOB requires two arguments (pattern, expression)")
         expression, pattern = (_strip_parens(arg) for arg in args)
@@ -549,7 +696,7 @@ def function_call(function: str, args: list[Node]) -> Node:
         if not isinstance(pattern, StringLiteral | BindName):
             raise TypeError("glob() second argument must be a string or a bind name (prefixed with colon)")
         return GlobNode(expression, pattern)
-    elif function.upper() == "UUID":
+    elif function_name == "UUID":
         if len(args) != 1:
             raise ValueError("UUID() requires a single arguments (uuid-string)")
         argument = _strip_parens(args[0])