datashare-python 0.2.13__tar.gz → 0.2.14__tar.gz

{datashare_python-0.2.13 → datashare_python-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datashare-python
-Version: 0.2.13
+Version: 0.2.14
 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/

{datashare_python-0.2.13 → datashare_python-0.2.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "datashare-python"
-version = "0.2.13"
+version = "0.2.14"
 description = "Manage Python tasks and local resources in Datashare"
 authors = [
   { name = "Clément Doumouro", email = "cdoumouro@icij.org" },
@@ -35,13 +35,15 @@ datashare-python = "datashare_python.__main__:main"
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
-package = ["datashare_python"]
 
 [tool.hatch.build.targets.wheel]
 artifacts = [
   "worker-template.tar.gz"
 ]
 
+[tool.hatch.build.targets.sdist]
+only-include = ["datashare_python"]
+
 [tool.uv]
 package = true
 

datashare_python-0.2.13/tests/cli/test_project.py

@@ -1,23 +0,0 @@
-from pathlib import Path
-
-from datashare_python.cli import cli_app
-from typer.testing import CliRunner
-
-
-async def test_init_project(
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-    local_template_build,  # noqa: ANN001, ARG001
-    tmp_path: Path,
-) -> None:
-    # Given
-    runner = CliRunner(mix_stderr=False)
-    test_worker_project = "test-project"
-    # When
-    args = ["project", "init", str(test_worker_project), "-p", str(tmp_path)]
-    result = runner.invoke(
-        cli_app,
-        args,
-        catch_exceptions=False,
-    )
-    # Then
-    assert result.exit_code == 0

datashare_python-0.2.13/tests/cli/test_tasks.py

@@ -1,241 +0,0 @@
-import logging
-from contextlib import AbstractAsyncContextManager
-from datetime import UTC, datetime
-from typing import Any, Self
-from unittest.mock import AsyncMock, MagicMock
-
-import click
-from _pytest.logging import LogCaptureFixture
-from _pytest.monkeypatch import MonkeyPatch
-from datashare_python.cli import cli_app
-from datashare_python.cli import task as cli_task
-from datashare_python.objects import StacktraceItem, Task, TaskError, TaskState
-from packaging.version import Version
-from typer.testing import CliRunner
-
-BUGGED_CLICK_VERSION = Version("8.1.8")
-CLICK_VERSION = Version(click.__version__)
-
-
-async def test_task_create_task(
-    monkeypatch: MonkeyPatch,
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-    caplog: LogCaptureFixture,
-) -> None:
-    # Given
-    mock_client_fn = MagicMock()
-    mock_client = AsyncMock()
-    task_id = "hello_world-some-id"
-    mock_client.create_task.return_value = task_id
-    mock_client_fn.return_value = mock_client
-
-    class MockedClient:
-        def __init__(self, datashare_url: str, api_key: str | None = None) -> None:  # noqa: ARG002
-            ...
-
-        async def __aenter__(self) -> Self:
-            return self
-
-        async def __aexit__(self, exc_type, exc_val, exc_tb): ...  # noqa: ANN001
-
-        async def create_task(
-            self,  # noqa: ANN001, ARG001
-            name: str,  # noqa: ARG001, ARG002
-            args: dict[str, Any],  # noqa: ARG001, ARG002
-            *,
-            id_: str | None = None,  # noqa: ARG001, ARG002
-            group: str | None = None,  # noqa: ARG001, ARG002
-        ) -> str:
-            return task_id
-
-    monkeypatch.setattr(cli_task, "DatashareTaskClient", MockedClient)
-    # When
-    runner = CliRunner(mix_stderr=False)
-    with caplog.at_level(logging.INFO):
-        result = runner.invoke(
-            cli_app, ["task", "start", "hello_world"], catch_exceptions=False
-        )
-    # Then
-    assert result.exit_code == 0
-    assert result.stdout == task_id + "\n"
-    assert ("Task(hello_world-some-id) started" in r for r in caplog.records)
-    assert ("Task(hello_world-some-id) 🛫" in r for r in caplog.records)
-
-
-async def test_task_watch(
-    monkeypatch: MonkeyPatch,
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-) -> None:
-    # Given
-    task_id = "hello_world-some-id"
-    created_at = datetime.now(UTC)
-
-    states = [
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=0,
-            state=TaskState.CREATED,
-            created_at=created_at,
-        ),
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=0,
-            state=TaskState.QUEUED,
-            created_at=created_at,
-        ),
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=0,
-            state=TaskState.RUNNING,
-            created_at=created_at,
-        ),
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=0.5,
-            state=TaskState.RUNNING,
-            created_at=created_at,
-        ),
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=0.99,
-            state=TaskState.RUNNING,
-            created_at=created_at,
-        ),
-        Task(
-            id=task_id,
-            name="hello_world",
-            progress=1.0,
-            state=TaskState.DONE,
-            completed_at=datetime.now(UTC),
-            created_at=created_at,
-        ),
-    ]
-
-    class MockedClient(AbstractAsyncContextManager):
-        def __init__(self, datashare_url: str, api_key: str | None = None) -> None:  # noqa: ARG002
-            self._state_it = None
-
-        async def get_task(self, task_id: str) -> Task:  # noqa: ARG002
-            return next(self._state_it)
-
-        async def __aenter__(self) -> Self:
-            self._state_it = iter(states)
-            return self
-
-        async def __aexit__(self, exc_type, exc_val, exc_tb): ...  # noqa: ANN001
-
-    monkeypatch.setattr(cli_task, "DatashareTaskClient", MockedClient)
-    # When
-    runner = CliRunner(mix_stderr=False)
-    result = runner.invoke(
-        cli_app, ["task", "watch", task_id, "-p", 0.001], catch_exceptions=False
-    )
-    # Then
-    assert result.exit_code == 0
-    assert result.stdout.endswith(task_id + "\n")
-    assert "Task(hello_world-some-id) 🛫" in result.stderr
-    if CLICK_VERSION > BUGGED_CLICK_VERSION:
-        assert "Task(hello_world-some-id) 🛬" in result.stderr
-        assert "Task(hello_world-some-id) ✅" in result.stderr
-    assert "1.0" in result.stderr
-
-
-async def test_task_watch_error(
-    monkeypatch: MonkeyPatch,
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-) -> None:
-    # Given
-    mock_client_fn = MagicMock()
-    mock_client = AsyncMock()
-    task_id = "hello_world-some-id"
-    mock_client_fn.return_value = mock_client
-    created_at = datetime.now(UTC)
-
-    class MockedClient(AbstractAsyncContextManager):
-        def __init__(self, datashare_url: str, api_key: str | None = None) -> None:  # noqa: ARG002
-            self._state_it = None
-
-        async def __aenter__(self) -> Self:
-            return self
-
-        async def __aexit__(self, exc_type, exc_val, exc_tb): ...  # noqa: ANN001
-
-        async def get_task(self, task_id: str) -> Task:  # noqa: ARG002
-            return Task(
-                id=task_id,
-                name="hello_world",
-                progress=0,
-                state=TaskState.ERROR,
-                created_at=created_at,
-            )
-
-        async def get_task_error(self, task_id: str) -> TaskError:  # noqa: ARG002
-            return TaskError(
-                name="SomeError",
-                message="some error occurred",
-                stacktrace=[
-                    StacktraceItem(name="some_func", file="some_file.py", lineno=666)
-                ],
-            )
-
-    monkeypatch.setattr(cli_task, "DatashareTaskClient", MockedClient)
-    # When
-    runner = CliRunner(mix_stderr=False)
-    result = runner.invoke(
-        cli_app, ["task", "watch", task_id, "-p", 0.001], catch_exceptions=False
-    )
-    # Then
-    assert result.exit_code == 1
-    if CLICK_VERSION > BUGGED_CLICK_VERSION:
-        assert (
-            "Task(hello_world-some-id) failed with the following error:"
-            in result.stderr
-        )
-        assert "Task(hello_world-some-id) ❌" in result.stderr
-
-
-async def test_task_watch_cancelled(
-    monkeypatch: MonkeyPatch,
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-) -> None:
-    # Given
-    mock_client_fn = MagicMock()
-    mock_client = AsyncMock()
-    task_id = "hello_world-some-id"
-    mock_client_fn.return_value = mock_client
-    created_at = datetime.now(UTC)
-
-    class MockedClient(AbstractAsyncContextManager):
-        def __init__(self, datashare_url: str, api_key: str | None = None) -> None:  # noqa: ARG002
-            self._state_it = None
-
-        async def __aenter__(self) -> Self:
-            return self
-
-        async def __aexit__(self, exc_type, exc_val, exc_tb): ...  # noqa: ANN001
-
-        async def get_task(self, task_id: str) -> Task:  # noqa: ARG002
-            return Task(
-                id=task_id,
-                name="hello_world",
-                progress=0,
-                state=TaskState.CANCELLED,
-                created_at=created_at,
-            )
-
-    monkeypatch.setattr(cli_task, "DatashareTaskClient", MockedClient)
-    # When
-    runner = CliRunner(mix_stderr=False)
-    result = runner.invoke(
-        cli_app, ["task", "watch", task_id, "-p", 0.001], catch_exceptions=False
-    )
-    # Then
-    assert result.exit_code == 1
-    if CLICK_VERSION > BUGGED_CLICK_VERSION:
-        assert "Task(hello_world-some-id) was cancelled" in result.stderr
-        assert "Task(hello_world-some-id) 🛑" in result.stderr

