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

pixeltable/globals.py

@@ -1,16 +1,37 @@
+from __future__ import annotations
+
 import logging
+import os
 import urllib.parse
-from typing import Any, Iterable, Literal, Optional, Union
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Iterable, Iterator, Literal, Optional, Union
 
 import pandas as pd
 from pandas.io.formats.style import Styler
 
 from pixeltable import DataFrame, catalog, exceptions as excs, exprs, func, share
 from pixeltable.catalog import Catalog, TableVersionPath
-from pixeltable.dataframe import DataFrameResultSet
+from pixeltable.catalog.insertable_table import OnErrorParameter
 from pixeltable.env import Env
 from pixeltable.iterators import ComponentIterator
 
+if TYPE_CHECKING:
+    import datasets  # type: ignore[import-untyped]
+
+    RowData = list[dict[str, Any]]
+    TableDataSource = Union[
+        str,
+        os.PathLike,
+        Path,  # OS paths, filenames, URLs
+        Iterator[dict[str, Any]],  # iterator producing dictionaries of values
+        RowData,  # list of dictionaries
+        DataFrame,  # Pixeltable DataFrame
+        pd.DataFrame,  # pandas DataFrame
+        'datasets.Dataset',
+        'datasets.DatasetDict',  # Huggingface datasets
+    ]
+
+
 _logger = logging.getLogger('pixeltable')
 
 
@@ -20,21 +41,35 @@ def init() -> None:
 
 
 def create_table(
-    path: str,
-    schema_or_df: Union[dict[str, Any], DataFrame],
+    path_str: str,
+    schema: Optional[dict[str, Any]] = None,
     *,
+    source: Optional[TableDataSource] = None,
+    source_format: Optional[Literal['csv', 'excel', 'parquet', 'json']] = None,
+    schema_overrides: Optional[dict[str, Any]] = None,
+    on_error: Literal['abort', 'ignore'] = 'abort',
     primary_key: Optional[Union[str, list[str]]] = None,
     num_retained_versions: int = 10,
     comment: str = '',
     media_validation: Literal['on_read', 'on_write'] = 'on_write',
     if_exists: Literal['error', 'ignore', 'replace', 'replace_force'] = 'error',
+    extra_args: Optional[dict[str, Any]] = None,  # Additional arguments to data source provider
 ) -> catalog.Table:
     """Create a new base table.
 
     Args:
-        path: Path to the table.
-        schema_or_df: Either a dictionary that maps column names to column types, or a
-            [`DataFrame`][pixeltable.DataFrame] whose contents and schema will be used to pre-populate the table.
+        path_str: Path to the table.
+        schema: A dictionary that maps column names to column types
+        source: A data source from which a table schema can be inferred and data imported
+        source_format: A hint to the format of the source data
+        schema_overrides: If specified, then columns in `schema_overrides` will be given the specified types
+        on_error: Determines the behavior if an error occurs while evaluating a computed column or detecting an
+            invalid media file (such as a corrupt image) for one of the inserted rows.
+
+            - If `on_error='abort'`, then an exception will be raised and the rows will not be inserted.
+            - If `on_error='ignore'`, then execution will continue and the rows will be inserted. Any cells
+                with errors will have a `None` value for that cell, with information about the error stored in the
+                corresponding `tbl.col_name.errortype` and `tbl.col_name.errormsg` fields.
         primary_key: An optional column name or list of column names to use as the primary key(s) of the
             table.
         num_retained_versions: Number of versions of the table to retain.
@@ -50,6 +85,7 @@ def create_table(
             - `'ignore'`: do nothing and return the existing table handle
             - `'replace'`: if the existing table has no views, drop and replace it with a new one
             - `'replace_force'`: drop the existing table and all its views, and create a new one
+        extra_args: Additional arguments to pass to the source data provider
 
     Returns:
         A handle to the newly created table, or to an already existing table at the path when `if_exists='ignore'`.
@@ -61,7 +97,8 @@ def create_table(
             - the path is invalid, or
             - the path already exists and `if_exists='error'`, or
             - the path already exists and is not a table, or
-            - an error occurs while attempting to create the table.
+            - an error occurs while attempting to create the table, or
+            - an error occurs while attempting to import data from the source.
 
     Examples:
         Create a table with an int and a string column:
@@ -81,45 +118,60 @@ def create_table(
         Create a table with an int and a float column, and replace any existing table:
 
         >>> tbl = pxt.create_table('my_table', schema={'col1': pxt.Int, 'col2': pxt.Float}, if_exists='replace')
+
+        Create a table from a CSV file:
+
+        >>> tbl = pxt.create_table('my_table', source='data.csv')
     """
