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

pixeltable/metadata/converters/convert_19.py

@@ -22,13 +22,10 @@ def _(engine: sql.engine.Engine) -> None:
             store_name = f'{store_prefix}_{id.hex}'
             column_md = md['column_md']
             timestamp_cols = [
-                col_id for col_id, col in column_md.items()
-                if col['col_type']['_classname'] == 'TimestampType'
+                col_id for col_id, col in column_md.items() if col['col_type']['_classname'] == 'TimestampType'
             ]
             for col_id in timestamp_cols:
-                conn.execute(
-                    sql.text(f'ALTER TABLE {store_name} ALTER COLUMN col_{col_id} TYPE TIMESTAMPTZ')
-                )
+                conn.execute(sql.text(f'ALTER TABLE {store_name} ALTER COLUMN col_{col_id} TYPE TIMESTAMPTZ'))
 
 
 def __update_timestamp_literals(k: Any, v: Any) -> Optional[tuple[Any, Any]]:

pixeltable/metadata/converters/convert_20.py

@@ -8,10 +8,7 @@ from pixeltable.metadata.converters.util import convert_table_md
 
 @register_converter(version=20)
 def _(engine: sql.engine.Engine) -> None:
-    convert_table_md(
-        engine,
-        substitution_fn=__substitute_md
-    )
+    convert_table_md(engine, substitution_fn=__substitute_md)
 
 
 def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], Any]]:

pixeltable/metadata/converters/convert_21.py

@@ -1,8 +1,9 @@
 from typing import Any, Optional
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
-from pixeltable.metadata.converters.util import convert_table_schema_version_md, convert_table_md
+from pixeltable.metadata.converters.util import convert_table_md, convert_table_schema_version_md
 
 
 @register_converter(version=21)
@@ -10,12 +11,9 @@ def _(engine: sql.engine.Engine) -> None:
     convert_table_schema_version_md(
         engine,
         table_schema_version_md_updater=__update_table_schema_version,
-        schema_column_updater=__update_schema_column
-    )
-    convert_table_md(
-        engine,
-        substitution_fn=__substitute_md
+        schema_column_updater=__update_schema_column,
     )
+    convert_table_md(engine, substitution_fn=__substitute_md)
 
 
 def __update_table_schema_version(table_schema_version_md: dict) -> None:

pixeltable/metadata/converters/convert_22.py

@@ -1,4 +1,5 @@
 from typing import Any, Optional
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter

pixeltable/metadata/converters/convert_23.py

@@ -1,6 +1,7 @@
 import logging
 from typing import Any, Optional
 from uuid import UUID
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
@@ -9,12 +10,11 @@ from pixeltable.metadata.schema import Table
 
 _logger = logging.getLogger('pixeltable')
 
+
 @register_converter(version=23)
 def _(engine: sql.engine.Engine) -> None:
-    convert_table_md(
-        engine,
-        table_md_updater=__update_table_md
-    )
+    convert_table_md(engine, table_md_updater=__update_table_md)
+
 
 def __update_table_md(table_md: dict, table_id: UUID) -> None:
     """update the index metadata to add indexed_col_tbl_id column if it is missing
@@ -32,4 +32,4 @@ def __update_table_md(table_md: dict, table_id: UUID) -> None:
             # assume that the indexed column is in the same table
             # and update the index metadata.
             _logger.info(f'Updating index metadata for table: {table_id} index: {idx_md["id"]}')
-            idx_md['indexed_col_tbl_id'] = str(table_id)    
+            idx_md['indexed_col_tbl_id'] = str(table_id)

pixeltable/metadata/converters/convert_24.py

@@ -15,11 +15,16 @@ def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], A
     from pixeltable import func
     from pixeltable.func.globals import resolve_symbol
 
-    if (isinstance(v, dict) and
-        '_classpath' in v and
-        v['_classpath'] in ['pixeltable.func.callable_function.CallableFunction',
-                            'pixeltable.func.aggregate_function.AggregateFunction',
-                            'pixeltable.func.expr_template_function.ExprTemplateFunction']):
+    if (
+        isinstance(v, dict)
+        and '_classpath' in v
+        and v['_classpath']
+        in [
+            'pixeltable.func.callable_function.CallableFunction',
+            'pixeltable.func.aggregate_function.AggregateFunction',
+            'pixeltable.func.expr_template_function.ExprTemplateFunction',
+        ]
+    ):
         if 'path' in v:
             assert 'signature' not in v
             f = resolve_symbol(__substitute_path(v['path']))
@@ -33,14 +38,8 @@ def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], A
         # and InlineDict back in convert_20, but not for FunctionCall.
         assert 'args' in v and isinstance(v['args'], list)
         assert 'kwargs' in v and isinstance(v['kwargs'], dict)
-        v['args'] = [
-            (None, arg) if idx == -1 else (idx, arg)
-            for idx, arg in v['args']
-        ]
-        v['kwargs'] = {
-            k: (None, arg) if idx == -1 else (idx, arg)
-            for k, (idx, arg) in v['kwargs'].items()
-        }
+        v['args'] = [(None, arg) if idx == -1 else (idx, arg) for idx, arg in v['args']]
+        v['kwargs'] = {k: (None, arg) if idx == -1 else (idx, arg) for k, (idx, arg) in v['kwargs'].items()}
         return k, v
 
     return None

pixeltable/metadata/converters/convert_26.py

@@ -0,0 +1,23 @@
+from typing import Any, Optional
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=26)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, substitution_fn=__substitute_md)
+
+
+def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], Any]]:
+    import pixeltable.type_system as ts
+    from pixeltable.exprs.literal import Literal
+
+    if k == 'limit_val' and v is not None:
+        assert isinstance(v, int)
+        newv = Literal(v, ts.IntType(nullable=False)).as_dict()
+        return k, newv
+
+    return None

pixeltable/metadata/converters/util.py

@@ -15,7 +15,7 @@ def convert_table_md(
     table_md_updater: Optional[Callable[[dict, UUID], None]] = None,
     column_md_updater: Optional[Callable[[dict], None]] = None,
     external_store_md_updater: Optional[Callable[[dict], None]] = None,
-    substitution_fn: Optional[Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]] = None
+    substitution_fn: Optional[Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]] = None,
 ) -> None:
     """
     Converts schema.TableMd dicts based on the specified conversion functions.
