pixeltable 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

pixeltable/func/expr_template_function.py

@@ -1,8 +1,6 @@
-import inspect
 from typing import Any, Optional, Sequence
 
-import pixeltable
-import pixeltable.exceptions as excs
+from pixeltable import exceptions as excs, exprs
 
 from .function import Function
 from .signature import Signature
@@ -15,13 +13,11 @@ class ExprTemplate:
     `CallableFunction`.)
     """
 
-    expr: 'pixeltable.exprs.Expr'
+    expr: 'exprs.Expr'
     signature: Signature
-    param_exprs: dict[str, 'pixeltable.exprs.Variable']
-
-    def __init__(self, expr: 'pixeltable.exprs.Expr', signature: Signature):
-        from pixeltable import exprs
+    param_exprs: dict[str, 'exprs.Variable']
 
+    def __init__(self, expr: 'exprs.Expr', signature: Signature):
         self.expr = expr
         self.signature = signature
 
@@ -59,9 +55,7 @@ class ExprTemplateFunction(Function):
         assert not self.is_polymorphic
         return self.templates[0]
 
-    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'pixeltable.exprs.Expr':
-        from pixeltable import exprs
-
+    def instantiate(self, args: Sequence[Any], kwargs: dict[str, Any]) -> 'exprs.Expr':
         assert not self.is_polymorphic
         template = self.template
         bound_args = self.signature.py_signature.bind(*args, **kwargs).arguments
@@ -86,14 +80,12 @@ class ExprTemplateFunction(Function):
         return result
 
     def _docstring(self) -> Optional[str]:
-        from pixeltable import exprs
-
         if isinstance(self.templates[0].expr, exprs.FunctionCall):
             return self.templates[0].expr.fn._docstring()
         return None
 
     def exec(self, args: Sequence[Any], kwargs: dict[str, Any]) -> Any:
-        from pixeltable import exec, exprs
+        from pixeltable import exec
 
         assert not self.is_polymorphic
         expr = self.instantiate(args, kwargs)
@@ -130,7 +122,5 @@ class ExprTemplateFunction(Function):
         if 'expr' not in 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

@@ -246,7 +246,7 @@ class Function(ABC):
         # `None` when any of its non-nullable inputs are `None`.
         for arg_name, arg in bound_args.items():
             param = self.signature.parameters[arg_name]
-            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 continue
             if arg.col_type.nullable and not param.col_type.nullable:
                 return_type = return_type.copy(nullable=True)
@@ -304,13 +304,12 @@ class Function(ABC):
                     callable_args[param.name] = arg
                 else:
                     return None
-            else:
+            elif isinstance(arg, exprs.Literal):
                 # The callable is expecting `param.name` to be a constant Python value. Unpack a Literal if we find
                 # one; otherwise return None.
-                if isinstance(arg, exprs.Literal):
-                    callable_args[param.name] = arg.val
-                else:
-                    return None
+                callable_args[param.name] = arg.val
+            else:
+                return None
 
         return callable_args
 
@@ -386,10 +385,10 @@ class Function(ABC):
             else:
                 var = exprs.Variable(name, param.col_type)
                 bindings[name] = var
-                if args_ok and param.kind in (
+                if args_ok and param.kind in {
                     inspect.Parameter.POSITIONAL_ONLY,
                     inspect.Parameter.POSITIONAL_OR_KEYWORD,
-                ):
+                }:
                     template_args.append(var)
                 else:
                     template_kwargs[name] = var
@@ -436,6 +435,9 @@ class Function(ABC):
             return False
         return self.self_path == other.self_path
 
+    def __hash__(self) -> int:
+        return hash(self.self_path)
+
     def source(self) -> None:
         """Print source code"""
         print('source not available')

pixeltable/func/function_registry.py

@@ -9,9 +9,7 @@ from uuid import UUID
 
 import sqlalchemy as sql
 
-import pixeltable.env as env
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
+from pixeltable import env, exceptions as excs, type_system as ts
 from pixeltable.metadata import schema
 
 from .function import Function

pixeltable/func/query_template_function.py

@@ -1,13 +1,9 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Any, Callable, Optional, Sequence, overload
+from typing import TYPE_CHECKING, Any, Callable, Optional, overload
 
-import sqlalchemy as sql
-
-import pixeltable.exceptions as excs
-import pixeltable.type_system as ts
-from pixeltable import exprs
+from pixeltable import exprs, type_system as ts
 
 from .function import Function
 from .signature import Signature
@@ -21,8 +17,6 @@ class QueryTemplateFunction(Function):
 
     template_df: Optional['DataFrame']
     self_name: Optional[str]
-    # conn: Optional[sql.engine.Connection]
-    defaults: dict[str, exprs.Literal]
 
     @classmethod
     def create(
@@ -50,20 +44,6 @@ class QueryTemplateFunction(Function):
         self.self_name = name
         self.template_df = template_df
 
-        # if we're running as part of an ongoing update operation, we need to use the same connection, otherwise
-        # we end up with a deadlock
-        # TODO: figure out a more general way to make execution state available
-        # self.conn = None
-
-        # convert defaults to Literals
-        self.defaults = {}  # key: param name, value: default value converted to a Literal
-        param_types = self.template_df.parameters()
-        for param in [p for p in sig.parameters.values() if p.has_default()]:
-            assert param.name in param_types
-            param_type = param_types[param.name]
-            literal_default = exprs.Literal(param.default, col_type=param_type)
-            self.defaults[param.name] = literal_default
-
     def _update_as_overload_resolution(self, signature_idx: int) -> None:
         pass  # only one signature supported for QueryTemplateFunction
 
@@ -76,7 +56,11 @@ class QueryTemplateFunction(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 self.defaults.items() if param_name not in bound_args}
+            {
+                param.name: param.default
+                for param in self.signature.parameters.values()
+                if param.has_default() and param.name not in bound_args
+            }
         )
         bound_df = self.template_df.bind(bound_args)
         result = await bound_df._acollect()
@@ -91,7 +75,7 @@ class QueryTemplateFunction(Function):
         return self.self_name
 
     def _as_dict(self) -> dict:
-        return {'name': self.name, 'signature': self.signatures[0].as_dict(), 'df': self.template_df.as_dict()}
+        return {'name': self.name, 'signature': self.signature.as_dict(), 'df': self.template_df.as_dict()}
 
     @classmethod
     def _from_dict(cls, d: dict) -> Function:

pixeltable/func/signature.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import dataclasses
 import inspect
-import json
 import logging
 import typing
-from typing import TYPE_CHECKING, Any, Callable, Optional
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Optional
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
@@ -69,6 +68,9 @@ class Parameter:
         py_default = self.default.val if self.default is not None else inspect.Parameter.empty
         return inspect.Parameter(self.name, self.kind, default=py_default)
 
+    def __hash__(self) -> int:
+        return hash((self.name, self.col_type, self.kind, self.default, self.is_batched))
+
 
 T = typing.TypeVar('T')
 Batch = typing.Annotated[list[T], 'pxt-batch']
@@ -81,7 +83,7 @@ class Signature:
     - self.is_batched: return type is a Batch[...] type
     """
 
