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

pixeltable/ext/functions/yolox.py

@@ -43,7 +43,7 @@ def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0
         Add a computed column that applies the model `yolox_m` to an existing
         Pixeltable column `tbl.image` of the table `tbl`:
 
-        >>> tbl['detections'] = yolox(tbl.image, model_id='yolox_m', threshold=0.8)
+        >>> tbl.add_computed_column(detections=yolox(tbl.image, model_id='yolox_m', threshold=0.8))
     """
     import torch
     from yolox.utils import postprocess  # type: ignore[import-untyped]
@@ -55,9 +55,7 @@ def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0
     with torch.no_grad():
         output_tensor = model(batch_tensor)
 
-    outputs = postprocess(
-        output_tensor, 80, threshold, exp.nmsthre, class_agnostic=False
-    )
+    outputs = postprocess(output_tensor, 80, threshold, exp.nmsthre, class_agnostic=False)
 
     results: list[dict] = []
     for image in images:
@@ -65,11 +63,13 @@ def yolox(images: Batch[PIL.Image.Image], *, model_id: str, threshold: float = 0
         if outputs[0] is None:
             results.append({'bboxes': [], 'scores': [], 'labels': []})
         else:
-            results.append({
-                'bboxes': [(output[:4] / ratio).tolist() for output in outputs[0]],
-                'scores': [output[4].item() * output[5].item() for output in outputs[0]],
-                'labels': [int(output[6]) for output in outputs[0]]
-            })
+            results.append(
+                {
+                    'bboxes': [(output[:4] / ratio).tolist() for output in outputs[0]],
+                    'scores': [output[4].item() * output[5].item() for output in outputs[0]],
+                    'labels': [int(output[6]) for output in outputs[0]],
+                }
+            )
     return results
 
 
@@ -90,8 +90,8 @@ def yolo_to_coco(detections: dict) -> list:
         Add a computed column that converts the output `tbl.detections` to COCO format, where `tbl.image`
         is the image for which detections were computed:
 
-        >>> tbl['detections'] = yolox(tbl.image, model_id='yolox_m', threshold=0.8)
-        ... tbl['detections_coco'] = yolo_to_coco(tbl.detections)
+        >>> tbl.add_computed_column(detections=yolox(tbl.image, model_id='yolox_m', threshold=0.8))
+        ... tbl.add_computed_column(detections_coco=yolo_to_coco(tbl.detections))
     """
     bboxes, labels = detections['bboxes'], detections['labels']
     num_annotations = len(detections['bboxes'])

pixeltable/func/aggregate_function.py

@@ -31,6 +31,7 @@ class AggregateFunction(Function):
     allows_std_agg: if True, the aggregate function can be used as a standard aggregate function w/o a window
     allows_window: if True, the aggregate function can be used with a window
     """
+
     ORDER_BY_PARAM = 'order_by'
     GROUP_BY_PARAM = 'group_by'
     RESERVED_PARAMS = {ORDER_BY_PARAM, GROUP_BY_PARAM}
@@ -45,7 +46,7 @@ class AggregateFunction(Function):
         self_path: str,
         requires_order_by: bool,
         allows_std_agg: bool,
-        allows_window: bool
+        allows_window: bool,
     ) -> None:
         if type_substitutions is None:
             type_substitutions = [None]  # single signature with no substitutions
@@ -80,8 +81,12 @@ class AggregateFunction(Function):
         inferred signature along with the list of init_param_names (for downstream error handling).
         """
         # infer type parameters; set return_type=InvalidType() because it has no meaning here
-        init_sig = Signature.create(py_fn=cls.__init__, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions)
-        update_sig = Signature.create(py_fn=cls.update, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions)
+        init_sig = Signature.create(
+            py_fn=cls.__init__, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions
+        )
+        update_sig = Signature.create(
+            py_fn=cls.update, return_type=ts.InvalidType(), is_cls_method=True, type_substitutions=type_substitutions
+        )
         value_sig = Signature.create(py_fn=cls.value, is_cls_method=True, type_substitutions=type_substitutions)
 
         init_types = [p.col_type for p in init_sig.parameters.values()]
