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

datashare_python/utils.py

@@ -1,21 +1,36 @@
 import asyncio
 import contextlib
+import fcntl
 import inspect
 import json
+import logging
 import os
 import shutil
-from collections.abc import Callable, Coroutine, Iterable, Sequence
+import sys
+import threading
+import time
+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
@@ -36,10 +51,19 @@ from datashare_python.types_ import (
     SyncProgressRateHandler,
 )
 
-from .constants import METADATA_JSON
-from .objects import DocArtifact, DocumentLocation, FilesystemDocument
+from .constants import MANIFEST_JSON, METADATA_JSON
+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]]
@@ -57,6 +81,11 @@ _NEVER_RETRIABLES = {
 }
 
 
+_ARTIFACT_LOCK = threading.Lock()
+# For test
+_LOCKED = threading.Event()
+
+
 @dataclass(frozen=True)
 class Progress:
     max_progress: float
@@ -126,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,
     *,
@@ -156,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:
@@ -203,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:
@@ -225,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:
@@ -261,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)
@@ -296,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:
@@ -338,34 +381,122 @@ def _metadata_path(doc_id: str, *, project: str) -> Path:
     return metadata_path
 
 
-def _read_artifact_metadata(root: Path, artifact: DocArtifact) -> dict:
-    m_path = root / _metadata_path(artifact.doc_id, project=artifact.project)
+def _manifest_path(doc_id: str, *, project: str) -> Path:
+    manifest_path = artifacts_dir(doc_id, project=project) / MANIFEST_JSON
+    return manifest_path
+
+
+def _read_artifact_manifest(root: Path, artifact: DocArtifact) -> dict:
+    m_path = root / _manifest_path(artifact.doc_id, project=artifact.project)
+    if not m_path.exists():
+        m_path = root / _metadata_path(artifact.doc_id, project=artifact.project)
+        if not m_path.exists():
+            msg = f"couldn't find manifest nor metadata for {artifact.doc_id}"
+            raise FileNotFoundError(msg)
     return json.loads(m_path.read_text())
 
 
-def write_artifact(root: Path, artifact: DocArtifact) -> Path:
+def write_artifact(
+    root: Path, artifact: DocArtifact, lock_timeout_ms: int = 30_000
+) -> Path:
+    # TODO: WARNING many writers could write at the time, to avoid inconsistent
+    #  states we should handle this somehow
     artif_dir = root / artifacts_dir(artifact.doc_id, project=artifact.project)
     artif_dir.mkdir(exist_ok=True, parents=True)
-    # TODO: if transcriptions are too large we could also serialize them
-    #  as jsonl
-    artifact_path: Path = artif_dir / artifact.filename
-    match artifact.artifact:
+    artifact_path = artif_dir / artifact.filename
+    # We're using POSIX locks which are not exclusive to filedescriptors
+    # but to processes, we hence have to ensure several threads from the same
+    # Python process acquire the lock at the same time. We're using a python mutex lock
+    with artifact_lock(artif_dir, lock_timeout_ms):
+        # Read the metadata first (things could go wrong here in case someone is reading
+        # at the same time). We read in a backward compatible wat and write to that same
+        # location. We don't take responsibility for migrating the data, the DS back
+        # will do it
+        manifest_path, manifest = _read_manifest_backward_compatible(root, artifact)
+        is_legacy = manifest_path.name == "metadata.json"
+        # Pop the status key from the manifest before writing
+        manifest_entry = manifest.get(artifact.type)
+        if manifest_entry is not None and not is_legacy:
+            manifest[artifact.type].pop("status", None)
+            manifest_path.write_text(json.dumps(manifest))
+        # Write the artifact
+        _write_artifact_bytes(artifact_path, artifact.artifact)
+        # Update the manifest entry with details and new states
+        if is_legacy:
+            manifest_entry = str(artifact_path.relative_to(artif_dir))
+        else:
+            manifest_entry = artifact.manifest_entry.model_dump(
+                mode="json", by_alias=True
+            )
+        manifest[artifact.type] = manifest_entry
+        manifest_path.write_text(json.dumps(manifest))
+        return artifact_path.relative_to(root)
+
+
+@contextlib.contextmanager
+def _set_event() -> Generator[None, None, None]:
+    try:
+        _LOCKED.set()
+        yield
+    finally:
+        _LOCKED.clear()
+
+
+@contextlib.contextmanager
+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)
+    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(
+    root: Path, artifact: DocArtifact
+) -> tuple[Path, dict[str, Any]]:
+    manifest_path = root / _manifest_path(artifact.doc_id, project=artifact.project)
+    if manifest_path.exists():
+        return manifest_path, _read_artifact_manifest(root, artifact)
+    meta_path = root / _metadata_path(artifact.doc_id, project=artifact.project)
+    if meta_path.exists():
+        return meta_path, _read_artifact_manifest(root, artifact)
+    return manifest_path, dict()
+
+
+def _write_artifact_bytes(path: Path, artifact: bytes | BytesIO | Path) -> None:
+    match artifact:
         case bytes():
