pixeltable 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

pixeltable/function.py

@@ -1,269 +0,0 @@
-import sys
-from typing import Optional, Callable, Dict, List, Any
-import importlib
-import sqlalchemy as sql
-import cloudpickle
-
-from pixeltable.type_system import ColumnType
-from pixeltable import store
-from pixeltable.env import Env
-from pixeltable import exceptions as exc
-#from pixeltable import function_pickle
-
-
-class Function:
-    """
-    A Function's executable function is specified either directly or as module/symbol.
-    In the former case, the function needs to be pickled and stored for serialization.
-    In the latter case, the executable function is resolved in init().
-    self.id is only set for non-module functions that are in the backing store.
-    """
-    def __init__(
-            self, return_type: ColumnType, param_types: Optional[List[ColumnType]], id: Optional[int] = None,
-            module_name: Optional[str] = None, eval_symbol: Optional[str] = None, init_symbol: Optional[str] = None,
-            update_symbol: Optional[str] = None, value_symbol: Optional[str] = None,
-            eval_fn: Optional[Callable] = None, init_fn: Optional[Callable] = None,
-            update_fn: Optional[Callable] = None, value_fn: Optional[Callable] = None,
-            order_by: List[int] = []
-    ):
-        has_agg_symbols = init_symbol is not None and update_symbol is not None and value_symbol is not None
-        has_agg_fns = init_fn is not None and update_fn is not None and value_fn is not None
-        assert (module_name is not None) == (eval_symbol is not None or has_agg_symbols)
-        assert (module_name is None) == (eval_fn is not None or has_agg_fns)
-        # exactly one of the 4 scenarios (is agg fn x is library fn) is specified
-        assert int(eval_symbol is not None) + int(eval_fn is not None) + int(has_agg_symbols) + int(has_agg_fns) == 1
-        self.return_type = return_type
-        self.param_types = param_types
-        self.id = id
-        self.module_name = module_name
-        self.eval_symbol = eval_symbol
-        self.eval_fn = eval_fn
-        self.init_symbol = init_symbol
-        self.init_fn = init_fn
-        self.update_symbol = update_symbol
-        self.update_fn = update_fn
-        self.value_symbol = value_symbol
-        self.value_fn = value_fn
-
-        if module_name is not None:
-            # resolve module_name and symbol
-            module = importlib.import_module(module_name)
-            if eval_symbol is not None:
-                self.eval_fn = self._resolve_symbol(module, eval_symbol)
-            if init_symbol is not None:
-                self.init_fn = self._resolve_symbol(module, init_symbol)
-            if update_symbol is not None:
-                self.update_fn = self._resolve_symbol(module, update_symbol)
-            if value_symbol is not None:
-                self.value_fn = self._resolve_symbol(module, value_symbol)
-
-        if len(order_by) > 0:
-            if self.init_fn is None:
-                raise exc.Error(f'order_by parameter only valid for aggregate functions')
-            for idx in order_by:
-                if not isinstance(idx, int) or idx >= len(param_types):
-                    raise exc.Error(f'order_by element not a valid index into param_types: {idx}')
-        self.order_by = order_by
-
-    def _resolve_symbol(self, module: Any, symbol: str) -> object:
-        obj = module
-        for el in symbol.split('.'):
-            obj = getattr(obj, el)
-        return obj
-
-    @property
-    def is_aggregate(self) -> bool:
-        return self.init_fn is not None
-
-    @property
-    def is_library_function(self) -> bool:
-        return self.module_name is not None
-
-    def __call__(self, *args: object) -> 'pixeltable.exprs.FunctionCall':
-        from pixeltable import exprs
-        return exprs.FunctionCall(self, args)
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
-        return self.return_type == other.return_type and self.param_types == other.param_types \
-            and self.id == other.id and self.module_name == other.module_name \
-            and self.eval_symbol == other.eval_symbol and self.init_symbol == other.init_symbol \
-            and self.update_symbol == other.update_symbol and self.value_symbol == other.value_symbol \
-            and self.eval_fn == other.eval_fn and self.init_fn == other.init_fn \
-            and self.update_fn == other.update_fn and self.value_fn == other.value_fn
-
-
-    def as_dict(self) -> Dict:
-        if self.module_name is None and self.id is None:
-            # this is not a library function and the absence of an assigned id indicates that it's not in the store yet
-            FunctionRegistry.get().create_function(self)
-            assert self.id is not None
-        return {
-            'return_type': self.return_type.as_dict(),
-            'param_types': [t.as_dict() for t in self.param_types] if self.param_types is not None else None,
-            'id': self.id,
-            'module_name': self.module_name,
-            'eval_symbol': self.eval_symbol,
-            'init_symbol': self.init_symbol,
-            'update_symbol': self.update_symbol,
-            'value_symbol': self.value_symbol,
-        }
-
-    @classmethod
-    def from_dict(cls, d: Dict) -> 'Function':
-        assert 'return_type' in d
-        return_type = ColumnType.from_dict(d['return_type'])
-        assert 'param_types' in d
-        if d['param_types'] is None:
-            param_types = None
-        else:
-            param_types = [ColumnType.from_dict(type_dict) for type_dict in d['param_types']]
-        assert 'id' in d
-        assert 'module_name' in d
-        assert 'eval_symbol' in d and 'init_symbol' in d and 'update_symbol' in d and 'value_symbol' in d
-
-        if d['id'] is not None:
-            assert d['module_name'] is None
-            return FunctionRegistry.get().get_function(d['id'])
-        else:
-            return cls(
-                return_type, param_types, module_name=d['module_name'], eval_symbol=d['eval_symbol'],
-                init_symbol=d['init_symbol'], update_symbol=d['update_symbol'], value_symbol=d['value_symbol'])
-
-
-class FunctionRegistry:
-    """
-    A central registry for all Functions. Handles interactions with the backing store.
-    Function are loaded from the store on demand.
-    """
-    _instance: Optional['FunctionRegistry'] = None
-
-    @classmethod
-    def get(cls) -> 'FunctionRegistry':
-        if cls._instance is None:
-            cls._instance = FunctionRegistry()
-        return cls._instance
-
-    def __init__(self):
-        self.fns_by_id: Dict[int, Function] = {}
-
-    def clear_cache(self) -> None:
-        """
-        Useful during testing
-        """
-        self.fns_by_id: Dict[int, Function] = {}
-
-    def get_function(self, id: int) -> Function:
-        if id not in self.fns_by_id:
-            stmt = sql.select(
-                store.Function.name, store.Function.return_type, store.Function.param_types,
-                store.Function.eval_obj, store.Function.init_obj, store.Function.update_obj, store.Function.value_obj) \
-                .where(store.Function.id == id)
-            with Env.get().engine.begin() as conn:
-                rows = conn.execute(stmt)
-                row = next(rows)
-                name = row[0]
-                return_type = ColumnType.deserialize(row[1])
-                param_types = ColumnType.deserialize_list(row[2])
-                eval_fn = cloudpickle.loads(row[3]) if row[3] is not None else None
-                # TODO: are these checks needed?
-                if row[3] is not None and eval_fn is None:
-                    raise exc.Error(f'Could not load eval_fn for function {name}')
-                init_fn = cloudpickle.loads(row[4]) if row[4] is not None else None
-                if row[4] is not None and init_fn is None:
-                    raise exc.Error(f'Could not load init_fn for aggregate function {name}')
-                update_fn = cloudpickle.loads(row[5]) if row[5] is not None else None
-                if row[5] is not None and update_fn is None:
-                    raise exc.Error(f'Could not load update_fn for aggregate function {name}')
-                value_fn = cloudpickle.loads(row[6]) if row[6] is not None else None
-                if row[6] is not None and value_fn is None:
-                    raise exc.Error(f'Could not load value_fn for aggregate function {name}')
-
-                func = Function(
-                    return_type, param_types, id=id, eval_fn=eval_fn, init_fn=init_fn, update_fn=update_fn,
-                    value_fn=value_fn)
-                self.fns_by_id[id] = func
-        assert id in self.fns_by_id
-        return self.fns_by_id[id]
-
-    def create_function(
-            self, fn: Function, db_id: Optional[int] = None, dir_id: Optional[int] = None,
-            name: Optional[str] = None
-    ) -> None:
-        with Env.get().engine.begin() as conn:
-            eval_fn_str = cloudpickle.dumps(fn.eval_fn) if fn.eval_fn is not None else None
-            init_fn_str = cloudpickle.dumps(fn.init_fn) if fn.init_fn is not None else None
-            update_fn_str = cloudpickle.dumps(fn.update_fn) if fn.update_fn is not None else None
-            value_fn_str = cloudpickle.dumps(fn.value_fn) if fn.value_fn is not None else None
-            res = conn.execute(
-                sql.insert(store.Function.__table__)
-                    .values(
-                        db_id=db_id, dir_id=dir_id, name=name, return_type=fn.return_type.serialize(),
-                        param_types=ColumnType.serialize_list(fn.param_types),
-                        eval_obj=eval_fn_str, init_obj=init_fn_str, update_obj=update_fn_str, value_obj=value_fn_str))
-            fn.id = res.inserted_primary_key[0]
-            self.fns_by_id[fn.id] = fn
-
-    def update_function(
-            self, id: int, eval_fn: Optional[Callable] = None, init_fn: Optional[Callable] = None,
-            update_fn: Optional[Callable] = None, value_fn: Optional[Callable] = None
-    ) -> None:
-        """
-        Updates the callable for the function with the given id in the store and in the cache, if present.
-        """
-        with Env.get().engine.begin() as conn:
-            updates = {}
-            if eval_fn is not None:
-                updates[store.Function.eval_obj] = cloudpickle.dumps(eval_fn)
-            if init_fn is not None:
-                updates[store.Function.init_obj] = cloudpickle.dumps(init_fn)
-            if update_fn is not None:
-                updates[store.Function.update_obj] = cloudpickle.dumps(update_fn)
-            if value_fn is not None:
-                updates[store.Function.value_obj] = cloudpickle.dumps(value_fn)
-            conn.execute(
-                sql.update(store.Function.__table__)
-                    .values(updates)
-                    .where(store.Function.id == id))
-        if id in self.fns_by_id:
-            if eval_fn is not None:
-                self.fns_by_id[id].eval_fn = eval_fn
-            if init_fn is not None:
-                self.fns_by_id[id].init_fn = init_fn
-            if update_fn is not None:
-                self.fns_by_id[id].update_fn = update_fn
-            if value_fn is not None:
-                self.fns_by_id[id].value_fn = value_fn
-
-    def delete_function(self, id: int) -> None:
-        assert id is not None
-        with Env.get().engine.begin() as conn:
-            conn.execute(
-                sql.delete(store.Function.__table__)
-                    .where(store.Function.id == id))
-
-
-# def create_module_list() -> None:
-#     """
-#     Generate file standard_modules.py, which contains a list of modules available after 'import pixeltable'.
-#     These are the modules we don't want to pickle.
-#     TODO: move this elsewhere?
-#     """
-#     with open('standard_modules.py', 'w') as f:
-#         f.write('module_names = set([\n    ')
-#         line_len = 0
-#         module_names = sys.modules.keys()
-#         for name in module_names:
-#             str = f"'{name}', "
-#             line_len += len(str)
-#             if line_len >= 80:
-#                 f.write('\n    ')
-#                 line_len = 4  # spaces
-#             f.write(str)
-#         f.write('\n])')
-
-
-# make create_module_list() callable from the commandline
-if __name__ == '__main__':
-    globals()[sys.argv[1]]()