@@ -110,8 +115,7 @@ class AggregateFunction(Function):
         duplicate_params = set(p.name for p in init_params) & set(p.name for p in update_params)
         if len(duplicate_params) > 0:
             raise excs.Error(
-                f'__init__() and update() cannot have parameters with the same name: '
-                f'{", ".join(duplicate_params)}'
+                f'__init__() and update() cannot have parameters with the same name: {", ".join(duplicate_params)}'
             )
         params = update_params + init_params  # init_params are keyword-only and come last
         init_param_names = [p.name for p in init_params]
@@ -166,7 +170,8 @@ class AggregateFunction(Function):
                 )
             if not self.allows_window:
                 raise excs.Error(
-                    f'{self.display_name}(): order_by invalid with an aggregate function that does not allow windows')
+                    f'{self.display_name}(): order_by invalid with an aggregate function that does not allow windows'
+                )
             order_by_clause = kwargs.pop(self.ORDER_BY_PARAM)
         elif self.requires_order_by:
             # the first argument is the order-by expr
@@ -185,7 +190,8 @@ class AggregateFunction(Function):
         if self.GROUP_BY_PARAM in kwargs:
             if not self.allows_window:
                 raise excs.Error(
-                    f'{self.display_name}(): group_by invalid with an aggregate function that does not allow windows')
+                    f'{self.display_name}(): group_by invalid with an aggregate function that does not allow windows'
+                )
             group_by_clause = kwargs.pop(self.GROUP_BY_PARAM)
 
         resolved_fn, bound_args = self._bind_to_matching_signature(args, kwargs)
@@ -195,7 +201,7 @@ class AggregateFunction(Function):
             bound_args,
             return_type,
             order_by_clause=[order_by_clause] if order_by_clause is not None else [],
-            group_by_clause=[group_by_clause] if group_by_clause is not None else []
+            group_by_clause=[group_by_clause] if group_by_clause is not None else [],
         )
 
     def validate_call(self, bound_args: dict[str, Any]) -> None:
@@ -228,7 +234,7 @@ def uda(
     requires_order_by: bool = False,
     allows_std_agg: bool = True,
     allows_window: bool = False,
-    type_substitutions: Optional[Sequence[dict]] = None
+    type_substitutions: Optional[Sequence[dict]] = None,
 ) -> Callable[[type[Aggregator]], AggregateFunction]: ...
 
 
@@ -249,13 +255,11 @@ def uda(*args, **kwargs):
     - allows_window: if True, the function can be used with a window
     """
     if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
-
         # Decorator invoked without parentheses: @pxt.uda
         # Simply call make_aggregator with defaults.
         return make_aggregator(cls=args[0])
 
     else:
-
         # Decorator schema invoked with parentheses: @pxt.uda(**kwargs)
         # Create a decorator for the specified schema.
         requires_order_by = kwargs.pop('requires_order_by', False)
@@ -273,7 +277,7 @@ def uda(*args, **kwargs):
                 requires_order_by=requires_order_by,
                 allows_std_agg=allows_std_agg,
                 allows_window=allows_window,
-                type_substitutions=type_substitutions
+                type_substitutions=type_substitutions,
             )
 
         return decorator
@@ -284,7 +288,7 @@ def make_aggregator(
     requires_order_by: bool = False,
     allows_std_agg: bool = True,
     allows_window: bool = False,
-    type_substitutions: Optional[Sequence[dict]] = None
+    type_substitutions: Optional[Sequence[dict]] = None,
 ) -> AggregateFunction:
     class_path = f'{cls.__module__}.{cls.__qualname__}'
     instance = AggregateFunction(cls, type_substitutions, class_path, requires_order_by, allows_std_agg, allows_window)

pixeltable/func/callable_function.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
+import asyncio
 import inspect
 from typing import Any, Callable, Optional, Sequence
 from uuid import UUID
-import asyncio
 
 import cloudpickle  # type: ignore[import-untyped]
 
@@ -20,6 +20,7 @@ class CallableFunction(Function):
     - references to lambdas and functions defined in notebooks, which are pickled and serialized to the store
     - functions that are defined in modules are serialized via the default mechanism
     """
+
     py_fns: list[Callable]
     self_name: Optional[str]
     batch_size: Optional[int]
@@ -32,7 +33,7 @@ class CallableFunction(Function):
         self_name: Optional[str] = None,
         batch_size: Optional[int] = None,
         is_method: bool = False,
-        is_property: bool = False
+        is_property: bool = False,
     ):
         assert len(signatures) > 0
         assert len(signatures) == len(py_fns)
