pixeltable 0.2.8__py3-none-any.whl → 0.2.9__py3-none-any.whl

pixeltable/utils/code.py

@@ -0,0 +1,34 @@
+import types
+from typing import Optional
+
+from pixeltable.func import Function
+
+
+# Utilities related to the organization of the Pixeltable codebase.
+
+def local_public_names(mod_name: str, exclude: Optional[list[str]] = None) -> list[str]:
+    """
+    Returns a list of all functions and submodules that are local to the specified module and are
+    publicly accessible. Intended to facilitate implementation of module __dir__() methods for
+    friendly tab-completion.
+    """
+    import importlib
+
+    if exclude is None:
+        exclude = []
+    mod = importlib.import_module(mod_name)
+    names = []
+    for obj in mod.__dict__.values():
+        if isinstance(obj, Function):
+            # Pixeltable function
+            names.append(obj.name)
+        elif isinstance(obj, types.FunctionType):
+            # Python function
+            if obj.__module__ == mod.__name__ and not obj.__name__.startswith('_'):
+                names.append(obj.__name__)
+        elif isinstance(obj, types.ModuleType):
+            # Module
+            components = obj.__name__.split('.')
+            if mod_name == '.'.join(components[:-1]):
+                names.append(components[-1])
+    return [name for name in names if name not in exclude]