pixeltable/functions/clip.py

@@ -1,10 +0,0 @@
-from pixeltable.type_system import StringType, ImageType, ArrayType, ColumnType
-from pixeltable.function import Function
-
-
-encode_image = Function(
-    ArrayType((512,), ColumnType.Type.FLOAT), [ImageType()],
-    module_name='pixeltable.utils.clip', eval_symbol='encode_image')
-encode_text = Function(
-    ArrayType((512,), ColumnType.Type.FLOAT), [StringType()],
-    module_name = 'pixeltable.utils.clip', eval_symbol = 'encode_text')

pixeltable/functions/pil/__init__.py

@@ -1,23 +0,0 @@
-import numpy as np
-import PIL
-
-from pixeltable.type_system import ImageType, ArrayType, ColumnType
-from pixeltable.function import Function
-from pixeltable.exceptions import Error
-
-def _draw_boxes(img: PIL.Image.Image, boxes: np.ndarray) -> PIL.Image.Image:
-    if len(boxes.shape) != 2 or boxes.shape[1] != 4:
-        raise Error(f'draw(): boxes needs to have shape (None, 4) but instead has shape {boxes.shape}')
-    result = img.copy()
-    d = PIL.ImageDraw.Draw(result)
-    for i in range(boxes.shape[0]):
-        d.rectangle(list(boxes[i]), width=3)
-    return result
-
-draw_boxes = Function(
-    ImageType(), [ImageType(), ArrayType((None, 6), dtype=ColumnType.Type.FLOAT)],
-    module_name=__name__, eval_symbol='_draw_boxes')
-
-__all__ = [
-    draw_boxes,
-]

