pixeltable 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

pixeltable/func/batched_function.py

@@ -1,53 +0,0 @@
-import inspect
-from typing import List, Dict, Any, Optional, Callable
-import abc
-
-from .function import Function
-from .signature import Signature
-
-
-class BatchedFunction(Function):
-    """Base class for functions that can run on batches"""
-
-    @abc.abstractmethod
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
-        """Return the batch size for the given arguments, or None if the batch size is unknown.
-        args/kwargs might be empty
-        """
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def invoke(self, arg_batches: List[List[Any]], kwarg_batches: Dict[str, List[Any]]) -> List[Any]:
-        """Invoke the function for the given batch and return a batch of results"""
-        raise NotImplementedError
-
-
-class ExplicitBatchedFunction(BatchedFunction):
-    """
-    A `BatchedFunction` that is defined by a signature and an explicit python
-    `Callable`.
-    """
-    def __init__(self, signature: Signature, batch_size: Optional[int], invoker_fn: Callable, self_path: str):
-        super().__init__(signature=signature, py_signature=inspect.signature(invoker_fn), self_path=self_path)
-        self.batch_size = batch_size
-        self.invoker_fn = invoker_fn
-
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
-        return self.batch_size
-
-    def invoke(self, arg_batches: List[List[Any]], kwarg_batches: Dict[str, List[Any]]) -> List[Any]:
-        """Invoke the function for the given batch and return a batch of results"""
-        constant_param_names = [p.name for p in self.signature.constant_parameters]
-        kwargs = {k: v[0] for k, v in kwarg_batches.items() if k in constant_param_names}
-        kwarg_batches = {k: v for k, v in kwarg_batches.items() if k not in constant_param_names}
-        return self.invoker_fn(*arg_batches, **kwargs, **kwarg_batches)
-
-    def validate_call(self, bound_args: Dict[str, Any]) -> None:
-        """Verify constant parameters"""
-        import pixeltable.exprs as exprs
-        for param in self.signature.constant_parameters:
-            if param.name in bound_args and isinstance(bound_args[param.name], exprs.Expr):
-                raise ValueError(
-                    f'{self.display_name}(): '
-                    f'parameter {param.name} must be a constant value, not a Pixeltable expression'
-                )

pixeltable/func/nos_function.py

