pixeltable 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

pixeltable/catalog/table_version_path.py

@@ -84,6 +84,7 @@ class TableVersionPath:
     def get_column_ref(self, col_name: str) -> exprs.ColumnRef:
         """Return a ColumnRef for the given column name."""
         from pixeltable.exprs import ColumnRef
+
         if col_name not in self.tbl_version.cols_by_name:
             if self.base is None:
                 raise AttributeError(f'Column {col_name} unknown')
@@ -121,11 +122,13 @@ class TableVersionPath:
             return None
 
     def has_column(self, col: Column, include_bases: bool = True) -> bool:
-        """Return True if this table has the given column.
-        """
+        """Return True if this table has the given column."""
         assert col.tbl is not None
-        if col.tbl.id == self.tbl_version.id and col.tbl.effective_version == self.tbl_version.effective_version \
-                and col.id in self.tbl_version.cols_by_id:
+        if (
+            col.tbl.id == self.tbl_version.id
+            and col.tbl.effective_version == self.tbl_version.effective_version
+            and col.id in self.tbl_version.cols_by_id
+        ):
             # the column is visible in this table version
             return True
         elif self.base is not None and include_bases:
@@ -136,7 +139,7 @@ class TableVersionPath:
     def as_dict(self) -> dict:
         return {
             'tbl_version': self.tbl_version.as_dict(),
-            'base': self.base.as_dict() if self.base is not None else None
+            'base': self.base.as_dict() if self.base is not None else None,
         }
 
     @classmethod

pixeltable/catalog/view.py

