pixeltable 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

pixeltable/exec/expr_eval/schedulers.py

@@ -11,7 +11,7 @@ from typing import Awaitable, Collection, Optional
 from pixeltable import env, func
 from pixeltable.config import Config
 
-from .globals import Dispatcher, FnCallArgs, Scheduler
+from .globals import Dispatcher, ExecCtx, FnCallArgs, Scheduler
 
 _logger = logging.getLogger('pixeltable')
 
@@ -62,9 +62,6 @@ class RateLimitsScheduler(Scheduler):
     def matches(cls, resource_pool: str) -> bool:
         return resource_pool.startswith('rate-limits:')
 
-    def submit(self, item: FnCallArgs) -> None:
-        self.queue.put_nowait(self.QueueItem(item, 0))
-
     def _set_pool_info(self) -> None:
         """Initialize pool_info with the RateLimitsInfo for the resource pool, if available"""
         if self.pool_info is not None:
@@ -76,7 +73,7 @@ class RateLimitsScheduler(Scheduler):
         assert hasattr(self.pool_info, 'get_request_resources')
         sig = inspect.signature(self.pool_info.get_request_resources)
         self.get_request_resources_param_names = [p.name for p in sig.parameters.values()]
-        self.est_usage = {r: 0 for r in self._resources}
+        self.est_usage = dict.fromkeys(self._resources, 0)
 
     async def _main_loop(self) -> None:
         item: Optional[RateLimitsScheduler.QueueItem] = None
@@ -90,7 +87,7 @@ class RateLimitsScheduler(Scheduler):
             if self.pool_info is None or not self.pool_info.is_initialized():
                 # wait for a single request to get rate limits
                 _logger.debug(f'initializing rate limits for {self.resource_pool}')
-                await self._exec(item.request, item.num_retries, is_task=False)
+                await self._exec(item.request, item.exec_ctx, item.num_retries, is_task=False)
                 _logger.debug(f'initialized rate limits for {self.resource_pool}')
                 item = None
                 # if this was the first request, it created the pool_info
@@ -141,7 +138,7 @@ class RateLimitsScheduler(Scheduler):
                 self.est_usage[resource] += val
             _logger.debug(f'creating task for {self.resource_pool}')
             self.num_in_flight += 1
-            task = asyncio.create_task(self._exec(item.request, item.num_retries, is_task=True))
+            task = asyncio.create_task(self._exec(item.request, item.exec_ctx, item.num_retries, is_task=True))
             self.dispatcher.register_task(task)
             item = None
 
@@ -171,7 +168,7 @@ class RateLimitsScheduler(Scheduler):
             return None
         return min(candidates, key=lambda x: x[1])[0]
 
-    async def _exec(self, request: FnCallArgs, num_retries: int, is_task: bool) -> None:
+    async def _exec(self, request: FnCallArgs, exec_ctx: ExecCtx, num_retries: int, is_task: bool) -> None:
         assert all(not row.has_val[request.fn_call.slot_idx] for row in request.rows)
         assert all(not row.has_exc(request.fn_call.slot_idx) for row in request.rows)
 
@@ -180,7 +177,8 @@ class RateLimitsScheduler(Scheduler):
             pxt_fn = request.fn_call.fn
             assert isinstance(pxt_fn, func.CallableFunction)
             _logger.debug(
-                f'scheduler {self.resource_pool}: start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: '
+                f'start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
             )
             self.total_requests += 1
             if request.is_batched:
@@ -193,13 +191,14 @@ class RateLimitsScheduler(Scheduler):
                 request.row[request.fn_call.slot_idx] = result
             end_ts = datetime.datetime.now(tz=datetime.timezone.utc)
             _logger.debug(
-                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} in {end_ts - start_ts}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} '
+                f'in {end_ts - start_ts}, batch_size={len(request.rows)}'
             )
 
             # purge accumulated usage estimate, now that we have a new report
-            self.est_usage = {r: 0 for r in self._resources}
+            self.est_usage = dict.fromkeys(self._resources, 0)
 
-            self.dispatcher.dispatch(request.rows)
+            self.dispatcher.dispatch(request.rows, exec_ctx)
         except Exception as exc:
             _logger.debug(f'scheduler {self.resource_pool}: exception in slot {request.fn_call.slot_idx}: {exc}')
             if self.pool_info is None:
@@ -212,7 +211,7 @@ class RateLimitsScheduler(Scheduler):
                     self.total_retried += 1
                     _logger.debug(f'scheduler {self.resource_pool}: retrying in {retry_delay} seconds')
                     await asyncio.sleep(retry_delay)
-                    self.queue.put_nowait(self.QueueItem(request, num_retries + 1))
+                    self.queue.put_nowait(self.QueueItem(request, num_retries + 1, exec_ctx))
                     return
             # TODO: update resource limits reported in exc.response.headers, if present
 
@@ -220,7 +219,7 @@ class RateLimitsScheduler(Scheduler):
             _, _, exc_tb = sys.exc_info()
             for row in request.rows:
                 row.set_exc(request.fn_call.slot_idx, exc)
-            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb)
+            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb, exec_ctx)
         finally:
             _logger.debug(f'Scheduler stats: #requests={self.total_requests}, #retried={self.total_retried}')
             if is_task:
@@ -301,15 +300,15 @@ class RequestRateScheduler(Scheduler):
             if item.num_retries > 0:
                 # the last request encountered some problem: retry it synchronously, to wait for the problem to pass
                 _logger.debug(f'retrying request for {self.resource_pool}: #retries={item.num_retries}')
-                await self._exec(item.request, item.num_retries, is_task=False)
+                await self._exec(item.request, item.exec_ctx, item.num_retries, is_task=False)
                 _logger.debug(f'retried request for {self.resource_pool}: #retries={item.num_retries}')
             else:
                 _logger.debug(f'creating task for {self.resource_pool}')
                 self.num_in_flight += 1
-                task = asyncio.create_task(self._exec(item.request, item.num_retries, is_task=True))
+                task = asyncio.create_task(self._exec(item.request, item.exec_ctx, item.num_retries, is_task=True))
                 self.dispatcher.register_task(task)
 
-    async def _exec(self, request: FnCallArgs, num_retries: int, is_task: bool) -> None:
+    async def _exec(self, request: FnCallArgs, exec_ctx: ExecCtx, num_retries: int, is_task: bool) -> None:
         assert all(not row.has_val[request.fn_call.slot_idx] for row in request.rows)
         assert all(not row.has_exc(request.fn_call.slot_idx) for row in request.rows)
 
@@ -318,7 +317,8 @@ class RequestRateScheduler(Scheduler):
             pxt_fn = request.fn_call.fn
             assert isinstance(pxt_fn, func.CallableFunction)
             _logger.debug(
-                f'scheduler {self.resource_pool}: start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: '
+                f'start evaluating slot {request.fn_call.slot_idx}, batch_size={len(request.rows)}'
             )
             self.total_requests += 1
             if request.is_batched:
@@ -331,9 +331,10 @@ class RequestRateScheduler(Scheduler):
                 request.row[request.fn_call.slot_idx] = result
             end_ts = datetime.datetime.now(tz=datetime.timezone.utc)
             _logger.debug(
-                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} in {end_ts - start_ts}, batch_size={len(request.rows)}'
+                f'scheduler {self.resource_pool}: evaluated slot {request.fn_call.slot_idx} '
+                f'in {end_ts - start_ts}, batch_size={len(request.rows)}'
             )
-            self.dispatcher.dispatch(request.rows)
+            self.dispatcher.dispatch(request.rows, exec_ctx)
 
         except Exception as exc:
             # TODO: which exception can be retried?
@@ -341,17 +342,18 @@ class RequestRateScheduler(Scheduler):
             status = getattr(exc, 'status', None)
             _logger.debug(f'type={type(exc)} has_status={hasattr(exc, "status")} status={status}')
             if num_retries < self.MAX_RETRIES:
-                self.queue.put_nowait(self.QueueItem(request, num_retries + 1))
+                self.queue.put_nowait(self.QueueItem(request, num_retries + 1, exec_ctx))
                 return
 
             # record the exception
             _, _, exc_tb = sys.exc_info()
             for row in request.rows:
                 row.set_exc(request.fn_call.slot_idx, exc)