-    SPECIAL_PARAM_NAMES = ['group_by', 'order_by']
+    SPECIAL_PARAM_NAMES: ClassVar[list[str]] = ['group_by', 'order_by']
 
     def __init__(self, return_type: ts.ColumnType, parameters: list[Parameter], is_batched: bool = False):
         assert isinstance(return_type, ts.ColumnType)
@@ -135,26 +137,28 @@ class Signature:
             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)
+                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)
-        for other_param in other.required_parameters:
+        for other_param in other.required_parameters:  # noqa: SIM110
             if other_param.name not in self.parameters:
                 return False
 
         return True
 
     def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
-        if context != '':
+        if context:
             context = f' ({context})'
 
         for param_name, arg in bound_args.items():
             assert param_name in self.parameters
             param = self.parameters[param_name]
-            is_var_param = param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD)
+            is_var_param = param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}
             if is_var_param:
                 continue
             assert param.col_type is not None
@@ -191,6 +195,9 @@ class Signature:
                 return False
         return True
 
+    def __hash__(self) -> int:
+        return hash((self.return_type, self.parameters))
+
     def __str__(self) -> str:
         param_strs: list[str] = []
         for p in self.parameters.values():
@@ -199,8 +206,8 @@ class Signature:
             elif p.kind == inspect.Parameter.VAR_KEYWORD:
                 param_strs.append(f'**{p.name}')
             else:
-                param_strs.append(f'{p.name}: {str(p.col_type)}')
-        return f'({", ".join(param_strs)}) -> {str(self.get_return_type())}'
+                param_strs.append(f'{p.name}: {p.col_type}')
+        return f'({", ".join(param_strs)}) -> {self.get_return_type()}'
 
     @classmethod
     def _infer_type(cls, annotation: Optional[type]) -> tuple[Optional[ts.ColumnType], Optional[bool]]:
@@ -213,7 +220,7 @@ class Signature:
             type_args = typing.get_args(annotation)
             if len(type_args) == 2 and type_args[1] == 'pxt-batch':
                 # this is our Batch