@@ -35,9 +35,10 @@ class View(Table):
     The exception is a snapshot view without a predicate and without additional columns: in that case, the view
     is simply a reference to a specific set of base versions.
     """
+
     def __init__(
-            self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath, base_id: UUID,
-            snapshot_only: bool):
+        self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath, base_id: UUID, snapshot_only: bool
+    ):
         super().__init__(id, dir_id, name, tbl_version_path)
         assert base_id in catalog.Catalog.get().tbl_dependents
         self._base_id = base_id  # keep a reference to the base Table ID, so that we can keep track of its dependents
@@ -49,10 +50,18 @@ class View(Table):
 
     @classmethod
     def _create(
-            cls, dir_id: UUID, name: str, base: TableVersionPath, additional_columns: dict[str, Any],
-            predicate: Optional['pxt.exprs.Expr'], is_snapshot: bool, num_retained_versions: int, comment: str,
-            media_validation: MediaValidation,
-            iterator_cls: Optional[type[ComponentIterator]], iterator_args: Optional[dict]
+        cls,
+        dir_id: UUID,
+        name: str,
+        base: TableVersionPath,
+        additional_columns: dict[str, Any],
+        predicate: Optional['pxt.exprs.Expr'],
+        is_snapshot: bool,
+        num_retained_versions: int,
+        comment: str,
+        media_validation: MediaValidation,
+        iterator_cls: Optional[type[ComponentIterator]],
+        iterator_args: Optional[dict],
     ) -> View:
         columns = cls._create_columns(additional_columns)
         cls._verify_schema(columns)
@@ -71,7 +80,8 @@ class View(Table):
             # make sure that the value can be computed in the context of the base
             if col.value_expr is not None and not col.value_expr.is_bound_by([base]):
                 raise excs.Error(
-                    f'Column {col.name}: value expression cannot be computed in the context of the base {base.tbl_name()}')
+                    f'Column {col.name}: value expression cannot be computed in the context of the base {base.tbl_name()}'
+                )
 
         if iterator_cls is not None:
             assert iterator_args is not None
@@ -92,6 +102,7 @@ class View(Table):
                 ]
                 sig = func.Signature(ts.InvalidType(), params)
                 from pixeltable.exprs import FunctionCall
+
                 FunctionCall.normalize_args(iterator_cls.__name__, sig, bound_args)
             except TypeError as e:
                 raise excs.Error(f'Cannot instantiate iterator with given arguments: {e}')
@@ -102,22 +113,28 @@ class View(Table):
             # stored=False: it is not stored separately (it's already stored as part of the rowid)
             iterator_cols = [Column(_POS_COLUMN_NAME, ts.IntType(), stored=False)]
             output_dict, unstored_cols = iterator_cls.output_schema(**bound_args)
-            iterator_cols.extend([
-                Column(col_name, col_type, stored=col_name not in unstored_cols)
-                for col_name, col_type in output_dict.items()
-            ])
+            iterator_cols.extend(
+                [
+                    Column(col_name, col_type, stored=col_name not in unstored_cols)
+                    for col_name, col_type in output_dict.items()
+                ]
+            )
 
             iterator_col_names = {col.name for col in iterator_cols}
             for col in columns:
                 if col.name in iterator_col_names:
-                    raise excs.Error(f'Duplicate name: column {col.name} is already present in the iterator output schema')
+                    raise excs.Error(
+                        f'Duplicate name: column {col.name} is already present in the iterator output schema'
+                    )
             columns = iterator_cols + columns
 
         with orm.Session(Env.get().engine, future=True) as session:
             from pixeltable.exprs import InlineDict
+
             iterator_args_expr: exprs.Expr = InlineDict(iterator_args) if iterator_args is not None else None
-            iterator_class_fqn = f'{iterator_cls.__module__}.{iterator_cls.__name__}' if iterator_cls is not None \
-                else None
+            iterator_class_fqn = (
+                f'{iterator_cls.__module__}.{iterator_cls.__name__}' if iterator_cls is not None else None
+            )
             base_version_path = cls._get_snapshot_path(base) if is_snapshot else base
             base_versions = [
                 (tbl_version.id.hex, tbl_version.version if is_snapshot or tbl_version.is_snapshot else None)
@@ -127,35 +144,53 @@ class View(Table):
             # if this is a snapshot, we need to retarget all exprs to the snapshot tbl versions
             if is_snapshot:
                 predicate = predicate.retarget(base_version_path) if predicate is not None else None
-                iterator_args_expr = iterator_args_expr.retarget(base_version_path) \
-                    if iterator_args_expr is not None else None
+                iterator_args_expr = (
+                    iterator_args_expr.retarget(base_version_path) if iterator_args_expr is not None else None
+                )
                 for col in columns:
                     if col.value_expr is not None:
                         col.set_value_expr(col.value_expr.retarget(base_version_path))
 
             view_md = md_schema.ViewMd(
-                is_snapshot=is_snapshot, predicate=predicate.as_dict() if predicate is not None else None,
+                is_snapshot=is_snapshot,
+                predicate=predicate.as_dict() if predicate is not None else None,
                 base_versions=base_versions,
                 iterator_class_fqn=iterator_class_fqn,
-                iterator_args=iterator_args_expr.as_dict() if iterator_args_expr is not None else None)
+                iterator_args=iterator_args_expr.as_dict() if iterator_args_expr is not None else None,
+            )
 
             id, tbl_version = TableVersion.create(
-                session, dir_id, name, columns, num_retained_versions, comment, media_validation=media_validation,
-                base_path=base_version_path, view_md=view_md)
+                session,
+                dir_id,
+                name,
+                columns,
+                num_retained_versions,
+                comment,
+                media_validation=media_validation,
+                base_path=base_version_path,
+                view_md=view_md,
+            )
             if tbl_version is None:
                 # this is purely a snapshot: we use the base's tbl version path
                 view = cls(id, dir_id, name, base_version_path, base.tbl_id(), snapshot_only=True)
                 _logger.info(f'created snapshot {name}')
             else:
                 view = cls(
-                    id, dir_id, name, TableVersionPath(tbl_version, base=base_version_path), base.tbl_id(),
-                    snapshot_only=False)
+                    id,
+                    dir_id,
+                    name,
+                    TableVersionPath(tbl_version, base=base_version_path),
+                    base.tbl_id(),
+                    snapshot_only=False,
+                )
                 _logger.info(f'Created view `{name}`, id={tbl_version.id}')
 
                 from pixeltable.plan import Planner
+
                 plan, num_values_per_row = Planner.create_view_load_plan(view._tbl_version_path)
                 num_rows, num_excs, cols_with_excs = tbl_version.store_tbl.insert_rows(
-                    plan, session.connection(), v_min=tbl_version.version)
+                    plan, session.connection(), v_min=tbl_version.version
+                )
                 Env.get().console_logger.info(f'Created view `{name}` with {num_rows} rows, {num_excs} exceptions.')
 
             session.commit()
@@ -188,7 +223,8 @@ class View(Table):
 
         return TableVersionPath(
             tbl_version,
-            base=cls._get_snapshot_path(tbl_version_path.base) if tbl_version_path.base is not None else None)
+            base=cls._get_snapshot_path(tbl_version_path.base) if tbl_version_path.base is not None else None,
+        )
 
     def _drop(self) -> None:
         cat = catalog.Catalog.get()
@@ -216,8 +252,13 @@ class View(Table):
         return md
 
     def insert(
-            self, rows: Optional[Iterable[dict[str, Any]]] = None, /, *, print_stats: bool = False,
-            on_error: Literal['abort', 'ignore'] = 'abort', **kwargs: Any
+        self,
+        rows: Optional[Iterable[dict[str, Any]]] = None,
+        /,
+        *,
+        print_stats: bool = False,
+        on_error: Literal['abort', 'ignore'] = 'abort',
+        **kwargs: Any,
     ) -> UpdateStatus:
         raise excs.Error(f'{self._display_name()} {self._name!r}: cannot insert into view')
 

pixeltable/dataframe.py

@@ -8,7 +8,7 @@ import json
 import logging
 import traceback
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Hashable, Iterator, Optional, Sequence, Union, AsyncIterator, NoReturn
+from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Hashable, Iterator, NoReturn, Optional, Sequence, Union
 
 import numpy as np
 import pandas as pd
@@ -138,7 +138,7 @@ class DataFrame:
     group_by_clause: Optional[list[exprs.Expr]]
     grouping_tbl: Optional[catalog.TableVersion]
     order_by_clause: Optional[list[tuple[exprs.Expr, bool]]]
-    limit_val: Optional[int]
+    limit_val: Optional[exprs.Expr]
 
     def __init__(
         self,
@@ -148,7 +148,7 @@ class DataFrame:
         group_by_clause: Optional[list[exprs.Expr]] = None,
         grouping_tbl: Optional[catalog.TableVersion] = None,
         order_by_clause: Optional[list[tuple[exprs.Expr, bool]]] = None,  # list[(expr, asc)]
-        limit: Optional[int] = None,
+        limit: Optional[exprs.Expr] = None,
     ):
         self._from_clause = from_clause
 
@@ -171,9 +171,7 @@ class DataFrame:
 
     @classmethod
     def _normalize_select_list(
-        cls,
-        tbls: list[catalog.TableVersionPath],
-        select_list: Optional[list[tuple[exprs.Expr, Optional[str]]]],
+        cls, tbls: list[catalog.TableVersionPath], select_list: Optional[list[tuple[exprs.Expr, Optional[str]]]]
     ) -> tuple[list[exprs.Expr], list[str]]:
         """
         Expand select list information with all columns and their names