{pixeltable-0.2.8.dist-info → pixeltable-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pixeltable
-Version: 0.2.8
+Version: 0.2.9
 Summary: Pixeltable: The Multimodal AI Data Plane
 Author: Marcel Kornacker
 Author-email: marcelk@gmail.com

pixeltable-0.2.9.dist-info/RECORD

@@ -0,0 +1,131 @@
+pixeltable/__init__.py,sha256=GNlV3jQKDQKTrOq8BVvPsnd9W9ROneP9-1C-zgNSWsg,1275
+pixeltable/__version__.py,sha256=ZH1jMRnmzFfm1T-NAz5ZJ08lYojBz6jzzdMQmFBGDzw,112
+pixeltable/catalog/__init__.py,sha256=E41bxaPeQIcgRYzTWc2vkDOboQhRymrJf4IcHQO7o_8,453
+pixeltable/catalog/catalog.py,sha256=gzEuse0f_rj7oKRWMyorhUpOLhYbWSQ8CFLOuFLbXak,7918
+pixeltable/catalog/column.py,sha256=Dmc6CgFLExJy3tdvuX0Emjc8SgqZvmCbAHozibO1-G0,9417
+pixeltable/catalog/dir.py,sha256=DWl9nnCOoiYLKWp31MNMvLmryXeQiQZu5YJcd4tpy38,921
+pixeltable/catalog/globals.py,sha256=yLEGNbsSnLzjWNHVJacfjA9hbw13Q6QXLOSCRmdTlq0,943
+pixeltable/catalog/insertable_table.py,sha256=jP6EFMqkGNAbqRAj6YpCaZzWdFwu13t_dQste_f0clk,6468
+pixeltable/catalog/named_function.py,sha256=UhHaimM_uJHS-0RQcqGOgvWeZtMfKsIgSeKSRwT2moU,1149
+pixeltable/catalog/path.py,sha256=QgccEi_QOfaKt8YsR2zLtd_z7z7QQkU_1kprJFi2SPQ,1677
+pixeltable/catalog/path_dict.py,sha256=xfvxg1Ze5jZCARUGASF2DRbQPh7pRVTYhuJ_u82gYUo,5941
+pixeltable/catalog/schema_object.py,sha256=Sf8aGARpsPeRUz1NjsZ97oSBMyElsctP39uU9x9Ic80,964
+pixeltable/catalog/table.py,sha256=qzxm3SN0hHObZlJycEsmzOd3VLsqSnrZ9fk1M3F5YGM,42636
+pixeltable/catalog/table_version.py,sha256=-46Z-aSKdjXpbmWlwZpGWZMw6VOKJZczNvx05Txe_0I,55148
+pixeltable/catalog/table_version_path.py,sha256=lE2EFn0kylXhy-oBXTyXbJox6rl_6klfOmDjK-2Uq_Q,6432
+pixeltable/catalog/view.py,sha256=dphf9ZFi_ReQkokcN_Auh6ZQFmGtnOcVDvz6fcJfJzs,10332
+pixeltable/dataframe.py,sha256=cQb70E0WVWsTQ_rA6CNx0dfCkGQoqgdoERa6HgpdPDY,37167
+pixeltable/env.py,sha256=WO_WLfRj9Fft6QyW89S9cw47RTg1ALviStu9pNygJEQ,21635
+pixeltable/exceptions.py,sha256=MSP9zeL0AmXT93XqjdvgGN4rzno1_KRrGriq6hpemnw,376
+pixeltable/exec/__init__.py,sha256=RK7SKvrQ7Ky3G_LXDP4Bf7lHmMM_uYZl8dJaZYs0FjY,454
+pixeltable/exec/aggregation_node.py,sha256=cf6rVAgrGh_uaMrCIgXJIwQTmbcboJlnrH_MmPIQSd0,3321
+pixeltable/exec/cache_prefetch_node.py,sha256=d5pEuR6AtJQkEVy9X3XeYFI_q0szMtoNAH96vYdtBE0,5241
+pixeltable/exec/component_iteration_node.py,sha256=Uz6zEeaJMcbvF3S0W0qmLI_uWsZsaSspHKNzuAMrasg,4069
+pixeltable/exec/data_row_batch.py,sha256=1IDYHBkSQ60dwOnAGnS-Wpp3AsnbMqKcY40zUT7ku-Q,3392
+pixeltable/exec/exec_context.py,sha256=0rg5V8HzSy-BvqmSbGr-U4aJ4eOZg2JN0x6zjYQGtBc,1090
+pixeltable/exec/exec_node.py,sha256=ixkv3p_EfF53UDWgwLjQGKR1LNIQxzgDXsTzzJj6ea4,2211
+pixeltable/exec/expr_eval_node.py,sha256=fEzbeZ0J-kylRQ2M0nSlUeLFRTHlwNzlvBo1yqWQ2rg,10856
+pixeltable/exec/in_memory_data_node.py,sha256=vvjr5-r94mRddOYIpKF8zDWCJPJrG0YpQVtYSyKlyVU,3502
+pixeltable/exec/media_validation_node.py,sha256=OKfRyKpcn7AZdACy_HD4NsDC87ZfNFs1tdrQz2NiIVw,1514
+pixeltable/exec/sql_scan_node.py,sha256=CGUoBKnhuDDkLepqCmS-1vjSvG8aiIhvAZHdZZFTRSM,10295
+pixeltable/exprs/__init__.py,sha256=7dwrdk-NpF66OT-m5yNtFEhq-o1T476dnXHjluw2K1s,951
+pixeltable/exprs/arithmetic_expr.py,sha256=sWBYCBKI6IHj9ASwDcm2BlkQ5gleVtKtmpiPvzFNBJM,4386
+pixeltable/exprs/array_slice.py,sha256=VmWc6iFusrM85MjyEBBCfXG1Jnt8-Gr6-J88BXxNoOE,2131
+pixeltable/exprs/column_property_ref.py,sha256=0PHiBys0fxe2LgjaMId5UHob4E-ZggyPLnnW41RgA0E,2706
+pixeltable/exprs/column_ref.py,sha256=jmKUHuRev3PI-58BqYQVcBPLQ3E7bM1mPlFSVlwa5b0,5554
+pixeltable/exprs/comparison.py,sha256=hP3M_lMWcFgENBICFosZPw2lRm1R6_qM_O9bKPmWJGI,4789
+pixeltable/exprs/compound_predicate.py,sha256=Gh22MKi625m5A_RunVRd-a1XFi-fitikqBVz2VNXKrs,3830
+pixeltable/exprs/data_row.py,sha256=RTBw1cBt29g_9g_hgdEYZ5aiHl7WZMBaBC2fOMOfwOc,8668
+pixeltable/exprs/expr.py,sha256=mxpBHOiKbHRX9FXLZWd5UjhPu2NjuXsO6v1RRjuH4GY,24813
+pixeltable/exprs/expr_set.py,sha256=Q64Q2yI0CTq2Ma_E-BUYlMotSstVuMm4OFZnBCedHRk,1222
+pixeltable/exprs/function_call.py,sha256=UKqErJyPUa6-Q-SqkVsK_tT4ti--z_YvQEmj1jHGc8w,17149
+pixeltable/exprs/globals.py,sha256=KhK4xwkLHv4NsXXcLdjRu2OFSvEnlC7GG-8Gs_IbQtI,1858
+pixeltable/exprs/image_member_access.py,sha256=KSYdTIaLh53dNRjv3SJFchPMPo7o5diJSQkV1NsyB4Y,3547
+pixeltable/exprs/in_predicate.py,sha256=burxrBCH1MXqU-wrNWJvD0PRGzJdWy85intOSftQK54,3696
+pixeltable/exprs/inline_array.py,sha256=293WuUEhYXrcp8-AnPDVIWQBPQMrPviB88A619Ls_Es,4499
+pixeltable/exprs/inline_dict.py,sha256=TWYokJ14Nq-evODcYFVO471WSEDbz6cJqIdRb2PkbZQ,3885
+pixeltable/exprs/is_null.py,sha256=nvpOXtQj1UeYJpkCWzbaGuQElzrA2HSG3XNQugOv-pw,1041
+pixeltable/exprs/json_mapper.py,sha256=I60VNgus64ai80gnFCIsRn0VRWYXMkqH5VNvnATsN9s,4559
+pixeltable/exprs/json_path.py,sha256=Wz_5zFsyc9TPhsSbsDjDmQ3Nb0uVIwMCx5nh-cQYBiE,6526
+pixeltable/exprs/literal.py,sha256=5NNza-WL1dd3hNznwwkr_yAcTGXSIRYUszGfy30lruI,2396
+pixeltable/exprs/object_ref.py,sha256=eTcx84aWRI59fIiGvbdv3_cfL0XW4xEFQ4lwpLpJkM8,1250
+pixeltable/exprs/predicate.py,sha256=OSDgjfSqiK7J_5GZMUXMvjfyomKEGi0JNxeB073SGXw,1859
+pixeltable/exprs/row_builder.py,sha256=0OYd51J2ECPHkk2iN3MfYpS7LqnHTV5l5ubsVcy0dJA,15926
+pixeltable/exprs/rowid_ref.py,sha256=74w4rEy21YysTVbyKNc3op-pYFqDAx8VJdtl7ZPpxHs,4268
+pixeltable/exprs/similarity_expr.py,sha256=i5urJiSD43lJIi0AnMZhNvl7q5I8P3BPRuMx4IaAym0,3015
+pixeltable/exprs/type_cast.py,sha256=JMg8p1qYoFfiAXfJPSbTEnfrK7lRO_JMaqlPHOrhNQU,1793
+pixeltable/exprs/variable.py,sha256=Kg_O4ytcHYZFijIyMHYBJn063cTKU1-YE583FAz8Qaw,1361
+pixeltable/ext/__init__.py,sha256=0uugfuME1FybVo-MdxaVNGagRjhcvNTnv5MZUem6Cyo,269
+pixeltable/ext/functions/whisperx.py,sha256=CnpSPZJgufXa01vgUubVkyxQuZIdublJzkwbm5kS1YQ,1078
+pixeltable/ext/functions/yolox.py,sha256=8e-S9SD0xpwkMlSHnpm6aZc7lToHZnEnbZvM_M1alwU,3688
+pixeltable/func/__init__.py,sha256=WjftUGyNkd6bF_qSxqZ5Gd7Elf8oExb3dUlpydhdFTo,407
+pixeltable/func/aggregate_function.py,sha256=PCY-pW1cJZPx3rsHzcBDddmDoxV7IEt5n3afyeAhZ8M,9329
+pixeltable/func/callable_function.py,sha256=eD-h1KlihM4SDbCKr2HJtP8XTxAV7L0bxPCdyt-71JY,4598
+pixeltable/func/expr_template_function.py,sha256=_5xkhODJRiObOAPErvVhlpLaBpXTcjhovibCeB_1AB0,4058
+pixeltable/func/function.py,sha256=cVmu3scwveMc2hgcvhAkAEuqvahL1sKD-txz4bs21pc,5539
+pixeltable/func/function_registry.py,sha256=1ibSQxEPm3Zd3r497vSlckQiDG9sfCnyJx3zcSm9t7c,11456
+pixeltable/func/globals.py,sha256=sEwn6lGgHMp6VQORb_P5qRd_-Q2_bUSqvqM9-XPN_ec,1483
+pixeltable/func/query_template_function.py,sha256=BUU0KZYkqVPjIFg6g6msU4PzVGf2fkEKveDaEMGXhzI,3680
+pixeltable/func/signature.py,sha256=6Lwf32auSnmhYGrN4NkHk07BmG2a73TNICbWnelkH1s,8638
+pixeltable/func/udf.py,sha256=TtFgA9gXUGasd3yj22S6NAsanPJhmmZI_ewbcrTB_VY,6798
+pixeltable/functions/__init__.py,sha256=mC_0y7aLAqamgOj94S5e9yQ4HbnqPiXy-1_t2s6SPqY,290
+pixeltable/functions/eval.py,sha256=FMn95e0GG-ge7ss6dkDOV-7KQK9mSPvn-UyFB2rgBFI,8492
+pixeltable/functions/fireworks.py,sha256=sbZy3HRn8o01nT4k1lOJJ_jGrjhBNkYmj1_TraoYCiM,1090
+pixeltable/functions/globals.py,sha256=MVKcwvfRaqBMV58KBxp5ACMsTbj29WD97AOg1N5ZheY,1596
+pixeltable/functions/huggingface.py,sha256=qFdFpBX4R8Iz6fB0PKOwicdfvnEV7DQhtdcvsIQz55I,7372
+pixeltable/functions/image.py,sha256=lC5PVvx0hXlINGcURLrLeTT7xUMXla6QUC1T9t4-A0Y,5440
+pixeltable/functions/openai.py,sha256=Q6imhdlyZRuWNgBq9msqXMT8up_0e9jSsZPfSJ5DgUY,7839
+pixeltable/functions/string.py,sha256=Ae_weygd9Aj98buLC4tPLRYGg3LGSJEpXaqr93TF4nw,645
+pixeltable/functions/together.py,sha256=2vHOoXMUIpeYwTYGTr3hDHePzy8zepvoeyORgV_9n34,4412
+pixeltable/functions/util.py,sha256=F2iiIL7UfhYdCVzdCa3efYqWbaeLKFrbycKnuPkG57M,650
+pixeltable/functions/video.py,sha256=yn52MimAVrSzUyAUtyxbd1RWveX_TyjwsomBuhK9V60,6516
+pixeltable/functions/whisper.py,sha256=0lsfaGPGmJCFh2Jh-RtzwLhjo9BA83X3l7ot15fNEiA,2406
+pixeltable/globals.py,sha256=WeIQbN6peyJL3VbIBxtL21p7XKREpDmtZ_MuDEUmOu4,14158
+pixeltable/index/__init__.py,sha256=XBwetNQQwnz0fiKwonOKhyy_U32l_cjt77kNvEIdjWs,102
+pixeltable/index/base.py,sha256=YAQ5Dz1mfI0dfu9rxWHWroE8TjB90yKfPtXAzoADq38,1568
+pixeltable/index/btree.py,sha256=NE4GYhcJWYJhdKyeHI0sQBlFvUaIgGOF9KLyCZOfFjE,1822
+pixeltable/index/embedding_index.py,sha256=AYphEggN-0B4GNrm4nMmi46CEtrQw5tguyk67BK2sWo,7627
+pixeltable/io/__init__.py,sha256=DdqOteR1Y-yRvFS0VojXHryBtIGzH8nAN-1MBj3LGRk,493
+pixeltable/io/external_store.py,sha256=ZtDkfHMBo73JMKJ-q3J5FMWztYog38APn8kg81nCg34,16434
+pixeltable/io/globals.py,sha256=lfaXosEu1e2xkWhwUCUJNhpnZxXlBdf6jPlf8cf4F50,4546
+pixeltable/io/hf_datasets.py,sha256=h5M1NkXOvEU8kaeT3AON1A18Vmhnc1lVo5a3TZ5AAic,8004
+pixeltable/io/label_studio.py,sha256=ZWXTuIFk4CheM2ON0VDyb_34L9BJUY7iUJLcPvrll7c,28782
+pixeltable/io/pandas.py,sha256=cDHUDW2CGiBbsEJB9zE5vkXopTKxDdI-CZxNcp0OnIk,6478
+pixeltable/io/parquet.py,sha256=i4hvYHsARe2GnZHxNmI66Vf3tr1sIFLN6KGCJYvH3o8,8149
+pixeltable/iterators/__init__.py,sha256=sjldFckkT8aVRiKgEP6faeAK2NQBdzbmpwAeRhI1FkM,366
+pixeltable/iterators/base.py,sha256=cnEh1tNN2JAxRzrLTg3dhun3N1oNQ8vifCm6ts3_UiE,1687
+pixeltable/iterators/document.py,sha256=netSCJatG8NcgbHZ69BvQVICdAorQlYi8OlcpqwLQD4,19436
+pixeltable/iterators/string.py,sha256=NG_fWc_GAITDfzl6MvrDOMrSoMcZdMZf6hPQztCSatE,1305
+pixeltable/iterators/video.py,sha256=xtxODL1AfZwTfHVzWekhTCLA8gwTJIvJFdxC0KecD9Q,3836
+pixeltable/metadata/__init__.py,sha256=uxufhyUkogiMhztO3OoS59Rqs5pWOHqFJqPO5mZfrVA,2172
+pixeltable/metadata/converters/convert_10.py,sha256=J1_r7LNNAWTdb042AwqFpJ4sEB-i4qhUdk5iOjcZk34,719
+pixeltable/metadata/converters/convert_12.py,sha256=Ci-qyZW1gqci-8wnjeOB5afdq7KTuN-hVSV9OqSPx8g,162
+pixeltable/metadata/converters/convert_13.py,sha256=yFR6lD3pOrZ46ZQBFKYvxiIYa7rRxh46Bsq7yiCBNak,1356
+pixeltable/metadata/converters/convert_14.py,sha256=o4Dwu5wujJYILN-2chg3xCSUsh4cnn0sImv6rc75rSM,388
+pixeltable/metadata/converters/convert_15.py,sha256=N-Lt3OdOrUprN-z1gFcxniZgAtZ7jzup_YUZzXX6EtY,1709
+pixeltable/metadata/converters/convert_16.py,sha256=SvcWOYgLwRw_gLTnLbCSI9f2cpdkXazYOmmtJUOOzv4,476
+pixeltable/metadata/converters/util.py,sha256=AcYs3yUICl93y8whf0pkeWZoCzE4JuUMafmcYMyJUCY,2618
+pixeltable/metadata/schema.py,sha256=WJZ1YPgS88rFElXbjYgDhcrI4VReR1I9VPOnTkoHvoI,8418
+pixeltable/plan.py,sha256=MXWgwQXD40GB57xQiq_wjXF3OL0XTEjjhQslMfFTt3w,32831
+pixeltable/store.py,sha256=UDn-UMYuL6dTUym3yFsVhv9hUtnP_QtzhDJzsFInApc,18853
+pixeltable/tool/create_test_db_dump.py,sha256=AYYHJKSDx7CMjNH6WUoOlUCICFZKRqQn7sSL3jKkDEw,10727
+pixeltable/tool/create_test_video.py,sha256=OLfccymYReIpzE8osZn4rQvLXxxiPC_l0vc06U74hVM,2899
+pixeltable/tool/embed_udf.py,sha256=llHUhjGnCMp7Wyz7eHgKZV2v6o2ZWSgLQKscESuHK_o,269
+pixeltable/type_system.py,sha256=oXnDVoP90ic6WSTF_DcgWDLx0MYKEU0ggGTesAKahic,29505
+pixeltable/utils/__init__.py,sha256=UYlrf6TIWJT0g-Hac0b34-dEk478B5Qx8dGco34YlIk,439
+pixeltable/utils/arrow.py,sha256=83_7aG5UR2qtTktw_otLkQs-RQbLk0VVM0JLJkbweNU,3692
+pixeltable/utils/coco.py,sha256=ISpFBhR4eO1jOcg_SPb0thVI4KdS6H0RyNQauZIA5A4,7287
+pixeltable/utils/code.py,sha256=AOw1u2r8_DQXpX-lxJhyHWARGrCRDXOJHFVgKOi54Uc,1231
+pixeltable/utils/documents.py,sha256=Q7e5U2Hk0go83MdKzD_MIiMscwbcFsLMgRw2IU_vQF4,2213
+pixeltable/utils/filecache.py,sha256=UoNONG2VaAc2IBB0e3sQdsvyOPOes2XSDc5_CsA4qek,7839
+pixeltable/utils/help.py,sha256=cCnxJ4VP9MJ57iDqExmnDcM-JG3a1lw_q7g-D7bpSVI,252
+pixeltable/utils/http_server.py,sha256=WQ5ILMzlz4TlwI9j5YqAPgEZyhrN1GytMNDbLD9occk,2422
+pixeltable/utils/media_store.py,sha256=x71wnJDZDHcdd13VCfL4AkHQ6IJB41gNA-zBvXJwFos,3116
+pixeltable/utils/pytorch.py,sha256=BR4tgfUWw-2rwWTOgzXj5qdMBpe1Arpp5SK4ax6jjpk,3483
+pixeltable/utils/s3.py,sha256=rkanuhk9DWvSfmbOLQW1j1Iov4sl2KhxGGKN-AJ8LSE,432
+pixeltable/utils/sql.py,sha256=5n5_OmXAGtqFdL6z5XvgnU-vlx6Ba6f1WJrO1ZwUle8,765
+pixeltable/utils/transactional_directory.py,sha256=UGzCrGtLR3hEEf8sYGuWBzLVFAEQml3vdIavigWeTBM,1349
+pixeltable-0.2.9.dist-info/LICENSE,sha256=0UNMmwuqWPC0xDY1NWMm4uNJ2_MyA1pnTNRgQTvuBiQ,746
+pixeltable-0.2.9.dist-info/METADATA,sha256=YInl_cYNpCosk7ENDDVZ9GGfFKCuKB3ZyWsGiezTrRI,9806
+pixeltable-0.2.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pixeltable-0.2.9.dist-info/RECORD,,

pixeltable/datatransfer/__init__.py

@@ -1 +0,0 @@
-from .remote import Remote

pixeltable/datatransfer/label_studio.py

@@ -1,452 +0,0 @@
-import logging
-import os
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any, Iterator, Optional
-from xml.etree import ElementTree
-
-import PIL.Image
-import label_studio_sdk
-import more_itertools
-from requests.exceptions import HTTPError
-
-import pixeltable as pxt
-import pixeltable.env as env
-import pixeltable.exceptions as excs
-from pixeltable import Table
-from pixeltable.datatransfer.remote import Remote
-from pixeltable.utils import coco
-
-_logger = logging.getLogger('pixeltable')
-
-
-@env.register_client('label_studio')
-def _(api_key: str, url: str) -> label_studio_sdk.Client:
-    return label_studio_sdk.Client(api_key=api_key, url=url)
-
-
-def _label_studio_client() -> label_studio_sdk.Client:
-    return env.Env.get().get_client('label_studio')
-
-
-class LabelStudioProject(Remote):
-    """
-    A [`Remote`][pixeltable.datatransfer.Remote] that represents a Label Studio project, providing functionality
-    for synchronizing between a Pixeltable table and a Label Studio project.
-
-    The API key and URL for a valid Label Studio server must be specified in Pixeltable config. Either:
-
-    * Set the `LABEL_STUDIO_API_KEY` and `LABEL_STUDIO_URL` environment variables; or
-    * Specify `api_key` and `url` fields in the `label-studio` section of `$PIXELTABLE_HOME/config.yaml`.
-    """
-    # TODO(aaron-siegel): Add link in docstring to a Label Studio howto
-
-    def __init__(self, project_id: int):
-        self.project_id = project_id
-        self._project: Optional[label_studio_sdk.project.Project] = None
-
-    @classmethod
-    def create(cls, title: str, label_config: str, **kwargs: Any) -> 'LabelStudioProject':
-        """
-        Creates a new Label Studio project, using the Label Studio client configured in Pixeltable.
-
-        Args:
-            title: The title of the project.
-            label_config: The Label Studio project configuration, in XML format.
-            **kwargs: Additional keyword arguments for the new project; these will be passed to `start_project`
-                in the Label Studio SDK.
-        """
-        # Check that the config is valid before creating the project
-        cls._parse_project_config(label_config)
-        project = _label_studio_client().start_project(title=title, label_config=label_config, **kwargs)
-        project_id = project.get_params()['id']
-        return LabelStudioProject(project_id)
-
-    @property
-    def project(self) -> label_studio_sdk.project.Project:
-        """The `Project` object corresponding to this Label Studio project."""
-        if self._project is None:
-            try:
-                self._project = _label_studio_client().get_project(self.project_id)
-            except HTTPError as exc:
-                raise excs.Error(f'Could not locate Label Studio project: {self.project_id} '
-                                 '(cannot connect to server or project no longer exists)') from exc
-        return self._project
-
-    @property
-    def project_params(self) -> dict[str, Any]:
-        """The parameters of this Label Studio project."""
-        return self.project.get_params()
-
-    @property
-    def project_title(self) -> str:
-        """The title of this Label Studio project."""
-        return self.project_params['title']
-
-    @property
-    def _project_config(self) -> '_LabelStudioConfig':
-        return self._parse_project_config(self.project_params['label_config'])
-
-    def get_export_columns(self) -> dict[str, pxt.ColumnType]:
-        """
-        The data keys and preannotation fields specified in this Label Studio project.
-        """
-        return self._project_config.export_columns
-
-    def get_import_columns(self) -> dict[str, pxt.ColumnType]:
-        """
-        Always contains a single entry:
-
-        ```
-        {"annotations": pxt.JsonType(nullable=True)}
-        ```
-        """
-        return {ANNOTATIONS_COLUMN: pxt.JsonType(nullable=True)}
-
-    def sync(self, t: Table, col_mapping: dict[str, str], export_data: bool, import_data: bool) -> None:
-        _logger.info(f'Syncing Label Studio project "{self.project_title}" with table `{t.get_name()}`'
-                     f' (export: {export_data}, import: {import_data}).')
-        # Collect all existing tasks into a dict with entries `rowid: task`
-        tasks = {tuple(task['meta']['rowid']): task for task in self._fetch_all_tasks()}
-        if export_data:
-            self._create_tasks_from_table(t, col_mapping, tasks)
-        if import_data:
-            self._update_table_from_tasks(t, col_mapping, tasks)
-
-    def _fetch_all_tasks(self) -> Iterator[dict]:
-        page = 1
-        unknown_task_count = 0
-        while True:
-            result = self.project.get_paginated_tasks(page=page, page_size=_PAGE_SIZE)
-            if result.get('end_pagination'):
-                break
-            for task in result['tasks']:
-                rowid = task['meta'].get('rowid')
-                if rowid is None:
-                    unknown_task_count += 1
-                else:
-                    yield task
-            page += 1
-        if unknown_task_count > 0:
-            _logger.warning(
-                f'Skipped {unknown_task_count} unrecognized task(s) when syncing Label Studio project "{self.project_title}".'
-            )
-
-    def _update_table_from_tasks(self, t: Table, col_mapping: dict[str, str], tasks: dict[tuple, dict]) -> None:
-        # `col_mapping` is guaranteed to be a one-to-one dict whose values are a superset
-        # of `get_import_columns`
-        assert ANNOTATIONS_COLUMN in col_mapping.values()
-        annotations_column = next(k for k, v in col_mapping.items() if v == ANNOTATIONS_COLUMN)
-        updates = [
-            {
-                '_rowid': task['meta']['rowid'],
-                # Replace [] by None to indicate no annotations. We do want to sync rows with no annotations,
-                # in order to properly handle the scenario where existing annotations have been deleted in
-                # Label Studio.
-                annotations_column: task[ANNOTATIONS_COLUMN] if len(task[ANNOTATIONS_COLUMN]) > 0 else None
-            }
-            for task in tasks.values()
-        ]
-        if len(updates) > 0:
-            _logger.info(
-                f'Updating table `{t.get_name()}`, column `{annotations_column}` with {len(updates)} total annotations.'
-            )
-            t.batch_update(updates)
-            annotations_count = sum(len(task[ANNOTATIONS_COLUMN]) for task in tasks.values())
-            print(f'Synced {annotations_count} annotation(s) from {len(updates)} existing task(s) in {self}.')
-
-    def _create_tasks_from_table(self, t: Table, col_mapping: dict[str, str], existing_tasks: dict[tuple, dict]) -> None:
-        t_col_types = t.column_types()
-        config = self._project_config
-
-        # Columns in `t` that map to Label Studio data keys
-        t_data_cols = [
-            t_col_name for t_col_name, r_col_name in col_mapping.items()
-            if r_col_name in config.data_keys
-        ]
-
-        # Columns in `t` that map to `rectanglelabels` preannotations
-        t_rl_cols = [
-            t_col_name for t_col_name, r_col_name in col_mapping.items()
-            if r_col_name in config.rectangle_labels
-        ]
-
-        # Destinations for `rectanglelabels` preannotations
-        rl_info = list(config.rectangle_labels.values())
-
-        _logger.debug('`t_data_cols`: %s', t_data_cols)
-        _logger.debug('`t_rl_cols`: %s', t_rl_cols)
-        _logger.debug('`rl_info`: %s', rl_info)
-
-        if len(t_data_cols) == 1 and t_col_types[t_data_cols[0]].is_media_type():
-            # With a single media column, we can post local files to Label Studio using
-            # the file transfer API.
-            self._create_tasks_by_post(t, col_mapping, existing_tasks, t_rl_cols, rl_info, t_data_cols[0])
-        else:
-            # Either a single non-media column or multiple columns. Either way, we can't
-            # use the file upload API and need to rely on externally accessible URLs for
-            # media columns.
-            self._create_tasks_by_urls(t, col_mapping, existing_tasks, t_data_cols, t_col_types, t_rl_cols, rl_info)
-
-    def _create_tasks_by_post(
-            self,
-            t: Table,
-            col_mapping: dict[str, str],
-            existing_tasks: dict[tuple, dict],
-            t_rl_cols: list[str],
-            rl_info: list['_RectangleLabel'],
-            media_col_name: str
-    ) -> None:
-        is_stored = t[media_col_name].col.is_stored
-        # If it's a stored column, we can use `localpath`
-        localpath_col_opt = [t[media_col_name].localpath] if is_stored else []
-        # Select the media column, rectanglelabels columns, and localpath (if appropriate)
-        rows = t.select(t[media_col_name], *[t[col] for col in t_rl_cols], *localpath_col_opt)
-        tasks_created = 0
-        row_ids_in_pxt: set[tuple] = set()
-
-        for row in rows._exec():
-            media_col_idx = rows._select_list_exprs[0].slot_idx
-            rl_col_idxs = [expr.slot_idx for expr in rows._select_list_exprs[1: 1 + len(t_rl_cols)]]
-            row_ids_in_pxt.add(row.rowid)
-            if row.rowid not in existing_tasks:
-                # Upload the media file to Label Studio
-                if is_stored:
-                    # There is an existing localpath; use it!
-                    localpath_col_idx = rows._select_list_exprs[-1].slot_idx
-                    file = Path(row.vals[localpath_col_idx])
-                    task_id: int = self.project.import_tasks(file)[0]
-                else:
-                    # No localpath; create a temp file and upload it
-                    assert isinstance(row.vals[media_col_idx], PIL.Image.Image)
-                    file = env.Env.get().create_tmp_path(extension='.png')
-                    row.vals[media_col_idx].save(file, format='png')
-                    task_id: int = self.project.import_tasks(file)[0]
-                    os.remove(file)
-
-                # Update the task with `rowid` metadata
-                self.project.update_task(task_id, meta={'rowid': row.rowid})
-
-                # Convert coco annotations to predictions
-                coco_annotations = [row.vals[i] for i in rl_col_idxs]
-                _logger.debug('`coco_annotations`: %s', coco_annotations)
-                predictions = [
-                    self._coco_to_predictions(
-                        coco_annotations[i], col_mapping[t_rl_cols[i]], rl_info[i], task_id=task_id
-                    )
-                    for i in range(len(coco_annotations))
-                ]
-                _logger.debug(f'`predictions`: %s', predictions)
-                self.project.create_predictions(predictions)
-                tasks_created += 1
-
-        print(f'Created {tasks_created} new task(s) in {self}.')
-
-        self._delete_stale_tasks(existing_tasks, row_ids_in_pxt, tasks_created)
-
-    def _create_tasks_by_urls(
-            self,
-            t: Table,
-            col_mapping: dict[str, str],
-            existing_tasks: dict[tuple, dict],
-            t_data_cols: list[str],
-            t_col_types: dict[str, pxt.ColumnType],
-            t_rl_cols: list[str],
-            rl_info: list['_RectangleLabel']
-    ):
-        # TODO(aaron-siegel): This is just a placeholder (implementation is not complete or tested!)
-        selection = [
-            t[col_name].fileurl if t_col_types[col_name].is_media_type() else t[col_name]
-            for col_name in t_data_cols
-        ]
-        r_data_cols = [col_mapping[col_name] for col_name in t_data_cols]
-        rows = t.select(*selection, *[t[col] for col in t_rl_cols])
-        new_rows = filter(lambda row: row.rowid not in existing_tasks, rows._exec())
-        tasks_created = 0
-        row_ids_in_pxt: set[tuple] = set()
-
-        for page in more_itertools.batched(new_rows, n=_PAGE_SIZE):
-            data_col_idxs = [expr.slot_idx for expr in rows._select_list_exprs[:len(t_data_cols)]]
-            rl_col_idxs = [expr.slot_idx for expr in rows._select_list_exprs[len(t_data_cols):]]
-            tasks = []
-
-            for row in page:
-                row_ids_in_pxt.add(row.rowid)
-                data_vals = [row.vals[i] for i in data_col_idxs]
-                coco_annotations = [row.vals[i] for i in rl_col_idxs]
-                predictions = [
-                    self._coco_to_predictions(coco_annotations[i], col_mapping[t_rl_cols[i]], rl_info[i])
-                    for i in range(len(coco_annotations))
-                ]
-
-                # Validate media columns
-                # TODO Support this if label studio is running on localhost?
-                for i in range(len(data_vals)):
-                    if t[t_data_cols[i]].col_type.is_media_type() and data_vals[i].startswith("file://"):
-                        raise excs.Error(
-                            'Cannot use locally stored media files in a `LabelStudioProject` with more than one '
-                            'data key. (This is a limitation of Label Studio; see warning here: '
-                            'https://labelstud.io/guide/tasks.html)'
-                        )
-
-                tasks.append({
-                    'data': zip(r_data_cols, data_vals),
-                    'meta': {'rowid': row.rowid},
-                    'predictions': predictions
-                })
-
-            self.project.import_tasks(tasks)
-            tasks_created += len(tasks)
-
-        print(f'Created {tasks_created} new task(s) in {self}.')
-
-        self._delete_stale_tasks(existing_tasks, row_ids_in_pxt, tasks_created)
-
-    def _delete_stale_tasks(self, existing_tasks: dict[tuple, dict], row_ids_in_pxt: set[tuple], tasks_created: int):
-        tasks_to_delete = [
-            task['id'] for rowid, task in existing_tasks.items()
-            if rowid not in row_ids_in_pxt
-        ]
-        # Sanity check the math
-        assert len(tasks_to_delete) == len(existing_tasks) + tasks_created - len(row_ids_in_pxt)
-
-        if len(tasks_to_delete) > 0:
-            self.project.delete_tasks(tasks_to_delete)
-            print(f'Deleted {len(tasks_to_delete)} tasks(s) in {self} that are no longer present in Pixeltable.')
-
-    def to_dict(self) -> dict[str, Any]:
-        return {'project_id': self.project_id}
-
-    @classmethod
-    def from_dict(cls, md: dict[str, Any]) -> 'LabelStudioProject':
-        return LabelStudioProject(md['project_id'])
-
-    def __repr__(self) -> str:
-        name = self.project.get_params()['title']
-        return f'LabelStudioProject `{name}`'
-
-    @classmethod
-    def _parse_project_config(cls, xml_config: str) -> '_LabelStudioConfig':
-        """
-        Parses a Label Studio XML config, extracting the names and Pixeltable types of
-        all input variables.
-        """
-        root: ElementTree.Element = ElementTree.fromstring(xml_config)
-        if root.tag.lower() != 'view':
-            raise excs.Error('Root of Label Studio config must be a `View`')
-        config = _LabelStudioConfig(
-            data_keys=dict(cls._parse_data_keys_config(root)),
-            rectangle_labels=dict(cls._parse_rectangle_labels_config(root))
-        )
-        config.validate()
-        return config
-
-    @classmethod
-    def _parse_data_keys_config(cls, root: ElementTree.Element) -> Iterator[tuple[str, '_DataKey']]:
-        for element in root:
-            if 'value' in element.attrib and element.attrib['value'][0] == '$':
-                remote_col_name = element.attrib['value'][1:]
-                if 'name' not in element.attrib:
-                    raise excs.Error(f'Data key is missing `name` attribute: `{remote_col_name}`')
-                element_type = _LS_TAG_MAP.get(element.tag.lower())
-                if element_type is None:
-                    raise excs.Error(
-                        f'Unsupported Label Studio data type: `{element.tag}` (in data key `{remote_col_name}`)'
-                    )
-                yield remote_col_name, _DataKey(element.attrib['name'], element_type)
-
-    @classmethod
-    def _parse_rectangle_labels_config(cls, root: ElementTree.Element) -> Iterator[tuple[str, '_RectangleLabel']]:
-        for element in root:
-            if element.tag.lower() == 'rectanglelabels':
-                name = element.attrib['name']
-                to_name = element.attrib['toName']
-                labels = [
-                    child.attrib['value']
-                    for child in element if child.tag.lower() == 'label'
-                ]
-                for label in labels:
-                    if label not in coco.COCO_2017_CATEGORIES.values():
-                        raise excs.Error(f'Label in `rectanglelabels` config is not a valid COCO object name: {label}')
-                yield name, _RectangleLabel(to_name=to_name, labels=labels)
-
-    @classmethod
-    def _coco_to_predictions(
-            cls,
-            coco_annotations: dict[str, Any],
-            from_name: str,
-            rl_info: '_RectangleLabel',
-            task_id: Optional[int] = None
-    ) -> dict[str, Any]:
-        width = coco_annotations['image']['width']
-        height = coco_annotations['image']['height']
-        result = [
-            {
-                'id': f'result_{i}',
-                'type': 'rectanglelabels',
-                'from_name': from_name,
-                'to_name': rl_info.to_name,
-                'image_rotation': 0,
-                'original_width': width,
-                'original_height': height,
-                'value': {
-                    'rotation': 0,
-                    # Label Studio expects image coordinates as % of image dimensions
-                    'x': entry['bbox'][0] * 100.0 / width,
-                    'y': entry['bbox'][1] * 100.0 / height,
-                    'width': entry['bbox'][2] * 100.0 / width,
-                    'height': entry['bbox'][3] * 100.0 / height,
-                    'rectanglelabels': [coco.COCO_2017_CATEGORIES[entry['category']]]
-                }
-            }
-            for i, entry in enumerate(coco_annotations['annotations'])
-            # include only the COCO labels that match a rectanglelabel name
-            if coco.COCO_2017_CATEGORIES[entry['category']] in rl_info.labels
-        ]
-        if task_id is not None:
-            return {'task': task_id, 'result': result}
-        else:
-            return {'result': result}
-
-
-@dataclass(frozen=True)
-class _DataKey:
-    name: str  # The 'name' attribute of the data key; may differ from the field name
-    column_type: pxt.ColumnType
-
-
-@dataclass(frozen=True)
-class _RectangleLabel:
-    to_name: str
-    labels: list[str]
-
-
-@dataclass(frozen=True)
-class _LabelStudioConfig:
-    data_keys: dict[str, _DataKey]
-    rectangle_labels: dict[str, _RectangleLabel]
-
-    def validate(self) -> None:
-        data_key_names = set(key.name for key in self.data_keys.values())
-        for name, rl in self.rectangle_labels.items():
-            if rl.to_name not in data_key_names:
-                raise excs.Error(
-                    f'Invalid Label Studio configuration: `toName` attribute of RectangleLabels `{name}` '
-                    f'references an unknown data key: `{rl.to_name}`'
-                )
-
-    @property
-    def export_columns(self) -> dict[str, pxt.ColumnType]:
-        data_key_cols = {key_name: key_info.column_type for key_name, key_info in self.data_keys.items()}
-        rl_cols = {name: pxt.JsonType() for name in self.rectangle_labels.keys()}
-        return {**data_key_cols, **rl_cols}
-
-
-ANNOTATIONS_COLUMN = 'annotations'
-_PAGE_SIZE = 100  # This is the default used in the LS SDK
-_LS_TAG_MAP = {
-    'text': pxt.StringType(),
-    'image': pxt.ImageType(),
-    'video': pxt.VideoType(),
-    'audio': pxt.AudioType()
-}