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

pixeltable/func/signature.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
 
 import dataclasses
-import enum
 import inspect
 import json
 import logging
 import typing
-from typing import Any, Callable, Optional, Union
+from typing import TYPE_CHECKING, Any, Callable, Optional
 
 import pixeltable.exceptions as excs
 import pixeltable.type_system as ts
 
+if TYPE_CHECKING:
+    from pixeltable import exprs
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -21,25 +23,24 @@ class Parameter:
     kind: inspect._ParameterKind
     # for some reason, this needs to precede is_batched in the dataclass definition,
     # otherwise Python complains that an argument with a default is followed by an argument without a default
-    default: Any = inspect.Parameter.empty  # default value for the parameter
+    default: Optional['exprs.Literal'] = None  # default value for the parameter
     is_batched: bool = False  # True if the parameter is a batched parameter (eg, Batch[dict])
 
     def __post_init__(self) -> None:
-        # make sure that default is json-serializable and of the correct type
-        if self.default is inspect.Parameter.empty or self.default is None:
-            return
-        try:
-            _ = json.dumps(self.default)
-        except TypeError:
-            raise excs.Error(f'Default value for parameter {self.name} is not JSON-serializable: {str(self.default)}')
-        if self.col_type is not None:
-            try:
-                self.col_type.validate_literal(self.default)
-            except TypeError as e:
-                raise excs.Error(f'Default value for parameter {self.name}: {str(e)}')
+        from pixeltable import exprs
+
+        if self.default is not None:
+            if self.col_type is None:
+                raise excs.Error(f'Cannot have a default value for variable parameter {self.name!r}')
+            if not isinstance(self.default, exprs.Literal):
+                raise excs.Error(f'Default value for parameter {self.name!r} is not a constant')
+            if not self.col_type.is_supertype_of(self.default.col_type):
+                raise excs.Error(
+                    f'Default value for parameter {self.name!r} is not of type {self.col_type!r}: {self.default}'
+                )
 
     def has_default(self) -> bool:
-        return self.default is not inspect.Parameter.empty
+        return self.default is not None
 
     def as_dict(self) -> dict[str, Any]:
         return {
@@ -47,17 +48,15 @@ class Parameter:
             'col_type': self.col_type.as_dict() if self.col_type is not None else None,
             'kind': self.kind.name,
             'is_batched': self.is_batched,
-            'has_default': self.has_default(),
-            'default': self.default if self.has_default() else None,
+            'default': None if self.default is None else self.default.as_dict(),
         }
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> Parameter:
-        has_default = d['has_default']
-        if has_default:
-            default = d['default']
-        else:
-            default = inspect.Parameter.empty
+        from pixeltable import exprs
+
+        assert d['default'] is None or isinstance(d['default'], dict), d
+        default = None if d['default'] is None else exprs.Literal.from_dict(d['default'])
         return cls(
             name=d['name'],
             col_type=ts.ColumnType.from_dict(d['col_type']) if d['col_type'] is not None else None,
@@ -67,7 +66,8 @@ class Parameter:
         )
 
     def to_py_param(self) -> inspect.Parameter:
-        return inspect.Parameter(self.name, self.kind, default=self.default)
+        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)
 
 
 T = typing.TypeVar('T')
@@ -147,6 +147,37 @@ class Signature:
 
         return True
 
+    def validate_args(self, bound_args: dict[str, Optional['exprs.Expr']], context: str = '') -> None:
+        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)
+            if is_var_param:
+                continue
+            assert param.col_type is not None
+
+            if arg is None:
+                raise excs.Error(f'Parameter {param_name!r}{context}: invalid argument')
+
+            # Check that the argument is consistent with the expected parameter type, with the allowance that
+            # non-nullable parameters can still accept nullable arguments (since in that event, FunctionCall.eval()
+            # detects the Nones and skips evaluation).
+            if not (
+                param.col_type.is_supertype_of(arg.col_type, ignore_nullable=True)
+                # TODO: this is a hack to allow JSON columns to be passed to functions that accept scalar
+                # types. It's necessary to avoid littering notebooks with `apply(str)` calls or equivalent.
+                # (Previously, this wasn't necessary because `is_supertype_of()` was improperly implemented.)
+                # We need to think through the right way to handle this scenario.
+                or (arg.col_type.is_json_type() and param.col_type.is_scalar_type())
+            ):
+                raise excs.Error(
+                    f'Parameter {param_name!r}{context}: argument type {arg.col_type} does not'
+                    f' match parameter type {param.col_type}'
+                )
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Signature):
             return False