pixeltable/functions/tf.py

@@ -1,21 +0,0 @@
-from typing import Callable, Any, Optional, Tuple
-import os
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import tensorflow as tf
-
-
-from pixeltable.type_system import ColumnType, ArrayType
-import pixeltable.utils.tf as tf_utils
-from pixeltable.function import Function
-
-def TFModelFunction(
-        model: tf.keras.Model, param_type: ColumnType, output_shape: Optional[Tuple[int, ...]] = None,
-        preprocess: Optional[Callable] = None) -> Function:
-    def predict(arg: Any) -> Any:
-        tensor = tf_utils.to_tensor(arg, param_type)
-        tensor = tf.expand_dims(tensor, axis=0)
-        if preprocess is not None:
-            tensor = preprocess(tensor)
-        output = model.predict(tensor)
-        return output[0]
-    return Function(ArrayType(output_shape, dtype=ColumnType.DType.FLOAT32), [param_type], eval_fn=predict)

pixeltable/index.py

@@ -1,57 +0,0 @@
-from typing import List, Set
-import PIL.Image
-import hnswlib
-import numpy as np
-
-from pixeltable.env import Env
-
-class VectorIndex:
-    def __init__(self, name: str, dim: int, idx: hnswlib.Index):
-        self.name = name
-        self.dim = dim
-        self.idx = idx
-
-    @classmethod
-    def create(cls, name: str, dim: int) -> 'VectorIndex':
-        idx = hnswlib.Index(space='cosine', dim=dim)
-        idx.init_index(max_elements=1000, M=64, ef_construction=200)
-        filename = cls._filename(name)
-        idx.save_index(filename)
-        return VectorIndex(name, dim, idx)
-
-    @classmethod
-    def load(cls, name: str, dim: int) -> 'VectorIndex':
-        idx = hnswlib.Index(space='cosine', dim=dim)
-        filename = cls._filename(name)
-        idx.load_index(filename)
-        return VectorIndex(name, dim, idx)
-
-    def insert(self, data: np.ndarray, rowids: np.ndarray) -> None:
-        assert data.shape[0] == rowids.shape[0]
-        total = self.idx.element_count + data.shape[0]
-        if total > self.idx.max_elements:
-            self.idx.resize_index(int(total * 1.1))
-        self.idx.add_items(data, rowids)
-        filename = self._filename(self.name)
-        self.idx.save_index(filename)
-
-    def search(self, embed: np.ndarray, num_nn: int, valid_rowids: Set[int]) -> List[int]:
-        """
-        Returns rowids of k nearest neighbors.
-        """
-        assert embed.shape == (512,)
-        k = num_nn
-        while True:
-            nn, _ = self.idx.knn_query(embed.reshape(1, 512), k)
-            # tolist(): make sure result contains ints, not uint64
-            result = [rowid for rowid in nn.squeeze().tolist() if rowid in valid_rowids]
-            if len(result) >= num_nn:
-                return list(result[:num_nn])
-            if k >= self.idx.element_count:
-                # nothing left to look for
-                return result
-            k *= 2
-
-    @classmethod
-    def _filename(cls, name: str) -> str:
-        return str(Env.get().nnidx_dir / f'idx_{name}')