-    path_obj = catalog.Path(path)
+    from pixeltable.io.table_data_conduit import DFTableDataConduit, UnkTableDataConduit
+    from pixeltable.io.utils import normalize_primary_key_parameter
+
+    if (schema is None) == (source is None):
+        raise excs.Error('Must provide either a `schema` or a `source`')
+
+    if schema is not None and (len(schema) == 0 or not isinstance(schema, dict)):
+        raise excs.Error('`schema` must be a non-empty dictionary')
+
+    path_obj = catalog.Path(path_str)
     if_exists_ = catalog.IfExistsParam.validated(if_exists, 'if_exists')
+    media_validation_ = catalog.MediaValidation.validated(media_validation, 'media_validation')
+    primary_key: Optional[list[str]] = normalize_primary_key_parameter(primary_key)
+    table: catalog.Table = None
+    tds = None
+    data_source = None
+    if source is not None:
+        tds = UnkTableDataConduit(source, source_format=source_format, extra_fields=extra_args)
+        tds.check_source_format()
+        data_source = tds.specialize()
+        data_source.src_schema_overrides = schema_overrides
+        data_source.src_pk = primary_key
+        data_source.infer_schema()
+        schema = data_source.pxt_schema
+        primary_key = data_source.pxt_pk
+        is_direct_df = data_source.is_direct_df()
+    else:
+        is_direct_df = False
 
-    df: Optional[DataFrame] = None
-    if isinstance(schema_or_df, dict):
-        schema = schema_or_df
-    elif isinstance(schema_or_df, DataFrame):
-        df = schema_or_df
-        schema = df.schema
-    elif isinstance(schema_or_df, DataFrameResultSet):
+    if len(schema) == 0 or not isinstance(schema, dict):
         raise excs.Error(
-            '`schema_or_df` must be either a schema dictionary or a Pixeltable DataFrame. '
-            '(Is there an extraneous call to `collect()`?)'
+            'Unable to create a proper schema from supplied `source`. Please use appropriate `schema_overrides`.'
         )
-    else:
-        raise excs.Error('`schema_or_df` must be either a schema dictionary or a Pixeltable DataFrame.')
-
-    if len(schema) == 0:
-        raise excs.Error(f'Table schema is empty: {path!r}')
-
-    if primary_key is None:
-        primary_key = []
-    elif isinstance(primary_key, str):
-        primary_key = [primary_key]
-    elif not isinstance(primary_key, list) or not all(isinstance(pk, str) for pk in primary_key):
-        raise excs.Error('primary_key must be a single column name or a list of column names')
 