@@ -66,8 +66,7 @@ def __update_external_store_md(table_md: dict, external_store_md_updater: Callab
 
 
 def __substitute_md_rec(
-    md: Any,
-    substitution_fn: Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]
+    md: Any, substitution_fn: Callable[[Optional[str], Any], Optional[tuple[Optional[str], Any]]]
 ) -> Any:
     if isinstance(md, dict):
         updated_dict: dict[str, Any] = {}
@@ -97,7 +96,7 @@ def __substitute_md_rec(
 def convert_table_schema_version_md(
     engine: sql.engine.Engine,
     table_schema_version_md_updater: Optional[Callable[[dict], None]] = None,
-    schema_column_updater: Optional[Callable[[dict], None]] = None
+    schema_column_updater: Optional[Callable[[dict], None]] = None,
 ) -> None:
     """
     Converts schema.TableSchemaVersionMd dicts based on the specified conversion functions.

pixeltable/metadata/notes.py

@@ -2,6 +2,7 @@
 # rather than as a comment, so that the existence of a description can be enforced by
 # the unit tests when new versions are added.
 VERSION_NOTES = {
+    27: 'Enable pxt.query parameterization of limit clauses',
     26: 'Rename clip_text and clip_image to clip',
     25: 'Functions with multiple signatures',
     24: 'Added TableMd/IndexMd.indexed_col_tbl_id',

pixeltable/metadata/schema.py

@@ -19,6 +19,7 @@ base_metadata = Base.metadata
 
 T = TypeVar('T')
 
+
 def md_from_dict(data_class_type: type[T], data: Any) -> T:
     """Re-instantiate a dataclass instance that contains nested dataclasses from a dict."""
     if dataclasses.is_dataclass(data_class_type):
@@ -56,6 +57,7 @@ def md_from_dict(data_class_type: type[T], data: Any) -> T:
 #   schema easier (the goal is not to have to rely on some schema migration framework; if that breaks for some user,
 #   it would be very difficult to patch up)
 
+
 @dataclasses.dataclass
 class SystemInfoMd:
     schema_version: int
@@ -63,6 +65,7 @@ class SystemInfoMd:
 
 class SystemInfo(Base):
     """A single-row table that contains system-wide metadata."""
+
     __tablename__ = 'systeminfo'
     dummy = sql.Column(Integer, primary_key=True, default=0, nullable=False)
     md = sql.Column(JSONB, nullable=False)  # SystemInfoMd
@@ -76,7 +79,9 @@ class DirMd:
 class Dir(Base):
     __tablename__ = 'dirs'
 
-    id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False)
+    id: orm.Mapped[uuid.UUID] = orm.mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False
+    )
     parent_id: orm.Mapped[uuid.UUID] = orm.mapped_column(UUID(as_uuid=True), ForeignKey('dirs.id'), nullable=True)
     md = sql.Column(JSONB, nullable=False)
 
@@ -89,7 +94,8 @@ class ColumnMd:
     - when a column was added/dropped, which is needed to GC unreachable storage columns
       (a column that was added after table snapshot n and dropped before table snapshot n+1 can be removed
       from the stored table).
-     """
+    """
+
     id: int
     schema_version_add: int
     schema_version_drop: Optional[int]
@@ -110,6 +116,7 @@ class IndexMd:
     """
     Metadata needed to instantiate an EmbeddingIndex
     """
+
     id: int
     name: str
     indexed_col_tbl_id: str  # UUID of the table (as string) that contains column being indexed
@@ -172,6 +179,7 @@ class Table(Base):
     - views have a base, which is either a (live) table or a snapshot
     - views can have a filter predicate
     """
+
     __tablename__ = 'tables'
 
     MAX_VERSION = 9223372036854775807  # 2^63 - 1
@@ -200,6 +208,7 @@ class SchemaColumn:
     """
     Records the versioned metadata of a column.
     """
+
     pos: int
     name: str
 
@@ -213,6 +222,7 @@ class TableSchemaVersionMd:
     """
     Records all versioned table metadata.
     """
+
     schema_version: int
     preceding_schema_version: Optional[int]
     columns: dict[int, SchemaColumn]  # col_id -> SchemaColumn
@@ -250,6 +260,7 @@ class Function(Base):
     We store the Python version under which a Function was created (and the callable pickled) in order to warn
     against version mismatches.
     """
+
     __tablename__ = 'functions'
 
     id = sql.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, nullable=False)