-            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb)
+            self.dispatcher.dispatch_exc(request.rows, request.fn_call.slot_idx, exc_tb, exec_ctx)
         finally:
             _logger.debug(
-                f'Scheduler stats: #in-flight={self.num_in_flight} #requests={self.total_requests}, #retried={self.total_retried}'
+                f'Scheduler stats: #in-flight={self.num_in_flight} #requests={self.total_requests}, '
+                f'#retried={self.total_retried}'
             )
             if is_task:
                 self.num_in_flight -= 1

pixeltable/exec/in_memory_data_node.py

@@ -1,8 +1,7 @@
 import logging
-from typing import Any, AsyncIterator, Iterator, Optional
+from typing import Any, AsyncIterator, Optional
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 from pixeltable.utils.media_store import MediaStore
 
 from .data_row_batch import DataRowBatch
@@ -68,9 +67,12 @@ class InMemoryDataNode(ExecNode):
                 if col_info.col.col_type.is_image_type() and isinstance(val, bytes):
                     # this is a literal image, ie, a sequence of bytes; we save this as a media file and store the path
                     path = str(MediaStore.prepare_media_path(self.tbl.id, col_info.col.id, self.tbl.get().version))
-                    open(path, 'wb').write(val)
-                    val = path
-                self.output_rows[row_idx][col_info.slot_idx] = val
+                    with open(path, 'wb') as fp:
+                        fp.write(val)
+                    self.output_rows[row_idx][col_info.slot_idx] = path
+                else:
+                    self.output_rows[row_idx][col_info.slot_idx] = val
+
                 input_slot_idxs.add(col_info.slot_idx)
 
             # set the remaining output slots to their default values (presently None)

pixeltable/exec/row_update_node.py

@@ -1,8 +1,7 @@
 import logging
 from typing import Any, AsyncIterator
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 
 from .data_row_batch import DataRowBatch
 from .exec_node import ExecNode
@@ -29,7 +28,7 @@ class RowUpdateNode(ExecNode):
         input: ExecNode,
     ):
         super().__init__(row_builder, [], [], input)
-        self.updates = {key_vals: col_vals for key_vals, col_vals in zip(key_vals_batch, col_vals_batch)}
+        self.updates = dict(zip(key_vals_batch, col_vals_batch))
         self.is_rowid_key = is_rowid_key
         # determine slot idxs of all columns we need to read or write
         # retrieve ColumnRefs from the RowBuilder (has slot_idx set)
@@ -38,7 +37,7 @@ class RowUpdateNode(ExecNode):
             for col_ref in row_builder.unique_exprs
             if isinstance(col_ref, exprs.ColumnRef)
         }
-        self.col_slot_idxs = {col: all_col_slot_idxs[col] for col in col_vals_batch[0].keys()}
+        self.col_slot_idxs = {col: all_col_slot_idxs[col] for col in col_vals_batch[0]}
         self.key_slot_idxs = {col: all_col_slot_idxs[col] for col in tbl.tbl_version.get().primary_key_columns()}
         self.matched_key_vals: set[tuple] = set()
 

pixeltable/exec/sql_node.py

@@ -6,8 +6,7 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.catalog as catalog
-import pixeltable.exprs as exprs
+from pixeltable import catalog, exprs
 from pixeltable.env import Env
 
 from .data_row_batch import DataRowBatch
@@ -217,31 +216,31 @@ class SqlNode(ExecNode):
         candidates = tbl.get_tbl_versions()
         assert len(candidates) > 0
         joined_tbls: list[catalog.TableVersionHandle] = [candidates[0]]
-        for tbl in candidates[1:]:
-            if tbl.id in refd_tbl_ids:
-                joined_tbls.append(tbl)
+        for t in candidates[1:]:
+            if t.id in refd_tbl_ids:
+                joined_tbls.append(t)
 
         first = True
-        prev_tbl: catalog.TableVersionHandle
-        for tbl in joined_tbls[::-1]:
+        prev_tbl: Optional[catalog.TableVersionHandle] = None
+        for t in joined_tbls[::-1]:
             if first:
-                stmt = stmt.select_from(tbl.get().store_tbl.sa_tbl)
+                stmt = stmt.select_from(t.get().store_tbl.sa_tbl)
                 first = False
             else:
                 # join tbl to prev_tbl on prev_tbl's rowid cols
                 prev_tbl_rowid_cols = prev_tbl.get().store_tbl.rowid_columns()