@@ -1,202 +0,0 @@
-from typing import Optional, Any, Dict, List, Tuple
-import inspect
-import logging
-import sys
-
-import numpy as np
-
-from .signature import Signature, Parameter
-from .batched_function import BatchedFunction
-import pixeltable.env as env
-import pixeltable.type_system as ts
-import pixeltable.exceptions as excs
-
-
-_logger = logging.getLogger('pixeltable')
-
-class NOSFunction(BatchedFunction):
-    def __init__(self, model_spec: 'nos.common.ModelSpec', self_path: str):
-        return_type, param_types = self._convert_nos_signature(model_spec.signature)
-        param_names = list(model_spec.signature.get_inputs_spec().keys())
-        params = [
-            Parameter(name, col_type, inspect.Parameter.POSITIONAL_OR_KEYWORD, is_batched=False)
-            for name, col_type in zip(param_names, param_types)
-        ]
-        signature = Signature(return_type, params)
-
-        # construct inspect.Signature
-        py_params = [
-            inspect.Parameter(name, inspect.Parameter.POSITIONAL_OR_KEYWORD)
-            for name, col_type in zip(param_names, param_types)
-        ]
-        py_signature = inspect.Signature(py_params)
-        super().__init__(signature, py_signature=py_signature, self_path=self_path)
-
-        self.model_spec = model_spec
-        self.nos_param_names = model_spec.signature.get_inputs_spec().keys()
-        self.scalar_nos_param_names = []
-
-        # for models on images
-        self.img_param_pos: Optional[int] = None  # position of the image parameter in the function signature
-        # for multi-resolution image models
-        import nos
-        self.img_batch_params: List[nos.common.ObjectTypeInfo] = []
-        self.img_resolutions: List[int] = []  # for multi-resolution models
-        self.batch_size: Optional[int] = None
-        self.img_size: Optional[Tuple[int, int]] = None  # W, H
-
-        # try to determine batch_size and img_size
-        batch_size = sys.maxsize
-        for pos, (param_name, type_info) in enumerate(model_spec.signature.get_inputs_spec().items()):
-            if isinstance(type_info, list):
-                assert isinstance(type_info[0].base_spec(), nos.common.ImageSpec)
-                # this is a multi-resolution image model
-                self.img_batch_params = type_info
-                self.img_param_pos = pos
-                self.img_resolutions = [
-                    info.base_spec().shape[0] * info.base_spec().shape[1] for info in self.img_batch_params
-                ]
-            else:
-                if not type_info.is_batched():
-                    self.scalar_nos_param_names.append(param_name)
-                else:
-                    batch_size = min(batch_size, type_info.batch_size())
-
-                if isinstance(type_info.base_spec(), nos.common.ImageSpec):
-                    # this is a single-resolution image model
-                    if type_info.base_spec().shape is not None:
-                        self.img_size = (type_info.base_spec().shape[1], type_info.base_spec().shape[0])
-                    self.img_param_pos = pos
-
-        if batch_size != sys.maxsize:
-            self.batch_size = batch_size
-
-    def _convert_nos_type(
-            self, type_info: 'nos.common.spec.ObjectTypeInfo', ignore_shape: bool = False
-    ) -> ts.ColumnType:
-        """Convert ObjectTypeInfo to ColumnType"""
-        import nos
-        if type_info.base_spec() is None:
-            if type_info.base_type() == str:
-                return ts.StringType()
-            if type_info.base_type() == int:
-                return ts.IntType()
-            if type_info.base_type() == float:
-                return ts.FloatType()
-            if type_info.base_type() == bool:
-                return ts.BoolType()
-            else:
-                raise excs.Error(f'Cannot convert {type_info} to ColumnType')
-        elif isinstance(type_info.base_spec(), nos.common.ImageSpec):
-            size = None
-            if not ignore_shape and type_info.base_spec().shape is not None:
-                size = (type_info.base_spec().shape[1], type_info.base_spec().shape[0])
-            # TODO: set mode
-            return ts.ImageType(size=size)
-        elif isinstance(type_info.base_spec(), nos.common.TensorSpec):
-            return ts.ArrayType(shape=type_info.base_spec().shape, dtype=ts.FloatType())
-        else:
-            raise excs.Error(f'Cannot convert {type_info} to ColumnType')
-
-    def _convert_nos_signature(
-            self, sig: 'nos.common.spec.FunctionSignature') -> Tuple[ts.ColumnType, List[ts.ColumnType]]:
-        if len(sig.get_outputs_spec()) > 1:
-            return_type = ts.JsonType()
-        else:
-            return_type = self._convert_nos_type(list(sig.get_outputs_spec().values())[0])
-        param_types: List[ts.ColumnType] = []
-        for _, type_info in sig.get_inputs_spec().items():
-            # if there are multiple input shapes we leave them out of the ColumnType and deal with them in FunctionCall
-            if isinstance(type_info, list):
-                param_types.append(self._convert_nos_type(type_info[0], ignore_shape=True))
-            else:
-                param_types.append(self._convert_nos_type(type_info, ignore_shape=False))
-        return return_type, param_types
-
-    def is_multi_res_model(self) -> bool:
-        return self.img_param_pos is not None and len(self.img_batch_params) > 0
-
-    def get_batch_size(self, *args: Any, **kwargs: Any) -> Optional[int]:
-        if self.batch_size is not None or len(self.img_batch_params) == 0 or len(args) == 0:
-            return self.batch_size
-
-        # return batch size appropriate for the given image size
-        img_arg = args[self.img_param_pos]
-        input_res = img_arg.size[0] * img_arg.size[1]
-        batch_size, _ = self._select_model_res(input_res)
-        return batch_size
-
-    def _select_model_res(self, input_res: int) -> Tuple[int, Tuple[int, int]]:
-        """Select the model resolution that is closest to the input resolution
-        Returns: batch size, image size
-        """
-        deltas = [abs(res - input_res) for res in self.img_resolutions]
-        idx = deltas.index(min(deltas))
-        type_info = self.img_batch_params[idx]
-        return type_info.batch_size(), (type_info.base_spec().shape[1], type_info.base_spec().shape[0])
-
-    def invoke(self, arg_batches: List[List[Any]], kwarg_batches: Dict[str, List[Any]]) -> List[Any]:
-        # check that scalar args are constant
-
-        num_batch_rows = len(arg_batches[0])
-        # if we need to rescale image args, and we're doing object detection, we need to rescale the
-        # bounding boxes as well
-        scale_factors = np.ndarray((num_batch_rows, 2), dtype=np.float32)
-
-        target_res: Optional[Tuple[int, int]] = None
-        if self.img_param_pos is not None:
-            # for now, NOS will only receive RGB images
-            arg_batches[self.img_param_pos] = \
-                [img.convert('RGB') if img.mode != 'RGB' else img for img in arg_batches[self.img_param_pos ]]
-            if self.is_multi_res_model():
-                # we need to select the resolution that is closest to the input resolution
-                sample_img = arg_batches[self.img_param_pos][0]
-                _, target_res = self._select_model_res(sample_img.size[0] * sample_img.size[1])
-            else:
-                target_res = self.img_size
-
-            if target_res is not None:
-                # we need to record the scale factors and resize the images;
-                # keep in mind that every image could have a different resolution
-                scale_factors[:, 0] = \
-                    [img.size[0] / target_res[0] for img in arg_batches[self.img_param_pos]]
-                scale_factors[:, 1] = \
-                    [img.size[1] / target_res[1] for img in arg_batches[self.img_param_pos]]
-                arg_batches[self.img_param_pos] = [
-                    # only resize if necessary
-                    img.resize(target_res) if img.size != target_res else img
-                    for img in arg_batches[self.img_param_pos]
-                ]
-
-        kwargs = {param_name: args for param_name, args in zip(self.nos_param_names, arg_batches)}
-        # fix up scalar parameters
-        kwargs.update(
-            {param_name: kwargs[param_name][0] for param_name in self.scalar_nos_param_names})
-        _logger.debug(
-            f'Running NOS task {self.model_spec.task}: '
-            f'batch_size={num_batch_rows} target_res={target_res}')
-        result = env.Env.get().nos_client.Run(
-            task=self.model_spec.task, model_name=self.model_spec.name, **kwargs)
-
-        import nos
-        if self.model_spec.task == nos.common.TaskType.OBJECT_DETECTION_2D and target_res is not None:
-            # we need to rescale the bounding boxes
-            result_bboxes = []  # workaround: result['bboxes'][*] is immutable
-            for i, bboxes in enumerate(result['bboxes']):
-                bboxes = np.copy(bboxes)
-                nos_batch_row_idx = i
-                bboxes[:, 0] *= scale_factors[nos_batch_row_idx, 0]
-                bboxes[:, 1] *= scale_factors[nos_batch_row_idx, 1]
-                bboxes[:, 2] *= scale_factors[nos_batch_row_idx, 0]
-                bboxes[:, 3] *= scale_factors[nos_batch_row_idx, 1]
-                result_bboxes.append(bboxes)
-            result['bboxes'] = result_bboxes
-
-        if len(result) == 1:
-            key = list(result.keys())[0]
-            row_results = result[key]
-        else:
-            # we rearrange result into one dict per row
-            row_results = [{k: v[i].tolist() for k, v in result.items()} for i in range(num_batch_rows)]
-        return row_results
-