@@ -199,6 +230,8 @@ class Signature:
         type_substitutions: Optional[dict] = None,
         is_cls_method: bool = False,
     ) -> list[Parameter]:
+        from pixeltable import exprs
+
         assert (py_fn is None) != (py_params is None)
         if py_fn is not None:
             sig = inspect.signature(py_fn)
@@ -212,7 +245,7 @@ class Signature:
             if is_cls_method and idx == 0:
                 continue  # skip 'self' or 'cls' parameter
             if param.name in cls.SPECIAL_PARAM_NAMES:
-                raise excs.Error(f"'{param.name}' is a reserved parameter name")
+                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:
                 parameters.append(Parameter(param.name, col_type=None, kind=param.kind))
                 continue
@@ -220,7 +253,7 @@ class Signature:
             # check non-var parameters for name collisions and default value compatibility
             if param_types is not None:
                 if idx >= len(param_types):
-                    raise excs.Error(f'Missing type for parameter {param.name}')
+                    raise excs.Error(f'Missing type for parameter {param.name!r}')
                 param_type = param_types[idx]
                 is_batched = False
             else:
@@ -231,12 +264,14 @@ class Signature:
                     py_type = 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}')
+                    raise excs.Error(f'Cannot infer pixeltable type for parameter {param.name!r}')
+
+            default = None if param.default is inspect.Parameter.empty else exprs.Expr.from_object(param.default)
+            if not (default is None or isinstance(default, exprs.Literal)):
+                raise excs.Error(f'Default value for parameter {param.name!r} must be a constant')
 
             parameters.append(
-                Parameter(
-                    param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=param.default
-                )
+                Parameter(param.name, col_type=param_type, kind=param.kind, is_batched=is_batched, default=default)
             )
 
         return parameters

pixeltable/func/tools.py

@@ -48,22 +48,27 @@ class Tool(pydantic.BaseModel):
             'additionalProperties': False,  # TODO Handle kwargs?
         }
 
-    # `tool_calls` must be in standardized tool invocation format:
-    # {tool_name: {'args': {name1: value1, name2: value2, ...}}, ...}
-    def invoke(self, tool_calls: 'exprs.Expr') -> 'exprs.FunctionCall':
-        kwargs = {param.name: self.__extract_tool_arg(param, tool_calls) for param in self.parameters.values()}
-        return self.fn(**kwargs)
+    # The output of `tool_calls` must be a dict in standardized tool invocation format:
+    # {tool_name: [{'args': {name1: value1, name2: value2, ...}}, ...], ...}
+    def invoke(self, tool_calls: 'exprs.Expr') -> 'exprs.Expr':
+        from pixeltable import exprs
 
-    def __extract_tool_arg(self, param: Parameter, tool_calls: 'exprs.Expr') -> 'exprs.Expr':
         func_name = self.name or self.fn.name
+        return exprs.JsonMapper(tool_calls[func_name]['*'], self.__invoke_kwargs(exprs.RELATIVE_PATH_ROOT.args))
+
+    def __invoke_kwargs(self, kwargs: 'exprs.Expr') -> 'exprs.FunctionCall':
+        kwargs = {param.name: self.__extract_tool_arg(param, kwargs) for param in self.parameters.values()}
+        return self.fn(**kwargs)
+
+    def __extract_tool_arg(self, param: Parameter, kwargs: 'exprs.Expr') -> 'exprs.FunctionCall':
         if param.col_type.is_string_type():
-            return _extract_str_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_str_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_int_type():
-            return _extract_int_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_int_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_float_type():
-            return _extract_float_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_float_tool_arg(kwargs, param_name=param.name)
         if param.col_type.is_bool_type():
-            return _extract_bool_tool_arg(tool_calls, func_name=func_name, param_name=param.name)
+            return _extract_bool_tool_arg(kwargs, param_name=param.name)
         assert False
 
 
@@ -113,34 +118,29 @@ class Tools(pydantic.BaseModel):
 
 
 @udf
-def _extract_str_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[str]:
-    return _extract_arg(str, tool_calls, func_name, param_name)
+def _extract_str_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[str]:
+    return _extract_arg(str, kwargs, param_name)
 
 
 @udf