@@ -227,6 +225,8 @@ class DataFrame:
             all_exprs.extend(self.group_by_clause)
         if self.order_by_clause is not None:
             all_exprs.extend([expr for expr, _ in self.order_by_clause])
+        if self.limit_val is not None:
+            all_exprs.append(self.limit_val)
         vars = exprs.Expr.list_subexprs(all_exprs, expr_class=exprs.Variable)
         unique_vars: dict[str, exprs.Variable] = {}
         for var in vars:
@@ -301,7 +301,7 @@ class DataFrame:
             where_clause=self.where_clause,
             group_by_clause=group_by_clause,
             order_by_clause=self.order_by_clause if self.order_by_clause is not None else [],
-            limit=self.limit_val
+            limit=self.limit_val,
         )
 
     def _has_joins(self) -> bool:
@@ -369,8 +369,12 @@ class DataFrame:
         select_list_exprs = copy.deepcopy(self._select_list_exprs)
         where_clause = copy.deepcopy(self.where_clause)
         group_by_clause = copy.deepcopy(self.group_by_clause)
-        order_by_exprs = [copy.deepcopy(order_by_expr) for order_by_expr, _ in self.order_by_clause] \
-            if self.order_by_clause is not None else None
+        order_by_exprs = (
+            [copy.deepcopy(order_by_expr) for order_by_expr, _ in self.order_by_clause]
+            if self.order_by_clause is not None
+            else None
+        )
+        limit_val = copy.deepcopy(self.limit_val)
 
         var_exprs: dict[exprs.Expr, exprs.Expr] = {}
         vars = self._vars()