-    media_validation_ = catalog.MediaValidation.validated(media_validation, 'media_validation')
-    return Catalog.get().create_table(
+    table = Catalog.get().create_table(
         path_obj,
         schema,
-        df,
+        data_source.pxt_df if isinstance(data_source, DFTableDataConduit) else None,
         if_exists=if_exists_,
         primary_key=primary_key,
         comment=comment,
         media_validation=media_validation_,
         num_retained_versions=num_retained_versions,
     )
+    if data_source is not None and not is_direct_df:
+        fail_on_exception = OnErrorParameter.fail_on_exception(on_error)
+        table.insert_table_data_source(data_source=data_source, fail_on_exception=fail_on_exception)
+
+    return table
 
 
 def create_view(

pixeltable/index/embedding_index.py

@@ -208,7 +208,18 @@ class EmbeddingIndex(IndexBase):
                 and len(sig.required_parameters) <= 1
                 and sig.parameters_by_pos[0].col_type.type_enum == expected_type
             ):
-                return resolved_fn
+                # We found a valid signature. Now, if it has more than one parameter, we need to transform it into a
+                # 1-ary function by fixing all the other parameters to their defaults. This is to ensure that
+                # conditional_return_type resolves correctly.
+                if len(sig.parameters) == 1:
+                    unary_fn = resolved_fn
+                else:
+                    assert all(sig.parameters_by_pos[i].has_default for i in range(1, len(sig.parameters)))
+                    defaults = {param.name: param.default for param in sig.parameters_by_pos[1:]}
+                    unary_fn = resolved_fn.using(**defaults)
+                assert not unary_fn.is_polymorphic
+                assert len(unary_fn.signature.parameters) == 1
+                return unary_fn
         return None
 
     @classmethod

pixeltable/io/__init__.py

@@ -1,13 +1,16 @@
+# ruff: noqa: F401
+
+from .datarows import import_json, import_rows
 from .external_store import ExternalStore, SyncStatus
-from .globals import create_label_studio_project, export_images_as_fo_dataset, import_json, import_rows
+from .globals import create_label_studio_project, export_images_as_fo_dataset
 from .hf_datasets import import_huggingface_dataset
 from .pandas import import_csv, import_excel, import_pandas
 from .parquet import export_parquet, import_parquet
 
-__default_dir = set(symbol for symbol in dir() if not symbol.startswith('_'))
-__removed_symbols = {'globals', 'hf_datasets', 'pandas', 'parquet'}
-__all__ = sorted(list(__default_dir - __removed_symbols))
+__default_dir = {symbol for symbol in dir() if not symbol.startswith('_')}
+__removed_symbols = {'globals', 'hf_datasets', 'pandas', 'parquet', 'datarows'}
+__all__ = sorted(__default_dir - __removed_symbols)
 
 
-def __dir__():
+def __dir__() -> list[str]:
     return __all__

pixeltable/io/datarows.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Any, Iterable, Optional, Union
+
+import pixeltable as pxt
+from pixeltable import exceptions as excs
+
+
+def _infer_schema_from_rows(
+    rows: Iterable[dict[str, Any]], schema_overrides: dict[str, Any], primary_key: list[str]
+) -> dict[str, pxt.ColumnType]:
+    schema: dict[str, pxt.ColumnType] = {}
+    cols_with_nones: set[str] = set()
+
+    for n, row in enumerate(rows):
+        for col_name, value in row.items():
+            if col_name in schema_overrides:
+                # We do the insertion here; this will ensure that the column order matches the order
+                # in which the column names are encountered in the input data, even if `schema_overrides`
+                # is specified.
+                if col_name not in schema:
+                    schema[col_name] = schema_overrides[col_name]
+            elif value is not None:
+                # If `key` is not in `schema_overrides`, then we infer its type from the data.
+                # The column type will always be nullable by default.
+                col_type = pxt.ColumnType.infer_literal_type(value, nullable=col_name not in primary_key)
+                if col_type is None:
+                    raise excs.Error(
+                        f'Could not infer type for column `{col_name}`; the value in row {n} '
+                        f'has an unsupported type: {type(value)}'
+                    )
+                if col_name not in schema:
+                    schema[col_name] = col_type
+                else:
+                    supertype = schema[col_name].supertype(col_type)
+                    if supertype is None:
+                        raise excs.Error(
+                            f'Could not infer type of column `{col_name}`; the value in row {n} '
+                            f'does not match preceding type {schema[col_name]}: {value!r}\n'
+                            'Consider specifying the type explicitly in `schema_overrides`.'
+                        )
+                    schema[col_name] = supertype
+            else:
+                cols_with_nones.add(col_name)
+
+    entirely_none_cols = cols_with_nones - schema.keys()
+    if len(entirely_none_cols) > 0:
+        # A column can only end up in `entirely_none_cols` if it was not in `schema_overrides` and
+        # was not encountered in any row with a non-None value.
+        raise excs.Error(
+            f'The following columns have no non-null values: {", ".join(entirely_none_cols)}\n'
+            'Consider specifying the type(s) explicitly in `schema_overrides`.'
+        )
+    return schema
+
+
+def import_rows(
+    tbl_path: str,
+    rows: list[dict[str, Any]],
+    *,
+    schema_overrides: Optional[dict[str, Any]] = None,
+    primary_key: Optional[Union[str, list[str]]] = None,
+    num_retained_versions: int = 10,
+    comment: str = '',
+) -> pxt.Table:
+    """
+    Creates a new base table from a list of dictionaries. The dictionaries must be of the
+    form `{column_name: value, ...}`. Pixeltable will attempt to infer the schema of the table from the
+    supplied data, using the most specific type that can represent all the values in a column.
+
+    If `schema_overrides` is specified, then for each entry `(column_name, type)` in `schema_overrides`,
+    Pixeltable will force the specified column to the specified type (and will not attempt any type inference
+    for that column).
+
+    All column types of the new table will be nullable unless explicitly specified as non-nullable in
+    `schema_overrides`.
+
+    Args:
+        tbl_path: The qualified name of the table to create.
+        rows: The list of dictionaries to import.
+        schema_overrides: If specified, then columns in `schema_overrides` will be given the specified types
+            as described above.
+        primary_key: The primary key of the table (see [`create_table()`][pixeltable.create_table]).
+        num_retained_versions: The number of retained versions of the table
+            (see [`create_table()`][pixeltable.create_table]).
+        comment: A comment to attach to the table (see [`create_table()`][pixeltable.create_table]).
+
+    Returns:
+        A handle to the newly created [`Table`][pixeltable.Table].
+    """
+    return pxt.create_table(
+        tbl_path,
+        source=rows,
+        schema_overrides=schema_overrides,
+        primary_key=primary_key,
+        num_retained_versions=num_retained_versions,
+        comment=comment,
+    )
+
+
+def import_json(
+    tbl_path: str,
+    filepath_or_url: str,
+    *,
+    schema_overrides: Optional[dict[str, Any]] = None,
+    primary_key: Optional[Union[str, list[str]]] = None,
+    num_retained_versions: int = 10,
+    comment: str = '',
+    **kwargs: Any,
+) -> pxt.Table:
+    """
+    Creates a new base table from a JSON file. This is a convenience method and is
+    equivalent to calling `import_data(table_path, json.loads(file_contents, **kwargs), ...)`, where `file_contents`
+    is the contents of the specified `filepath_or_url`.
+
+    Args:
+        tbl_path: The name of the table to create.
+        filepath_or_url: The path or URL of the JSON file.
+        schema_overrides: If specified, then columns in `schema_overrides` will be given the specified types
+            (see [`import_rows()`][pixeltable.io.import_rows]).
+        primary_key: The primary key of the table (see [`create_table()`][pixeltable.create_table]).
+        num_retained_versions: The number of retained versions of the table
+            (see [`create_table()`][pixeltable.create_table]).
+        comment: A comment to attach to the table (see [`create_table()`][pixeltable.create_table]).
+        kwargs: Additional keyword arguments to pass to `json.loads`.
+
+    Returns:
+        A handle to the newly created [`Table`][pixeltable.Table].
+    """
+    return pxt.create_table(
+        tbl_path,
+        source=filepath_or_url,
+        schema_overrides=schema_overrides,
+        primary_key=primary_key,
+        num_retained_versions=num_retained_versions,
+        comment=comment,
+        extra_args=kwargs,
+    )

pixeltable/io/external_store.py

@@ -97,7 +97,7 @@ class Project(ExternalStore, abc.ABC):
         # This ensures that the media in those columns resides in the media store.
         # First determine which columns (if any) need stored proxies, but don't have one yet.
         stored_proxies_needed: list[Column] = []
-        for col in self.col_mapping.keys():
+        for col in self.col_mapping:
             if col.col_type.is_media_type() and not (col.is_stored and col.is_computed):
                 # If this column is already proxied in some other Project, use the existing proxy to avoid
                 # duplication. Otherwise, we'll create a new one.
@@ -234,7 +234,8 @@ class Project(ExternalStore, abc.ABC):
                 else:
                     raise excs.Error(
                         f'Column `{t_col}` does not exist in Table `{table._name}`. Either add a column `{t_col}`, '
-                        f'or specify a `col_mapping` to associate a different column with the external field `{ext_col}`.'
+                        f'or specify a `col_mapping` to associate a different column with '
+                        f'the external field `{ext_col}`.'
                     )
             if ext_col not in export_cols and ext_col not in import_cols:
                 raise excs.Error(
@@ -253,7 +254,8 @@ class Project(ExternalStore, abc.ABC):
                 ext_col_type = export_cols[ext_col]
                 if not ext_col_type.is_supertype_of(t_col_type, ignore_nullable=True):
                     raise excs.Error(
-                        f'Column `{t_col}` cannot be exported to external column `{ext_col}` (incompatible types; expecting `{ext_col_type}`)'
+                        f'Column `{t_col}` cannot be exported to external column `{ext_col}` '
+                        f'(incompatible types; expecting `{ext_col_type}`)'
                     )
             if ext_col in import_cols:
                 # Validate that the external column can be assigned to the table column
@@ -264,7 +266,8 @@ class Project(ExternalStore, abc.ABC):
                 ext_col_type = import_cols[ext_col]
                 if not t_col_type.is_supertype_of(ext_col_type, ignore_nullable=True):
                     raise excs.Error(
-                        f'Column `{t_col}` cannot be imported from external column `{ext_col}` (incompatible types; expecting `{ext_col_type}`)'
+                        f'Column `{t_col}` cannot be imported from external column `{ext_col}` '
+                        f'(incompatible types; expecting `{ext_col_type}`)'
                     )
         return resolved_col_mapping
 
@@ -368,7 +371,7 @@ class MockProject(Project):
             {cls._column_from_dict(entry[0]): cls._column_from_dict(entry[1]) for entry in md['stored_proxies']},
         )
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, MockProject):
             return False
         return self.name == other.name