-                tbl_rowid_cols = tbl.get().store_tbl.rowid_columns()
+                tbl_rowid_cols = t.get().store_tbl.rowid_columns()
                 rowid_clauses = [
                     c1 == c2 for c1, c2 in zip(prev_tbl_rowid_cols, tbl_rowid_cols[: len(prev_tbl_rowid_cols)])
                 ]
-                stmt = stmt.join(tbl.get().store_tbl.sa_tbl, sql.and_(*rowid_clauses))
-            if tbl.id in exact_version_only:
-                stmt = stmt.where(tbl.get().store_tbl.v_min_col == tbl.get().version)
+                stmt = stmt.join(t.get().store_tbl.sa_tbl, sql.and_(*rowid_clauses))
+            if t.id in exact_version_only:
+                stmt = stmt.where(t.get().store_tbl.v_min_col == t.get().version)
             else:
-                stmt = stmt.where(tbl.get().store_tbl.v_min_col <= tbl.get().version).where(
-                    tbl.get().store_tbl.v_max_col > tbl.get().version
+                stmt = stmt.where(t.get().store_tbl.v_min_col <= t.get().version).where(
+                    t.get().store_tbl.v_max_col > t.get().version
                 )
-            prev_tbl = tbl
+            prev_tbl = t
         return stmt
 
     def set_where(self, where_clause: exprs.Expr) -> None:
@@ -291,7 +290,7 @@ class SqlNode(ExecNode):
 
             conn = Env.get().conn
             result_cursor = conn.execute(stmt)
-            for warning in w:
+            for _ in w:
                 pass
 
         tbl_version = self.tbl.tbl_version if self.tbl is not None else None
@@ -494,7 +493,7 @@ class SqlJoinNode(SqlNode):
                 if join_clause.join_type != plan.JoinType.CROSS
                 else sql.sql.expression.literal(True)
             )