pixeltable/tests/test_dict.py

@@ -1,24 +0,0 @@
-import sqlalchemy as sql
-import pytest
-
-from pixeltable import catalog
-from pixeltable.type_system import IntType, JsonType
-from pixeltable.tests.utils import make_tbl, create_table_data, read_data_file
-
-from pixeltable.env import Env
-
-class TestExprs:
-    def test_basic(self, test_tbl: catalog.Table) -> None:
-        t = test_tbl
-        res = t[t.c6].show()
-        stmt = sql.select(sql.func.jsonb_path_query(t.cols_by_name['c6'].sa_col, '$.detections[*].bounding_box'))
-        #stmt = sql.select(t.cols_by_name['c2'].sa_col['iscrowd']).where(sql.cast(t.cols_by_name['c2'].sa_col['iscrowd'], sql.Integer) == 0)
-        #stmt = sql.select(t.cols_by_name['c2'].sa_col['iscrowd']).where(t.cols_by_name['c2'].sa_col['supercategory'] == '"furniture"')
-        #stmt = sql.select(t.cols_by_name['c2'].sa_col['bounding_box', 0]).where(t.cols_by_name['c2'].sa_col['supercategory'] == '"furniture"')
-        #stmt = sql.select(t.cols_by_name['c2'].sa_col['bounding_box', 0]).where(t.cols_by_name['c2'].sa_col['supercategory'].astext == 'furniture')
-        with Env.get().engine.connect() as conn:
-            result = conn.execute(stmt)
-            for row in result:
-                print(row)
-        print(res)
-