@@ -386,7 +390,7 @@ class DataFrame:
 
         exprs.Expr.list_substitute(select_list_exprs, var_exprs)
         if where_clause is not None:
-            where_clause.substitute(var_exprs)
+            where_clause = where_clause.substitute(var_exprs)
         if group_by_clause is not None:
             exprs.Expr.list_substitute(group_by_clause, var_exprs)
         if order_by_exprs is not None:
@@ -398,14 +402,23 @@ class DataFrame:
             order_by_clause = [
                 (expr, asc) for expr, asc in zip(order_by_exprs, [asc for _, asc in self.order_by_clause])
             ]
+        if limit_val is not None:
+            limit_val = limit_val.substitute(var_exprs)
+            if limit_val is not None and not isinstance(limit_val, exprs.Literal):
+                raise excs.Error(f'limit(): parameter must be a constant, but got {limit_val}')
 
         return DataFrame(
-            from_clause=self._from_clause, select_list=select_list, where_clause=where_clause,
-            group_by_clause=group_by_clause, grouping_tbl=self.grouping_tbl,
-            order_by_clause=order_by_clause, limit=self.limit_val)
+            from_clause=self._from_clause,
+            select_list=select_list,
+            where_clause=where_clause,
+            group_by_clause=group_by_clause,
+            grouping_tbl=self.grouping_tbl,
+            order_by_clause=order_by_clause,
+            limit=limit_val,
+        )
 
     def _raise_expr_eval_err(self, e: excs.ExprEvalError) -> NoReturn:
-        msg = f'In row {e.row_num} the {e.expr_msg} encountered exception ' f'{type(e.exc).__name__}:\n{str(e.exc)}'
+        msg = f'In row {e.row_num} the {e.expr_msg} encountered exception {type(e.exc).__name__}:\n{str(e.exc)}'
         if len(e.input_vals) > 0:
             input_msgs = [
                 f"'{d}' = {d.col_type.print_value(e.input_vals[i])}" for i, d in enumerate(e.expr.dependencies())
@@ -419,7 +432,7 @@ class DataFrame:
             nl = '\n'
             # [-1:0:-1]: leave out entry 0 and reverse order, so that the most recent frame is at the top
             msg += f'\nStack:\n{nl.join(stack_trace[-1:1:-1])}'
-        raise excs.Error(msg)
+        raise excs.Error(msg) from e
 
     def _output_row_iterator(self, conn: Optional[sql.engine.Connection] = None) -> Iterator[list]:
         try:
@@ -438,10 +451,7 @@ class DataFrame:
 
     async def _acollect(self, conn: sql.engine.Connection) -> DataFrameResultSet:
         try:
-            result = [
-                [row[e.slot_idx] for e in self._select_list_exprs]
-                async for row in self._aexec(conn)
-            ]
+            result = [[row[e.slot_idx] for e in self._select_list_exprs] async for row in self._aexec(conn)]
             return DataFrameResultSet(result, self.schema)
         except excs.ExprEvalError as e:
             self._raise_expr_eval_err(e)
@@ -471,14 +481,16 @@ class DataFrame:
         return helper
 
     def _col_descriptor(self) -> pd.DataFrame:
-        return pd.DataFrame([
-            {
-                'Name': name,
-                'Type': expr.col_type._to_str(as_schema=True),
-                'Expression': expr.display_str(inline=False),
-            }
-            for name, expr in zip(self.schema.keys(), self._select_list_exprs)
-        ])
+        return pd.DataFrame(
+            [
+                {
+                    'Name': name,
+                    'Type': expr.col_type._to_str(as_schema=True),
+                    'Expression': expr.display_str(inline=False),
+                }
+                for name, expr in zip(self.schema.keys(), self._select_list_exprs)
+            ]
+        )
 
     def _query_descriptor(self) -> pd.DataFrame:
         heading_vals: list[str] = []
@@ -500,7 +512,7 @@ class DataFrame:
             )
         if self.limit_val is not None:
             heading_vals.append('Limit')