-                assert typing.get_origin(type_args[0]) == list
+                assert typing.get_origin(type_args[0]) is list
                 is_batched = True
                 py_type = typing.get_args(type_args[0])[0]
         if py_type is None:
@@ -246,7 +253,7 @@ class Signature:
                 continue  # skip 'self' or 'cls' parameter
             if param.name in cls.SPECIAL_PARAM_NAMES:
                 raise excs.Error(f'{param.name!r} is a reserved parameter name')
-            if param.kind == inspect.Parameter.VAR_POSITIONAL or param.kind == inspect.Parameter.VAR_KEYWORD:
+            if param.kind in {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD}:
                 parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
 
@@ -257,11 +264,8 @@ class Signature:
                 param_type = param_types[idx]
                 is_batched = False
             else:
-                py_type: Optional[type]
-                if param.annotation in type_substitutions:
-                    py_type = type_substitutions[param.annotation]
-                else:
-                    py_type = param.annotation
+                # Look up the substitution for param.annotation, defaulting to param.annotation if there is none
+                py_type = type_substitutions.get(param.annotation, param.annotation)
                 param_type, is_batched = cls._infer_type(py_type)
                 if param_type is None:
                     raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name!r}')
@@ -297,11 +301,8 @@ class Signature:
         )
         sig = inspect.signature(py_fn)
         if return_type is None:
-            py_type: Optional[type]
-            if sig.return_annotation in type_substitutions:
-                py_type = type_substitutions[sig.return_annotation]
-            else:
-                py_type = sig.return_annotation
+            # Look up the substitution for sig.return_annotation, defaulting to return_annotation if there is none
+            py_type = type_substitutions.get(sig.return_annotation, sig.return_annotation)
             return_type, return_is_batched = cls._infer_type(py_type)
             if return_type is None:
                 raise excs.Error('Cannot infer pixeltable return type')

pixeltable/func/tools.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
 import pydantic
 
@@ -69,7 +69,7 @@ class Tool(pydantic.BaseModel):
             return _extract_float_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_bool_type():
             return _extract_bool_tool_arg(kwargs, param_name=param.name)
-        assert False
+        raise AssertionError()
 
 
 class ToolChoice(pydantic.BaseModel):
@@ -113,7 +113,7 @@ class Tools(pydantic.BaseModel):
                 )
                 tool_name = tool_obj.name or tool_obj.fn.name
             except StopIteration:
-                raise excs.Error(f'That tool is not in the specified list of tools: {tool}')
+                raise excs.Error(f'That tool is not in the specified list of tools: {tool}') from None
         return ToolChoice(auto=auto, required=required, tool=tool_name, parallel_tool_calls=parallel_tool_calls)
 
 

pixeltable/func/udf.py

@@ -146,7 +146,8 @@ def make_function(
             raise excs.Error(f'Cannot specify both `is_method` and `is_property` (in function `{function_name}`)')
         if is_property and len(sig.parameters) != 1:
             raise excs.Error(
-                f'`is_property=True` expects a UDF with exactly 1 parameter, but `{function_name}` has {len(sig.parameters)}'
+                '`is_property=True` expects a UDF with exactly 1 parameter, but '
+                f'`{function_name}` has {len(sig.parameters)}'
             )
         if (is_method or is_property) and function_path is None:
             raise excs.Error('Stored functions cannot be declared using `is_method` or `is_property`')
@@ -205,6 +206,8 @@ def expr_udf(*, param_types: Optional[list[ts.ColumnType]] = None) -> Callable[[
 
 def expr_udf(*args: Any, **kwargs: Any) -> Any:
     def make_expr_template(py_fn: Callable, param_types: Optional[list[ts.ColumnType]]) -> ExprTemplateFunction:
+        from pixeltable import exprs
+
         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__}'
@@ -216,7 +219,6 @@ def expr_udf(*args: Any, **kwargs: Any) -> Any:
 
         # construct Signature from the function signature
         sig = Signature.create(py_fn=py_fn, param_types=param_types, return_type=ts.InvalidType())
-        import pixeltable.exprs as exprs
 
         var_exprs = [exprs.Variable(param.name, param.col_type) for param in sig.parameters.values()]
         # call the function with the parameter expressions to construct an Expr with parameters
@@ -260,7 +262,7 @@ def from_table(
     """
     from pixeltable import exprs
 
-    ancestors = [tbl] + tbl._bases
+    ancestors = [tbl, *tbl._bases]
     ancestors.reverse()  # We must traverse the ancestors in order from base to derived
 
     subst: dict[exprs.Expr, exprs.Expr] = {}