datashare-python 0.9.9__py3-none-any.whl → 0.10.0.dev0__py3-none-any.whl

datashare_python/utils.py

@@ -3,22 +3,34 @@ import contextlib
 import fcntl
 import inspect
 import json
+import logging
 import os
 import shutil
+import sys
 import threading
 import time
-from collections.abc import Callable, Coroutine, Generator, Iterable, Sequence
+from collections.abc import (
+    AsyncIterable,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Generator,
+    Iterable,
+    Sequence,
+)
 from copy import deepcopy
 from dataclasses import dataclass
 from datetime import timedelta
-from functools import wraps
+from functools import cache, wraps
 from hashlib import sha256
 from io import BytesIO
 from pathlib import Path
-from typing import Any, ParamSpec, TypeVar
+from typing import Any, ParamSpec, Self, TypeVar
 from uuid import uuid4
 
 import temporalio
+from aiofile import async_open
+from lru import LRU
 from pydantic import ValidationError
 from temporalio import activity, workflow
 from temporalio.api.common.v1 import Payload
@@ -40,9 +52,18 @@ from datashare_python.types_ import (
 )
 
 from .constants import MANIFEST_JSON, METADATA_JSON
-from .objects import DocArtifact, DocumentLocation, FilesystemDocument
+from .mimetypes_ import types_map
+from .objects import (
+    BaseModel,
+    DocArtifact,
+    DocumentLocation,
+    ProcessedFile,
+    WorkerPaths,
+)
 from .types_ import RawAsyncProgressHandler
 
+logger = logging.getLogger(__name__)
+
 DependencyLabel = str | None
 DependencySetup = Callable[..., None]
 DependencyAsyncSetup = Callable[..., Coroutine[None, None, None]]