pixeltable/io/fiftyone.py

@@ -1,5 +1,5 @@
 import os
-from typing import Iterator, Optional, Union
+from typing import Any, Iterator, Optional, Union
 
 import fiftyone as fo  # type: ignore[import-untyped]
 import fiftyone.utils.data as foud  # type: ignore[import-untyped]
@@ -59,10 +59,9 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
         for exprs_, label_cls, default_name in label_categories:
             if exprs_ is None or isinstance(exprs_, dict):
                 continue
-            if isinstance(exprs_, exprs.Expr):
-                exprs_ = [exprs_]
-            assert isinstance(exprs_, list)
-            for expr in exprs_:
+            exprs_list = [exprs_] if isinstance(exprs_, exprs.Expr) else exprs_
+            assert isinstance(exprs_list, list)
+            for expr in exprs_list:
                 if default_name not in self.__labels:
                     name = default_name
                 else:
@@ -125,7 +124,7 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
             elif label_cls is fo.Detections:
                 label = fo.Detections(detections=self.__as_fo_detections(label_data))
             else:
-                assert False
+                raise AssertionError()
             labels[label_name] = label
 
         return file, metadata, labels
@@ -166,5 +165,5 @@ class PxtImageDatasetImporter(foud.LabeledImageDatasetImporter):
     def get_dataset_info(self) -> dict:
         pass
 