pixeltable/tests/test_tf.py

@@ -1,69 +0,0 @@
-import os
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import tensorflow as tf
-
-from pixeltable import catalog
-from pixeltable.functions import dict_map
-from pixeltable.functions.tf import TFModelFunction
-from pixeltable.type_system import ImageType
-import pixeltable.tf
-
-
-class TestTf:
-    def verify_type(self, df: pixeltable.DataFrame, ds: tf.data.Dataset) -> None:
-        """
-        Verify that column types of df matches element spec of ds.
-        """
-        result_set = df.show(1)
-        assert isinstance(ds.element_spec, tuple)
-        assert len(result_set.col_types) == len(ds.element_spec)
-        for i in range(len(result_set.col_types)):
-            col_type = result_set.col_types[i]
-            if col_type.is_scalar_type():
-                assert ds.element_spec[i].shape == ()
-            if col_type.is_image_type():
-                assert ds.element_spec[i].shape == (col_type.height, col_type.width, col_type.num_channels)
-
-    def test_basic(self, img_tbl: catalog.Table) -> None:
-        # TODO: test all data types
-        t = img_tbl
-        m = t[t.category].categorical_map()
-        # image types with increasingly specific dimensions
-        df = t[t.img, dict_map(t.category, m)]
-        ds = pixeltable.tf.to_dataset(df)
-        self.verify_type(df, ds)
-        for row in ds:
-            pass
-
-        df = t[t.img.resize((224, 224))]
-        ds = pixeltable.tf.to_dataset(df)
-        self.verify_type(df, ds)
-        for row in ds:
-            pass
-
-        df = t[t.img.convert('RGB').resize((224, 224)), dict_map(t.category, m)]
-        ds = pixeltable.tf.to_dataset(df)
-        self.verify_type(df, ds)
-        for row in ds:
-            pass
-
-        df = t[[{'a': t.img.convert('RGB').resize((224, 224)), 'b': dict_map(t.category, m)}]]
-        ds = pixeltable.tf.to_dataset(df).batch(32)
-        for row in ds:
-            pass
-
-        df = t[[t.img.convert('RGB').resize((224, 224)), {'b': dict_map(t.category, m)}]]
-        ds = pixeltable.tf.to_dataset(df).batch(32)
-        for row in ds:
-            pass
-
-
-    def test_model_fn(self, img_tbl: catalog.Table) -> None:
-        model = tf.keras.applications.resnet50.ResNet50()
-        preprocess = tf.keras.applications.resnet50.preprocess_input
-        model_udf = TFModelFunction(
-            model, ImageType(size=(224, 224), mode=ImageType.Mode.RGB), output_shape=(1000,),preprocess=preprocess)
-        t = img_tbl
-        df = t[model_udf(t.img)]
-        res = df.show(1)
-        _ = res._repr_html_()

