pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/metadata/__init__.py

@@ -1,53 +1,78 @@
 import dataclasses
 import importlib
+import logging
 import os
 import pkgutil
 from typing import Callable
 
 import sqlalchemy as sql
-import sqlalchemy.orm as orm
+from sqlalchemy import orm
+
+import pixeltable as pxt
+import pixeltable.exceptions as excs
+from pixeltable.utils.console_output import ConsoleLogger
 
 from .schema import SystemInfo, SystemInfoMd
 
+_console_logger = ConsoleLogger(logging.getLogger('pixeltable'))
+_logger = logging.getLogger('pixeltable')
+
 # current version of the metadata; this is incremented whenever the metadata schema changes
-VERSION = 23
+VERSION = 44
 
 
 def create_system_info(engine: sql.engine.Engine) -> None:
     """Create the system metadata record"""
     system_md = SystemInfoMd(schema_version=VERSION)
     record = SystemInfo(md=dataclasses.asdict(system_md))
+    _logger.debug(f'Creating pixeltable system info record {record}')
     with orm.Session(engine, future=True) as session:
-        session.add(record)
-        session.flush()
-        session.commit()
+        # Write system metadata only once for idempotency
+        if session.query(SystemInfo).count() == 0:
+            session.add(record)
+            session.flush()
+            session.commit()
+
 
 # conversion functions for upgrading the metadata schema from one version to the following
 # key: old schema version
 converter_cbs: dict[int, Callable[[sql.engine.Engine], None]] = {}
 
+
 def register_converter(version: int) -> Callable[[Callable[[sql.engine.Engine], None]], None]:
     def decorator(fn: Callable[[sql.engine.Engine], None]) -> None:
-        global converter_cbs
+        assert version not in converter_cbs
         converter_cbs[version] = fn
+
     return decorator
 
+
 # load all converter modules
 for _, modname, _ in pkgutil.iter_modules([os.path.dirname(__file__) + '/converters']):
     importlib.import_module('pixeltable.metadata.converters.' + modname)
 
+
 def upgrade_md(engine: sql.engine.Engine) -> None:
     """Upgrade the metadata schema to the current version"""
     with orm.Session(engine) as session:
-        system_info = session.query(SystemInfo).one().md
+        # Get exclusive lock on SystemInfo row
+        system_info = session.query(SystemInfo).with_for_update().one().md
         md_version = system_info['schema_version']
         assert isinstance(md_version, int)
+        _logger.info(f'Current database version: {md_version}, installed version: {VERSION}')
+        if md_version > VERSION:
+            raise excs.Error(
+                'This Pixeltable database was created with a newer Pixeltable version '
+                f'than the one currently installed ({pxt.__version__}).\n'
+                'Please update to the latest Pixeltable version by running: pip install --upgrade pixeltable'
+            )
         if md_version == VERSION:
             return
         while md_version < VERSION:
             if md_version not in converter_cbs:
                 raise RuntimeError(f'No metadata converter for version {md_version}')
-            print(f'Converting metadata from version {md_version} to {md_version + 1}')
+            # We can't use the console logger in Env, because Env might not have been initialized yet.
+            _console_logger.info(f'Converting metadata from version {md_version} to {md_version + 1}')
             converter_cbs[md_version](engine)
             md_version += 1
         # update system info

pixeltable/metadata/converters/convert_10.py

@@ -1,16 +1,15 @@
 import sqlalchemy as sql
 
-from pixeltable.metadata.schema import Table, TableSchemaVersion
 from pixeltable.metadata import register_converter
+from pixeltable.metadata.schema import Table, TableSchemaVersion
 
 
 @register_converter(version=10)
 def _(engine: sql.engine.Engine) -> None:
-    default_table_attrs = {"comment": None, "num_retained_versions": 10}
+    default_table_attrs = {'comment': None, 'num_retained_versions': 10}
     with engine.begin() as conn:
         # Because `parameters` wasn't actually used for anything,
         # we can simply delete it without any data loss.
         conn.execute(sql.update(Table).values(md=Table.md - 'parameters'))
         # Add `table_attrs` to all instances of tableschemaversions.md.
         conn.execute(sql.update(TableSchemaVersion).values(md=TableSchemaVersion.md.concat(default_table_attrs)))