datashare_python-0.2.13/tests/cli/test_worker.py

@@ -1,46 +0,0 @@
-from _pytest.capture import CaptureFixture
-from _pytest.monkeypatch import MonkeyPatch
-from datashare_python.cli import cli_app
-from temporalio.worker import Worker
-from typer.testing import CliRunner
-
-
-async def _mock_worker_run(self) -> None:  # noqa: ANN001
-    pass
-
-
-async def test_start_workers(
-    worker_lifetime_deps,  # noqa: ANN001, ARG001
-    typer_asyncio_patch,  # noqa: ANN001, ARG001
-    monkeypatch: MonkeyPatch,
-    capsys: CaptureFixture[str],
-) -> None:
-    # Given
-    runner = CliRunner(mix_stderr=False)
-    monkeypatch.setattr(Worker, "run", _mock_worker_run)
-    with capsys.disabled():
-        # When
-        result = runner.invoke(
-            cli_app,
-            [
-                "worker",
-                "start",
-                "--queue",
-                "cpu",
-                "--activities",
-                "ping",
-                "--activities",
-                "create-translation-batches",
-                "--workflows",
-                "ping",
-                "--temporal-address",
-                "localhost:7233",
-            ],
-            catch_exceptions=False,
-        )
-    # Then
-    assert result.exit_code == 0
-    expected = """Starting datashare worker running:
-- 1 workflow: ping
-- 1 activity: create-translation-batches"""
-    assert expected in result.stderr