pixeltable/tf.py

@@ -1,33 +0,0 @@
-from typing import Any, Tuple, List, Generator
-import os
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import tensorflow as tf
-
-from pixeltable.dataframe import DataFrame
-import pixeltable.utils.tf as tf_utils
-
-
-def to_dataset(df: DataFrame) -> tf.data.Dataset:
-    """
-    Convert df result set to tf.data.Dataset.
-    """
-    result_set = df.show(0)
-    # construct output signature
-    if len(result_set.col_types) == 1 and result_set.col_types[0].is_json_type():
-        # we're only getting one column back and it's a dict: make the dataset type a dict
-        type_spec = result_set.col_types[0].to_tf()
-    else:
-        tf_types = [t.to_tf() for t in result_set.col_types]
-        type_spec = tuple(tf_types)
-
-    def f() -> Generator[Tuple[Any, ...], None, None]:
-        if isinstance(type_spec, dict):
-            json_type = result_set.col_types[0]
-            for row in result_set.rows:
-                res = {k: tf_utils.to_tensor(v, json_type.type_spec[k]) for k, v in row[0].items()}
-                yield res
-        else:
-            for row in result_set.rows:
-                tf_row = [tf_utils.to_tensor(val, result_set.col_types[i]) for i, val in enumerate(row)]
-                yield tuple(tf_row)
-    return tf.data.Dataset.from_generator(f, output_signature=type_spec)

pixeltable/utils/tf.py

@@ -1,33 +0,0 @@
-from typing import Any, Tuple
-import os
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
-import tensorflow as tf
-
-from  pixeltable.type_system import ColumnType, JsonType
-
-TF_DTYPES = {
-    # ColumnType.DType.INT8: tf.int8,
-    # ColumnType.DType.INT16: tf.int16,
-    # ColumnType.DType.INT32: tf.int32,
-    # ColumnType.DType.INT64: tf.int64,
-    # ColumnType.DType.UINT8: tf.uint8,
-    # ColumnType.DType.UINT16: tf.uint16,
-    # ColumnType.DType.UINT32: tf.uint32,
-    # ColumnType.DType.UINT64: tf.uint64,
-    ColumnType.Type.INT: tf.int64,
-    ColumnType.Type.FLOAT: tf.float32
-}
-
-def to_tensor(v: Any, t: ColumnType) -> tf.Tensor:
-    if t.is_scalar_type():
-        return tf.convert_to_tensor(v)
-    if t.is_image_type():
-        # convert PIL.Image.Image to tf.Tensor
-        return tf.cast(tf.keras.utils.img_to_array(v), tf.uint8)
-    if t.is_array_type():
-        return tf.convert_to_tensor(v, dtype=TF_DTYPES[t.dtype])
-    if t.is_json_type():
-        assert isinstance(v, dict)
-        assert isinstance(t, JsonType)
-        assert t.type_spec is not None
-        return {key: to_tensor(val, t.type_spec[key]) for key, val in v.items()}

pixeltable/utils/video.py