pixeltable/tests/conftest.py

@@ -1,171 +0,0 @@
-import json
-import logging
-import os
-import pathlib
-from typing import List
-
-import numpy as np
-import pytest
-import PIL.Image
-
-import pixeltable as pxt
-import pixeltable.catalog as catalog
-from pixeltable import exprs
-import pixeltable.functions as pxtf
-from pixeltable.exprs import RELATIVE_PATH_ROOT as R
-from pixeltable.metadata import SystemInfo, create_system_info
-from pixeltable.metadata.schema import TableSchemaVersion, TableVersion, Table, Function, Dir
-from pixeltable.tests.utils import read_data_file, create_test_tbl, create_all_datatypes_tbl, skip_test_if_not_installed
-from pixeltable.type_system import StringType, ImageType, FloatType
-
-
-@pytest.fixture(scope='session')
-def init_env(tmp_path_factory) -> None:
-    from pixeltable.env import Env
-    # set the relevant env vars for Client() to connect to the test db
-
-    shared_home = pathlib.Path(os.environ.get('PIXELTABLE_HOME', str(pathlib.Path.home() / '.pixeltable')))
-    home_dir = str(tmp_path_factory.mktemp('base') / '.pixeltable')
-    os.environ['PIXELTABLE_HOME'] = home_dir
-    os.environ['PIXELTABLE_CONFIG'] = str(shared_home / 'config.yaml')
-    test_db = 'test'
-    os.environ['PIXELTABLE_DB'] = test_db
-    os.environ['PIXELTABLE_PGDATA'] = str(shared_home / 'pgdata')
-
-    # ensure this home dir exits
-    shared_home.mkdir(parents=True, exist_ok=True)
-    # this also runs create_all()
-    Env.get().set_up(echo=True)
-    yield
-    # leave db in place for debugging purposes
-
-@pytest.fixture(scope='function')
-def test_client(init_env) -> pxt.Client:
-    # Clean the DB *before* instantiating a client object. This is because some tests
-    # (such as test_migration.py) may leave the DB in a broken state, from which the
-    # client is uninstantiable.
-    clean_db()
-    cl = pxt.Client(reload=True)
-    cl.logging(level=logging.DEBUG, to_stdout=True)
-    yield cl
-
-
-def clean_db(restore_tables: bool = True) -> None:
-    from pixeltable.env import Env
-    # The logic from Client.reset_catalog() has been moved here, so that it
-    # does not rely on instantiating a Client object. As before, UUID-named data tables will
-    # not be cleaned. If in the future it is desirable to clean out data tables as well,
-    # the commented lines may be used to drop ALL tables from the test db.
-    # sql_md = declarative_base().metadata
-    # sql_md.reflect(Env.get().engine)
-    # sql_md.drop_all(bind=Env.get().engine)
-    engine = Env.get().engine
-    SystemInfo.__table__.drop(engine, checkfirst=True)
-    TableSchemaVersion.__table__.drop(engine, checkfirst=True)
-    TableVersion.__table__.drop(engine, checkfirst=True)
-    Table.__table__.drop(engine, checkfirst=True)
-    Function.__table__.drop(engine, checkfirst=True)
-    Dir.__table__.drop(engine, checkfirst=True)
-    if restore_tables:
-        Dir.__table__.create(engine)
-        Function.__table__.create(engine)
-        Table.__table__.create(engine)
-        TableVersion.__table__.create(engine)
-        TableSchemaVersion.__table__.create(engine)
-        SystemInfo.__table__.create(engine)
-        create_system_info(engine)
-
-
-@pytest.fixture(scope='function')
-def test_tbl(test_client: pxt.Client) -> catalog.Table:
-    return create_test_tbl(test_client)
-
-# @pytest.fixture(scope='function')
-# def test_stored_fn(test_client: pxt.Client) -> pxt.Function:
-#     @pxt.udf(return_type=pxt.IntType(), param_types=[pxt.IntType()])
-#     def test_fn(x):
-#         return x + 1
-#     test_client.create_function('test_fn', test_fn)
-#     return test_fn
-
-@pytest.fixture(scope='function')
-def test_tbl_exprs(test_tbl: catalog.Table) -> List[exprs.Expr]:
-#def test_tbl_exprs(test_tbl: catalog.Table, test_stored_fn: pxt.Function) -> List[exprs.Expr]:
-
-    t = test_tbl
-    return [
-        t.c1,
-        t.c7['*'].f1,
-        exprs.Literal('test'),
-        exprs.InlineDict({
-            'a': t.c1, 'b': t.c6.f1, 'c': 17,
-            'd': exprs.InlineDict({'e': t.c2}),
-            'f': exprs.InlineArray((t.c3, t.c3))
-        }),
-        exprs.InlineArray([[t.c2, t.c2], [t.c2, t.c2]]),
-        t.c2 > 5,
-        t.c2 == None,
-        ~(t.c2 > 5),
-        (t.c2 > 5) & (t.c1 == 'test'),
-        (t.c2 > 5) | (t.c1 == 'test'),
-        t.c7['*'].f5 >> [R[3], R[2], R[1], R[0]],
-        t.c8[0, 1:],
-        t.c2.astype(FloatType()),
-        (t.c2 + 1).astype(FloatType()),
-        t.c2.apply(str),
-        (t.c2 + 1).apply(str),
-        t.c3.apply(str),
-        t.c4.apply(str),
-        t.c5.apply(str),
-        t.c6.apply(str),
-        t.c1.apply(json.loads),
-        t.c8.errortype,
-        t.c8.errormsg,
-        pxtf.sum(t.c2, group_by=t.c4, order_by=t.c3),
-    ]
-
-@pytest.fixture(scope='function')
-def all_datatypes_tbl(test_client: pxt.Client) -> catalog.Table:
-    return create_all_datatypes_tbl(test_client)
-
-@pytest.fixture(scope='function')
-def img_tbl(test_client: pxt.Client) -> catalog.Table:
-    schema = {
-        'img': ImageType(nullable=False),
-        'category': StringType(nullable=False),
-        'split': StringType(nullable=False),
-    }
-    # this table is not indexed in order to avoid the cost of computing embeddings
-    tbl = test_client.create_table('test_img_tbl', schema)
-    rows = read_data_file('imagenette2-160', 'manifest.csv', ['img'])
-    tbl.insert(rows)
-    return tbl
-
-@pytest.fixture(scope='function')
-def img_tbl_exprs(img_tbl: catalog.Table) -> List[exprs.Expr]:
-    img_t = img_tbl
-    return [
-        img_t.img.width,
-        img_t.img.rotate(90),
-        # we're using a list here, not a tuple; the latter turns into a list during the back/forth conversion
-        img_t.img.rotate(90).resize([224, 224]),
-        img_t.img.fileurl,
-        img_t.img.localpath,
-    ]
-
-@pytest.fixture(scope='function')
-def small_img_tbl(test_client: pxt.Client) -> catalog.Table:
-    cl = test_client
-    schema = {
-        'img': ImageType(nullable=False),
-        'category': StringType(nullable=False),
-        'split': StringType(nullable=False),
-    }
-    tbl = cl.create_table('test_indexed_img_tbl', schema)
-    rows = read_data_file('imagenette2-160', 'manifest.csv', ['img'])
-    # select output_rows randomly in the hope of getting a good sample of the available categories
-    rng = np.random.default_rng(17)
-    idxs = rng.choice(np.arange(len(rows)), size=40, replace=False)
-    rows = [rows[i] for i in idxs]
-    tbl.insert(rows)
-    return tbl