datashare_python-0.2.13/tests/conftest.py

@@ -1,14 +0,0 @@
-import pytest  # noqa: I001
-import nest_asyncio
-from datashare_python.conftest import *  # noqa: F403
-from datashare_python.template import build_template_tarball
-
-
-@pytest.fixture  # noqa: F405
-def typer_asyncio_patch() -> None:
-    nest_asyncio.apply()
-
-
-@pytest.fixture(scope="session")
-def local_template_build() -> None:
-    build_template_tarball()

datashare_python-0.2.13/tests/test_discovery.py

@@ -1,44 +0,0 @@
-import pytest
-from datashare_python.discovery import discover_activities, discover_workflows
-
-
-@pytest.mark.parametrize(
-    ("names", "expected_workflows"),
-    [
-        ([], {"ping", "translate-and-classify"}),
-        (["ping", "translate-and-classify"], {"ping", "translate-and-classify"}),
-        (["ping"], {"ping"}),
-        (["pi.*"], {"ping"}),
-        (["pong"], set()),
-    ],
-)
-def test_discover_workflows(names: list[str], expected_workflows: set[str]) -> None:
-    # When
-    workflows = {wf_name for wf_name, _ in discover_workflows(names)}
-    # Then
-    assert workflows == expected_workflows
-
-
-@pytest.mark.parametrize(
-    ("names", "expected_activities"),
-    [
-        (
-            [],
-            {
-                "classify-docs",
-                "create-classification-batches",
-                "create-translation-batches",
-                "pong",
-                "translate-docs",
-            },
-        ),
-        (["translate-docs"], {"translate-docs"}),
-        ([".*transl.*"], {"create-translation-batches", "translate-docs"}),
-        (["idontexist"], set()),
-    ],
-)
-def test_discover_activities(names: list[str], expected_activities: set[str]) -> None:
-    # When
-    activities = {act_name for act_name, _ in discover_activities(names)}
-    # Then
-    assert activities == expected_activities

datashare_python-0.2.13/tests/test_object.py