-            info_vals.append(str(self.limit_val))
+            info_vals.append(self.limit_val.display_str(inline=False))
         assert len(heading_vals) == len(info_vals)
         return pd.DataFrame(info_vals, index=heading_vals)
 
@@ -512,6 +524,7 @@ class DataFrame:
         """
         if getattr(builtins, '__IPYTHON__', False):
             from IPython.display import display
+
             display(self._repr_html_())
         else:
             print(repr(self))
@@ -523,7 +536,7 @@ class DataFrame:
         return self._descriptors().to_html()
 
     def select(self, *items: Any, **named_items: Any) -> DataFrame:
-        """ Select columns or expressions from the DataFrame.
+        """Select columns or expressions from the DataFrame.
 
         Args:
             items: expressions to be selected
@@ -565,21 +578,17 @@ class DataFrame:
         # analyze select list; wrap literals with the corresponding expressions
         select_list: list[tuple[exprs.Expr, Optional[str]]] = []
         for raw_expr, name in base_list:
-            if isinstance(raw_expr, exprs.Expr):
-                select_list.append((raw_expr, name))
-            elif isinstance(raw_expr, (dict, list, tuple)):
-                select_list.append((exprs.Expr.from_object(raw_expr), name))
-            elif isinstance(raw_expr, np.ndarray):
-                select_list.append((exprs.Expr.from_array(raw_expr), name))
-            else:
-                select_list.append((exprs.Literal(raw_expr), name))
-            expr = select_list[-1][0]
+            expr = exprs.Expr.from_object(raw_expr)
+            if expr is None:
+                raise excs.Error(f'Invalid expression: {raw_expr}')
             if expr.col_type.is_invalid_type():
                 raise excs.Error(f'Invalid type: {raw_expr}')
             if not expr.is_bound_by(self._from_clause.tbls):
                 raise excs.Error(
                     f"Expression '{expr}' cannot be evaluated in the context of this query's tables "
-                    f"({','.join(tbl.tbl_name() for tbl in self._from_clause.tbls)})")
+                    f'({",".join(tbl.tbl_name() for tbl in self._from_clause.tbls)})'
+                )
+            select_list.append((expr, name))
 
         # check user provided names do not conflict among themselves or with auto-generated ones
         seen: set[str] = set()
@@ -640,7 +649,7 @@ class DataFrame:
         )
 
     def _create_join_predicate(
-            self, other: catalog.TableVersionPath, on: Union[exprs.Expr, Sequence[exprs.ColumnRef]]
+        self, other: catalog.TableVersionPath, on: Union[exprs.Expr, Sequence[exprs.ColumnRef]]
     ) -> exprs.Expr:
         """Verifies user-specified 'on' argument and converts it into a join predicate."""
         col_refs: list[exprs.ColumnRef] = []
@@ -656,14 +665,12 @@ class DataFrame:
             return on
         else:
             if not isinstance(on, Sequence) or len(on) == 0:
-                raise excs.Error(
-                    f"'on': must be a sequence of column references or a boolean expression")
+                raise excs.Error(f"'on': must be a sequence of column references or a boolean expression")
 
         assert isinstance(on, Sequence)
         for col_ref in on:
             if not isinstance(col_ref, exprs.ColumnRef):
-                raise excs.Error(
-                    f"'on': must be a sequence of column references or a boolean expression")
+                raise excs.Error(f"'on': must be a sequence of column references or a boolean expression")
             if not col_ref.is_bound_by(joined_tbls):
                 raise excs.Error(f"'on': expression cannot be evaluated in the context of the joined tables: {col_ref}")
             col_refs.append(col_ref)
@@ -693,8 +700,7 @@ class DataFrame:
                     lhs_col_ref = exprs.ColumnRef(col)
                 if lhs_col_ref is None:
                     tbl_names = [tbl.tbl_name() for tbl in self._from_clause.tbls]
-                    raise excs.Error(
-                        f"'on': column {col_ref.col.name!r} not found in any of: {' '.join(tbl_names)}")
+                    raise excs.Error(f"'on': column {col_ref.col.name!r} not found in any of: {' '.join(tbl_names)}")
             pred = exprs.Comparison(exprs.ComparisonOperator.EQ, lhs_col_ref, rhs_col_ref)
             predicates.append(pred)
 
@@ -705,8 +711,10 @@ class DataFrame:
             return exprs.CompoundPredicate(operator=exprs.LogicalOperator.AND, operands=predicates)
 
     def join(
-        self, other: catalog.Table,  on: Optional[Union[exprs.Expr, Sequence[exprs.ColumnRef]]] = None,
-        how: plan.JoinType.LiteralType = 'inner'
+        self,
+        other: catalog.Table,
+        on: Optional[Union[exprs.Expr, Sequence[exprs.ColumnRef]]] = None,
+        how: plan.JoinType.LiteralType = 'inner',
     ) -> DataFrame:
         """
         Join this DataFrame with a table.