-    def close(self, *args) -> None:
+    def close(self, *args: Any) -> None:
         pass

pixeltable/io/globals.py

@@ -1,7 +1,5 @@
-import json
-import urllib.parse
-import urllib.request
-from pathlib import Path
+from __future__ import annotations
+
 from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import pixeltable as pxt
@@ -9,61 +7,11 @@ import pixeltable.exceptions as excs
 from pixeltable import Table, exprs
 from pixeltable.env import Env
 from pixeltable.io.external_store import SyncStatus
-from pixeltable.utils import parse_local_file_path
 
 if TYPE_CHECKING:
     import fiftyone as fo  # type: ignore[import-untyped]
 
 
-from .utils import find_or_create_table, normalize_import_parameters, normalize_schema_names
-
-
-def _infer_schema_from_rows(
-    rows: list[dict[str, Any]], schema_overrides: dict[str, Any], primary_key: list[str]
-) -> dict[str, pxt.ColumnType]:
-    schema: dict[str, pxt.ColumnType] = {}
-    cols_with_nones: set[str] = set()
-
-    for n, row in enumerate(rows):
-        for col_name, value in row.items():
-            if col_name in schema_overrides:
-                # We do the insertion here; this will ensure that the column order matches the order
-                # in which the column names are encountered in the input data, even if `schema_overrides`
-                # is specified.
-                if col_name not in schema:
-                    schema[col_name] = schema_overrides[col_name]
-            elif value is not None:
-                # If `key` is not in `schema_overrides`, then we infer its type from the data.
-                # The column type will always be nullable by default.
-                col_type = pxt.ColumnType.infer_literal_type(value, nullable=col_name not in primary_key)
-                if col_type is None:
-                    raise excs.Error(
-                        f'Could not infer type for column `{col_name}`; the value in row {n} has an unsupported type: {type(value)}'
-                    )
-                if col_name not in schema:
-                    schema[col_name] = col_type
-                else:
-                    supertype = schema[col_name].supertype(col_type)
-                    if supertype is None:
-                        raise excs.Error(
-                            f'Could not infer type of column `{col_name}`; the value in row {n} does not match preceding type {schema[col_name]}: {value!r}\n'
-                            'Consider specifying the type explicitly in `schema_overrides`.'
-                        )
-                    schema[col_name] = supertype
-            else:
-                cols_with_nones.add(col_name)
-
-    entirely_none_cols = cols_with_nones - schema.keys()
-    if len(entirely_none_cols) > 0:
-        # A column can only end up in `entirely_none_cols` if it was not in `schema_overrides` and
-        # was not encountered in any row with a non-None value.
-        raise excs.Error(
-            f'The following columns have no non-null values: {", ".join(entirely_none_cols)}\n'
-            'Consider specifying the type(s) explicitly in `schema_overrides`.'
-        )
-    return schema
-
-
 def create_label_studio_project(
     t: Table,
     label_config: str,
@@ -140,9 +88,9 @@ def create_label_studio_project(
             parameters of the Label Studio `connect_s3_import_storage` method, as described in the
             [Label Studio connect_s3_import_storage docs](https://labelstud.io/sdk/project.html#label_studio_sdk.project.Project.connect_s3_import_storage).
             `bucket` must be specified; all other parameters are optional. If credentials are not specified explicitly,
-            Pixeltable will attempt to retrieve them from the environment (such as from `~/.aws/credentials`). If a title is not
-            specified, Pixeltable will use the default `'Pixeltable-S3-Import-Storage'`. All other parameters use their Label
-            Studio defaults.
+            Pixeltable will attempt to retrieve them from the environment (such as from `~/.aws/credentials`).
+            If a title is not specified, Pixeltable will use the default `'Pixeltable-S3-Import-Storage'`.
+            All other parameters use their Label Studio defaults.
         kwargs: Additional keyword arguments are passed to the `start_project` method in the Label
             Studio SDK, as described in the
             [Label Studio start_project docs](https://labelstud.io/sdk/project.html#label_studio_sdk.project.Project.start_project).
@@ -151,7 +99,8 @@ def create_label_studio_project(
         A `SyncStatus` representing the status of any synchronization operations that occurred.
 
     Examples:
-        Create a Label Studio project whose tasks correspond to videos stored in the `video_col` column of the table `tbl`:
+        Create a Label Studio project whose tasks correspond to videos stored in the `video_col`
+        column of the table `tbl`:
 
         >>> config = \"\"\"
             <View>
@@ -190,108 +139,6 @@ def create_label_studio_project(
         return SyncStatus.empty()
 
 
-def import_rows(
-    tbl_path: str,
-    rows: list[dict[str, Any]],
-    *,
-    schema_overrides: Optional[dict[str, Any]] = None,
-    primary_key: Optional[Union[str, list[str]]] = None,
-    num_retained_versions: int = 10,
-    comment: str = '',
-) -> Table:
-    """
-    Creates a new base table from a list of dictionaries. The dictionaries must be of the
-    form `{column_name: value, ...}`. Pixeltable will attempt to infer the schema of the table from the
-    supplied data, using the most specific type that can represent all the values in a column.
-
-    If `schema_overrides` is specified, then for each entry `(column_name, type)` in `schema_overrides`,
-    Pixeltable will force the specified column to the specified type (and will not attempt any type inference
-    for that column).
-
-    All column types of the new table will be nullable unless explicitly specified as non-nullable in
-    `schema_overrides`.
-
-    Args:
-        tbl_path: The qualified name of the table to create.
-        rows: The list of dictionaries to import.
-        schema_overrides: If specified, then columns in `schema_overrides` will be given the specified types
-            as described above.
-        primary_key: The primary key of the table (see [`create_table()`][pixeltable.create_table]).
-        num_retained_versions: The number of retained versions of the table (see [`create_table()`][pixeltable.create_table]).
-        comment: A comment to attach to the table (see [`create_table()`][pixeltable.create_table]).
-
-    Returns:
-        A handle to the newly created [`Table`][pixeltable.Table].
-    """
-    schema_overrides, primary_key = normalize_import_parameters(schema_overrides, primary_key)
-    row_schema = _infer_schema_from_rows(rows, schema_overrides, primary_key)
-    schema, pxt_pk, _ = normalize_schema_names(row_schema, primary_key, schema_overrides, True)
-
-    table = find_or_create_table(
-        tbl_path, schema, primary_key=pxt_pk, num_retained_versions=num_retained_versions, comment=comment
-    )
-    table.insert(rows)
-    return table
-
-
-def import_json(
-    tbl_path: str,
-    filepath_or_url: str,
-    *,
-    schema_overrides: Optional[dict[str, Any]] = None,
-    primary_key: Optional[Union[str, list[str]]] = None,
-    num_retained_versions: int = 10,
-    comment: str = '',
-    **kwargs: Any,
-) -> Table:
-    """
-    Creates a new base table from a JSON file. This is a convenience method and is
-    equivalent to calling `import_data(table_path, json.loads(file_contents, **kwargs), ...)`, where `file_contents`
-    is the contents of the specified `filepath_or_url`.
-
-    Args:
-        tbl_path: The name of the table to create.
-        filepath_or_url: The path or URL of the JSON file.
-        schema_overrides: If specified, then columns in `schema_overrides` will be given the specified types
-            (see [`import_rows()`][pixeltable.io.import_rows]).
-        primary_key: The primary key of the table (see [`create_table()`][pixeltable.create_table]).
-        num_retained_versions: The number of retained versions of the table (see [`create_table()`][pixeltable.create_table]).
-        comment: A comment to attach to the table (see [`create_table()`][pixeltable.create_table]).
-        kwargs: Additional keyword arguments to pass to `json.loads`.
-
-    Returns:
-        A handle to the newly created [`Table`][pixeltable.Table].
-    """
-    path = parse_local_file_path(filepath_or_url)
-    if path is None:  # it's a URL
-        # TODO: This should read from S3 as well.
-        contents = urllib.request.urlopen(filepath_or_url).read()
-    else:
-        with open(path) as fp:
-            contents = fp.read()
-
-    rows = json.loads(contents, **kwargs)
-
-    schema_overrides, primary_key = normalize_import_parameters(schema_overrides, primary_key)
-    row_schema = _infer_schema_from_rows(rows, schema_overrides, primary_key)
-    schema, pxt_pk, col_mapping = normalize_schema_names(row_schema, primary_key, schema_overrides, False)
-
-    # Convert all rows to insertable format - not needed, misnamed columns and types are errors in the incoming row format
-    if col_mapping is not None:
-        tbl_rows = [
-            {field if col_mapping is None else col_mapping[field]: val for field, val in row.items()} for row in rows
-        ]
-    else:
-        tbl_rows = rows
-
-    table = find_or_create_table(
-        tbl_path, schema, primary_key=pxt_pk, num_retained_versions=num_retained_versions, comment=comment
-    )
-
-    table.insert(tbl_rows)
-    return table
-
-
 def export_images_as_fo_dataset(
     tbl: pxt.Table,
     images: exprs.Expr,