@@ -1,28 +0,0 @@
-from datetime import datetime
-
-from datashare_python.objects import Task, TaskState
-
-
-def test_task_ser() -> None:
-    # Given
-    task = Task(id="some_id", name="some_name", args=dict())
-
-    # When
-    serialized = task.model_dump()
-
-    # Then
-    assert isinstance(serialized.pop("createdAt"), datetime)
-    expected = {
-        "@type": "Task",
-        "args": {},
-        "completedAt": None,
-        "error": None,
-        "id": "some_id",
-        "maxRetries": None,
-        "name": "some_name",
-        "progress": None,
-        "result": None,
-        "retriesLeft": None,
-        "state": TaskState.CREATED,
-    }
-    assert serialized == expected

datashare_python-0.2.13/tests/test_task_client.py

@@ -1,242 +0,0 @@
-import uuid
-from collections.abc import AsyncGenerator
-from contextlib import asynccontextmanager
-from datetime import UTC, datetime
-from typing import Any
-from unittest.mock import AsyncMock
-
-from _pytest.monkeypatch import MonkeyPatch
-from aiohttp.typedefs import StrOrURL
-from datashare_python.objects import (
-    StacktraceItem,
-    Task,
-    TaskError,
-    TaskResult,
-    TaskState,
-    User,
-)
-from datashare_python.task_client import AiohttpClient, DatashareTaskClient
-
-
-async def test_task_client_create_task(monkeypatch: MonkeyPatch) -> None:
-    # Given
-    datashare_url = "http://some-url"
-    user = User(id="user")
-    api_key = "some-api-key"
-    auth = (user, api_key)
-    task_name = "hello"
-    task_id = f"{task_name}-{uuid.uuid4()}"
-    args = {"greeted": "world"}
-    group = "PYTHON"
-
-    @asynccontextmanager
-    async def _put_and_assert(
-        _,  # noqa: ANN001
-        url: StrOrURL,
-        *,
-        data: Any = None,
-        **kwargs: Any,
-    ) -> AsyncGenerator[AsyncMock, None]:
-        assert url == f"/api/task/{task_id}?group={group}"
-        expected_task = {
-            "@type": "Task",
-            "id": task_id,
-            "state": "CREATED",
-            "name": "hello",
-            "args": {
-                "greeted": "world",
-                "user": {
-                    "@type": "org.icij.datashare.user.User",
-                    "details": {},
-                    "id": "user",
-                },
-            },
-        }
-        assert data is None
-        json_data = kwargs.pop("json")
-        assert not kwargs
-        assert isinstance(json_data.pop("createdAt", None), str)
-        assert json_data == expected_task
-        mocked_res = AsyncMock()
-        mocked_res.json.return_value = {"taskId": task_id}
-        yield mocked_res
-
-    monkeypatch.setattr(AiohttpClient, "_put", _put_and_assert)
-
-    task_client = DatashareTaskClient(datashare_url, auth=auth)
-    async with task_client:
-        # When
-        t_id = await task_client.create_task(task_name, args, id_=task_id, group=group)
-    assert t_id == task_id
-
-
-async def test_task_client_get_task(monkeypatch: MonkeyPatch) -> None:
-    # Given
-    datashare_url = "http://some-url"
-    user = User(id="user")
-    api_key = "some-api-key"
-    auth = (user, api_key)
-    task_name = "hello"
-    task_id = f"{task_name}-{uuid.uuid4()}"
-
-    @asynccontextmanager
-    async def _get_and_assert(
-        _,  # noqa: ANN001
-        url: StrOrURL,
-        *,
-        allow_redirects: bool = True,
-        **kwargs: Any,
-    ) -> AsyncGenerator[AsyncMock, None]:
-        assert url == f"/api/task/{task_id}"
-        task_ = {
-            "@type": "Task",
-            "id": task_id,
-            "state": "CREATED",
-            "createdAt": datetime.now(UTC),
-            "name": "hello",
-            "args": {"greeted": "world"},
-        }
-        assert allow_redirects
-        assert not kwargs
-        mocked_res = AsyncMock()
-        mocked_res.json.return_value = task_
-        yield mocked_res
-
-    monkeypatch.setattr(AiohttpClient, "_get", _get_and_assert)
-
-    task_client = DatashareTaskClient(datashare_url, auth=auth)
-    async with task_client:
-        # When
-        task = await task_client.get_task(task_id)
-    assert isinstance(task, Task)
-
-
-async def test_task_client_get_task_state(monkeypatch: MonkeyPatch) -> None:
-    # Given
-    datashare_url = "http://some-url"
-    user = User(id="user")
-    api_key = "some-api-key"
-    auth = (user, api_key)
-    task_name = "hello"
-    task_id = f"{task_name}-{uuid.uuid4()}"
-
-    @asynccontextmanager
-    async def _get_and_assert(
-        _,  # noqa: ANN001
-        url: StrOrURL,
-        *,
-        allow_redirects: bool = True,
-        **kwargs: Any,
-    ) -> AsyncGenerator[AsyncMock, None]:
-        assert url == f"/api/task/{task_id}"
-        task = {
-            "@type": "Task",
-            "id": task_id,
-            "state": "DONE",
-            "createdAt": datetime.now(UTC),
-            "completedAt": datetime.now(UTC),
-            "name": "hello",
-            "args": {"greeted": "world"},
-            "result": TaskResult(value="hellow"),
-        }
-        assert allow_redirects
-        assert not kwargs
-        mocked_res = AsyncMock()
-        mocked_res.json.return_value = task
-        yield mocked_res
-
-    monkeypatch.setattr(AiohttpClient, "_get", _get_and_assert)
-
-    task_client = DatashareTaskClient(datashare_url, auth=auth)
-    async with task_client:
-        # When
-        res = await task_client.get_task_state(task_id)
-    assert res == TaskState.DONE
-
-
-async def test_task_client_get_task_result(monkeypatch: MonkeyPatch) -> None:
-    # Given
-    datashare_url = "http://some-url"
-    user = User(id="user")
-    api_key = "some-api-key"
-    auth = (user, api_key)
-    task_name = "hello"
-    task_id = f"{task_name}-{uuid.uuid4()}"
-
-    @asynccontextmanager
-    async def _get_and_assert(
-        _,  # noqa: ANN001
-        url: StrOrURL,
-        *,
-        allow_redirects: bool = True,
-        **kwargs: Any,
-    ) -> AsyncGenerator[AsyncMock, None]:
-        assert url == f"/api/task/{task_id}/result"
-        assert allow_redirects
-        assert not kwargs
-        mocked_res = AsyncMock()
-        mocked_res.json.return_value = "hellow world"
-        yield mocked_res
-
-    monkeypatch.setattr(AiohttpClient, "_get", _get_and_assert)
-
-    task_client = DatashareTaskClient(datashare_url, auth=auth)
-    async with task_client:
-        # When
-        res = await task_client.get_task_result(task_id)
-    assert res == "hellow world"
-
-
-async def test_task_client_get_task_error(monkeypatch: MonkeyPatch) -> None:
-    # Given
-    datashare_url = "http://some-url"
-    user = User(id="user")
-    api_key = "some-api-key"
-    auth = (user, api_key)
-    task_name = "hello"
-    task_id = f"{task_name}-{uuid.uuid4()}"
-
-    @asynccontextmanager
-    async def _get_and_assert(
-        _,  # noqa: ANN001
-        url: StrOrURL,
-        *,
-        allow_redirects: bool = True,
-        **kwargs: Any,
-    ) -> AsyncGenerator[AsyncMock, None]:
-        assert url == f"/api/task/{task_id}"
-        task = {
-            "@type": "Task",
-            "id": task_id,
-            "state": "ERROR",
-            "createdAt": datetime.now(UTC),
-            "completedAt": datetime.now(UTC),
-            "name": "hello",
-            "args": {"greeted": "world"},
-            "error": {
-                "@type": "TaskError",
-                "name": "SomeError",
-                "message": "some error found",
-                "cause": "i'm the culprit",
-                "stacktrace": [{"lineno": 666, "file": "some_file.py", "name": "err"}],
-            },
-        }
-        assert allow_redirects
-        assert not kwargs
-        mocked_res = AsyncMock()
-        mocked_res.json.return_value = task
-        yield mocked_res
-
-    monkeypatch.setattr(AiohttpClient, "_get", _get_and_assert)
-
-    task_client = DatashareTaskClient(datashare_url, auth=auth)
-    async with task_client:
-        # When
-        error = await task_client.get_task_error(task_id)
-    expected_error = TaskError(
-        name="SomeError",
-        message="some error found",
-        cause="i'm the culprit",
-        stacktrace=[StacktraceItem(name="err", file="some_file.py", lineno=666)],
-    )
-    assert error == expected_error