-    return

pixeltable/metadata/converters/convert_13.py

@@ -12,9 +12,9 @@ _logger = logging.getLogger('pixeltable')
 @register_converter(version=13)
 def _(engine: sql.engine.Engine) -> None:
     with engine.begin() as conn:
-        for row in conn.execute(sql.select(Table)):
+        for row in conn.execute(sql.select(Table.id, Table.md)):
             id = row[0]
-            md = row[2]
+            md = row[1]
             updated_md = __update_md(md)
             if updated_md != md:
                 _logger.info(f'Updating schema for table: {id}')

pixeltable/metadata/converters/convert_15.py

@@ -1,4 +1,3 @@
-
 import inspect
 import logging
 from typing import Any
@@ -6,8 +5,6 @@ from typing import Any
 import cloudpickle  # type: ignore[import-untyped]
 import sqlalchemy as sql
 
-import pixeltable.func as func
-import pixeltable.type_system as ts
 from pixeltable.metadata import register_converter
 from pixeltable.metadata.schema import Function
 
@@ -18,7 +15,7 @@ _logger = logging.getLogger('pixeltable')
 def _(engine: sql.engine.Engine) -> None:
     with engine.begin() as conn:
         for row in conn.execute(sql.select(Function)):
-            id, dir_id, md, binary_obj = row
+            id, _, md, binary_obj = row
             md['md'] = __update_md(md['md'], binary_obj)
             _logger.info(f'Updating function: {id}')
             conn.execute(sql.update(Function).where(Function.id == id).values(md=md))
@@ -28,17 +25,24 @@ def __update_md(orig_d: dict, binary_obj: bytes) -> Any:
     # construct dict produced by CallableFunction.to_store()
     py_fn = cloudpickle.loads(binary_obj)
     py_params = inspect.signature(py_fn).parameters
-    return_type = ts.ColumnType.from_dict(orig_d['return_type'])
-    params: list[func.Parameter] = []
+    return_type = orig_d['return_type']
+    params: list[dict] = []
     for name, col_type_dict, kind_int, is_batched in orig_d['parameters']:
-        col_type = ts.ColumnType.from_dict(col_type_dict) if col_type_dict is not None else None
         default = py_params[name].default
-        kind = inspect._ParameterKind(kind_int)  # is there a way to avoid referencing a private type?
-        params.append(func.Parameter(name=name, col_type=col_type, kind=kind, default=default, is_batched=is_batched))
+        kind = inspect._ParameterKind(kind_int)
+        params.append(
+            {
+                'name': name,
+                'col_type': col_type_dict,
+                'kind': str(kind),
+                'is_batched': is_batched,
+                'has_default': default is not inspect.Parameter.empty,
+                'default': None if default is inspect.Parameter.empty else default,
+            }
+        )
     is_batched = 'batch_size' in orig_d
-    sig = func.Signature(return_type, params, is_batched=is_batched)
     d = {
-        'signature': sig.as_dict(),
+        'signature': {'return_type': return_type, 'parameters': params, 'is_batched': is_batched},
         'batch_size': orig_d['batch_size'] if is_batched else None,
     }
     return d

pixeltable/metadata/converters/convert_16.py

@@ -1,3 +1,5 @@
+from uuid import UUID
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
@@ -6,13 +8,10 @@ from pixeltable.metadata.converters.util import convert_table_md
 
 @register_converter(version=16)
 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) -> None:
+def __update_table_md(table_md: dict, table_id: UUID) -> None:
     # External stores are not migratable; just drop them
     del table_md['remotes']
     table_md['external_stores'] = {}

pixeltable/metadata/converters/convert_17.py

@@ -1,3 +1,5 @@
+from uuid import UUID
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
@@ -6,13 +8,10 @@ from pixeltable.metadata.converters.util import convert_table_md
 
 @register_converter(version=17)
 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) -> None:
+def __update_table_md(table_md: dict, table_id: UUID) -> None:
     # key changes in IndexMd.init_args: img_embed -> image_embed, txt_embed -> string_embed
     if len(table_md['index_md']) == 0:
         return

pixeltable/metadata/converters/convert_18.py

@@ -1,4 +1,5 @@
-from typing import Any, Optional
+from typing import Any
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
@@ -7,13 +8,10 @@ from pixeltable.metadata.converters.util import convert_table_md
 
 @register_converter(version=18)
 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]]:
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
     # Migrate a few changed function names
     if k == 'path' and v == 'pixeltable.functions.string.str_format':
         return 'path', 'pixeltable.functions.string.format'

pixeltable/metadata/converters/convert_19.py

@@ -1,9 +1,9 @@
 import datetime
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
-import pixeltable as pxt
+import pixeltable.type_system as ts
 from pixeltable.metadata import register_converter, schema
 from pixeltable.metadata.converters.util import convert_table_md
 
@@ -22,22 +22,19 @@ 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]]:
+def __update_timestamp_literals(k: Any, v: Any) -> tuple[Any, Any] | None:
     if isinstance(v, dict) and 'val_t' in v:
         # It's a literal with an explicit 'val_t' field. In version 19 this can only mean a
         # timestamp literal, which (in version 19) is stored in the DB as a naive datetime.
         # We convert it to an aware datetime, stored in UTC.
         assert v['_classname'] == 'Literal'
-        assert v['val_t'] == pxt.ColumnType.Type.TIMESTAMP.name
+        assert v['val_t'] == ts.ColumnType.Type.TIMESTAMP.name
         assert isinstance(v['val'], str)
         dt = datetime.datetime.fromisoformat(v['val'])
         assert dt.tzinfo is None  # In version 19 all timestamps are naive

pixeltable/metadata/converters/convert_20.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import sqlalchemy as sql
 
@@ -8,13 +8,10 @@ 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]]:
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
     if isinstance(v, dict) and '_classname' in v:
         # The way InlineArray is represented changed in v20. Previously, literal values were stored
         # directly in the Inline expr; now we store them in Literal sub-exprs. This converter

pixeltable/metadata/converters/convert_21.py

@@ -1,8 +1,9 @@
-from typing import Any, Optional
+from typing import Any
+
 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:
@@ -26,7 +24,7 @@ def __update_schema_column(schema_column: dict) -> None:
     schema_column['media_validation'] = None
 
 
-def __substitute_md(k: Optional[str], v: Any) -> Optional[tuple[Optional[str], Any]]:
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
     if isinstance(v, dict) and '_classname' in v and v['_classname'] == 'ColumnRef':
         if 'perform_validation' not in v:
             v['perform_validation'] = False

pixeltable/metadata/converters/convert_22.py

@@ -1,4 +1,5 @@
-from typing import Any, Optional
+from typing import Any
+
 import sqlalchemy as sql
 
 from pixeltable.metadata import register_converter
@@ -10,7 +11,7 @@ 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]]:
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
     if isinstance(v, dict) and '_classname' in v and v['_classname'] == 'DataFrame':
         v['from_clause'] = {'tbls': [v['tbl']], 'join_clauses': []}
         return k, v

pixeltable/metadata/converters/convert_23.py