@@ -165,6 +166,7 @@ class CallableFunction(Function):
             # this is not a module function
             assert not self.is_method and not self.is_property
             from .function_registry import FunctionRegistry
+
             id = FunctionRegistry.get().create_stored_function(self)
             return {'id': id.hex}
         return super()._as_dict()
@@ -173,15 +175,13 @@ class CallableFunction(Function):
     def _from_dict(cls, d: dict) -> Function:
         if 'id' in d:
             from .function_registry import FunctionRegistry
+
             return FunctionRegistry.get().get_stored_function(UUID(hex=d['id']))
         return super()._from_dict(d)
 
     def to_store(self) -> tuple[dict, bytes]:
         assert not self.is_polymorphic  # multi-signature UDFs not allowed for stored fns
-        md = {
-            'signature': self.signature.as_dict(),
-            'batch_size': self.batch_size,
-        }
+        md = {'signature': self.signature.as_dict(), 'batch_size': self.batch_size}
         return md, cloudpickle.dumps(self.py_fn)
 
     @classmethod

pixeltable/func/expr_template_function.py

@@ -14,9 +14,10 @@ class ExprTemplate:
     along with various precomputed metadata. (This is analogous to a `Callable`-`Signature` pair in a
     `CallableFunction`.)
     """
+
     expr: 'pixeltable.exprs.Expr'
     signature: Signature
-    param_exprs: list['pixeltable.exprs.Variable']
+    param_exprs: dict[str, 'pixeltable.exprs.Variable']
 
     def __init__(self, expr: 'pixeltable.exprs.Expr', signature: Signature):
         from pixeltable import exprs
@@ -24,17 +25,18 @@ class ExprTemplate:
         self.expr = expr
         self.signature = signature
 
-        self.param_exprs = list(set(expr.subexprs(expr_class=exprs.Variable)))
-        # make sure there are no duplicate names
-        assert len(self.param_exprs) == len(set(p.name for p in self.param_exprs))
-        self.param_exprs_by_name = {p.name: p for p in self.param_exprs}
+        self.param_exprs = {name: exprs.Variable(name, param.col_type) for name, param in signature.parameters.items()}
+
+        # validate that all variables in the expression are parameters
+        for var in expr.subexprs(expr_class=exprs.Variable):
+            assert var.name in self.param_exprs, f"Variable '{var.name}' in expression is not a parameter"
 
         # verify default values
         self.defaults: dict[str, exprs.Literal] = {}  # key: param name, value: default value converted to a Literal
         for param in self.signature.parameters.values():
             if param.default is inspect.Parameter.empty:
                 continue
-            param_expr = self.param_exprs_by_name[param.name]
+            param_expr = self.param_exprs[param.name]
             try:
                 literal_default = exprs.Literal(param.default, col_type=param_expr.col_type)
                 self.defaults[param.name] = literal_default
@@ -45,6 +47,7 @@ class ExprTemplate:
 
 class ExprTemplateFunction(Function):
     """A parameterized expression from which an executable Expr is created with a function call."""
+
     templates: list[ExprTemplate]
     self_name: str
 
@@ -70,11 +73,12 @@ class ExprTemplateFunction(Function):
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
         # apply defaults, otherwise we might have Parameters left over
         bound_args.update(
-            {param_name: default for param_name, default in template.defaults.items() if param_name not in bound_args})
+            {param_name: default for param_name, default in template.defaults.items() if param_name not in bound_args}
+        )
         result = template.expr.copy()
         arg_exprs: dict[exprs.Expr, exprs.Expr] = {}
         for param_name, arg in bound_args.items():
-            param_expr = template.param_exprs_by_name[param_name]
+            param_expr = template.param_exprs[param_name]
             if not isinstance(arg, exprs.Expr):
                 # TODO: use the available param_expr.col_type
                 arg_expr = exprs.Expr.from_object(arg)
@@ -125,17 +129,14 @@ class ExprTemplateFunction(Function):
             return super()._as_dict()
         assert not self.is_polymorphic
         assert len(self.templates) == 1
-        return {
-            'expr': self.template.expr.as_dict(),
-            'signature': self.signature.as_dict(),
-            'name': self.name,
-        }
+        return {'expr': self.template.expr.as_dict(), 'signature': self.signature.as_dict(), 'name': self.name}
 
     @classmethod
     def _from_dict(cls, d: dict) -> Function:
         if 'expr' not in d:
-             return super()._from_dict(d)
+            return super()._from_dict(d)
         assert 'signature' in d and 'name' in d
         import pixeltable.exprs as exprs
+
         template = ExprTemplate(exprs.Expr.from_dict(d['expr']), Signature.from_dict(d['signature']))
         return cls([template], name=d['name'])

pixeltable/func/function.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import importlib
 import inspect
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 from copy import copy
 from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, cast
 
@@ -12,6 +12,7 @@ from typing_extensions import Self
 import pixeltable as pxt
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
+
 from .globals import resolve_symbol
 from .signature import Signature
 
@@ -48,13 +49,12 @@ class Function(ABC):
     # of the parameters of the original function, with the same type.
     _resource_pool: Callable[..., Optional[str]]
 
-
     def __init__(
         self,
         signatures: list[Signature],
         self_path: Optional[str] = None,
         is_method: bool = False,
-        is_property: bool = False
+        is_property: bool = False,
     ):
         # Check that stored functions cannot be declared using `is_method` or `is_property`:
         assert not ((is_method or is_property) and self_path is None)
@@ -80,7 +80,7 @@ class Function(ABC):
             return '<anonymous>'
         ptf_prefix = 'pixeltable.functions.'
         if self.self_path.startswith(ptf_prefix):
-            return self.self_path[len(ptf_prefix):]
+            return self.self_path[len(ptf_prefix) :]
         return self.self_path
 
     @property
@@ -197,10 +197,13 @@ class Function(ABC):
         """Return the kwargs to pass to callable, given kwargs passed to this function"""
         bound_args = self.signature.py_signature.bind(**kwargs).arguments
         # add defaults to bound_args, if not already present
-        bound_args.update({
-            name: param.default
-            for name, param in self.signature.parameters.items() if name not in bound_args and param.has_default()
-        })
+        bound_args.update(
+            {
+                name: param.default
+                for name, param in self.signature.parameters.items()
+                if name not in bound_args and param.has_default()
+            }
+        )
         result: dict[str, Any] = {}
         sig = inspect.signature(callable)
         for param in sig.parameters.values():
@@ -233,7 +236,9 @@ class Function(ABC):
         for param in fn_sig.parameters.values():
             for self_sig in self.signatures:
                 if param.name not in self_sig.parameters:
-                    raise ValueError(f'`conditional_return_type` has parameter `{param.name}` that is not in a signature')
+                    raise ValueError(
+                        f'`conditional_return_type` has parameter `{param.name}` that is not in a signature'
+                    )
         self._conditional_return_type = fn
         return fn
 
@@ -279,9 +284,7 @@ class Function(ABC):
                 raise excs.Error(f'Expected type `{param.col_type}` for parameter `{k}`; got `{expr.col_type}`')
             bindings[k] = v  # Use the original value, not the Expr (The Expr is only for validation)
 
-        residual_params = [
-            p for p in self.signature.parameters.values() if p.name not in bindings
-        ]
+        residual_params = [p for p in self.signature.parameters.values() if p.name not in bindings]
 
         # Bind each remaining parameter to a like-named variable
         for param in residual_params:
@@ -346,10 +349,7 @@ class Function(ABC):
     def _as_dict(self) -> dict:
         """Default serialization: store the path to self (which includes the module path) and signature."""
         assert self.self_path is not None
-        return {
-            'path': self.self_path,
-            'signature': self.signature.as_dict(),
-        }
+        return {'path': self.self_path, 'signature': self.signature.as_dict()}
 
     @classmethod
     def from_dict(cls, d: dict) -> Function:

pixeltable/func/function_registry.py

@@ -18,11 +18,13 @@ from .function import Function
 
 _logger = logging.getLogger('pixeltable')
 
+
 class FunctionRegistry:
     """
     A central registry for all Functions. Handles interactions with the backing store.
     Function are loaded from the store on demand.
     """
+
     _instance: Optional[FunctionRegistry] = None
 
     @classmethod
@@ -151,14 +153,16 @@ class FunctionRegistry:
             return self.type_methods[base_type][name]
         return None
 
-    #def create_function(self, md: schema.FunctionMd, binary_obj: bytes, dir_id: Optional[UUID] = None) -> UUID:
+    # def create_function(self, md: schema.FunctionMd, binary_obj: bytes, dir_id: Optional[UUID] = None) -> UUID:
     def create_stored_function(self, pxt_fn: Function, dir_id: Optional[UUID] = None) -> UUID:
         fn_md, binary_obj = pxt_fn.to_store()
         md = schema.FunctionMd(name=pxt_fn.name, md=fn_md, py_version=sys.version, class_name=pxt_fn.__class__.__name__)
         with env.Env.get().engine.begin() as conn:
             res = conn.execute(
-                sql.insert(schema.Function.__table__)
-                    .values(dir_id=dir_id, md=dataclasses.asdict(md), binary_obj=binary_obj))
+                sql.insert(schema.Function.__table__).values(
+                    dir_id=dir_id, md=dataclasses.asdict(md), binary_obj=binary_obj
+                )
+            )
             id = res.inserted_primary_key[0]
             _logger.info(f'Created function {pxt_fn.name} (id {id}) in store')
             self.stored_fns_by_id[id] = pxt_fn
@@ -167,8 +171,9 @@ class FunctionRegistry:
     def get_stored_function(self, id: UUID) -> Function:
         if id in self.stored_fns_by_id:
             return self.stored_fns_by_id[id]
-        stmt = sql.select(schema.Function.md, schema.Function.binary_obj, schema.Function.dir_id)\
-            .where(schema.Function.id == id)
+        stmt = sql.select(schema.Function.md, schema.Function.binary_obj, schema.Function.dir_id).where(
+            schema.Function.id == id
+        )
         with env.Env.get().engine.begin() as conn:
             row = conn.execute(stmt).fetchone()
             if row is None:
@@ -238,7 +243,5 @@ class FunctionRegistry:
     def delete_function(self, id: UUID) -> None:
         assert id is not None
         with env.Env.get().engine.begin() as conn:
-            conn.execute(
-                sql.delete(schema.Function.__table__)
-                    .where(schema.Function.id == id))
+            conn.execute(sql.delete(schema.Function.__table__).where(schema.Function.id == id))
             _logger.info(f'Deleted function with id {id} from store')

pixeltable/func/globals.py

@@ -28,10 +28,12 @@ def validate_symbol_path(fn_path: str) -> None:
     fn_name = path_elems[-1]
     if any(el == '<locals>' for el in path_elems):
         raise excs.Error(
-            f'{fn_name}(): nested functions are not supported. Move the function to the module level or into a class.')
+            f'{fn_name}(): nested functions are not supported. Move the function to the module level or into a class.'
+        )
     if any(not el.isidentifier() for el in path_elems):
         raise excs.Error(
-            f'{fn_name}(): cannot resolve symbol path {fn_path}. Move the function to the module level or into a class.')
+            f'{fn_name}(): cannot resolve symbol path {fn_path}. Move the function to the module level or into a class.'
+        )
 
 
 def get_caller_module_path() -> str:

pixeltable/func/query_template_function.py

@@ -18,6 +18,7 @@ if TYPE_CHECKING:
 
 class QueryTemplateFunction(Function):
     """A parameterized query/DataFrame from which an executable DataFrame is created with a function call."""
+
     template_df: Optional['DataFrame']
     self_name: Optional[str]
     conn: Optional[sql.engine.Connection]
@@ -35,14 +36,14 @@ class QueryTemplateFunction(Function):
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in params]
         template_df = template_callable(*var_exprs)
         from pixeltable import DataFrame
+
         assert isinstance(template_df, DataFrame)
         # we take params and return json
         sig = Signature(return_type=ts.JsonType(), parameters=params)
         return QueryTemplateFunction(template_df, sig, path=path, name=name)
 
     def __init__(
-            self, template_df: Optional['DataFrame'], sig: Signature, path: Optional[str] = None,
-            name: Optional[str] = None,
+        self, template_df: Optional['DataFrame'], sig: Signature, path: Optional[str] = None, name: Optional[str] = None
     ):
         assert sig is not None
         super().__init__([sig], self_path=path)
@@ -74,11 +75,12 @@ class QueryTemplateFunction(Function):
         return True
 
     async def aexec(self, *args: Any, **kwargs: Any) -> Any:
-        #assert not self.is_polymorphic
+        # assert not self.is_polymorphic
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
         # apply defaults, otherwise we might have Parameters left over
         bound_args.update(
-            {param_name: default for param_name, default in self.defaults.items() if param_name not in bound_args})
+            {param_name: default for param_name, default in self.defaults.items() if param_name not in bound_args}
+        )
         bound_df = self.template_df.bind(bound_args)
         result = await bound_df._acollect(self.conn)
         return list(result)
@@ -97,30 +99,27 @@ class QueryTemplateFunction(Function):
     @classmethod
     def _from_dict(cls, d: dict) -> Function:
         from pixeltable.dataframe import DataFrame
+
         return cls(DataFrame.from_dict(d['df']), Signature.from_dict(d['signature']), name=d['name'])
 
 
 @overload
 def query(py_fn: Callable) -> QueryTemplateFunction: ...
 
+
 @overload
-def query(
-    *,
-    param_types: Optional[list[ts.ColumnType]] = None
-) -> Callable[[Callable], QueryTemplateFunction]: ...
+def query(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[Callable], QueryTemplateFunction]: ...
+
 
 def query(*args: Any, **kwargs: Any) -> Any:
-    def make_query_template(
-        py_fn: Callable, param_types: Optional[list[ts.ColumnType]]
-    ) -> QueryTemplateFunction:
+    def make_query_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> QueryTemplateFunction:
         if py_fn.__module__ != '__main__' and py_fn.__name__.isidentifier():
             # this is a named function in a module
             function_path = f'{py_fn.__module__}.{py_fn.__qualname__}'
         else:
             function_path = None
         query_name = py_fn.__name__
-        query_fn = QueryTemplateFunction.create(
-            py_fn, param_types=param_types, path=function_path, name=query_name)
+        query_fn = QueryTemplateFunction.create(py_fn, param_types=param_types, path=function_path, name=query_name)
         return query_fn
 
         # TODO: verify that the inferred return type matches that of the template

pixeltable/func/signature.py

@@ -63,7 +63,7 @@ class Parameter:
             col_type=ts.ColumnType.from_dict(d['col_type']) if d['col_type'] is not None else None,
             kind=getattr(inspect.Parameter, d['kind']),
             is_batched=d['is_batched'],
-            default=default
+            default=default,
         )
 
     def to_py_param(self) -> inspect.Parameter:
@@ -80,6 +80,7 @@ class Signature:
 
     - self.is_batched: return type is a Batch[...] type
     """