-            is_outer = join_clause.join_type == plan.JoinType.LEFT or join_clause.join_type == plan.JoinType.FULL_OUTER
+            is_outer = join_clause.join_type in (plan.JoinType.LEFT, plan.JoinType.FULL_OUTER)
             stmt = stmt.join(
                 self.input_ctes[i + 1],
                 onclause=on_clause,

pixeltable/exprs/__init__.py

@@ -15,7 +15,7 @@ from .globals import ArithmeticOperator, ComparisonOperator, LogicalOperator
 from .in_predicate import InPredicate
 from .inline_expr import InlineArray, InlineDict, InlineList
 from .is_null import IsNull
-from .json_mapper import JsonMapper
+from .json_mapper import JsonMapper, JsonMapperDispatch
 from .json_path import JsonPath
 from .literal import Literal
 from .method_ref import MethodRef

pixeltable/exprs/column_property_ref.py

@@ -52,7 +52,7 @@ class ColumnPropertyRef(Expr):
         return f'{self._col_ref}.{self.prop.name.lower()}'
 
     def is_error_prop(self) -> bool:
-        return self.prop in {self.Property.ERRORTYPE, self.Property.ERRORMSG}
+        return self.prop in (self.Property.ERRORTYPE, self.Property.ERRORMSG)
 
     def sql_expr(self, sql_elements: SqlElementCache) -> Optional[sql.ColumnElement]:
         if not self._col_ref.col.is_stored:

pixeltable/exprs/column_ref.py

@@ -176,13 +176,13 @@ class ColumnRef(Expr):
         tbl = catalog.Catalog.get().get_table_by_id(self.col.tbl.id)
         return tbl.select(self)
 
-    def show(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def show(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().show(*args, **kwargs)
 
-    def head(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def head(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().head(*args, **kwargs)
 
-    def tail(self, *args, **kwargs) -> 'pxt.dataframe.DataFrameResultSet':
+    def tail(self, *args: Any, **kwargs: Any) -> 'pxt.dataframe.DataFrameResultSet':
         return self._df().tail(*args, **kwargs)
 
     def count(self) -> int:

pixeltable/exprs/compound_predicate.py

@@ -61,7 +61,7 @@ class CompoundPredicate(Expr):
         return [*super()._id_attrs(), ('operator', self.operator.value)]
 
     def split_conjuncts(self, condition: Callable[[Expr], bool]) -> tuple[list[Expr], Optional[Expr]]:
-        if self.operator in {LogicalOperator.OR, LogicalOperator.NOT}:
+        if self.operator in (LogicalOperator.OR, LogicalOperator.NOT):
             return super().split_conjuncts(condition)
         matches = [op for op in self.components if condition(op)]
         non_matches = [op for op in self.components if not condition(op)]

pixeltable/exprs/data_row.py

@@ -63,11 +63,25 @@ class DataRow:
     # - None if vals[i] is not a media type or if there is no local file yet for file_urls[i]
     file_paths: np.ndarray  # of str
 
-    def __init__(self, size: int, img_slot_idxs: list[int], media_slot_idxs: list[int], array_slot_idxs: list[int]):
+    # for nested rows (ie, those produced by JsonMapperDispatcher)
+    parent_row: Optional[DataRow]
+    parent_slot_idx: Optional[int]
+
+    def __init__(
+        self,
+        size: int,
+        img_slot_idxs: list[int],
+        media_slot_idxs: list[int],
+        array_slot_idxs: list[int],
+        parent_row: Optional[DataRow] = None,
+        parent_slot_idx: Optional[int] = None,
+    ):
         self.img_slot_idxs = img_slot_idxs
         self.media_slot_idxs = media_slot_idxs
         self.array_slot_idxs = array_slot_idxs
         self.init(size)
+        self.parent_row = parent_row
+        self.parent_slot_idx = parent_slot_idx
 
     def init(self, num_slots: int) -> None:
         self.vals = np.full(num_slots, None, dtype=object)
@@ -79,6 +93,8 @@ class DataRow:
         self.pk = None
         self.file_urls = np.full(num_slots, None, dtype=object)
         self.file_paths = np.full(num_slots, None, dtype=object)
+        self.parent_row = None
+        self.parent_slot_idx = None
 
     def clear(self, idxs: Optional[np.ndarray] = None) -> None:
         if idxs is not None:

pixeltable/exprs/expr.py

@@ -69,6 +69,8 @@ class Expr(abc.ABC):
     # - not set for subexprs that don't need to be materialized because the parent can be materialized via SQL
     slot_idx: Optional[int]
 
+    T = TypeVar('T', bound='Expr')
+
     def __init__(self, col_type: ts.ColumnType):
         self.col_type = col_type
         self.components = []
@@ -97,9 +99,11 @@ class Expr(abc.ABC):
         by the immediately containing JsonMapper during initialization.
         """
         self._bind_rel_paths()
-        assert not self._has_relative_path, self._expr_tree()
+        has_rel_path = self._has_relative_path()
+        assert not has_rel_path, self._expr_tree()
+        assert not self._has_relative_path(), self._expr_tree()
 
-    def _bind_rel_paths(self, mapper: Optional['exprs.JsonMapper'] = None) -> None:
+    def _bind_rel_paths(self, mapper: Optional['exprs.JsonMapperDispatch'] = None) -> None:
         for c in self.components:
             c._bind_rel_paths(mapper)
 
@@ -188,7 +192,7 @@ class Expr(abc.ABC):
             return False
         return all(a[i].equals(b[i]) for i in range(len(a)))
 
-    def copy(self) -> Expr:
+    def copy(self: T) -> T:
         """
         Creates a copy that can be evaluated separately: it doesn't share any eval context (slot_idx)
         but shares everything else (catalog objects, etc.)
@@ -206,7 +210,7 @@ class Expr(abc.ABC):
             return None
         return [e.copy() for e in expr_list]
 
-    def __deepcopy__(self, memo=None) -> Expr:
+    def __deepcopy__(self, memo: Optional[dict[int, Any]] = None) -> Expr:
         # we don't need to create an actual deep copy because all state other than execution state is read-only
         if memo is None:
             memo = {}
@@ -296,8 +300,6 @@ class Expr(abc.ABC):
     # instances of that subclass; and another that returns all subexpressions that match the given filter.
     # In order for type checking to behave correctly on both forms, we provide two overloaded signatures.
 
-    T = TypeVar('T', bound='Expr')
-
     @overload
     def subexprs(
         self, *, filter: Optional[Callable[[Expr], bool]] = None, traverse_matches: bool = True
@@ -370,9 +372,8 @@ class Expr(abc.ABC):
         except StopIteration:
             return False
 
-    @property
     def _has_relative_path(self) -> bool:
-        return any(c._has_relative_path for c in self.components)
+        return any(c._has_relative_path() for c in self.components)
 
     def tbl_ids(self) -> set[UUID]:
         """Returns table ids referenced by this expr."""
@@ -459,7 +460,6 @@ class Expr(abc.ABC):
                 return Literal(o, col_type=obj_type)
         return None
 
-    @abc.abstractmethod
     def sql_expr(self, sql_elements: 'exprs.SqlElementCache') -> Optional[sql.ColumnElement]:
         """
         If this expr can be materialized directly in SQL:
@@ -469,7 +469,7 @@ class Expr(abc.ABC):
         - returns None
         - eval() will be called
         """
-        pass
+        return None
 
     @abc.abstractmethod
     def eval(self, data_row: DataRow, row_builder: 'exprs.RowBuilder') -> None:
@@ -835,13 +835,13 @@ class Expr(abc.ABC):
             first_param = next(params_iter) if len(params) >= 1 else None
             second_param = next(params_iter) if len(params) >= 2 else None
             # Check that fn has at least one positional parameter
-            if len(params) == 0 or first_param.kind in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.VAR_KEYWORD}:
+            if len(params) == 0 or first_param.kind in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.VAR_KEYWORD):
                 raise excs.Error(f'Function `{fn.__name__}` has no positional parameters.')
             # Check that fn has at most one required parameter, i.e., its second parameter
             # has no default and is not a varargs
             if (
                 len(params) >= 2
-                and second_param.kind not in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
+                and second_param.kind not in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
                 and second_param.default is inspect.Parameter.empty
             ):
                 raise excs.Error(f'Function `{fn.__name__}` has multiple required parameters.')

pixeltable/exprs/function_call.py

@@ -205,6 +205,10 @@ class FunctionCall(Expr):
     def has_group_by(self) -> bool:
         return self.group_by_stop_idx != 0
 
+    @property
+    def is_async(self) -> bool:
+        return self.fn.is_async
+
     @property
     def group_by(self) -> list[Expr]:
         return self.components[self.group_by_start_idx : self.group_by_stop_idx]
@@ -272,6 +276,34 @@ class FunctionCall(Expr):
         assert isinstance(self.fn, func.AggregateFunction)
         self.aggregator = self.fn.agg_class(**self.agg_init_args)
 
+    @property
+    def bound_args(self) -> dict[str, Expr]:
+        """
+        Reconstructs bound arguments from the components of this FunctionCall.
+        """
+        bound_args: dict[str, Expr] = {}
+        for name, idx in self.bound_idxs.items():
+            if isinstance(idx, int):
+                bound_args[name] = self.components[idx]
+            elif isinstance(idx, Sequence):
+                bound_args[name] = Expr.from_object([self.components[i] for i in idx])
+            elif isinstance(idx, dict):
+                bound_args[name] = Expr.from_object({k: self.components[i] for k, i in idx.items()})
+            else:
+                raise AssertionError(f'{name}: {idx} (of type `{type(idx)}`)')
+        return bound_args
+
+    def substitute(self, spec: dict[Expr, Expr]) -> Expr:
+        """
+        Substitution of FunctionCall arguments could cause the return value to become more specific, in the case
+        where a variable is replaced with a specific value.
+        """
+        res = super().substitute(spec)
+        assert res is self
+        self.return_type = self.fn.call_return_type(self.bound_args)
+        self.col_type = self.return_type
+        return self
+
     def update(self, data_row: DataRow) -> None:
         """
         Update agg state
@@ -289,7 +321,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters_by_pos[idx].kind
-                in {inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
+                in (inspect.Parameter.POSITIONAL_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
                 and not parameters_by_pos[idx].col_type.nullable
             ):
                 return None
@@ -302,7 +334,7 @@ class FunctionCall(Expr):
             if (
                 val is None
                 and parameters[param_name].kind
-                in {inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD}
+                in (inspect.Parameter.KEYWORD_ONLY, inspect.Parameter.POSITIONAL_OR_KEYWORD)
                 and not parameters[param_name].col_type.nullable
             ):
                 return None