-            artifact_path.write_bytes(artifact.artifact)
+            path.write_bytes(artifact)
         case BytesIO():
-            with artifact_path.open("wb") as f:
-                f.write(artifact.artifact.read())
+            with path.open("wb") as f:
+                f.write(artifact.read())
         case Path():
-            artifact_path.unlink(missing_ok=True)
-            shutil.move(artifact.artifact, artifact_path)
+            path.unlink(missing_ok=True)
+            shutil.move(artifact, path)
         case _:
-            msg = f"unsupported artifact type: {artifact.artifact.__class__.__name__}"
+            msg = f"unsupported artifact type: {artifact.__class__.__name__}"
             raise ValueError(msg)
-    meta_path = root / _metadata_path(artifact.doc_id, project=artifact.project)
-    meta = _read_artifact_metadata(root, artifact) if meta_path.exists() else dict()
-    meta[artifact.metadata_key] = artifact.filename
-    meta_path.write_text(json.dumps(meta))
-    return artifact_path.relative_to(artif_dir)
 
 
 def debuggable_name(
@@ -436,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
@@ -472,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(
@@ -504,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.8.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.8
+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,15 +8,16 @@ 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
-Requires-Dist: icij-common[elasticsearch]~=0.8.2
+Requires-Dist: icij-common[elasticsearch]~=0.8.3
 Requires-Dist: langcodes~=3.5
 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.8.dist-info → datashare_python-0.10.0.dev0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any

datashare_python-0.9.8.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=uX90ZdWGXq7TjjKgylBKHPZ3Hdp01k4diN-xZaZ7VHA,355
-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=6ZZtS_msT-V7jDZo6n9MLxKS-Pie9j22qy7BaVFRk2I,4492
-datashare_python/objects.py,sha256=4vZXLHhrOEorghq4GY_E6SgJc1eVtqHi6ae-eP_H-X8,12649
-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=rfdcHlKnBhtn9ukDZLL5KYmk6MxZTiMog0csbzHsPBs,16609
-datashare_python/worker-template.tar.gz,sha256=NuInLEuBY_NagDLmsyx7vLwcCsEKYrZ7TFLpmaxIpkE,289250
-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=8mvKGS21bZ14BgZ0Uo-dfameljkaI2ZBha80ywCy-E8,5822
-datashare_python/cli/utils.py,sha256=p69CQb0zfixuyBkiZprhdMCc_NuYwXyAn6vC9H1UzAw,911
-datashare_python/cli/worker.py,sha256=eIMgUatSmpQpeu0MSMMKBrmx3GWm_eQ-aLfVrgl513o,5773
-datashare_python-0.9.8.dist-info/METADATA,sha256=vAUnuH6dRFVYQFfmfPHRdoYgzOyqHHviiBwYw49C21k,982
-datashare_python-0.9.8.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-datashare_python-0.9.8.dist-info/entry_points.txt,sha256=ILE7auxabHWiu3GC-AunWnzjhOI_SbZp7D4GqZHlLw4,68
-datashare_python-0.9.8.dist-info/RECORD,,