pixeltable/tests/ext/test_yolox.py

@@ -1,21 +0,0 @@
-import pixeltable as pxt
-from pixeltable.tests.utils import skip_test_if_not_installed, get_image_files, validate_update_status
-
-
-class TestYolox:
-
-    def test_yolox(self, test_client: pxt.Client):
-        skip_test_if_not_installed('yolox')
-        from pixeltable.ext.functions.yolox import yolox
-        cl = test_client
-        t = cl.create_table('yolox_test', {'image': pxt.ImageType()})
-        t['detect_yolox_tiny'] = yolox(t.image, model_id='yolox_tiny')
-        t['detect_yolox_nano'] = yolox(t.image, model_id='yolox_nano', threshold=0.2)
-        t['yolox_nano_bboxes'] = t.detect_yolox_nano.bboxes
-        images = get_image_files()[:10]
-        validate_update_status(t.insert({'image': image} for image in images), expected_rows=10)
-        rows = t.collect()
-        # Verify correctly formed JSON
-        assert all(list(result.keys()) == ['bboxes', 'labels', 'scores'] for result in rows['detect_yolox_tiny'])
-        # Verify that bboxes are actually present in at least some of the rows.
-        assert any(len(bboxes) > 0 for bboxes in rows['yolox_nano_bboxes'])

