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

pixeltable/type_system.py

@@ -9,17 +9,25 @@ import types
 import typing
 import urllib.parse
 import urllib.request
+import uuid
 from pathlib import Path
-from typing import Any, Iterable, Mapping, Optional, Sequence, Union
+from typing import Any, ClassVar, Iterable, Literal, Mapping, Sequence, Union
 
-import PIL.Image
-import av  # type: ignore
+from typing import _GenericAlias  # type: ignore[attr-defined]  # isort: skip
+
+import av
+import jsonschema
+import jsonschema.protocols
+import jsonschema.validators
 import numpy as np
+import PIL.Image
+import pydantic
 import sqlalchemy as sql
-from typing import _GenericAlias  # type: ignore[attr-defined]
 from typing_extensions import _AnnotatedAlias
 
 import pixeltable.exceptions as excs
+from pixeltable.env import Env
+from pixeltable.utils import parse_local_file_path
 
 
 class ColumnType:
@@ -36,16 +44,21 @@ class ColumnType:
         VIDEO = 8
         AUDIO = 9
         DOCUMENT = 10
+        DATE = 11
+        UUID = 12
+        BINARY = 13
 
         # exprs that don't evaluate to a computable value in Pixeltable, such as an Image member function
         INVALID = 255
 
         @classmethod
         def supertype(
-                cls, type1: 'ColumnType.Type', type2: 'ColumnType.Type',
-                # we need to pass this in because we can't easily append it as a class member
-                common_supertypes: dict[tuple['ColumnType.Type', 'ColumnType.Type'], 'ColumnType.Type']
-        ) -> Optional['ColumnType.Type']:
+            cls,
+            type1: 'ColumnType.Type' | None,
+            type2: 'ColumnType.Type' | None,
+            # we need to pass this in because we can't easily append it as a class member
+            common_supertypes: dict[tuple['ColumnType.Type', 'ColumnType.Type'], 'ColumnType.Type'],
+        ) -> 'ColumnType.Type' | None:
             if type1 == type2:
                 return type1
             t = common_supertypes.get((type1, type2))
@@ -56,28 +69,10 @@ class ColumnType:
                 return t
             return None
 