@@ -766,16 +774,20 @@ class DataFrame:
         join_clause = plan.JoinClause(join_type=plan.JoinType.validated(how, "'how'"), join_predicate=join_pred)
         from_clause = plan.FromClause(
             tbls=[*self._from_clause.tbls, other._tbl_version_path],
-            join_clauses=[*self._from_clause.join_clauses, join_clause])
+            join_clauses=[*self._from_clause.join_clauses, join_clause],
+        )
         return DataFrame(
             from_clause=from_clause,
-            select_list=self.select_list, where_clause=self.where_clause,
-            group_by_clause=self.group_by_clause, grouping_tbl=self.grouping_tbl,
-            order_by_clause=self.order_by_clause, limit=self.limit_val,
+            select_list=self.select_list,
+            where_clause=self.where_clause,
+            group_by_clause=self.group_by_clause,
+            grouping_tbl=self.grouping_tbl,
+            order_by_clause=self.order_by_clause,
+            limit=self.limit_val,
         )
 
     def group_by(self, *grouping_items: Any) -> DataFrame:
-        """ Add a group-by clause to this DataFrame.
+        """Add a group-by clause to this DataFrame.
 
         Variants:
         - group_by(<base table>): group a component view by their respective base table rows
@@ -846,7 +858,7 @@ class DataFrame:
         )
 
     def order_by(self, *expr_list: exprs.Expr, asc: bool = True) -> DataFrame:
-        """ Add an order-by clause to this DataFrame.
+        """Add an order-by clause to this DataFrame.
 
         Args:
             expr_list: expressions to order by
@@ -891,7 +903,7 @@ class DataFrame:
         )
 
     def limit(self, n: int) -> DataFrame:
-        """ Limit the number of rows in the DataFrame.
+        """Limit the number of rows in the DataFrame.
 
         Args:
             n: Number of rows to select.