@@ -1,32 +0,0 @@
-from typing import List
-import ffmpeg
-import glob
-from pathlib import Path
-
-from pixeltable.exceptions import OperationalError
-
-
-def extract_frames(video_path_str: str, output_path_prefix: str, fps: int = 0) -> List[str]:
-    """
-    Extract frames at given fps as jpg files (fps == 0: all frames).
-    Returns list of frame file paths.
-    """
-    video_path = Path(video_path_str)
-    if not video_path.exists():
-        raise OperationalError(f'File not found: {video_path_str}')
-    if not video_path.is_file():
-        raise OperationalError(f'Not a file: {video_path_str}')
-    output_path_str = f'{output_path_prefix}_%07d.jpg'
-    s = ffmpeg.input(video_path)
-    if fps > 0:
-        s = s.filter('fps', fps)
-    s = s.output(output_path_str, loglevel='quiet')
-    try:
-        s.run()
-    except ffmpeg.Error:
-        raise OperationalError(f'ffmpeg exception')
-
-    # collect generated files
-    frame_paths = glob.glob(f'{output_path_prefix}_*.jpg')
-    frame_paths.sort()
-    return frame_paths

pixeltable-0.1.1.dist-info/METADATA

@@ -1,31 +0,0 @@
-Metadata-Version: 2.1
-Name: pixeltable
-Version: 0.1.1
-Summary: 
-Author: Marcel Kornacker
-Author-email: marcelk@gmail.com
-Requires-Python: >=3.9,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: cloudpickle (>=2.2.1,<3.0.0)
-Requires-Dist: ffmpeg-python (>=0.2.0,<0.3.0)
-Requires-Dist: ftfy (>=6.1.1,<7.0.0)
-Requires-Dist: hnswlib (>=0.6.2,<0.7.0)
-Requires-Dist: jmespath (>=1.0.1,<2.0.0)
-Requires-Dist: numpy (>=1.24.1,<2.0.0)
-Requires-Dist: opencv-python-headless (>=4.7.0.68,<5.0.0.0)
-Requires-Dist: pandas (>=1.5.3,<2.0.0)
-Requires-Dist: pillow (>=9.4.0,<10.0.0)
-Requires-Dist: psycopg2-binary (>=2.9.5,<3.0.0)
-Requires-Dist: regex (>=2022.10.31,<2023.0.0)
-Requires-Dist: sqlalchemy (>=1.4.41,<2.0.0)
-Requires-Dist: sqlalchemy-utils (>=0.39.0,<0.40.0)
-Requires-Dist: tqdm (>=4.64.1,<5.0.0)
-Description-Content-Type: text/markdown
-
-# Pixeltable
-
-Pixeltable is a Python library that exposes image and video data via a table interface.
-

pixeltable-0.1.1.dist-info/RECORD