@@ -134,7 +155,7 @@ def _retry_policy_with_default(retry_policy: RetryPolicy | None) -> RetryPolicy:
 
 
 async def execute_activity(
-    activity: Callable,
+    activity: Callable | str,
     task_queue: str,
     arg: Any = temporalio.common._arg_unset,
     *,
@@ -164,7 +185,7 @@ def positional_args_only(activity_fn: Callable[P, T]) -> Callable[P, T]:
     params = list(sig.parameters.values())
     keyword_only = {p.name for p in params if p.kind == inspect.Parameter.KEYWORD_ONLY}
 
-    if asyncio.iscoroutinefunction(activity_fn):
+    if inspect.iscoroutinefunction(activity_fn):
 
         @wraps(activity_fn)
         async def wrapper(*args, **kwargs) -> T:
@@ -211,7 +232,7 @@ def with_retriables(
     if retriables is None:
 
         def decorator(activity_fn: Callable[P, T]) -> Callable[P, T]:
-            if asyncio.iscoroutinefunction(activity_fn):
+            if inspect.iscoroutinefunction(activity_fn):
 
                 @wraps(activity_fn)
                 async def wrapper(*args, **kwargs) -> T:
@@ -233,7 +254,7 @@ def with_retriables(
         return decorator
 
     def decorator(activity_fn: Callable[P, T]) -> Callable[P, T]:
-        if asyncio.iscoroutinefunction(activity_fn):
+        if inspect.iscoroutinefunction(activity_fn):
 
             @wraps(activity_fn)
             async def wrapper(*args, **kwargs) -> T:
@@ -269,7 +290,7 @@ def activity_defn(
         activity_fn = with_retriables(retriables)(activity_fn)
         activity_fn = activity.defn(activity_fn, name=name)
 
-        is_async = asyncio.iscoroutinefunction(activity_fn)
+        is_async = inspect.iscoroutinefunction(activity_fn)
         if is_async:
 
             @wraps(activity_fn)
@@ -304,6 +325,20 @@ def to_raw_async_progress(
     return raw
 
 
+def to_incremental_async_progress(
+    progress: RawAsyncProgressHandler,
+) -> RawAsyncProgressHandler:
+
+    offset = 0
+
+    async def incremental(p: int) -> None:
+        nonlocal offset
+        offset += p
+        await progress(offset)
+
+    return incremental
+
+
 def to_raw_sync_progress(
     progress: SyncProgressRateHandler, max_progress: int
 ) -> RawSyncProgressHandler:
@@ -395,7 +430,7 @@ def write_artifact(
             )
         manifest[artifact.type] = manifest_entry
         manifest_path.write_text(json.dumps(manifest))
-        return artifact_path.relative_to(artif_dir)
+        return artifact_path.relative_to(root)
 
 
 @contextlib.contextmanager
@@ -412,23 +447,29 @@ def artifact_lock(
     artifacts_dir: Path, lock_timeout_ms: int
 ) -> Generator[None, None, None]:
     lock_path = artifacts_dir / f"{MANIFEST_JSON}.lock"
+    acquired = False
     fd = os.open(lock_path, os.O_CREAT | os.O_WRONLY)
-    with _ARTIFACT_LOCK, _set_event():
-        start = time.time()
-        timeout_s = lock_timeout_ms / 1000
-        while time.time() - start < timeout_s:
-            try:
-                fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
-            except OSError:
-                # TODO: we shouldn't block here, use asyncio instead
-                time.sleep(0.02)
-                continue
-            yield
-            return
-        msg = (
-            f"failed to acquire lock on {lock_path} in less than {lock_timeout_ms} ms."
-        )
-        raise TimeoutError(msg)
+    try:
+        with _ARTIFACT_LOCK, _set_event():
+            start = time.time()
+            timeout_s = lock_timeout_ms / 1000
+            while time.time() - start < timeout_s:
+                try:
+                    _, acquired = fcntl.lockf(fd, fcntl.LOCK_EX | fcntl.LOCK_NB), True
+                except OSError:
+                    # TODO: we shouldn't block here, use asyncio instead
+                    time.sleep(0.02)
+                    continue
+                yield
+                return
+            msg = (
+                f"failed to acquire lock on {lock_path} in less than "
+                f"{lock_timeout_ms} ms."
+            )
+            raise TimeoutError(msg)
+    finally:
+        if acquired:
+            lock_path.unlink(missing_ok=True)
 
 
 def _read_manifest_backward_compatible(
@@ -526,35 +567,44 @@ def activity_workdir(
 
 
 def symlink_embedded_document_to_workdir(
-    doc: FilesystemDocument, artifacts_root: Path, *, workdir: Path
-) -> FilesystemDocument:
+    doc: ProcessedFile, paths: WorkerPaths
+) -> ProcessedFile:
     match doc.location:
         case DocumentLocation.ARTIFACTS:
-            symlinks_dir = workdir / doc.index / "symlinks"
+            symlinks_dir = paths.workdir / doc.project / "symlinks"
             symlinks_dir.mkdir(parents=True, exist_ok=True)
-            symlink_path = Path(*doc.path.parts[:-1], doc.id)
-            # Replace the "raw" with the doc id
-            doc_ext = Path(doc.resource_name).suffix
-            symlink_path = symlink_path.relative_to(Path(doc.index))
-            symlink_path = symlinks_dir / f"{symlink_path}{doc_ext}"
+            symlink_path = Path(*doc.path.parts[1:-1], doc.resource_name)
+            symlink_path = symlinks_dir / symlink_path
+            # Replace the "raw" with the resource name
             symlink_path.parent.mkdir(parents=True, exist_ok=True)
-            artifact_path = artifacts_root / doc.path
+            artifact_path = paths.artifacts / doc.path
             with contextlib.suppress(FileExistsError):
                 os.symlink(artifact_path, symlink_path)
-            return FilesystemDocument(
-                path=symlink_path.relative_to(workdir),
+            return ProcessedFile(
+                path=symlink_path.relative_to(paths.workdir),
                 id=doc.id,
                 location=DocumentLocation.WORKDIR,
-                index=doc.index,
+                project=doc.project,
                 resource_name=doc.resource_name,
+                n_pages=doc.n_pages,
             )
-        case DocumentLocation.ORIGINAL:
+        case DocumentLocation.FILESYSTEM:
             return doc
         case _:
             raise ValueError(f"unsupported location {doc.location}")
 
 
-def read_jsonl(path: Path) -> Iterable[dict]:
+def artifact_path(
+    doc_id: str,
+    artifact_type: type[DocArtifact],
+    *,
+    project: str,
+    root: Path,
+) -> Path:
+    return root / artifacts_dir(doc_id, project=project) / artifact_type.filename
+
+
+def _read_jsonl(path: Path) -> Iterable[dict]:
     with path.open() as f:
         for line in f:
             line = line.strip()  # noqa: PLW2901
@@ -562,6 +612,77 @@ def read_jsonl(path: Path) -> Iterable[dict]:
                 yield json.loads(line)
 
 
+M = TypeVar("M", bound=BaseModel)
+
+
+def read_jsonl_as(path: Path, cls: type[M]) -> Iterable[M]:
+    return (cls.model_validate(d) for d in _read_jsonl(path))
+
+
+async def async_read_jsonl_as(
+    path: Path, processed_file_cls: type[M]
+) -> AsyncIterable[M]:
+    async with async_open(path, "r") as f:
+        async for line in f:
+            line = line.strip()  # noqa: PLW2901
+            if line:
+                yield processed_file_cls.model_validate_json(line)
+
+
+@cache
+def ext_to_mime_types(ext: str) -> set[str]:
+    # All particular cases
+    match ext:
+        case ".nxml" | ".dclg" | ".dclg_xml":
+            return ext_to_mime_types(".xml")
+        case ".qmd" | ".rmd":
+            return ext_to_mime_types(".md")
+        case ".xbrl":
+            return ext_to_mime_types(".html")
+        case ".j2c" | ".j2k" | ".jpc" | ".jpf" | ".jpx":
+            return ext_to_mime_types(".jp2")
+        case ".rgba":
+            return ext_to_mime_types(".png")
+        case ".svm":
+            return ext_to_mime_types(".wmf")
+        case ".uof" | ".uop" | ".uos" | ".uot":
+            return ext_to_mime_types(".xml")
+        case ".dclg.xml":
+            return ext_to_mime_types(".xml")
+    try:
+        return types_map()[ext]
+    except KeyError as e:
+        raise ValueError(f"unsupported mimetype {ext}") from e
+
+
+async def publish_and_consume(
+    publisher: asyncio.Task,
+    publisher_completion_callback: Callable[[], None],
+    *,
+    consumer: asyncio.Task,
+) -> tuple[Any, Any]:
+    # Publish and consume concurrently
+    logger.debug("starting publish and subscribe")
+    done, pending = await asyncio.wait(
+        [publisher, consumer], return_when=asyncio.FIRST_COMPLETED
+    )
+    for d in done:
+        # Stop everything case of exception
+        exc = d.exception()
+        if exc:
+            for p in pending:
+                p.cancel()
+            raise exc
+    # Wait for publish to be done and push the poison pill to stop consuming
+    p_res = await publisher
+    publisher_completion_callback()
+    logger.debug("done publishing, waiting for consumer to complete...")
+    # Wait for consumption to be done
+    c_res = await consumer
+    logger.debug("done consuming !")
+    return p_res, c_res
+
+
 class _PydanticPayloadConverter(CompositePayloadConverter):
     def __init__(self) -> None:
         json_payload_converter = PydanticJSONPlainPayloadConverter(
@@ -594,3 +715,97 @@ class _PydanticPayloadConverter(CompositePayloadConverter):
 PYDANTIC_DATA_CONVERTER = DataConverter(
     payload_converter_class=_PydanticPayloadConverter
 )
+
+
+class SharedResources:
+    def __init__(
+        self,
+        cache_size: int = 1,
+        eviction_callback: Callable[[Any, Any], None] | None = None,
+    ) -> None:
+        self._eviction_callback = eviction_callback
+        self._cache = LRU(cache_size, self._eviction_callback)
+        self._sentinel = object()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # noqa: ANN001
+        if self._eviction_callback is not None:
+            for k, v in self._cache.items():
+                self._eviction_callback(k, v)
+
+    def get_or_cache_resource(
+        self, key: str, default_factory: Callable[[], Any]
+    ) -> Any:
+        value = self._cache.get(key, self._sentinel)
+        if value is not self._sentinel:
+            return value
+        # Get the value first to be sure to return the right one in case of concurrent
+        # access.
+        #
+        # Additionally, the factory can be long to complete (that's one of the reason
+        # we want to cache its results). Because we don't lock the factory call,
+        # together with the cache update, in case of concurrent access,
+        # quicker factories will complete first and will stay longer in the cache.
+        # This is fine, the alternative is to lock factory + cache update to avoid
+        # concurrent access but this will mean waiting for the first factory call to
+        # complete, this can potentially imply longer waits than no getting the value
+        # from the cache
+        value = default_factory()
+        self._cache[key] = value
+        return value
+
+    async def async_get_or_cache_resource(
+        self, key: str, default_factory: Callable[[], Awaitable[Any]]
+    ) -> Any:
+        value = self._cache.get(key, self._sentinel)
+        if value is not self._sentinel:
+            return value
+        # Get the value first to be sure to return the right one in case of concurrent
+        # access.
+        #
+        # Additionally, the factory can be long to complete (that's one of the reason
+        # we want to cache its results). Because we don't lock the factory call,
+        # together with the cache update, in case of concurrent access,
+        # quicker factories will complete first and will stay longer in the cache.
+        # This is fine, the alternative is to lock factory + cache update to avoid
+        # concurrent access but this will mean waiting for the first factory call to
+        # complete, this can potentially imply longer waits than no getting the value
+        # from the cache
+        value = await default_factory()
+        self._cache[key] = value
+        return value
+
+
+def close_cm_callback(key: str, value: Any) -> None:  # noqa: ARG001
+    if hasattr(value, "__exit__"):
+        value.__exit__(*sys.exc_info())
+
+
+def enter_cm(
+    cm_factory: Callable[[], contextlib.AbstractContextManager],
+) -> Callable[[], contextlib.AbstractContextManager]:  # noqa: ARG001
+    @wraps(cm_factory)
+    def factory() -> contextlib.AbstractContextManager:
+        cm = cm_factory()
+        cm.__enter__()
+        return cm
+
+    return factory
+
+
+def async_enter_cm(
+    cm_factory: Callable[[], contextlib.AbstractAsyncContextManager],
+) -> Callable[[], Awaitable[contextlib.AbstractAsyncContextManager]]:  # noqa: ARG001
+    @wraps(cm_factory)
+    async def wrapper() -> contextlib.AbstractAsyncContextManager:
+        cm = cm_factory()
+        await cm.__aenter__()
+        return cm
+
+    return wrapper
+
+
+def config_cache_key(config: BaseModel) -> str:
+    return str(hash(config))

datashare_python/worker.py

@@ -61,6 +61,16 @@ class DatashareWorker(Worker):
             raise ValueError("worker is not running")
         await self._async_context_run_task
 
+    async def __aexit__(self, exc_type: type[BaseException] | None, *args: Any) -> None:
+        await super().__aexit__(exc_type, *args)
+        logger.info("worker %s exited", self._config["identity"])
+
+    async def __aenter__(self) -> "DatashareWorker":
+        await super().__aenter__()
+        # TODO: remove me
+        logger.info("worker %s started working", self._config["identity"])
+        return self
+
 
 def datashare_worker(
     client: TemporalClient,
@@ -71,7 +81,8 @@ def datashare_worker(
     task_queue: str,
     # Scale horizontally be default for activities, each worker processes one activity
     # at a time
-    max_concurrent_io_activities: int = 10,
+    max_concurrent_activities: int = 1,
+    max_activities_per_second: float = 20.0,
     sandboxed: bool = True,
 ) -> DatashareWorker:
     if workflows is None:
@@ -91,7 +102,6 @@ def datashare_worker(
         )
         logger.warning(_SEPARATE_IO_AND_CPU_ACTIVITIES)
 
-    max_concurrent_activities = max_concurrent_io_activities
     if isinstance(activity_executor, ThreadPoolExecutor):
         max_concurrent_activities = 1
         if workflows:
@@ -118,6 +128,7 @@ def datashare_worker(
         # several of them
         workflow_task_poller_behavior=PollerBehaviorSimpleMaximum(5),
         workflow_runner=wf_runner,
+        max_activities_per_second=max_activities_per_second,
     )
 
 
@@ -204,7 +215,7 @@ async def worker_context(
             workflows=workflows,
             activities=acts,
             task_queue=task_queue,
-            max_concurrent_io_activities=worker_config.max_concurrent_io_activities,
+            max_concurrent_activities=worker_config.max_concurrent_activities,
             sandboxed=sandboxed,
         )
         async with worker:

{datashare_python-0.9.9.dist-info → datashare_python-0.10.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datashare-python
-Version: 0.9.9
+Version: 0.10.0.dev0
 Summary: Manage Python tasks and local resources in Datashare
 Project-URL: Homepage, https://icij.github.io/datashare-python/
 Project-URL: Documentation, https://icij.github.io/datashare-python/
@@ -8,6 +8,7 @@ Project-URL: Repository, https://github.com/ICIJ/datashare-python
 Project-URL: Issues, https://github.com/ICIJ/datashare-python/issues
 Author-email: Clément Doumouro <cdoumouro@icij.org>, Clément Doumouro <clement.doumouro@gmail.com>, Lion Summerbell <lsummerbell@icij.org>
 Requires-Python: <4,>=3.11
+Requires-Dist: aiofile~=3.11
 Requires-Dist: aiohttp~=3.11
 Requires-Dist: alive-progress~=3.2
 Requires-Dist: hatchling~=1.27
@@ -17,6 +18,6 @@ Requires-Dist: lru-dict~=1.4
 Requires-Dist: pydantic-extra-types[pycountry]>=2.11.1
 Requires-Dist: python-json-logger~=4.0
 Requires-Dist: pyyaml~=6.0
-Requires-Dist: temporalio~=1.23
+Requires-Dist: temporalio~=1.31
 Requires-Dist: tomlkit~=0.14.0
 Requires-Dist: typer<0.25.1,>=0.15.4

datashare_python-0.10.0.dev0.dist-info/RECORD

@@ -0,0 +1,28 @@
+datashare_python/.gitignore,sha256=e-SRgnvGGdsjRrqgKsTzALz6Obx8IYiOjr0yaAxT6v8,22
+datashare_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datashare_python/__main__.py,sha256=g-fvS46zl9umKmGrSpl-OG-8PSuZgjqvTCqjpsZtSps,101
+datashare_python/config.py,sha256=V3LBXdxzAt8_UcHiPw6I4HN7RTo-Fns6xd50eZ8nHtQ,4116
+datashare_python/conftest.py,sha256=-cEtlPEl6EagrxB5GTvjD92QQats3ItyFuIKkOKTf1s,13623
+datashare_python/constants.py,sha256=-Irwd2bbnFGIkLVJi_SiQ7PM2eNW3Ia_co4SE6z4j-A,352
+datashare_python/dependencies.py,sha256=Q-BIhCwWu-GGp9omYNhENZ88cF0QJ8spfaMZX40mmNU,4386
+datashare_python/discovery.py,sha256=3mUck2GUSKu2DSP9-MM1OdVM4FqFKqfBeSQDQZxgh2g,7177
+datashare_python/exceptions.py,sha256=bVHEAXxDPKfxeeMC0hJXEsrJkgsKO2ESAhxWU96GA4M,496
+datashare_python/interceptors.py,sha256=6ZJG7VJN5EHZkO6XD3nJyRCzCDb1Nh3x24VL1ip2Iyw,13314
+datashare_python/logging_.py,sha256=96KNXhP-JR5ybu9dld4VLtF7v7PfiphOCR1Nio-mmUs,4483
+datashare_python/mimetypes_.py,sha256=mjQgaqnSFZEcl3LoLDGBaBBjTTzwYfSNZND9Fmkk2zs,49682
+datashare_python/objects.py,sha256=sSmXlsnj3PH_LZJwliUZcyXlVHbRHM7q19k_bLscAgs,16085
+datashare_python/task_client.py,sha256=oTmP8bvZW0UyhLNMi1AV3XIAx7hrdbxNRss2Mw2azEc,8435
+datashare_python/template.py,sha256=N1uM8TRXh5tQPV7BC1oJj-Pdm2Gs_SkjaXv50RnNYso,4682
+datashare_python/types_.py,sha256=80XTD481HxjbkS330pqHHmlsM-cxUyGGgcJnG8_vYR8,1134
+datashare_python/utils.py,sha256=9RhgubRztlCdDPaAgmnbnMzwFkiCL_azt74yKFUhqjc,26627
+datashare_python/worker-template.tar.gz,sha256=EdE9rOAFuy01ghQAvLf8M0pvxh0nCuIs40Z-3rnr0QQ,278668
+datashare_python/worker.py,sha256=9BqtVTell9lhyHwdvpuYS_SNvxHGkS75HGhu1E_OhMM,8224
+datashare_python/cli/__init__.py,sha256=9BPWtssDgsVfWMsZ1TtZCla0EC_kai4RHttr8oNLYOE,1401
+datashare_python/cli/project.py,sha256=w32Gy9AOL5B00uDT4in7YUCt2g68FnNbvwg2M3a8G6o,946
+datashare_python/cli/task.py,sha256=GsyR5o0fN4Pd8tJKAUgivAvCBKT3L4Ay5j_BCW1XBHk,5828
+datashare_python/cli/utils.py,sha256=p69CQb0zfixuyBkiZprhdMCc_NuYwXyAn6vC9H1UzAw,911
+datashare_python/cli/worker.py,sha256=x0p3a1_NsZPbmV7-WSVMRyW3_iadYcgyZKbDvWgymQc,5790
+datashare_python-0.10.0.dev0.dist-info/METADATA,sha256=3g8Tbq3QGjfHXMEp0YUop3xOCDSv7ptglIDrOmBHXW8,1017
+datashare_python-0.10.0.dev0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+datashare_python-0.10.0.dev0.dist-info/entry_points.txt,sha256=ILE7auxabHWiu3GC-AunWnzjhOI_SbZp7D4GqZHlLw4,68
+datashare_python-0.10.0.dev0.dist-info/RECORD,,

datashare_python-0.9.9.dist-info/RECORD

@@ -1,27 +0,0 @@
-datashare_python/.gitignore,sha256=e-SRgnvGGdsjRrqgKsTzALz6Obx8IYiOjr0yaAxT6v8,22
-datashare_python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-datashare_python/__main__.py,sha256=g-fvS46zl9umKmGrSpl-OG-8PSuZgjqvTCqjpsZtSps,101
-datashare_python/config.py,sha256=1-uksky9GwmPh85E3JYt6X4hgjP68gUmZjZM7qf3VUI,3779
-datashare_python/conftest.py,sha256=28mDi35cpGlH3gOofNWPzjPRp5FvZawE2JZTDVFnY6w,9184
-datashare_python/constants.py,sha256=Fq8aX80SIznES2tC_Sj9I85ppq0p1wpfVmLXJAUd7EA,387
-datashare_python/dependencies.py,sha256=JdKZX3TlbYQk1YLvscGEdXQNJ9TFjtbxmYwlxNyqGOg,4793
-datashare_python/discovery.py,sha256=3mUck2GUSKu2DSP9-MM1OdVM4FqFKqfBeSQDQZxgh2g,7177
-datashare_python/exceptions.py,sha256=bVHEAXxDPKfxeeMC0hJXEsrJkgsKO2ESAhxWU96GA4M,496
-datashare_python/interceptors.py,sha256=6ZJG7VJN5EHZkO6XD3nJyRCzCDb1Nh3x24VL1ip2Iyw,13314
-datashare_python/logging_.py,sha256=96KNXhP-JR5ybu9dld4VLtF7v7PfiphOCR1Nio-mmUs,4483
-datashare_python/objects.py,sha256=r-2qGpUR1u6X4484x8988Xbn8L8yjAg2kvhQgE68V1c,16193
-datashare_python/task_client.py,sha256=oTmP8bvZW0UyhLNMi1AV3XIAx7hrdbxNRss2Mw2azEc,8435
-datashare_python/template.py,sha256=N1uM8TRXh5tQPV7BC1oJj-Pdm2Gs_SkjaXv50RnNYso,4682
-datashare_python/types_.py,sha256=80XTD481HxjbkS330pqHHmlsM-cxUyGGgcJnG8_vYR8,1134
-datashare_python/utils.py,sha256=5vheHeDvMKa6KESf8zYbIT4w69CLRF_ahD-CHq66R1w,19960
-datashare_python/worker-template.tar.gz,sha256=nW0JEZJNXWFlPcMfnNT4Yw31P9wtTv2Nuv9kCb80g5s,282769
-datashare_python/worker.py,sha256=cmqLRJ0_b1xm0qjjAZrRMOVXfhdrErimA_QY0xMtxRo,7774
-datashare_python/cli/__init__.py,sha256=9BPWtssDgsVfWMsZ1TtZCla0EC_kai4RHttr8oNLYOE,1401
-datashare_python/cli/project.py,sha256=w32Gy9AOL5B00uDT4in7YUCt2g68FnNbvwg2M3a8G6o,946
-datashare_python/cli/task.py,sha256=GsyR5o0fN4Pd8tJKAUgivAvCBKT3L4Ay5j_BCW1XBHk,5828
-datashare_python/cli/utils.py,sha256=p69CQb0zfixuyBkiZprhdMCc_NuYwXyAn6vC9H1UzAw,911
-datashare_python/cli/worker.py,sha256=eIMgUatSmpQpeu0MSMMKBrmx3GWm_eQ-aLfVrgl513o,5773
-datashare_python-0.9.9.dist-info/METADATA,sha256=uEbimB84kKuvwFlje3KjnVARqGhFlZZziRrBCdV3_g8,982
-datashare_python-0.9.9.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-datashare_python-0.9.9.dist-info/entry_points.txt,sha256=ILE7auxabHWiu3GC-AunWnzjhOI_SbZp7D4GqZHlLw4,68
-datashare_python-0.9.9.dist-info/RECORD,,