@@ -899,8 +911,10 @@ class DataFrame:
         Returns:
             A new DataFrame with the specified limited rows.
         """
-        # TODO: allow n to be a Variable that can be substituted in bind()
-        assert n is not None and isinstance(n, int)
+        assert n is not None
+        n = exprs.Expr.from_object(n)
+        if not n.col_type.is_int_type():
+            raise excs.Error(f'limit(): parameter must be of type int, instead of {n.col_type}')
         return DataFrame(
             from_clause=self._from_clause,
             select_list=self.select_list,
@@ -912,7 +926,7 @@ class DataFrame:
         )
 
     def update(self, value_spec: dict[str, Any], cascade: bool = True) -> UpdateStatus:
-        """ Update rows in the underlying table of the DataFrame.
+        """Update rows in the underlying table of the DataFrame.
 
         Update rows in the table with the specified value_spec.
 
@@ -941,7 +955,7 @@ class DataFrame:
         return self._first_tbl.tbl_version.update(value_spec, where=self.where_clause, cascade=cascade)
 
     def delete(self) -> UpdateStatus:
-        """ Delete rows form the underlying table of the DataFrame.
+        """Delete rows form the underlying table of the DataFrame.
 
         The delete operation is only allowed for DataFrames on base tables.
 
@@ -982,17 +996,20 @@ class DataFrame:
             '_classname': 'DataFrame',
             'from_clause': {
                 'tbls': [tbl.as_dict() for tbl in self._from_clause.tbls],
-                'join_clauses': [dataclasses.asdict(clause) for clause in self._from_clause.join_clauses]
+                'join_clauses': [dataclasses.asdict(clause) for clause in self._from_clause.join_clauses],
             },
-            'select_list':
-                [(e.as_dict(), name) for (e, name) in self.select_list] if self.select_list is not None else None,
+            'select_list': [(e.as_dict(), name) for (e, name) in self.select_list]
+            if self.select_list is not None
+            else None,
             'where_clause': self.where_clause.as_dict() if self.where_clause is not None else None,
-            'group_by_clause':
-                [e.as_dict() for e in self.group_by_clause] if self.group_by_clause is not None else None,
+            'group_by_clause': [e.as_dict() for e in self.group_by_clause]
+            if self.group_by_clause is not None
+            else None,
             'grouping_tbl': self.grouping_tbl.as_dict() if self.grouping_tbl is not None else None,
-            'order_by_clause':
-                [(e.as_dict(), asc) for (e,asc) in self.order_by_clause] if self.order_by_clause is not None else None,
-            'limit_val': self.limit_val,
+            'order_by_clause': [(e.as_dict(), asc) for (e, asc) in self.order_by_clause]
+            if self.order_by_clause is not None
+            else None,
+            'limit_val': self.limit_val.as_dict() if self.limit_val is not None else None,
         }
         return d
 
@@ -1001,21 +1018,29 @@ class DataFrame:
         tbls = [catalog.TableVersionPath.from_dict(tbl_dict) for tbl_dict in d['from_clause']['tbls']]
         join_clauses = [plan.JoinClause(**clause_dict) for clause_dict in d['from_clause']['join_clauses']]
         from_clause = plan.FromClause(tbls=tbls, join_clauses=join_clauses)
-        select_list = [(exprs.Expr.from_dict(e), name) for e, name in d['select_list']] \
-            if d['select_list'] is not None else None
-        where_clause = exprs.Expr.from_dict(d['where_clause']) \
-            if d['where_clause'] is not None else None
-        group_by_clause = [exprs.Expr.from_dict(e) for e in d['group_by_clause']] \
-            if d['group_by_clause'] is not None else None
-        grouping_tbl = catalog.TableVersion.from_dict(d['grouping_tbl']) \
-            if d['grouping_tbl'] is not None else None
-        order_by_clause = [(exprs.Expr.from_dict(e), asc) for e, asc in d['order_by_clause']] \
-            if d['order_by_clause'] is not None else None
-        limit_val = d['limit_val']
+        select_list = (
+            [(exprs.Expr.from_dict(e), name) for e, name in d['select_list']] if d['select_list'] is not None else None
+        )
+        where_clause = exprs.Expr.from_dict(d['where_clause']) if d['where_clause'] is not None else None
+        group_by_clause = (
+            [exprs.Expr.from_dict(e) for e in d['group_by_clause']] if d['group_by_clause'] is not None else None
+        )
+        grouping_tbl = catalog.TableVersion.from_dict(d['grouping_tbl']) if d['grouping_tbl'] is not None else None
+        order_by_clause = (
+            [(exprs.Expr.from_dict(e), asc) for e, asc in d['order_by_clause']]
+            if d['order_by_clause'] is not None
+            else None
+        )
+        limit_val = exprs.Expr.from_dict(d['limit_val']) if d['limit_val'] is not None else None
         return DataFrame(
-            from_clause=from_clause, select_list=select_list, where_clause=where_clause,
-            group_by_clause=group_by_clause, grouping_tbl=grouping_tbl, order_by_clause=order_by_clause,
-            limit=limit_val)
+            from_clause=from_clause,
+            select_list=select_list,
+            where_clause=where_clause,
+            group_by_clause=group_by_clause,
+            grouping_tbl=grouping_tbl,
+            order_by_clause=order_by_clause,
+            limit=limit_val,
+        )
 
     def _hash_result_set(self) -> str:
         """Return a hash that changes when the result set changes."""