+
     SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
 
     def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
@@ -131,9 +132,12 @@ class Signature:
             if param_name not in other.parameters:
                 return False
             other_param = other.parameters[param_name]
-            if (param.kind != other_param.kind or
-                (param.col_type is None) != (other_param.col_type is None) or  # this can happen if they are varargs
-                param.col_type is not None and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)):
+            if (
+                param.kind != other_param.kind
+                or (param.col_type is None) != (other_param.col_type is None)  # this can happen if they are varargs
+                or param.col_type is not None
+                and not other_param.col_type.is_supertype_of(param.col_type, ignore_nullable=True)
+            ):
                 return False
 
         # Check (iii)
@@ -193,7 +197,7 @@ class Signature:
         py_params: Optional[list[inspect.Parameter]] = None,
         param_types: Optional[list[ts.ColumnType]] = None,
         type_substitutions: Optional[dict] = None,
-        is_cls_method: bool = False
+        is_cls_method: bool = False,
     ) -> list[Parameter]:
         assert (py_fn is None) != (py_params is None)
         if py_fn is not None:
@@ -229,8 +233,11 @@ class Signature:
                 if param_type is None:
                     raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name}')
 
-            parameters.append(Parameter(
-                param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=param.default))
+            parameters.append(
+                Parameter(
+                    param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=param.default
+                )
+            )
 
         return parameters
 
@@ -241,7 +248,7 @@ class Signature:
         param_types: Optional[list[ts.ColumnType]] = None,
         return_type: Optional[ts.ColumnType] = None,
         type_substitutions: Optional[dict] = None,
-        is_cls_method: bool = False
+        is_cls_method: bool = False,
     ) -> Signature:
         """Create a signature for the given Callable.
         Infer the parameter and return types, if none are specified.
@@ -250,7 +257,9 @@ class Signature:
         if type_substitutions is None:
             type_substitutions = {}
 
-        parameters = cls.create_parameters(py_fn=py_fn, param_types=param_types, is_cls_method=is_cls_method, type_substitutions=type_substitutions)
+        parameters = cls.create_parameters(
+            py_fn=py_fn, param_types=param_types, is_cls_method=is_cls_method, type_substitutions=type_substitutions
+        )
         sig = inspect.signature(py_fn)
         if return_type is None:
             py_type: Optional[type]