-
-    @enum.unique
-    class DType(enum.Enum):
-        """
-        Base type used in images and arrays
-        """
-        BOOL = 0,
-        INT8 = 1,
-        INT16 = 2,
-        INT32 = 3,
-        INT64 = 4,
-        UINT8 = 5,
-        UINT16 = 6,
-        UINT32 = 7,
-        UINT64 = 8,
-        FLOAT16 = 9,
-        FLOAT32 = 10,
-        FLOAT64 = 11
-
-    scalar_types = {Type.STRING, Type.INT, Type.FLOAT, Type.BOOL, Type.TIMESTAMP}
-    numeric_types = {Type.INT, Type.FLOAT}
-    common_supertypes: dict[tuple[Type, Type], Type] = {
+    scalar_json_types: ClassVar[set[Type]] = {Type.STRING, Type.INT, Type.FLOAT, Type.BOOL}
+    scalar_types: ClassVar[set[Type]] = scalar_json_types | {Type.TIMESTAMP, Type.DATE, Type.UUID}
+    numeric_types: ClassVar[set[Type]] = {Type.INT, Type.FLOAT}
+    common_supertypes: ClassVar[dict[tuple[Type, Type], Type]] = {
         (Type.BOOL, Type.INT): Type.INT,
         (Type.BOOL, Type.FLOAT): Type.FLOAT,
         (Type.INT, Type.FLOAT): Type.FLOAT,
@@ -87,6 +82,9 @@ class ColumnType:
         self._type = t
         self._nullable = nullable
 
+    def has_supertype(self) -> bool:
+        return True
+
     @property
     def nullable(self) -> bool:
         return self._nullable
@@ -110,10 +108,7 @@ class ColumnType:
         return json.dumps([t.as_dict() for t in type_list])
 
     def as_dict(self) -> dict:
-        return {
-            '_classname': self.__class__.__name__,
-            **self._as_dict(),
-        }
+        return {'_classname': self.__class__.__name__, **self._as_dict()}
 
     def _as_dict(self) -> dict:
         return {'nullable': self.nullable}
@@ -144,27 +139,37 @@ class ColumnType:
 
     @classmethod
     def make_type(cls, t: Type) -> ColumnType:
-        assert t != cls.Type.INVALID and t != cls.Type.ARRAY
-        if t == cls.Type.STRING:
-            return StringType()
-        if t == cls.Type.INT:
-            return IntType()
-        if t == cls.Type.FLOAT:
-            return FloatType()
-        if t == cls.Type.BOOL:
-            return BoolType()
-        if t == cls.Type.TIMESTAMP:
-            return TimestampType()
-        if t == cls.Type.JSON:
-            return JsonType()
-        if t == cls.Type.IMAGE:
-            return ImageType()
-        if t == cls.Type.VIDEO:
-            return VideoType()
-        if t == cls.Type.AUDIO:
-            return AudioType()
-        if t == cls.Type.DOCUMENT:
-            return DocumentType()
+        match t:
+            case cls.Type.STRING:
+                return StringType()
+            case cls.Type.INT:
+                return IntType()
+            case cls.Type.FLOAT:
+                return FloatType()
+            case cls.Type.BOOL:
+                return BoolType()
+            case cls.Type.TIMESTAMP:
+                return TimestampType()
+            case cls.Type.JSON:
+                return JsonType()
+            case cls.Type.ARRAY:
+                return ArrayType()
+            case cls.Type.IMAGE:
+                return ImageType()
+            case cls.Type.VIDEO:
+                return VideoType()
+            case cls.Type.AUDIO:
+                return AudioType()
+            case cls.Type.DOCUMENT:
+                return DocumentType()
+            case cls.Type.DATE:
+                return DateType()
+            case cls.Type.UUID:
+                return UUIDType()
+            case cls.Type.BINARY:
+                return BinaryType()
+            case _:
+                raise AssertionError(t)
 
     def __repr__(self) -> str:
         return self._to_str(as_schema=False)
@@ -174,7 +179,7 @@ class ColumnType:
         if as_schema:
             return base_str if self.nullable else f'Required[{base_str}]'
         else:
-            return f'Optional[{base_str}]' if self.nullable else base_str
+            return f'{base_str} | None' if self.nullable else base_str
 
     def _to_base_str(self) -> str:
         """
@@ -203,27 +208,41 @@ class ColumnType:
         # Default: just compare base types (this works for all types whose only parameter is nullable)
         return self._type == other._type
 
-    def supertype(self, other: ColumnType) -> Optional[ColumnType]:
+    def supertype(self, other: ColumnType, for_inference: bool = False) -> ColumnType | None:
+        """
+        Returns the most specific type that is a supertype of both `self` and `other`.
+
+        If `for_inference=True`, then we disallow certain type relationships that are technically correct, but may
+        be confusing for schema inference during data imports.
+        """
         if self == other:
             return self
         if self.matches(other):
             return self.copy(nullable=(self.nullable or other.nullable))
 
         if self.is_invalid_type():
-            return other
+            return other.copy(nullable=(self.nullable or other.nullable))
         if other.is_invalid_type():
-            return self
+            return self.copy(nullable=(self.nullable or other.nullable))
 
         if self.is_scalar_type() and other.is_scalar_type():
             t = self.Type.supertype(self._type, other._type, self.common_supertypes)
             if t is not None:
                 return self.make_type(t).copy(nullable=(self.nullable or other.nullable))
-            return None
+
+        # If we see a mix of JSON and/or JSON-compatible scalar types, resolve to JSON.
+        # (For JSON+JSON, we return None to allow JsonType to handle merging the type schemas.)
+        if not for_inference and (
+            (self.is_json_type() and other.is_scalar_json_type())
+            or (self.is_scalar_json_type() and other.is_json_type())
+            or (self.is_scalar_json_type() and other.is_scalar_json_type())
+        ):
+            return JsonType(nullable=(self.nullable or other.nullable))
 
         return None
 
     @classmethod
-    def infer_literal_type(cls, val: Any, nullable: bool = False) -> Optional[ColumnType]:
+    def infer_literal_type(cls, val: Any, nullable: bool = False) -> ColumnType | None:
         if val is None:
             return InvalidType(nullable=True)
         if isinstance(val, str):
@@ -235,16 +254,24 @@ class ColumnType:
             return IntType(nullable=nullable)
         if isinstance(val, float):
             return FloatType(nullable=nullable)
+        # When checking types of dates / timestamps, be aware that a datetime is also a date,
+        # but a date is not a datetime. So check for datetime first.
         if isinstance(val, datetime.datetime):
             return TimestampType(nullable=nullable)
+        if isinstance(val, datetime.date):
+            return DateType(nullable=nullable)
+        if isinstance(val, uuid.UUID):
+            return UUIDType(nullable=nullable)
+        if isinstance(val, bytes):
+            return BinaryType(nullable=nullable)
         if isinstance(val, PIL.Image.Image):
             return ImageType(width=val.width, height=val.height, mode=val.mode, nullable=nullable)
         if isinstance(val, np.ndarray):
             col_type = ArrayType.from_literal(val, nullable=nullable)
             if col_type is not None:
                 return col_type
-            # this could still be json-serializable
-        if isinstance(val, dict) or isinstance(val, list) or isinstance(val, np.ndarray):
+        # this could still be json-serializable
+        if isinstance(val, (list, tuple, dict, np.ndarray, pydantic.BaseModel)):
             try:
                 JsonType().validate_literal(val)
                 return JsonType(nullable=nullable)
@@ -253,7 +280,7 @@ class ColumnType:
         return None
 
     @classmethod
-    def infer_common_literal_type(cls, vals: Iterable[Any]) -> Optional[ColumnType]:
+    def infer_common_literal_type(cls, vals: Iterable[Any]) -> ColumnType | None:
         """
         Returns the most specific type that is a supertype of all literals in `vals`. If no such type
         exists, returns None.
@@ -261,24 +288,27 @@ class ColumnType:
         Args:
             vals: A collection of literals.
         """
-        inferred_type: Optional[ColumnType] = None
+        inferred_type: ColumnType | None = None
         for val in vals:
             val_type = cls.infer_literal_type(val)
             if inferred_type is None:
                 inferred_type = val_type
             else:
-                inferred_type = inferred_type.supertype(val_type)
-                if inferred_type is None:
-                    return None
+                inferred_type = inferred_type.supertype(val_type, for_inference=True)
+            if inferred_type is None:
+                return None
+            if not inferred_type.has_supertype():
+                return inferred_type
         return inferred_type
 
     @classmethod
     def from_python_type(
         cls,
-        t: Union[type, _GenericAlias],
+        t: type | _GenericAlias,
         nullable_default: bool = False,
-        allow_builtin_types: bool = True
-    ) -> Optional[ColumnType]:
+        allow_builtin_types: bool = True,
+        infer_pydantic_json: bool = False,
+    ) -> ColumnType | None:
         """
         Convert a Python type into a Pixeltable `ColumnType` instance.
 
@@ -290,34 +320,34 @@ class ColumnType:
                 allowed (as in UDF definitions). If False, then only Pixeltable types such as `pxt.String`,
                 `pxt.Int`, etc., will be allowed (as in schema definitions). `Optional` and `Required`
                 designations will be allowed regardless.
+            infer_pydantic_json: If True, accepts an extended set of built-ins (eg, Enum, Path) and returns the type to
+                which pydantic.BaseModel.model_dump(mode='json') serializes it.
         """
         origin = typing.get_origin(t)
-        if origin is typing.Union:
-            # Check if `t` has the form Optional[T].
-            union_args = typing.get_args(t)
-            if len(union_args) == 2 and type(None) in union_args:
-                # `t` is a type of the form Optional[T] (equivalently, Union[T, None] or Union[None, T]).
+        type_args = typing.get_args(t)
+        if origin in (typing.Union, types.UnionType):
+            # Check if `t` has the form T | None.
+            if len(type_args) == 2 and type(None) in type_args:
+                # `t` is a type of the form T | None (equivalently, T | None or None | T).
                 # We treat it as the underlying type but with nullable=True.
-                underlying_py_type = union_args[0] if union_args[1] is type(None) else union_args[1]
-                underlying = cls.from_python_type(underlying_py_type, allow_builtin_types=allow_builtin_types)
+                underlying_py_type = type_args[0] if type_args[1] is type(None) else type_args[1]
+                underlying = cls.from_python_type(
+                    underlying_py_type, allow_builtin_types=allow_builtin_types, infer_pydantic_json=infer_pydantic_json
+                )
                 if underlying is not None:
                     return underlying.copy(nullable=True)
         elif origin is Required:
-            required_args = typing.get_args(t)
-            assert len(required_args) == 1
+            assert len(type_args) == 1
             return cls.from_python_type(
-                required_args[0],
-                nullable_default=False,
-                allow_builtin_types=allow_builtin_types
-            )
+                type_args[0], nullable_default=False, allow_builtin_types=allow_builtin_types
+            ).copy(nullable=False)
         elif origin is typing.Annotated:
-            annotated_args = typing.get_args(t)
-            origin = annotated_args[0]
-            parameters = annotated_args[1]
+            origin = type_args[0]
+            parameters = type_args[1]
             if isinstance(parameters, ColumnType):
                 return parameters.copy(nullable=nullable_default)
         else:
-            # It's something other than Optional[T], Required[T], or an explicitly annotated type.
+            # It's something other than T | None, Required[T], or an explicitly annotated type.
             if origin is not None:
                 # Discard type parameters to ensure that parameterized types such as `list[T]`
                 # are correctly mapped to Pixeltable types.
@@ -325,6 +355,18 @@ class ColumnType:
             if isinstance(t, type) and issubclass(t, _PxtType):
                 return t.as_col_type(nullable=nullable_default)
             elif allow_builtin_types:
+                if t is Literal and len(type_args) > 0:
+                    literal_type = cls.infer_common_literal_type(type_args)
+                    if literal_type is None:
+                        return None
+                    return literal_type.copy(nullable=(literal_type.nullable or nullable_default))
+                if infer_pydantic_json and isinstance(t, type) and issubclass(t, enum.Enum):
+                    literal_type = cls.infer_common_literal_type(member.value for member in t)
+                    if literal_type is None:
+                        return None
+                    return literal_type.copy(nullable=(literal_type.nullable or nullable_default))
+                if infer_pydantic_json and t is Path:
+                    return StringType(nullable=nullable_default)
                 if t is str:
                     return StringType(nullable=nullable_default)
                 if t is int:
@@ -335,18 +377,21 @@ class ColumnType:
                     return BoolType(nullable=nullable_default)
                 if t is datetime.datetime:
                     return TimestampType(nullable=nullable_default)
+                if t is datetime.date:
+                    return DateType(nullable=nullable_default)
+                if t is uuid.UUID:
+                    return UUIDType(nullable=nullable_default)
+                if t is bytes:
+                    return BinaryType(nullable=nullable_default)
                 if t is PIL.Image.Image:
                     return ImageType(nullable=nullable_default)
-                if issubclass(t, Sequence) or issubclass(t, Mapping):
+                if isinstance(t, type) and issubclass(t, (Sequence, Mapping, pydantic.BaseModel)):
                     return JsonType(nullable=nullable_default)
         return None
 
     @classmethod
     def normalize_type(
-        cls,
-        t: Union[ColumnType, type, _AnnotatedAlias],
-        nullable_default: bool = False,
-        allow_builtin_types: bool = True
+        cls, t: ColumnType | type | _AnnotatedAlias, nullable_default: bool = False, allow_builtin_types: bool = True
     ) -> ColumnType:
         """
         Convert any type recognizable by Pixeltable to its corresponding ColumnType.
@@ -358,25 +403,58 @@ class ColumnType:
             cls.__raise_exc_for_invalid_type(t)
         return col_type
 
-    __TYPE_SUGGESTIONS: list[tuple[type, str]] = [
+    __TYPE_SUGGESTIONS: ClassVar[list[tuple[type, str]]] = [
         (str, 'pxt.String'),
         (bool, 'pxt.Bool'),
         (int, 'pxt.Int'),
         (float, 'pxt.Float'),
         (datetime.datetime, 'pxt.Timestamp'),
+        (datetime.date, 'pxt.Date'),
+        (uuid.UUID, 'pxt.UUID'),
         (PIL.Image.Image, 'pxt.Image'),
+        (bytes, 'pxt.Binary'),
         (Sequence, 'pxt.Json'),
         (Mapping, 'pxt.Json'),
     ]
 
     @classmethod
-    def __raise_exc_for_invalid_type(cls, t: Union[type, _AnnotatedAlias]) -> None:
+    def __raise_exc_for_invalid_type(cls, t: type | _AnnotatedAlias) -> None:
         for builtin_type, suggestion in cls.__TYPE_SUGGESTIONS:
             if t is builtin_type or (isinstance(t, type) and issubclass(t, builtin_type)):
                 name = t.__name__ if t.__module__ == 'builtins' else f'{t.__module__}.{t.__name__}'
                 raise excs.Error(f'Standard Python type `{name}` cannot be used here; use `{suggestion}` instead')
         raise excs.Error(f'Unknown type: {t}')
 
+    @classmethod
+    def from_json_schema(cls, schema: dict[str, Any]) -> ColumnType | None:
+        # We first express the JSON schema as a Python type, and then convert it to a Pixeltable type.
+        # TODO: Is there a meaningful fallback if one of these operations fails? (Maybe another use case for a pxt Any
+        #     type?)
+        py_type = cls.__json_schema_to_py_type(schema)
+        return cls.from_python_type(py_type) if py_type is not None else None
+
+    @classmethod
+    def __json_schema_to_py_type(cls, schema: dict[str, Any]) -> type | _GenericAlias | None:
+        if 'type' in schema:
+            if schema['type'] == 'null':
+                return type(None)
+            if schema['type'] == 'string':
+                return str
+            if schema['type'] == 'integer':
+                return int
+            if schema['type'] == 'number':
+                return float
+            if schema['type'] == 'boolean':
+                return bool
+            if schema['type'] in ('array', 'object'):
+                return list
+        elif 'anyOf' in schema:
+            subscripts = tuple(cls.__json_schema_to_py_type(subschema) for subschema in schema['anyOf'])
+            if all(subscript is not None for subscript in subscripts):
+                return Union[subscripts]
+
+        return None
+
     def validate_literal(self, val: Any) -> None:
         """Raise TypeError if val is not a valid literal for this type"""
         if val is None:
@@ -396,15 +474,11 @@ class ColumnType:
     def _validate_file_path(self, val: Any) -> None:
         """Raises TypeError if not a valid local file path or not a path/byte sequence"""
         if isinstance(val, str):
-            parsed = urllib.parse.urlparse(val)
-            if parsed.scheme != '' and parsed.scheme != 'file':
-                return
-            path = Path(urllib.parse.unquote(urllib.request.url2pathname(parsed.path)))
-            if not path.is_file():
-                raise TypeError(f'File not found: {str(path)}')
-        else:
-            if not isinstance(val, bytes):
-                raise TypeError(f'expected file path or bytes, got {type(val)}')
+            path = parse_local_file_path(val)
+            if path is not None and not path.is_file():
+                raise TypeError(f'File not found: {path}')
+        elif not isinstance(val, bytes):
+            raise TypeError(f'expected file path or bytes, got {type(val)}')
 
     @abc.abstractmethod
     def _validate_literal(self, val: Any) -> None:
@@ -412,7 +486,7 @@ class ColumnType:
 
     def _create_literal(self, val: Any) -> Any:
         """Create a literal of this type from val, including any needed conversions.
-             val is guaranteed to be non-None"""
+        val is guaranteed to be non-None"""
         return val
 
     def create_literal(self, val: Any) -> Any:
@@ -429,6 +503,9 @@ class ColumnType:
     def is_scalar_type(self) -> bool:
         return self._type in self.scalar_types
 
+    def is_scalar_json_type(self) -> bool:
+        return self._type in self.scalar_json_types
+
     def is_numeric_type(self) -> bool:
         return self._type in self.numeric_types
 
@@ -450,12 +527,21 @@ class ColumnType:
     def is_timestamp_type(self) -> bool:
         return self._type == self.Type.TIMESTAMP
 
+    def is_date_type(self) -> bool:
+        return self._type == self.Type.DATE
+
+    def is_uuid_type(self) -> bool:
+        return self._type == self.Type.UUID
+
     def is_json_type(self) -> bool:
         return self._type == self.Type.JSON
 
     def is_array_type(self) -> bool:
         return self._type == self.Type.ARRAY
 
+    def is_binary_type(self) -> bool:
+        return self._type == self.Type.BINARY
+
     def is_image_type(self) -> bool:
         return self._type == self.Type.IMAGE
 
@@ -472,35 +558,85 @@ class ColumnType:
         # types that refer to external media files
         return self.is_image_type() or self.is_video_type() or self.is_audio_type() or self.is_document_type()
 
+    def supports_file_offloading(self) -> bool:
+        # types that can be offloaded to file-based storage via a CellMaterializationNode
+        return self.is_array_type() or self.is_json_type() or self.is_binary_type()
+
+    @classmethod
     @abc.abstractmethod
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         """
         Return corresponding SQLAlchemy type.
         """
-        pass
+
+    def to_json_schema(self) -> dict[str, Any]:
+        if self.nullable:
+            return {'anyOf': [self._to_json_schema(), {'type': 'null'}]}
+        else:
+            return self._to_json_schema()
+
+    def _to_json_schema(self) -> dict[str, Any]:
+        raise excs.Error(f'Pixeltable type {self} is not a valid JSON type')
+
+    @classmethod
+    def from_np_dtype(cls, dtype: np.dtype, nullable: bool) -> ColumnType | None:
+        """
+        Return pixeltable type corresponding to a given simple numpy dtype
+        """
+        if np.issubdtype(dtype, np.integer):
+            return IntType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.floating):
+            return FloatType(nullable=nullable)
+
+        if dtype == np.bool_:
+            return BoolType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.str_):
+            return StringType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.character):
+            return StringType(nullable=nullable)
+
+        if np.issubdtype(dtype, np.datetime64):
+            unit, _ = np.datetime_data(dtype)
+            if unit in ('D', 'M', 'Y'):
+                return DateType(nullable=nullable)
+            else:
+                return TimestampType(nullable=nullable)
+
+        return None
 
 
 class InvalidType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.INVALID, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
-        assert False
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
+        return sql.types.NullType()
 
     def print_value(self, val: Any) -> str:
         return str(val)
 
     def _validate_literal(self, val: Any) -> None:
-        assert False
+        raise AssertionError()
 
 
 class StringType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.STRING, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    def has_supertype(self) -> bool:
+        return not self.nullable
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.String()
 
+    def _to_json_schema(self) -> dict[str, Any]:
+        return {'type': 'string'}
+
     def print_value(self, val: Any) -> str:
         return f"'{val}'"
 
@@ -521,11 +657,17 @@ class IntType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.INT, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.BigInteger()
 
+    def _to_json_schema(self) -> dict[str, Any]:
+        return {'type': 'integer'}
+
     def _validate_literal(self, val: Any) -> None:
-        if not isinstance(val, int):
+        # bool is a subclass of int, so we need to check for it
+        # explicitly first
+        if isinstance(val, bool) or not isinstance(val, int):
             raise TypeError(f'Expected int, got {val.__class__.__name__}')
 
 
@@ -533,9 +675,13 @@ class FloatType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.FLOAT, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.Float()
 
+    def _to_json_schema(self) -> dict[str, Any]:
+        return {'type': 'number'}
+
     def _validate_literal(self, val: Any) -> None:
         if not isinstance(val, float):
             raise TypeError(f'Expected float, got {val.__class__.__name__}')
@@ -550,9 +696,13 @@ class BoolType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.BOOL, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.Boolean()
 
+    def _to_json_schema(self) -> dict[str, Any]:
+        return {'type': 'boolean'}
+
     def _validate_literal(self, val: Any) -> None:
         if not isinstance(val, bool):
             raise TypeError(f'Expected bool, got {val.__class__.__name__}')
@@ -567,7 +717,11 @@ class TimestampType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.TIMESTAMP, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    def has_supertype(self) -> bool:
+        return not self.nullable
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.TIMESTAMP(timezone=True)
 
     def _validate_literal(self, val: Any) -> None:
@@ -577,65 +731,120 @@ class TimestampType(ColumnType):
     def _create_literal(self, val: Any) -> Any:
         if isinstance(val, str):
             return datetime.datetime.fromisoformat(val)
+        # Place naive timestamps in the default time zone
+        if isinstance(val, datetime.datetime) and val.tzinfo is None:
+            return val.replace(tzinfo=Env.get().default_time_zone)
+        return val
+
+
+class DateType(ColumnType):
+    def __init__(self, nullable: bool = False):
+        super().__init__(self.Type.DATE, nullable=nullable)
+
+    def has_supertype(self) -> bool:
+        return not self.nullable
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
+        return sql.Date()
+
+    def _validate_literal(self, val: Any) -> None:
+        if not isinstance(val, datetime.date):
+            raise TypeError(f'Expected datetime.date, got {val.__class__.__name__}')
+
+    def _create_literal(self, val: Any) -> Any:
+        if isinstance(val, str):
+            return datetime.datetime.fromisoformat(val).date()
+        if isinstance(val, datetime.date):
+            return val
+        return val
+
+
+class UUIDType(ColumnType):
+    def __init__(self, nullable: bool = False):
+        super().__init__(self.Type.UUID, nullable=nullable)
+
+    def has_supertype(self) -> bool:
+        return not self.nullable
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
+        return sql.UUID(as_uuid=True)
+
+    def _to_json_schema(self) -> dict[str, Any]:
+        return {'type': 'string', 'format': 'uuid'}
+
+    def print_value(self, val: Any) -> str:
+        return f"'{val}'"
+
+    def _to_base_str(self) -> str:
+        return 'UUID'
+
+    def _validate_literal(self, val: Any) -> None:
+        if not isinstance(val, uuid.UUID):
+            raise TypeError(f'Expected uuid.UUID, got {val.__class__.__name__}')
+
+    def _create_literal(self, val: Any) -> Any:
+        if isinstance(val, str):
+            return uuid.UUID(val)
         return val
 
 
+class BinaryType(ColumnType):
+    def __init__(self, nullable: bool = False):
+        super().__init__(self.Type.BINARY, nullable=nullable)
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
+        return sql.LargeBinary()
+
+    def _to_base_str(self) -> str:
+        return 'Binary'
+
+    def _validate_literal(self, val: Any) -> None:
+        if not isinstance(val, bytes):
+            raise TypeError(f'Expected `bytes`, got `{val.__class__.__name__}`')
+
+
 class JsonType(ColumnType):
-    # TODO: type_spec also needs to be able to express lists
-    def __init__(self, type_spec: Optional[dict[str, ColumnType]] = None, nullable: bool = False):
+    json_schema: dict[str, Any] | None
+    __validator: jsonschema.protocols.Validator | None
+
+    def __init__(self, json_schema: dict[str, Any] | None = None, nullable: bool = False):
         super().__init__(self.Type.JSON, nullable=nullable)
-        self.type_spec = type_spec
+        self.json_schema = json_schema
+        if json_schema is None:
+            self.__validator = None
+        else:
+            validator_cls = jsonschema.validators.validator_for(json_schema)
+            validator_cls.check_schema(json_schema)
+            self.__validator = validator_cls(json_schema)
 
     def copy(self, nullable: bool) -> ColumnType:
-        return JsonType(self.type_spec, nullable=nullable)
+        return JsonType(json_schema=self.json_schema, nullable=nullable)
 
     def matches(self, other: ColumnType) -> bool:
-        return isinstance(other, JsonType) and self.type_spec == other.type_spec
-
-    def supertype(self, other: ColumnType) -> Optional[JsonType]:
-        if not isinstance(other, JsonType):
-            return None
-        if self.type_spec is None:
-            # we don't have a type spec and can accept anything accepted by other
-            return JsonType(nullable=(self.nullable or other.nullable))
-        if other.type_spec is None:
-            # we have a type spec but other doesn't
-            return JsonType(nullable=(self.nullable or other.nullable))
-
-        # we both have type specs; the supertype's type spec is the union of the two
-        type_spec: dict[str, ColumnType] = {}
-        type_spec.update(self.type_spec)
-        for other_field_name, other_field_type in other.type_spec.items():
-            if other_field_name not in type_spec:
-                type_spec[other_field_name] = other_field_type
-            else:
-                # both type specs have this field
-                field_type = type_spec[other_field_name].supertype(other_field_type)
-                if field_type is None:
-                    # conflicting types
-                    return JsonType(nullable=(self.nullable or other.nullable))
-                type_spec[other_field_name] = field_type
-        return JsonType(type_spec, nullable=(self.nullable or other.nullable))
+        return isinstance(other, JsonType) and self.json_schema == other.json_schema
 
     def _as_dict(self) -> dict:
         result = super()._as_dict()
-        if self.type_spec is not None:
-            type_spec_dict = {field_name: field_type.serialize() for field_name, field_type in self.type_spec.items()}
-            result.update({'type_spec': type_spec_dict})
+        if self.json_schema is not None:
+            result.update({'json_schema': self.json_schema})
         return result
 
     @classmethod
     def _from_dict(cls, d: dict) -> ColumnType:
-        type_spec = None
-        if 'type_spec' in d:
-            type_spec = {
-                field_name: cls.deserialize(field_type_dict) for field_name, field_type_dict in d['type_spec'].items()
-            }
-        return cls(type_spec, nullable=d['nullable'])
-
-    def to_sa_type(self) -> sql.types.TypeEngine:
+        return cls(json_schema=d.get('json_schema'), nullable=d['nullable'])
+
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.dialects.postgresql.JSONB()
 
+    def _to_json_schema(self) -> dict[str, Any]:
+        if self.json_schema is None:
+            return {}
+        return self.json_schema
+
     def print_value(self, val: Any) -> str:
         val_type = self.infer_literal_type(val)
         if val_type is None:
@@ -645,38 +854,200 @@ class JsonType(ColumnType):
         return val_type.print_value(val)
 
     def _validate_literal(self, val: Any) -> None:
-        if not isinstance(val, dict) and not isinstance(val, list):
-            # TODO In the future we should accept scalars too, which would enable us to remove this top-level check
-            raise TypeError(f'Expected dict or list, got {val.__class__.__name__}')
-        if not self.__is_valid_literal(val):
+        if isinstance(val, tuple):
+            val = list(val)
+        if isinstance(val, pydantic.BaseModel):
+            val = val.model_dump()
+        if not self.__is_valid_json(val):
             raise TypeError(f'That literal is not a valid Pixeltable JSON object: {val}')
+        if self.__validator is not None:
+            self.__validator.validate(val)
 
     @classmethod
-    def __is_valid_literal(cls, val: Any) -> bool:
-        if val is None or isinstance(val, (str, int, float, bool)):
+    def __is_valid_json(cls, val: Any) -> bool:
+        if val is None or isinstance(val, (str, int, float, bool, np.ndarray, PIL.Image.Image, bytes)):
             return True
         if isinstance(val, (list, tuple)):
-            return all(cls.__is_valid_literal(v) for v in val)
+            return all(cls.__is_valid_json(v) for v in val)
         if isinstance(val, dict):
-            return all(isinstance(k, str) and cls.__is_valid_literal(v) for k, v in val.items())
+            return all(isinstance(k, str) and cls.__is_valid_json(v) for k, v in val.items())
         return False
 
     def _create_literal(self, val: Any) -> Any:
         if isinstance(val, tuple):
             val = list(val)
+        if isinstance(val, pydantic.BaseModel):
+            return val.model_dump()
         return val
 
+    def supertype(self, other: ColumnType, for_inference: bool = False) -> JsonType | None:
+        # Try using the (much faster) supertype logic in ColumnType first. That will work if, for example, the types
+        # are identical except for nullability. If that doesn't work and both types are JsonType, then we will need to
+        # merge their schemas.
+        basic_supertype = super().supertype(other)
+        if basic_supertype is not None:
+            assert isinstance(basic_supertype, JsonType)
+            return basic_supertype
+
+        if not isinstance(other, JsonType):
+            return None
+
+        if self.json_schema is None or other.json_schema is None:
+            return JsonType(nullable=(self.nullable or other.nullable))
+
+        superschema = self.__superschema(self.json_schema, other.json_schema)
+
+        return JsonType(
+            json_schema=(None if len(superschema) == 0 else superschema), nullable=(self.nullable or other.nullable)
+        )
+
+    @classmethod
+    def __superschema(cls, a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any] | None:
+        # Defining a general type hierarchy over all JSON schemas would be a challenging problem. In order to keep
+        # things manageable, we only define a hierarchy among "conforming" schemas, which provides enough generality
+        # for the most important use cases (unions for type inference, validation of inline exprs). A schema is
+        # considered to be conforming if either:
+        # (i) it is a scalar (string, integer, number, boolean) or dictionary (object) type; or
+        # (ii) it is an "anyOf" schema of one of the above types and the exact schema {'type': 'null'}.
+        # Conforming schemas are organized into a type hierarchy in an internally consistent way. Nonconforming
+        # schemas are allowed, but they are isolates in the type hierarchy: a nonconforming schema has no proper
+        # subtypes, and its only proper supertype is an unconstrained JsonType().
+        #
+        # There is some subtlety in the handling of nullable fields. Nullable fields are represented in JSON
+        # schemas as (for example) {'anyOf': [{'type': 'string'}, {'type': 'null'}]}. When finding the supertype
+        # of schemas that might be nullable, we first unpack the 'anyOf's, find the supertype of the underlyings,
+        # then reapply the 'anyOf' if appropriate. The top-level schema (i.e., JsonType.json_schema) is presumed
+        # to NOT be in this form (since nullability is indicated by the `nullable` field of the JsonType object),
+        # so this subtlety is applicable only to types that occur in subfields.
+        #
+        # There is currently no special handling of lists; distinct schemas with type 'array' will union to the
+        # generic {'type': 'array'} schema. This could be a TODO item if there is a need for it in the future.
+
+        if a == b:
+            return a
+
+        if 'properties' in a and 'properties' in b:
+            a_props = a['properties']
+            b_props = b['properties']
+            a_req = a.get('required', [])
+            b_req = b.get('required', [])
+            super_props = {}
+            super_req = []
+            for key, a_prop_schema in a_props.items():
+                if key in b_props:  # in both a and b
+                    prop_schema = cls.__superschema_with_nulls(a_prop_schema, b_props[key])
+                    super_props[key] = prop_schema
+                    if key in a_req and key in b_req:
+                        super_req.append(key)
+                else:  # in a but not b
+                    # Add it to the supertype schema as optional (regardless of its status in a)
+                    super_props[key] = a_prop_schema
+            for key, b_prop_schema in b_props.items():
+                if key not in a_props:  # in b but not a
+                    super_props[key] = b_prop_schema
+            schema = {'type': 'object', 'properties': super_props}
+            if len(super_req) > 0:
+                schema['required'] = super_req
+            return schema
+
+        a_type = a.get('type')
+        b_type = b.get('type')
+
+        if a_type in ('string', 'integer', 'number', 'boolean', 'object', 'array') and a_type == b_type:
+            # a and b both have the same type designation, but are not identical. This can happen if
+            # (for example) they have validators or other attributes that differ. In this case, we
+            # generalize to {'type': t}, where t is their shared type, with no other qualifications.
+            return {'type': a_type}
+
+        return {}  # Unresolvable type conflict; the supertype is an unrestricted JsonType.
+
+    @classmethod
+    def __superschema_with_nulls(cls, a: dict[str, Any], b: dict[str, Any]) -> dict[str, Any] | None:
+        a, a_nullable = cls.__unpack_null_from_schema(a)
+        b, b_nullable = cls.__unpack_null_from_schema(b)
+
+        result = cls.__superschema(a, b)
+        if len(result) > 0 and (a_nullable or b_nullable):
+            # if len(result) == 0, then null is implicitly accepted; otherwise, we need to explicitly allow it
+            return {'anyOf': [result, {'type': 'null'}]}
+        return result
+
+    @classmethod
+    def __unpack_null_from_schema(cls, s: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+        if 'anyOf' in s and len(s['anyOf']) == 2 and {'type': 'null'} in s['anyOf']:
+            try:
+                return next(s for s in s['anyOf'] if s != {'type': 'null'}), True
+            except StopIteration:
+                pass
+        return s, False
+
+    def _to_base_str(self) -> str:
+        if self.json_schema is None:
+            return 'Json'
+        elif 'title' in self.json_schema:
+            return f'Json[{self.json_schema["title"]}]'
+        else:
+            return f'Json[{self.json_schema}]'
+
+
+ARRAY_SUPPORTED_NUMPY_DTYPES = [
+    np.bool_,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.float16,
+    np.float32,
+    np.float64,
+    np.str_,
+]
+
 
 class ArrayType(ColumnType):
-    def __init__(self, shape: tuple[Union[int, None], ...], dtype: ColumnType, nullable: bool = False):
+    pxt_dtype_to_numpy_dtype: ClassVar[dict[ColumnType.Type, np.dtype]] = {
+        ColumnType.Type.INT: np.dtype(np.int64),
+        ColumnType.Type.FLOAT: np.dtype(np.float32),
+        ColumnType.Type.BOOL: np.dtype(np.bool_),
+        ColumnType.Type.STRING: np.dtype(np.str_),
+    }
+
+    shape: tuple[int | None, ...] | None
+    dtype: np.dtype | None
+
+    def __init__(
+        self,
+        shape: tuple[int | None, ...] | None = None,
+        dtype: ColumnType | np.dtype | None = None,
+        nullable: bool = False,
+    ):
         super().__init__(self.Type.ARRAY, nullable=nullable)
+        assert shape is None or dtype is not None, (shape, dtype)  # cannot specify a shape without a dtype
         self.shape = shape
-        assert dtype.is_int_type() or dtype.is_float_type() or dtype.is_bool_type() or dtype.is_string_type()
-        self.pxt_dtype = dtype
-        self.dtype = dtype._type
+        if dtype is None:
+            self.dtype = None
+        elif isinstance(dtype, np.dtype):
+            # Numpy string has some specifications (endianness, max length, encoding) that we don't support, so we just
+            # strip them out.
+            if dtype.type == np.str_:
+                self.dtype = np.dtype(np.str_)
+            else:
+                if dtype not in ARRAY_SUPPORTED_NUMPY_DTYPES:
+                    raise ValueError(f'Unsupported dtype: {dtype}')
+                self.dtype = dtype
+        elif isinstance(dtype, ColumnType):
+            self.dtype = self.pxt_dtype_to_numpy_dtype.get(dtype._type, None)
+            if self.dtype is None:
+                raise ValueError(f'Unsupported dtype: {dtype}')
+            assert self.dtype in ARRAY_SUPPORTED_NUMPY_DTYPES
+        else:
+            raise ValueError(f'Unsupported dtype: {dtype}')
 
     def copy(self, nullable: bool) -> ColumnType:
-        return ArrayType(self.shape, self.pxt_dtype, nullable=nullable)
+        return ArrayType(self.shape, self.dtype, nullable=nullable)
 
     def matches(self, other: ColumnType) -> bool:
         return isinstance(other, ArrayType) and self.shape == other.shape and self.dtype == other.dtype
@@ -684,106 +1055,133 @@ class ArrayType(ColumnType):
     def __hash__(self) -> int:
         return hash((self._type, self.nullable, self.shape, self.dtype))
 
-    def supertype(self, other: ColumnType) -> Optional[ArrayType]:
+    def supertype(self, other: ColumnType, for_inference: bool = False) -> ArrayType | None:
+        basic_supertype = super().supertype(other)
+        if basic_supertype is not None:
+            assert isinstance(basic_supertype, ArrayType)
+            return basic_supertype
+
         if not isinstance(other, ArrayType):
             return None
-        if len(self.shape) != len(other.shape):
-            return None
-        base_type = self.Type.supertype(self.dtype, other.dtype, self.common_supertypes)
-        if base_type is None:
-            return None
-        shape = [n1 if n1 == n2 else None for n1, n2 in zip(self.shape, other.shape)]
-        return ArrayType(tuple(shape), self.make_type(base_type), nullable=(self.nullable or other.nullable))
+
+        # Supertype has dtype only if dtypes are identical. We can change this behavior to consider casting rules or
+        # something else if there's demand for it.
+        if self.dtype != other.dtype:
+            return ArrayType(nullable=(self.nullable or other.nullable))
+        super_dtype = self.dtype
+
+        # Determine the shape of the supertype
+        super_shape: tuple[int | None, ...] | None
+        if self.shape is None or other.shape is None or len(self.shape) != len(other.shape):
+            super_shape = None
+        else:
+            super_shape = tuple(n1 if n1 == n2 else None for n1, n2 in zip(self.shape, other.shape))
+        return ArrayType(super_shape, super_dtype, nullable=(self.nullable or other.nullable))
 
     def _as_dict(self) -> dict:
         result = super()._as_dict()
-        result.update(shape=list(self.shape), dtype=self.dtype.value)
+        shape_as_list = None if self.shape is None else list(self.shape)
+        result.update(shape=shape_as_list)
+
+        if self.dtype is None:
+            result.update(numpy_dtype=None)
+        elif self.dtype == np.str_:
+            # str(np.str_) would be something like '<U', but since we don't support the string specifications, just use
+            # 'str' instead to avoid confusion.
+            result.update(numpy_dtype='str')
+        else:
+            result.update(numpy_dtype=str(self.dtype))
         return result
 
     def _to_base_str(self) -> str:
-        return f'Array[{self.shape}, {self.pxt_dtype}]'
+        if self.shape is None and self.dtype is None:
+            return 'Array'
+        if self.shape is None:
+            return f'Array[{self.dtype.name}]'
+        assert self.dtype is not None
+        return f'Array[{self.shape}, {self.dtype.name}]'
 
     @classmethod
     def _from_dict(cls, d: dict) -> ColumnType:
+        assert 'numpy_dtype' in d
+        dtype = None if d['numpy_dtype'] is None else np.dtype(d['numpy_dtype'])
         assert 'shape' in d
-        assert 'dtype' in d
-        shape = tuple(d['shape'])
-        dtype = cls.make_type(cls.Type(d['dtype']))
+        shape = None if d['shape'] is None else tuple(d['shape'])
         return cls(shape, dtype, nullable=d['nullable'])
 
     @classmethod
-    def from_literal(cls, val: np.ndarray, nullable: bool = False) -> Optional[ArrayType]:
-        # determine our dtype
+    def from_literal(cls, val: np.ndarray, nullable: bool = False) -> ArrayType | None:
         assert isinstance(val, np.ndarray)
-        if np.issubdtype(val.dtype, np.integer):
-            dtype: ColumnType = IntType()
-        elif np.issubdtype(val.dtype, np.floating):
-            dtype = FloatType()
-        elif val.dtype == np.bool_:
-            dtype = BoolType()
-        elif val.dtype == np.str_:
-            dtype = StringType()
-        else:
+        if val.dtype.type not in ARRAY_SUPPORTED_NUMPY_DTYPES:
             return None
-        return cls(val.shape, dtype=dtype, nullable=nullable)
+        return cls(val.shape, dtype=val.dtype, nullable=nullable)
 
-    def is_valid_literal(self, val: np.ndarray) -> bool:
-        if not isinstance(val, np.ndarray):
-            return False
-        if len(val.shape) != len(self.shape):
-            return False
-        # check that the shapes are compatible
-        for n1, n2 in zip(val.shape, self.shape):
-            if n1 is None:
-                return False
-            if n2 is None:
-                # wildcard
-                continue
-            if n1 != n2:
-                return False
-        return val.dtype == self.numpy_dtype()
+    def _to_json_schema(self) -> dict[str, Any]:
+        schema: dict[str, Any] = {'type': 'array'}
+        if self.dtype == np.str_:
+            schema.update({'items': {'type': 'str'}})
+        elif self.dtype is not None:
+            schema.update({'items': {'type': str(self.dtype)}})
+        return schema
 
     def _validate_literal(self, val: Any) -> None:
         if not isinstance(val, np.ndarray):
             raise TypeError(f'Expected numpy.ndarray, got {val.__class__.__name__}')
-        if not self.is_valid_literal(val):
-            raise TypeError((
-                f'Expected ndarray({self.shape}, dtype={self.numpy_dtype()}), '
-                f'got ndarray({val.shape}, dtype={val.dtype})'))
+
+        # If column type has a dtype, check if it matches
+        if self.dtype == np.str_:
+            if val.dtype.type != np.str_:
+                raise TypeError(f'Expected numpy.ndarray of dtype {self.dtype}, got numpy.ndarray of dtype {val.dtype}')
+        elif self.dtype is not None and self.dtype != val.dtype:
+            raise TypeError(f'Expected numpy.ndarray of dtype {self.dtype}, got numpy.ndarray of dtype {val.dtype}')
+
+        # Check that the dtype is one of the supported types
+        if val.dtype.type != np.str_ and val.dtype not in ARRAY_SUPPORTED_NUMPY_DTYPES:
+            raise TypeError(f'Unsupported dtype {val.dtype}')
+
+        # If a shape is specified, check that there's a match
+        if self.shape is not None:
+            if len(val.shape) != len(self.shape):
+                raise TypeError(
+                    f'Expected numpy.ndarray({self.shape}, dtype={self.dtype}), '
+                    f'got numpy.ndarray({val.shape}, dtype={val.dtype})'
+                )
+            # check that the shapes are compatible
+            for n1, n2 in zip(val.shape, self.shape):
+                assert n1 is not None  # `val` must have a concrete shape
+                if n2 is None:
+                    continue  # wildcard
+                if n1 != n2:
+                    raise TypeError(
+                        f'Expected numpy.ndarray({self.shape}, dtype={self.dtype}), '
+                        f'got numpy.ndarray({val.shape}, dtype={val.dtype})'
+                    )
 
     def _create_literal(self, val: Any) -> Any:
-        if isinstance(val, (list,tuple)):
+        if isinstance(val, (list, tuple)):
             # map python float to whichever numpy float is
             # declared for this type, rather than assume float64
-            return np.array(val, dtype=self.numpy_dtype())
+            return np.array(val, dtype=self.dtype)
         return val
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.LargeBinary()
 
-    def numpy_dtype(self) -> np.dtype:
-        if self.dtype == self.Type.INT:
-            return np.dtype(np.int64)
-        if self.dtype == self.Type.FLOAT:
-            return np.dtype(np.float32)
-        if self.dtype == self.Type.BOOL:
-            return np.dtype(np.bool_)
-        if self.dtype == self.Type.STRING:
-            return np.dtype(np.str_)
-        assert False
-
 
 class ImageType(ColumnType):
     def __init__(
-            self, width: Optional[int] = None, height: Optional[int] = None, size: Optional[tuple[int, int]] = None,
-            mode: Optional[str] = None, nullable: bool = False
+        self,
+        width: int | None = None,
+        height: int | None = None,
+        size: tuple[int, int] | None = None,
+        mode: str | None = None,
+        nullable: bool = False,
     ):
-        """
-        TODO: does it make sense to specify only width or height?
-        """
+        # TODO: does it make sense to specify only width or height?
         super().__init__(self.Type.IMAGE, nullable=nullable)
-        assert not(width is not None and size is not None)
-        assert not(height is not None and size is not None)
+        assert not (width is not None and size is not None)
+        assert not (height is not None and size is not None)
         if size is not None:
             self.width = size[0]
             self.height = size[1]
@@ -818,16 +1216,22 @@ class ImageType(ColumnType):
     def __hash__(self) -> int:
         return hash((self._type, self.nullable, self.size, self.mode))
 
-    def supertype(self, other: ColumnType) -> Optional[ImageType]:
+    def supertype(self, other: ColumnType, for_inference: bool = False) -> ImageType | None:
+        basic_supertype = super().supertype(other)
+        if basic_supertype is not None:
+            assert isinstance(basic_supertype, ImageType)
+            return basic_supertype
+
         if not isinstance(other, ImageType):
             return None
+
         width = self.width if self.width == other.width else None
         height = self.height if self.height == other.height else None
         mode = self.mode if self.mode == other.mode else None
         return ImageType(width=width, height=height, mode=mode, nullable=(self.nullable or other.nullable))
 
     @property
-    def size(self) -> Optional[tuple[int, int]]:
+    def size(self) -> tuple[int, int] | None:
         if self.width is None or self.height is None:
             return None
         return (self.width, self.height)
@@ -844,7 +1248,8 @@ class ImageType(ColumnType):
         assert 'mode' in d
         return cls(width=d['width'], height=d['height'], mode=d['mode'], nullable=d['nullable'])
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         return sql.String()
 
     def _create_literal(self, val: Any) -> Any:
@@ -857,8 +1262,8 @@ class ImageType(ColumnType):
                 img.load()
                 return img
             except Exception as exc:
-                errormsg_val = val if len(val) < 50 else val[:50] + '...'
-                raise excs.Error(f'data URL could not be decoded into a valid image: {errormsg_val}') from exc
+                error_msg_val = val if len(val) < 50 else val[:50] + '...'
+                raise excs.Error(f'data URL could not be decoded into a valid image: {error_msg_val}') from exc
         return val
 
     def _validate_literal(self, val: Any) -> None:
@@ -878,7 +1283,8 @@ class VideoType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.VIDEO, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         # stored as a file path
         return sql.String()
 
@@ -902,7 +1308,7 @@ class VideoType(ColumnType):
                 if num_decoded < 2:
                     # this is most likely an image file
                     raise excs.Error(f'Not a valid video: {val}')
-        except av.AVError:
+        except av.FFmpegError:
             raise excs.Error(f'Not a valid video: {val}') from None
 
 
@@ -910,7 +1316,8 @@ class AudioType(ColumnType):
     def __init__(self, nullable: bool = False):
         super().__init__(self.Type.AUDIO, nullable=nullable)
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         # stored as a file path
         return sql.String()
 
@@ -929,7 +1336,7 @@ class AudioType(ColumnType):
                 for packet in container.demux(audio_stream):
                     for _ in packet.decode():
                         pass
-        except av.AVError as e:
+        except av.FFmpegError as e:
             raise excs.Error(f'Not a valid audio file: {val}\n{e}') from None
 
 
@@ -940,8 +1347,23 @@ class DocumentType(ColumnType):
         MD = 1
         PDF = 2
         XML = 3
+        TXT = 4
+
+        @classmethod
+        def from_extension(cls, ext: str) -> 'DocumentType.DocumentFormat' | None:
+            if ext in ('.htm', '.html'):
+                return cls.HTML
+            if ext == '.md':
+                return cls.MD
+            if ext == '.pdf':
+                return cls.PDF
+            if ext == '.xml':
+                return cls.XML
+            if ext == '.txt':
+                return cls.TXT
+            return None
 
-    def __init__(self, nullable: bool = False, doc_formats: Optional[str] = None):
+    def __init__(self, nullable: bool = False, doc_formats: str | None = None):
         super().__init__(self.Type.DOCUMENT, nullable=nullable)
         self.doc_formats = doc_formats
         if doc_formats is not None:
@@ -951,7 +1373,7 @@ class DocumentType(ColumnType):
                     raise ValueError(f'Invalid document type: {type_str}')
             self._doc_formats = [self.DocumentFormat[type_str.upper()] for type_str in type_strs]
         else:
-            self._doc_formats = [t for t in self.DocumentFormat]
+            self._doc_formats = list(self.DocumentFormat)
 
     def copy(self, nullable: bool) -> ColumnType:
         return DocumentType(doc_formats=self.doc_formats, nullable=nullable)
@@ -962,7 +1384,8 @@ class DocumentType(ColumnType):
     def __hash__(self) -> int:
         return hash((self._type, self.nullable, self._doc_formats))
 
-    def to_sa_type(self) -> sql.types.TypeEngine:
+    @classmethod
+    def to_sa_type(cls) -> sql.types.TypeEngine:
         # stored as a file path
         return sql.String()
 
@@ -972,9 +1395,8 @@ class DocumentType(ColumnType):
     def validate_media(self, val: Any) -> None:
         assert isinstance(val, str)
         from pixeltable.utils.documents import get_document_handle
-        dh = get_document_handle(val)
-        if dh is None:
-            raise excs.Error(f'Not a recognized document format: {val}')
+
+        _ = get_document_handle(val)
 
 
 T = typing.TypeVar('T')
@@ -985,6 +1407,7 @@ class Required(typing.Generic[T]):
     Marker class to indicate that a column is non-nullable in a schema definition. This has no meaning as a type hint,
     and is intended only for schema declarations.
     """
+
     pass
 
 
@@ -993,6 +1416,9 @@ Int = typing.Annotated[int, IntType(nullable=False)]
 Float = typing.Annotated[float, FloatType(nullable=False)]
 Bool = typing.Annotated[bool, BoolType(nullable=False)]
 Timestamp = typing.Annotated[datetime.datetime, TimestampType(nullable=False)]
+Date = typing.Annotated[datetime.date, DateType(nullable=False)]
+UUID = typing.Annotated[uuid.UUID, UUIDType(nullable=False)]
+Binary = typing.Annotated[bytes, BinaryType(nullable=False)]
 
 
 class _PxtType:
@@ -1007,7 +1433,8 @@ class _PxtType:
     `Image[(300, 300), 'RGB']`. The specialized forms resolve to `typing.Annotated` instances whose annotation is a
     `ColumnType`.
     """
-    def __init__(self):
+
+    def __init__(self) -> None:
         raise TypeError(f'Type `{type(self)}` cannot be instantiated.')
 
     @classmethod
@@ -1016,6 +1443,16 @@ class _PxtType:
 
 
 class Json(_PxtType):
+    def __class_getitem__(cls, item: Any) -> _AnnotatedAlias:
+        """
+        `item` (the type subscript) must be a `dict` representing a valid JSON Schema.
+        """
+        if not isinstance(item, dict):
+            raise TypeError('Json type parameter must be a dict')
+
+        # The JsonType initializer will validate the JSON Schema.
+        return typing.Annotated[Any, JsonType(json_schema=item, nullable=False)]
+
     @classmethod
     def as_col_type(cls, nullable: bool) -> ColumnType:
         return JsonType(nullable=nullable)
@@ -1024,14 +1461,19 @@ class Json(_PxtType):
 class Array(np.ndarray, _PxtType):
     def __class_getitem__(cls, item: Any) -> _AnnotatedAlias:
         """
-        `item` (the type subscript) must be a tuple with exactly two elements (in any order):
-        - A tuple of `Optional[int]`s, specifying the shape of the array
-        - A type, specifying the dtype of the array
-        Example: Array[(3, None, 2), pxt.Float]
+        `item` (the type subscript) must be a tuple with at most two elements (in any order):
+        - An optional tuple of `int | None`s, specifying the shape of the array
+        - A type (`ColumnType | np.dtype`), specifying the dtype of the array
+        Examples:
+        * Array[(3, None, 2), pxt.Float]
+        * Array[(4, 4), np.uint8]
+        * Array[np.bool]
         """
         params = item if isinstance(item, tuple) else (item,)
-        shape: Optional[tuple] = None
-        dtype: Optional[ColumnType] = None
+        shape: tuple | None = None
+        dtype: ColumnType | np.dtype | None = None
+        if not any(isinstance(param, (type, _AnnotatedAlias)) for param in params):
+            raise TypeError('Array type parameter must include a dtype.')
         for param in params:
             if isinstance(param, tuple):
                 if not all(n is None or (isinstance(n, int) and n >= 1) for n in param):
@@ -1039,21 +1481,20 @@ class Array(np.ndarray, _PxtType):
                 if shape is not None:
                     raise TypeError(f'Duplicate Array type parameter: {param}')
                 shape = param
-            elif isinstance(param, type) or isinstance(param, _AnnotatedAlias):
+            elif isinstance(param, (type, _AnnotatedAlias)):
                 if dtype is not None:
                     raise TypeError(f'Duplicate Array type parameter: {param}')
-                dtype = ColumnType.normalize_type(param, allow_builtin_types=False)
+                if isinstance(param, type) and param in ARRAY_SUPPORTED_NUMPY_DTYPES:
+                    dtype = np.dtype(param)
+                else:
+                    dtype = ColumnType.normalize_type(param, allow_builtin_types=False)
             else:
                 raise TypeError(f'Invalid Array type parameter: {param}')
-        if shape is None:
-            raise TypeError('Array type is missing parameter: shape')
-        if dtype is None:
-            raise TypeError('Array type is missing parameter: dtype')
         return typing.Annotated[np.ndarray, ArrayType(shape=shape, dtype=dtype, nullable=False)]
 
     @classmethod
     def as_col_type(cls, nullable: bool) -> ColumnType:
-        raise TypeError('Array type cannot be used without specifying shape and dtype')
+        return ArrayType(nullable=nullable)
 
 
 class Image(PIL.Image.Image, _PxtType):
@@ -1073,11 +1514,15 @@ class Image(PIL.Image.Image, _PxtType):
         else:
             # Not a tuple (single arg)
             params = (item,)
-        size: Optional[tuple] = None
-        mode: Optional[str] = None
+        size: tuple | None = None
+        mode: str | None = None
         for param in params:
             if isinstance(param, tuple):
-                if len(param) != 2 or not isinstance(param[0], (int, type(None))) or not isinstance(param[1], (int, type(None))):
+                if (
+                    len(param) != 2
+                    or not isinstance(param[0], (int, type(None)))
+                    or not isinstance(param[1], (int, type(None)))
+                ):
                     raise TypeError(f'Invalid Image type parameter: {param}')
                 if size is not None:
                     raise TypeError(f'Duplicate Image type parameter: {param}')
@@ -1113,3 +1558,21 @@ class Document(str, _PxtType):
     @classmethod
     def as_col_type(cls, nullable: bool) -> ColumnType:
         return DocumentType(nullable=nullable)
+
+
+ALL_PIXELTABLE_TYPES = (
+    String,
+    Bool,
+    Int,
+    Float,
+    Timestamp,
+    Json,
+    Array,
+    Image,
+    Video,
+    Audio,
+    Document,
+    Date,
+    UUID,
+    Binary,
+)