-def _extract_int_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[int]:
-    return _extract_arg(int, tool_calls, func_name, param_name)
+def _extract_int_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[int]:
+    return _extract_arg(int, kwargs, param_name)
 
 
 @udf
-def _extract_float_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[float]:
-    return _extract_arg(float, tool_calls, func_name, param_name)
+def _extract_float_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[float]:
+    return _extract_arg(float, kwargs, param_name)
 
 
 @udf
-def _extract_bool_tool_arg(tool_calls: dict[str, Any], func_name: str, param_name: str) -> Optional[bool]:
-    return _extract_arg(bool, tool_calls, func_name, param_name)
+def _extract_bool_tool_arg(kwargs: dict[str, Any], param_name: str) -> Optional[bool]:
+    return _extract_arg(bool, kwargs, param_name)
 
 
 T = TypeVar('T')
 
 
-def _extract_arg(
-    eval_fn: Callable[[Any], T], tool_calls: dict[str, Any], func_name: str, param_name: str
-) -> Optional[T]:
-    if func_name in tool_calls:
-        arguments = tool_calls[func_name]['args']
-        if param_name in arguments:
-            return eval_fn(arguments[param_name])
-        return None
+def _extract_arg(eval_fn: Callable[[Any], T], kwargs: dict[str, Any], param_name: str) -> Optional[T]:
+    if param_name in kwargs:
+        return eval_fn(kwargs[param_name])
     return None

pixeltable/func/udf.py