@@ -1,36 +0,0 @@
-pixeltable/__init__.py,sha256=fFMx_T8IYfOL2J2WmVjOu__TNx19J0pSgtlERNJVmD0,281
-pixeltable/catalog.py,sha256=gxjSkf852f4ZdqguyQ0k-q9fNN1ezDl0S86GS26Pk9c,65851
-pixeltable/client.py,sha256=KoPRDLQm9KaBdURDU99rL6R4EzYL6GmzzWZHYS79W_I,1091
-pixeltable/dataframe.py,sha256=pFPOfK9UjW3JnFq-j-omw5UQGYxppxdJzBG5TiinExc,20828
-pixeltable/env.py,sha256=Qn8lvRHj6uT88fYYV9opIi4ZPOiJi_hUeViH--1imvs,2809
-pixeltable/exceptions.py,sha256=C-OjDMhDLBwG9yJ0vbugk61JwGPsxjsVU7NV-03HOo0,312
-pixeltable/exprs.py,sha256=SjTjg6BzjvKaqtMGxjUZMhqnl6RL50gCHxjeGUYzVqk,68598
-pixeltable/function.py,sha256=TWqhUTF87ZmlL1RC7EvBAT2oMPSfsnJQq-eR5q99Pg4,12275
-pixeltable/functions/__init__.py,sha256=CIpacjTdO6k_9pfeFFYW5fUCHqdoa47Rqm7rIMHZnw0,4733
-pixeltable/functions/clip.py,sha256=2iSkVFhp1zBPNgM1LaLdO115jctjKEZ1lF-ARgMJoUE,436
-pixeltable/functions/pil/__init__.py,sha256=mZS5tp_D1Y_15UsurLtawYMrAbTzvl-NXJrPHqNSj00,763
-pixeltable/functions/pil/image.py,sha256=79XgGkgyCbwo6n84qe5UNBUS4PCy5hFYzOTnZL439cE,475
-pixeltable/functions/tf.py,sha256=XSeOU1cD3ZT9PTB0SbO69chuNNsMXO-ewdDlO7sSBfM,830
-pixeltable/index.py,sha256=EQsjXvwpU72RwgXnEv7II47DZuYhGSKExqHzH583ZDs,2009
-pixeltable/store.py,sha256=VpSyUSphpocg5fCm0aVrJ2GHuTvNOMpzbC1B9PO0Ilk,7966
-pixeltable/tests/conftest.py,sha256=2WNdzlYA9ts3qUa1asu4xgf0E-gKrCD6AqVs0Uc8s3o,4010
-pixeltable/tests/test_client.py,sha256=K_ayeutgaLyODAhEgEd2-f2RsOU-C-xgl9oklc52SCE,552
-pixeltable/tests/test_dict.py,sha256=dqm2QKiQk4CCbyHfRVGAQ0b4BRmsS8DN6qT3ZgTltV0,1213
-pixeltable/tests/test_dirs.py,sha256=lvllfBzqJKuu6w3k6P9T8O3r6bt5iIIqf6TJj05lKmY,3184
-pixeltable/tests/test_exprs.py,sha256=Cb13yq5BWQEa0SLQMGwyu-JDg-Njf__vpr-j1dQMbCk,13866
-pixeltable/tests/test_function.py,sha256=He46y8NJrszyFE0WAaDnTFRQ_1HnQBGhTMKEG2cbN50,3369
-pixeltable/tests/test_functions.py,sha256=vxKPiaiK-14ZB6rX9p1fHLn90cWjg3hOa4KwNMzC56o,302
-pixeltable/tests/test_table.py,sha256=OXBQFOD2b0Pi9sPMryxsOpxLCwZ3lRfQm6TurMs4i0g,13794
-pixeltable/tests/test_tf.py,sha256=xpLTIxej6PSWer2G7I4X_67d3Mqr1izM6618AetbY-w,2503
-pixeltable/tests/test_types.py,sha256=zr8CxZYvozOay3pO26KEmSLtAVzbYBzF-Lr3JA81qUo,1162
-pixeltable/tests/test_video.py,sha256=l3EMMn8gvcW_L3Ko9EcNJ66-4n3qC2hXim97dgOxOcg,1603
-pixeltable/tests/utils.py,sha256=QRKuAmdrCEGSg7ABmP5T90e3EaROJuLvE2364-lK4MM,4690
-pixeltable/tf.py,sha256=ZEaR_TRyfJ2opml69p4QSPzKDdGr2MLHVbnbJkYTF1c,1289
-pixeltable/type_system.py,sha256=_KTiPjrvdOloiKuP1z3iL5P40Qzst9AlggbicMp1W64,17376
-pixeltable/utils/__init__.py,sha256=QyqUCCNp1_A1cBJWzkL-nCjYUR8Cd4E0u4il7ruQR-c,1763
-pixeltable/utils/clip.py,sha256=6kGbnGj8F1cETrZYQDU_l2qCRhc6uOlJ9EoLHucab9o,628
-pixeltable/utils/tf.py,sha256=ZDrkaWutMAqIOx3G-uR5uYuaFkSRJaXyt53CJmwnM-Y,1143
-pixeltable/utils/video.py,sha256=KzkCROl3z2OVZILmakw-90uDvCqXFrREZiaNVnh62wI,1007
-pixeltable-0.1.1.dist-info/METADATA,sha256=489b7eIM89bc3iVT9uw5TLWjXzrQzi_76KevRCb7lws,1106
-pixeltable-0.1.1.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-pixeltable-0.1.1.dist-info/RECORD,,