@@ -0,0 +1,33 @@
+import logging
+from uuid import UUID
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+_logger = logging.getLogger('pixeltable')
+
+
+@register_converter(version=23)
+def _(engine: sql.engine.Engine) -> None:
+    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
+
+    Args:
+        table_md (dict): copy of the original table metadata. this gets updated in place.
+        table_id (UUID): the table id
+
+    """
+    if len(table_md['index_md']) == 0:
+        return
+    for idx_md in table_md['index_md'].values():
+        if 'indexed_col_tbl_id' not in idx_md:
+            # index metadata is missing indexed_col_tbl_id
+            # 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)

pixeltable/metadata/converters/convert_24.py

@@ -0,0 +1,55 @@
+from typing import Any
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=24)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, substitution_fn=__substitute_md)
+
+
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
+    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 'path' in v:
+            assert 'signature' not in v
+            f = resolve_symbol(__substitute_path(v['path']))
+            assert isinstance(f, func.Function)
+            v['signature'] = f.signatures[0].as_dict()
+        return k, v
+
+    if isinstance(v, dict) and '_classname' in v and v['_classname'] == 'FunctionCall':
+        # Correct an older serialization mechanism where Expr elements of FunctionCall args and
+        # kwargs were indicated with idx == -1 rather than None. This was fixed for InlineList
+        # 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()}
+        return k, v
+
+    return None
+
+
+def __substitute_path(path: str) -> str:
+    # Starting with version 25, function signatures are preserved in metadata. To migrate from older
+    # versions, it's necessary to resolve the function symbol to get the signature. The following
+    # adjustment is necessary for function names that are stored in db artifacts of version < 25, but
+    # have changed in some version > 25.
+    if path in ('pixeltable.functions.huggingface.clip_text', 'pixeltable.functions.huggingface.clip_image'):
+        return 'pixeltable.functions.huggingface.clip'
+    return path

pixeltable/metadata/converters/convert_25.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=25)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, substitution_fn=__substitute_md)
+
+
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
+    if k == 'path' and (
+        v in ('pixeltable.functions.huggingface.clip_text', 'pixeltable.functions.huggingface.clip_image')
+    ):
+        return 'path', 'pixeltable.functions.huggingface.clip'
+    return None

pixeltable/metadata/converters/convert_26.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+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: str | None, v: Any) -> tuple[str | None, Any] | None:
+    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/convert_27.py

@@ -0,0 +1,29 @@
+import logging
+from uuid import UUID
+
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+_logger = logging.getLogger('pixeltable')
+
+
+@register_converter(version=27)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, table_md_updater=__update_table_md)
+
+
+def __update_table_md(table_md: dict, table_id: UUID) -> None:
+    """Update the view metadata to add the include_base_columns boolean if it is missing
+
+    Args:
+        table_md (dict): copy of the original table metadata. this gets updated in place.
+        table_id (UUID): the table id
+
+    """
+    if table_md['view_md'] is None:
+        return
+    if 'include_base_columns' not in table_md['view_md']:
+        table_md['view_md']['include_base_columns'] = True
+        _logger.info(f'Updating view metadata for table: {table_id}')

pixeltable/metadata/converters/convert_28.py

@@ -0,0 +1,13 @@
+import sqlalchemy as sql
+
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.schema import Dir, Table, TableSchemaVersion, TableVersion
+
+
+@register_converter(version=28)
+def _(engine: sql.engine.Engine) -> None:
+    with engine.begin() as conn:
+        conn.execute(sql.update(Dir).values(md=Dir.md.concat({'user': None, 'additional_md': {}})))
+        conn.execute(sql.update(Table).values(md=Table.md.concat({'user': None, 'additional_md': {}})))
+        conn.execute(sql.update(TableVersion).values(md=TableVersion.md.concat({'additional_md': {}})))
+        conn.execute(sql.update(TableSchemaVersion).values(md=TableSchemaVersion.md.concat({'additional_md': {}})))

pixeltable/metadata/converters/convert_29.py

@@ -0,0 +1,110 @@
+from typing import Any
+
+import sqlalchemy as sql
+
+from pixeltable import exprs
+from pixeltable.metadata import register_converter
+from pixeltable.metadata.converters.util import convert_table_md
+
+
+@register_converter(version=29)
+def _(engine: sql.engine.Engine) -> None:
+    convert_table_md(engine, substitution_fn=__substitute_md)
+
+
+def __substitute_md(k: str | None, v: Any) -> tuple[str | None, Any] | None:
+    # Defaults are now stored as literals in signatures
+    if k == 'parameters':
+        for param in v:
+            assert isinstance(param, dict)
+            has_default = param.get('has_default') or (param.get('default') is not None)
+            if 'has_default' in param:
+                del param['has_default']
+            literal = exprs.Expr.from_object(param['default']) if has_default else None
+            assert literal is None or isinstance(literal, exprs.Literal)
+            param['default'] = None if literal is None else literal.as_dict()
+        return k, v
+
+    # Method of organizing argument expressions has changed
+    if isinstance(v, dict) and v.get('_classname') == 'FunctionCall':
+        args = v['args']
+        kwargs = v['kwargs']
+        components = v['components']
+        group_by_start_idx = v['group_by_start_idx']
+        group_by_stop_idx = v['group_by_stop_idx']
+        order_by_start_idx = v['order_by_start_idx']
+
+        new_args = []
+        for arg in args:
+            if arg[0] is not None:
+                assert isinstance(arg[0], int)
+                new_args.append(components[arg[0]])
+            else:
+                literal = exprs.Expr.from_object(arg[1])
+                new_args.append(literal.as_dict())
+
+        new_kwargs = {}
+        for name, kwarg in kwargs.items():
+            if kwarg[0] is not None:
+                assert isinstance(kwarg[0], int)
+                new_kwargs[name] = components[kwarg[0]]
+            else:
+                literal = exprs.Expr.from_object(kwarg[1])
+                new_kwargs[name] = literal.as_dict()
+
+        # We need to expand ("unroll") any var-args or var-kwargs.
+
+        new_args_len = len(new_args)
+        rolled_args: dict | None = None
+        rolled_kwargs: dict | None = None
+
+        if 'signature' in v['fn']:
+            # If it's a pickled function, there's no signature, so we're out of luck; varargs in a pickled function
+            # is an edge case that won't migrate properly.
+            parameters: list[dict] = v['fn']['signature']['parameters']
+            for i, param in enumerate(parameters):
+                if param['kind'] == 'VAR_POSITIONAL' and new_args_len > i:
+                    # For peculiar historical reasons, variable kwargs might show up in args. Thus variable
+                    # positional args is not necessarily the last element of args; it might be the second-to-last.
+                    assert new_args_len <= i + 2, new_args
+                    rolled_args = new_args[i]
+                    new_args = new_args[:i] + new_args[i + 1 :]
+                if param['kind'] == 'VAR_KEYWORD':
+                    # As noted above, variable kwargs might show up either in args or in kwargs. If it's in args, it
+                    # is necessarily the last element.
+                    if new_args_len > i:
+                        assert new_args_len <= i + 1, new_args
+                        rolled_kwargs = new_args.pop()
+                    if param['name'] in kwargs:
+                        assert rolled_kwargs is None
+                        rolled_kwargs = kwargs.pop(param['name'])
+
+        if rolled_args is not None:
+            assert rolled_args['_classname'] in ('InlineArray', 'InlineList')
+            new_args.extend(rolled_args['components'])
+        if rolled_kwargs is not None:
+            assert rolled_kwargs['_classname'] == 'InlineDict'
+            new_kwargs.update(zip(rolled_kwargs['keys'], rolled_kwargs['components']))
+
+        group_by_exprs = [components[i] for i in range(group_by_start_idx, group_by_stop_idx)]
+        order_by_exprs = [components[i] for i in range(order_by_start_idx, len(components))]
+
+        new_components = [*new_args, *new_kwargs.values(), *group_by_exprs, *order_by_exprs]
+
+        newv = {
+            'fn': v['fn'],
+            'arg_idxs': list(range(len(new_args))),
+            'kwarg_idxs': {name: i + len(new_args) for i, name in enumerate(new_kwargs.keys())},
+            'group_by_start_idx': len(new_args) + len(new_kwargs),
+            'group_by_stop_idx': len(new_args) + len(new_kwargs) + len(group_by_exprs),
+            'order_by_start_idx': len(new_args) + len(new_kwargs) + len(group_by_exprs),
+            'is_method_call': False,
+            '_classname': 'FunctionCall',
+            'components': new_components,
+        }
+        if 'return_type' in v:
+            newv['return_type'] = v['return_type']
+
+        return k, newv
+
+    return None