@@ -283,7 +283,7 @@ def from_table(
                 result_dict[name] = var
                 # Since this is a data column, it becomes a UDF parameter.
                 # If the column is nullable, then the parameter will have a default value of None.
-                default_value = None if col.col_type.nullable else inspect.Parameter.empty
+                default_value = exprs.Literal(None) if col.col_type.nullable else None
                 param = Parameter(name, col.col_type, inspect._ParameterKind.POSITIONAL_OR_KEYWORD, default_value)
                 params.append(param)
 

pixeltable/functions/__init__.py

@@ -3,6 +3,7 @@ from pixeltable.utils.code import local_public_names
 from . import (
     anthropic,
     audio,
+    deepseek,
     fireworks,
     gemini,
     huggingface,

pixeltable/functions/anthropic.py

@@ -213,9 +213,15 @@ def invoke_tools(tools: Tools, response: exprs.Expr) -> exprs.InlineDict:
 @pxt.udf
 def _anthropic_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
     anthropic_tool_calls = [r for r in response['content'] if r['type'] == 'tool_use']
-    if len(anthropic_tool_calls) > 0:
-        return {tool_call['name']: {'args': tool_call['input']} for tool_call in anthropic_tool_calls}
-    return None
+    if len(anthropic_tool_calls) == 0:
+        return None
+    pxt_tool_calls: dict[str, list[dict[str, Any]]] = {}
+    for tool_call in anthropic_tool_calls:
+        tool_name = tool_call['name']
+        if tool_name not in pxt_tool_calls:
+            pxt_tool_calls[tool_name] = []
+        pxt_tool_calls[tool_name].append({'args': tool_call['input']})
+    return pxt_tool_calls
 
 
 _T = TypeVar('_T')

pixeltable/functions/deepseek.py

@@ -0,0 +1,121 @@
+import json
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
+
+import httpx
+
+import pixeltable as pxt
+from pixeltable import env
+from pixeltable.utils.code import local_public_names
+
+from .openai import _opt
+
+if TYPE_CHECKING:
+    import openai
+
+
+@env.register_client('deepseek')
+def _(api_key: str) -> 'openai.AsyncOpenAI':
+    import openai
+
+    return openai.AsyncOpenAI(
+        api_key=api_key,
+        base_url='https://api.deepseek.com',
+        http_client=httpx.AsyncClient(limits=httpx.Limits(max_keepalive_connections=100, max_connections=500)),
+    )
+
+
+def _deepseek_client() -> 'openai.AsyncOpenAI':
+    return env.Env.get().get_client('deepseek')
+
+
+@pxt.udf
+async def chat_completions(
+    messages: list,
+    *,
+    model: str,
+    frequency_penalty: Optional[float] = None,
+    logprobs: Optional[bool] = None,
+    top_logprobs: Optional[int] = None,
+    max_tokens: Optional[int] = None,
+    presence_penalty: Optional[float] = None,
+    response_format: Optional[dict] = None,
+    stop: Optional[list[str]] = None,
+    temperature: Optional[float] = None,
+    tools: Optional[list[dict]] = None,
+    tool_choice: Optional[dict] = None,
+    top_p: Optional[float] = None,
+) -> dict:
+    """
+    Creates a model response for the given chat conversation.
+
+    Equivalent to the Deepseek `chat/completions` API endpoint.
+    For additional details, see: <https://api-docs.deepseek.com/api/create-chat-completion>
+
+    Deepseek uses the OpenAI SDK, so you will need to install the `openai` package to use this UDF.
+
+    __Requirements:__
+
+    - `pip install openai`
+
+    Args:
+        messages: A list of messages to use for chat completion, as described in the Deepseek API documentation.
+        model: The model to use for chat completion.
+
+    For details on the other parameters, see: <https://api-docs.deepseek.com/api/create-chat-completion>
+
+    Returns:
+        A dictionary containing the response and other metadata.
+
+    Examples:
+        Add a computed column that applies the model `deepseek-chat` to an existing Pixeltable column `tbl.prompt`
+        of the table `tbl`:
+
+        >>> messages = [
+                {'role': 'system', 'content': 'You are a helpful assistant.'},
+                {'role': 'user', 'content': tbl.prompt}
+            ]
+            tbl.add_computed_column(response=chat_completions(messages, model='deepseek-chat'))
+    """
+    if tools is not None:
+        tools = [{'type': 'function', 'function': tool} for tool in tools]
+
+    tool_choice_: Union[str, dict, None] = None
+    if tool_choice is not None:
+        if tool_choice['auto']:
+            tool_choice_ = 'auto'
+        elif tool_choice['required']:
+            tool_choice_ = 'required'
+        else:
+            assert tool_choice['tool'] is not None
+            tool_choice_ = {'type': 'function', 'function': {'name': tool_choice['tool']}}
+
+    extra_body: Optional[dict[str, Any]] = None
+    if tool_choice is not None and not tool_choice['parallel_tool_calls']:
+        extra_body = {'parallel_tool_calls': False}
+
+    # cast(Any, ...): avoid mypy errors
+    result = await _deepseek_client().chat.completions.with_raw_response.create(
+        messages=messages,
+        model=model,
+        frequency_penalty=_opt(frequency_penalty),
+        logprobs=_opt(logprobs),
+        top_logprobs=_opt(top_logprobs),
+        max_tokens=_opt(max_tokens),
+        presence_penalty=_opt(presence_penalty),
+        response_format=_opt(cast(Any, response_format)),
+        stop=_opt(stop),
+        temperature=_opt(temperature),
+        tools=_opt(cast(Any, tools)),
+        tool_choice=_opt(cast(Any, tool_choice_)),
+        top_p=_opt(top_p),
+        extra_body=extra_body,
+    )
+
+    return json.loads(result.text)
+
+
+__all__ = local_public_names(__name__)
+
+
+def __dir__():
+    return __all__

pixeltable/functions/image.py

@@ -131,6 +131,13 @@ def getchannel(self: PIL.Image.Image, channel: int) -> PIL.Image.Image:
     pass
 
 
+@getchannel.conditional_return_type
+def _(self: Expr) -> pxt.ColumnType:
+    input_type = self.col_type
+    assert isinstance(input_type, pxt.ImageType)
+    return pxt.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
+
+
 @pxt.udf(is_method=True)
 def get_metadata(self: PIL.Image.Image) -> dict:
     """
@@ -146,13 +153,6 @@ def get_metadata(self: PIL.Image.Image) -> dict:
     }
 
 
-@getchannel.conditional_return_type
-def _(self: Expr) -> pxt.ColumnType:
-    input_type = self.col_type
-    assert isinstance(input_type, pxt.ImageType)
-    return pxt.ImageType(size=input_type.size, mode='L', nullable=input_type.nullable)
-
-
 # Image.point()
 @pxt.udf(is_method=True)
 def point(self: PIL.Image.Image, lut: list[int], mode: Optional[str] = None) -> PIL.Image.Image:

pixeltable/functions/openai.py

@@ -325,10 +325,30 @@ async def translations(
 
 
 def _default_max_tokens(model: str) -> int:
-    if model in ('o1', 'o3-mini'):
+    if (
+        _is_model_family(model, 'gpt-4o-realtime')
+        or _is_model_family(model, 'gpt-4o-mini-realtime')
+        or _is_model_family(model, 'gpt-4-turbo')
+        or _is_model_family(model, 'gpt-3.5-turbo')
+    ):
+        return 4096
+    if _is_model_family(model, 'gpt-4'):
+        return 8192  # All other gpt-4 models (will not match on gpt-4o models)
+    if _is_model_family(model, 'gpt-4o') or _is_model_family(model, 'gpt-4.5-preview'):
+        return 16384  # All other gpt-4o / gpt-4.5 models
+    if _is_model_family(model, 'o1-preview'):
+        return 32768
+    if _is_model_family(model, 'o1-mini'):
         return 65536
-    else:
-        return 1024
+    if _is_model_family(model, 'o1') or _is_model_family(model, 'o3'):
+        return 100000  # All other o1 / o3 models
+    return 100000  # global default
+
+
+def _is_model_family(model: str, family: str) -> bool:
+    # `model.startswith(family)` would be a simpler match, but increases the risk of false positives.
+    # We use a slightly more complicated criterion to make things a little less error prone.
+    return model == family or model.startswith(f'{family}-')
 
 
 def _chat_completions_get_request_resources(
@@ -427,9 +447,6 @@ async def chat_completions(
         resource_pool, lambda: OpenAIRateLimitsInfo(_chat_completions_get_request_resources)
     )
 
-    if max_completion_tokens is None and max_tokens is None:
-        max_completion_tokens = _default_max_tokens(model)
-
     # cast(Any, ...): avoid mypy errors
     result = await _openai_client().chat.completions.with_raw_response.create(
         messages=messages,
@@ -555,9 +572,6 @@ async def vision(
         resource_pool, lambda: OpenAIRateLimitsInfo(_vision_get_request_resources)
     )
 
-    if max_completion_tokens is None and max_tokens is None:
-        max_completion_tokens = _default_max_tokens(model)
-
     result = await _openai_client().chat.completions.with_raw_response.create(
         messages=messages,  # type: ignore
         model=model,
@@ -802,10 +816,13 @@ def _openai_response_to_pxt_tool_calls(response: dict) -> Optional[dict]:
     if 'tool_calls' not in response['choices'][0]['message'] or response['choices'][0]['message']['tool_calls'] is None:
         return None
     openai_tool_calls = response['choices'][0]['message']['tool_calls']
-    return {
-        tool_call['function']['name']: {'args': json.loads(tool_call['function']['arguments'])}
-        for tool_call in openai_tool_calls
-    }
+    pxt_tool_calls: dict[str, list[dict[str, Any]]] = {}
+    for tool_call in openai_tool_calls:
+        tool_name = tool_call['function']['name']
+        if tool_name not in pxt_tool_calls:
+            pxt_tool_calls[tool_name] = []
+        pxt_tool_calls[tool_name].append({'args': json.loads(tool_call['function']['arguments'])})
+    return pxt_tool_calls
 
 
 _T = TypeVar('_T')

pixeltable/functions/video.py

@@ -14,9 +14,9 @@ t.select(pxt_video.extract_audio(t.video_col)).collect()
 import tempfile
 import uuid
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
-import av  # type: ignore[import-untyped]
+import av
 import numpy as np
 import PIL.Image
 
@@ -53,10 +53,14 @@ class make_video(pxt.Aggregator):
     Aggregator that creates a video from a sequence of images.
     """
 
+    container: Optional[av.container.OutputContainer]
+    stream: Optional[av.video.stream.VideoStream]
+    fps: int
+
     def __init__(self, fps: int = 25):
         """follows https://pyav.org/docs/develop/cookbook/numpy.html#generating-video"""
-        self.container: Optional[av.container.OutputContainer] = None
-        self.stream: Optional[av.stream.Stream] = None
+        self.container = None
+        self.stream = None
         self.fps = fps
 
     def update(self, frame: PIL.Image.Image) -> None:
@@ -107,9 +111,10 @@ def extract_audio(
 
         with av.open(output_filename, 'w', format=format) as output_container:
             output_stream = output_container.add_stream(codec or default_codec)
+            assert isinstance(output_stream, av.audio.stream.AudioStream)
             for packet in container.demux(audio_stream):
                 for frame in packet.decode():
-                    output_container.mux(output_stream.encode(frame))
+                    output_container.mux(output_stream.encode(frame))  # type: ignore[arg-type]
 
         return output_filename
 
@@ -141,7 +146,7 @@ def __get_stream_metadata(stream: av.stream.Stream) -> dict:
         return {'type': stream.type}  # Currently unsupported
 
     codec_context = stream.codec_context
-    codec_context_md = {
+    codec_context_md: dict[str, Any] = {
         'name': codec_context.name,
         'codec_tag': codec_context.codec_tag.encode('unicode-escape').decode('utf-8'),
         'profile': codec_context.profile,
@@ -160,9 +165,11 @@ def __get_stream_metadata(stream: av.stream.Stream) -> dict:
 
     if stream.type == 'audio':
         # Additional metadata for audio
-        codec_context_md['channels'] = int(codec_context.channels) if codec_context.channels is not None else None
+        channels = getattr(stream.codec_context, 'channels', None)
+        codec_context_md['channels'] = int(channels) if channels is not None else None
     else:
         assert stream.type == 'video'
+        assert isinstance(stream, av.video.stream.VideoStream)
         # Additional metadata for video
         codec_context_md['pix_fmt'] = getattr(stream.codec_context, 'pix_fmt', None)
         metadata.update(

pixeltable/globals.py

@@ -1,5 +1,6 @@
 import dataclasses
 import logging
+import urllib.parse
 from typing import Any, Iterable, Literal, Optional, Union
 from uuid import UUID
 
@@ -10,7 +11,7 @@ from sqlalchemy.util.preloaded import orm
 
 import pixeltable.exceptions as excs
 import pixeltable.exprs as exprs
-from pixeltable import DataFrame, catalog, func
+from pixeltable import DataFrame, catalog, func, share
 from pixeltable.catalog import Catalog
 from pixeltable.dataframe import DataFrameResultSet
 from pixeltable.env import Env
@@ -279,14 +280,16 @@ def create_view(
         ... view = pxt.create_view('my_view', tbl.where(tbl.col1 > 100), if_exists='replace_force')
     """
     where: Optional[exprs.Expr] = None
+    select_list: Optional[list[tuple[exprs.Expr, Optional[str]]]] = None
     if isinstance(base, catalog.Table):
         tbl_version_path = base._tbl_version_path
     elif isinstance(base, DataFrame):
-        base._validate_mutable('create_view')
+        base._validate_mutable('create_view', allow_select=True)
         if len(base._from_clause.tbls) > 1:
             raise excs.Error('Cannot create a view of a join')
         tbl_version_path = base._from_clause.tbls[0]
         where = base.where_clause
+        select_list = base.select_list
     else:
         raise excs.Error('`base` must be an instance of `Table` or `DataFrame`')
     assert isinstance(base, catalog.Table) or isinstance(base, DataFrame)
@@ -322,6 +325,7 @@ def create_view(
         dir._id,
         path.name,
         base=tbl_version_path,
+        select_list=select_list,
         additional_columns=additional_columns,
         predicate=where,
         is_snapshot=is_snapshot,
@@ -630,7 +634,7 @@ def create_dir(
     parent = cat.paths[path.parent]
     assert parent is not None
     with orm.Session(Env.get().engine, future=True) as session:
-        dir_md = schema.DirMd(name=path.name)
+        dir_md = schema.DirMd(name=path.name, user=None, additional_md={})
         dir_record = schema.Dir(parent_id=parent._id, md=dataclasses.asdict(dir_md))
         session.add(dir_record)
         session.flush()
@@ -723,6 +727,13 @@ def drop_dir(path_str: str, force: bool = False, if_not_exists: Literal['error',
     _logger.info(f'Removed directory `{path_str}`.')
 
 
+def publish_snapshot(dest_uri: str, table: catalog.Table) -> None:
+    parsed_uri = urllib.parse.urlparse(dest_uri)
+    if parsed_uri.scheme != 'pxt':
+        raise excs.Error(f'Invalid Pixeltable URI (does not start with pxt://): {dest_uri}')
+    share.publish_snapshot(dest_uri, table)
+
+
 def list_dirs(path_str: str = '', recursive: bool = True) -> list[str]:
     """List the directories in a directory.