pixeltable/tests/functions/test_fireworks.py

@@ -1,43 +0,0 @@
-import pytest
-
-import pixeltable as pxt
-import pixeltable.exceptions as excs
-from pixeltable.tests.utils import skip_test_if_not_installed, validate_update_status
-
-
-@pytest.mark.remote_api
-class TestFireworks:
-
-    def test_fireworks(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('fireworks')
-        TestFireworks.skip_test_if_no_fireworks_client()
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': pxt.StringType()})
-        from pixeltable.functions.fireworks import chat_completions
-        messages = [{'role': 'user', 'content': t.input}]
-        t['output'] = chat_completions(
-            messages=messages,
-            model='accounts/fireworks/models/llama-v2-7b-chat'
-        )
-        t['output_2'] = chat_completions(
-            messages=messages,
-            model='accounts/fireworks/models/llama-v2-7b-chat',
-            max_tokens=300,
-            top_k=40,
-            top_p=0.9,
-            temperature=0.7
-        )
-        validate_update_status(t.insert(input="How's everything going today?"), 1)
-        results = t.collect()
-        assert len(results['output'][0]['choices'][0]['message']['content']) > 0
-        assert len(results['output_2'][0]['choices'][0]['message']['content']) > 0
-
-    # This ensures that the test will be skipped, rather than returning an error, when no API key is
-    # available (for example, when a PR runs in CI).
-    @staticmethod
-    def skip_test_if_no_fireworks_client() -> None:
-        try:
-            import pixeltable.functions.fireworks
-            _ = pixeltable.functions.fireworks.fireworks_client()
-        except excs.Error as exc:
-            pytest.skip(str(exc))

pixeltable/tests/functions/test_functions.py

@@ -1,60 +0,0 @@
-import pixeltable as pxt
-from pixeltable import catalog
-from pixeltable.functions.pil.image import blend
-from pixeltable.iterators import FrameIterator
-from pixeltable.tests.utils import get_video_files, skip_test_if_not_installed
-from pixeltable.type_system import VideoType, StringType
-
-
-class TestFunctions:
-    def test_pil(self, img_tbl: catalog.Table) -> None:
-        t = img_tbl
-        _ = t[t.img, t.img.rotate(90), blend(t.img, t.img.rotate(90), 0.5)].show()
-
-    def test_eval_detections(self, test_client: pxt.Client) -> None:
-        skip_test_if_not_installed('nos')
-        cl = test_client
-        video_t = cl.create_table('video_tbl', {'video': VideoType()})
-        # create frame view
-        args = {'video': video_t.video, 'fps': 1}
-        v = cl.create_view('test_view', video_t, iterator_class=FrameIterator, iterator_args=args)
-
-        files = get_video_files()
-        video_t.insert(video=files[-1])
-        v.add_column(frame_s=v.frame.resize([640, 480]))
-        from pixeltable.functions.nos.object_detection_2d import yolox_nano, yolox_small, yolox_large
-        v.add_column(detections_a=yolox_nano(v.frame_s))
-        v.add_column(detections_b=yolox_small(v.frame_s))
-        v.add_column(gt=yolox_large(v.frame_s))
-        from pixeltable.functions.eval import eval_detections, mean_ap
-        res = v.select(
-            eval_detections(
-                v.detections_a.bboxes, v.detections_a.labels, v.detections_a.scores, v.gt.bboxes, v.gt.labels
-            )).show()
-        v.add_column(
-            eval_a=eval_detections(
-                v.detections_a.bboxes, v.detections_a.labels, v.detections_a.scores, v.gt.bboxes, v.gt.labels))
-        v.add_column(
-            eval_b=eval_detections(
-                v.detections_b.bboxes, v.detections_b.labels, v.detections_b.scores, v.gt.bboxes, v.gt.labels))
-        ap_a = v.select(mean_ap(v.eval_a)).show()[0, 0]
-        ap_b = v.select(mean_ap(v.eval_b)).show()[0, 0]
-        common_classes = set(ap_a.keys()) & set(ap_b.keys())
-
-        ## TODO: following assertion is failing on CI, 
-        # It is not necessarily a bug, as assert codition is not expected to be always true
-        # for k in common_classes:
-        # assert ap_a[k] <= ap_b[k]
-
-    def test_str(self, test_client: pxt.Client) -> None:
-        cl = test_client
-        t = cl.create_table('test_tbl', {'input': StringType()})
-        from pixeltable.functions.string import str_format
-        t.add_column(s1=str_format('ABC {0}', t.input))
-        t.add_column(s2=str_format('DEF {this}', this=t.input))
-        t.add_column(s3=str_format('GHI {0} JKL {this}', t.input, this=t.input))
-        status = t.insert(input='MNO')
-        assert status.num_rows == 1
-        assert status.num_excs == 0
-        row = t.head()[0]
-        assert row == {'input': 'MNO', 's1': 'ABC MNO', 's2': 'DEF MNO', 's3': 'GHI MNO JKL MNO'}