fractal-task-tools 0.0.8__tar.gz → 0.0.9__tar.gz

{fractal_task_tools-0.0.8/src/fractal_task_tools.egg-info → fractal_task_tools-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fractal-task-tools
-Version: 0.0.8
+Version: 0.0.9
 Summary: Shared tools for Fractal tasks
 Author-email: Tommaso Comparin <tommaso.comparin@exact-lab.it>
 License: BSD-3-Clause
@@ -17,6 +17,14 @@ Requires-Dist: bumpver==2024.1130; extra == "dev"
 Requires-Dist: devtools==0.12.2; extra == "dev"
 Requires-Dist: pytest<9.0.0,>=8.3.0; extra == "dev"
 Requires-Dist: coverage<7.7.0,>=7.6.0; extra == "dev"
+Requires-Dist: mkdocs==1.5.2; extra == "dev"
+Requires-Dist: mkdocs-material==9.1.21; extra == "dev"
+Requires-Dist: mkdocs-literate-nav==0.5.0; extra == "dev"
+Requires-Dist: mkdocs-gen-files==0.4.0; extra == "dev"
+Requires-Dist: mkdocs-section-index==0.3.5; extra == "dev"
+Requires-Dist: mkdocstrings[python]==0.25.2; extra == "dev"
+Requires-Dist: mkdocs-include-markdown-plugin<6.0.0,>=5.0.0; extra == "dev"
+Dynamic: license-file
 
 # Fractal task tools
 

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fractal-task-tools"
-version = "0.0.8"
+version = "0.0.9"
 description = "Shared tools for Fractal tasks"
 authors = [
     {name="Tommaso Comparin", email="tommaso.comparin@exact-lab.it"},
@@ -18,6 +18,13 @@ dev = [
     "devtools ==0.12.2",
     "pytest >=8.3.0, <9.0.0",
     "coverage >=7.6.0,<7.7.0",
+    "mkdocs ==1.5.2",
+    "mkdocs-material ==9.1.21",
+    "mkdocs-literate-nav ==0.5.0",
+    "mkdocs-gen-files ==0.4.0",
+    "mkdocs-section-index ==0.3.5",
+    "mkdocstrings[python] ==0.25.2",
+    "mkdocs-include-markdown-plugin >=5.0.0,<6.0.0",
 ]
 
 [project.urls]
@@ -34,7 +41,7 @@ build-backend = "setuptools.build_meta"
 fractal-manifest = "fractal_task_tools._cli:main"
 
 [tool.bumpver]
-current_version = "0.0.8"
+current_version = "0.0.9"
 version_pattern = "MAJOR.MINOR.PATCH[PYTAGNUM]"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/__init__.py

@@ -2,4 +2,4 @@ import logging
 
 logging.basicConfig(level=logging.INFO)
 
-__VERSION__ = "0.0.8"
+__VERSION__ = "0.0.9"

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/_create_manifest.py

@@ -7,9 +7,10 @@ from typing import Any
 
 from ._args_schemas import create_schema_for_single_task
 from ._package_name_tools import normalize_package_name
+from ._task_arguments import validate_arguments
 from ._task_docs import create_docs_info
 from ._task_docs import read_docs_info_from_file
-
+from .task_models import _BaseTask
 
 ARGS_SCHEMA_VERSION = "pydantic_v2"
 MANIFEST_FILENAME = "__FRACTAL_MANIFEST__.json"
@@ -60,7 +61,7 @@ def create_manifest(
     task_list_module = import_module(f"{package_name}.{task_list_path}")
 
     # Load TASK_LIST
-    TASK_LIST = getattr(task_list_module, "TASK_LIST")
+    TASK_LIST: list[_BaseTask] = getattr(task_list_module, "TASK_LIST")
 
     # Load INPUT_MODELS
     try:
@@ -89,9 +90,15 @@ def create_manifest(
     for task_obj in TASK_LIST:
         # Convert Pydantic object to dictionary
         task_dict = task_obj.model_dump(
-            exclude={"meta_init", "executable_init", "meta", "executable"},
+            exclude={
+                "meta_init",
+                "executable_init",
+                "meta",
+                "executable",
+            },
             exclude_unset=True,
         )
+        task_dict["type"] = task_obj.type
 
         # Copy some properties from `task_obj` to `task_dict`
         if task_obj.executable_non_parallel is not None:
@@ -115,6 +122,13 @@ def create_manifest(
                     package=package_name,
                     pydantic_models=INPUT_MODELS,
                 )
+
+                validate_arguments(
+                    task_type=task_obj.type,
+                    schema=schema,
+                    executable_kind=kind,
+                )
+
                 logging.info(f"[{executable}] END (new schema)")
                 task_dict[f"args_schema_{kind}"] = schema
 

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/_deepdiff.py

@@ -17,7 +17,7 @@ def deepdiff(
     if type(old_object) is not type(new_object):
         raise ValueError(
             f"[{path}] Type difference:\n"
-            f"\tOld: {type(old_object)}\n\tNew:{type(new_object)}"
+            f"\tOld: {type(old_object)}\n\tNew: {type(new_object)}"
         )
 
     if type(old_object) not in [list, dict, str, int, float, bool, type(None)]:
@@ -64,5 +64,5 @@ def deepdiff(
         if old_object != new_object:
             raise ValueError(
                 f"{path} Values are different:\n"
-                f"\tOld: '{old_object}'\n\tNew:'{new_object}'"
+                f"\tOld: '{old_object}'\n\tNew: '{new_object}'"
             )

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/_descriptions.py

@@ -122,24 +122,18 @@ def _get_function_args_descriptions(
     return descriptions
 
 
-def _get_class_attrs_descriptions(
-    package_name: str, module_relative_path: str, class_name: str
+def _get_class_attrs_descriptions_from_file(
+    *,
+    module_path: Path,
+    class_name: str,
 ) -> dict[str, str]:
     """
-    Extract attribute descriptions from a class.
+    Extract class-attribute descriptions from a Python script
 
     Args:
-        package_name: Example `fractal_tasks_core`.
-        module_relative_path: Example `lib_channels.py`.
+        module_path: Example `/something/my_class.py`.
         class_name: Example `OmeroChannel`.
     """
-
-    if not module_relative_path.endswith(".py"):
-        raise ValueError(f"Module {module_relative_path} must end with '.py'")
-
-    # Get the class ast.ClassDef object
-    package_path = Path(import_module(package_name).__file__).parent
-    module_path = package_path / module_relative_path
     tree = ast.parse(module_path.read_text())
     try:
         _class = next(
@@ -148,10 +142,7 @@ def _get_class_attrs_descriptions(
             if (isinstance(c, ast.ClassDef) and c.name == class_name)
         )
     except StopIteration:
-        raise RuntimeError(
-            f"Cannot find {class_name=} for {package_name=} "
-            f"and {module_relative_path=}"
-        )
+        raise RuntimeError(f"Cannot find {class_name=} in {module_path}.")
     docstring = ast.get_docstring(_class)
     parsed_docstring = docparse(docstring)
     descriptions = {
@@ -160,6 +151,31 @@ def _get_class_attrs_descriptions(
         else "Missing description"
         for x in parsed_docstring.params
     }
+    return descriptions
+
+
+def _get_class_attrs_descriptions(
+    package_name: str, module_relative_path: str, class_name: str
+) -> dict[str, str]:
+    """
+    Extract class-attribute descriptions from an imported module
+
+    Args:
+        package_name: Example `fractal_tasks_core`.
+        module_relative_path: Example `lib_channels.py`.
+        class_name: Example `OmeroChannel`.
+    """
+
+    if not module_relative_path.endswith(".py"):
+        raise ValueError(f"Module {module_relative_path} must end with '.py'")
+
+    # Get the class ast.ClassDef object
+    package_path = Path(import_module(package_name).__file__).parent
+    module_path = package_path / module_relative_path
+    descriptions = _get_class_attrs_descriptions_from_file(
+        module_path=module_path,
+        class_name=class_name,
+    )
     logging.info(f"[_get_class_attrs_descriptions] END ({class_name=})")
     return descriptions
 

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/_package_name_tools.py

@@ -12,7 +12,7 @@ def normalize_package_name(pkg_name: str) -> str:
         imported-module name.
 
     Args:
-        name: The non-normalized package name.
+        pkg_name: The non-normalized package name.
 
     Returns:
         The normalized package name.

fractal_task_tools-0.0.9/src/fractal_task_tools/_task_arguments.py

@@ -0,0 +1,75 @@
+import logging
+from typing import Any
+from typing import Literal
+
+
+REQUIRED_ARGUMENTS: dict[tuple[str, str], set[str]] = {
+    ("non_parallel", "non_parallel"): {"zarr_urls", "zarr_dir"},
+    ("compound", "non_parallel"): {"zarr_urls", "zarr_dir"},
+    ("parallel", "parallel"): {"zarr_url"},
+    ("compound", "parallel"): {"zarr_url", "init_args"},
+    ("converter_non_parallel", "non_parallel"): {"zarr_dir"},
+    ("converter_compound", "non_parallel"): {"zarr_dir"},
+    ("converter_compound", "parallel"): {"zarr_url", "init_args"},
+}
+FORBIDDEN_ARGUMENTS: dict[tuple[str, str], set[str]] = {
+    ("non_parallel", "non_parallel"): {"zarr_url"},
+    ("compound", "non_parallel"): {"zarr_url"},
+    ("parallel", "parallel"): {"zarr_urls", "zarr_dir"},
+    ("compound", "parallel"): {"zarr_urls", "zarr_dir"},
+    ("converter_non_parallel", "non_parallel"): {"zarr_url", "zarr_urls"},
+    ("converter_compound", "non_parallel"): {"zarr_url", "zarr_urls"},
+    ("converter_compound", "parallel"): {"zarr_urls", "zarr_dir"},
+}
+
+
+def validate_arguments(
+    *,
+    task_type: Literal["parallel", "non_parallel", "compound"],
+    executable_kind: Literal["parallel", "non_parallel"],
+    schema: dict[str, Any],
+) -> None:
+    """
+    Validate schema arguments against required/forbidden ones.
+
+    Arguments:
+        task_type:
+        executable_kind: The `parallel`/`non_parallel` part of the task.
+        schema:
+    """
+
+    key = (task_type, executable_kind)
+    if not (key in REQUIRED_ARGUMENTS and key in FORBIDDEN_ARGUMENTS):
+        logging.error(f"Invalid {task_type=}, {executable_kind=}.")
+        raise ValueError(f"Invalid {task_type=}, {executable_kind=}.")
+
+    required_args = REQUIRED_ARGUMENTS[key]
+    forbidden_args = FORBIDDEN_ARGUMENTS[key]
+
+    schema_properties = set(schema["properties"].keys())
+
+    logging.info(
+        f"[validate_arguments] Task has arguments: {schema_properties}"
+    )
+    logging.info(f"[validate_arguments] Required arguments: {required_args}")
+    logging.info(f"[validate_arguments] Forbidden arguments: {forbidden_args}")
+
+    missing_required_arguments = {
+        arg for arg in required_args if arg not in schema_properties
+    }
+    if missing_required_arguments:
+        error_msg = (
+            "[validate_arguments] Required arguments "
+            f"{missing_required_arguments} are missing."
+        )
+        logging.error(error_msg)
+        raise ValueError(error_msg)
+
+    present_forbidden_args = forbidden_args.intersection(schema_properties)
+    if present_forbidden_args:
+        error_msg = (
+            "[validate_arguments] Forbidden arguments "
+            f"{present_forbidden_args} are present."
+        )
+        logging.error(error_msg)
+        raise ValueError(error_msg)

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools/task_models.py

@@ -1,4 +1,5 @@
 from typing import Any
+from typing import Literal
 from typing import Optional
 
 from pydantic import BaseModel
@@ -18,6 +19,23 @@ class _BaseTask(BaseModel):
     modality: Optional[str] = None
     tags: list[str] = Field(default_factory=list)
     docs_info: Optional[str] = None
+    type: str
+
+    @property
+    def executable_non_parallel(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def meta_non_parallel(self) -> Optional[dict[str, Any]]:
+        raise NotImplementedError()
+
+    @property
+    def executable_parallel(self) -> str:
+        raise NotImplementedError()
+
+    @property
+    def meta_parallel(self) -> Optional[dict[str, Any]]:
+        raise NotImplementedError()
 
 
 class CompoundTask(_BaseTask):
@@ -29,6 +47,34 @@ class CompoundTask(_BaseTask):
 
     executable_init: str
     meta_init: Optional[dict[str, Any]] = None
+    type: Literal["compound"] = "compound"
+
+    @property
+    def executable_non_parallel(self) -> str:
+        return self.executable_init
+
+    @property
+    def meta_non_parallel(self) -> Optional[dict[str, Any]]:
+        return self.meta_init
+
+    @property
+    def executable_parallel(self) -> str:
+        return self.executable
+
+    @property
+    def meta_parallel(self) -> Optional[dict[str, Any]]:
+        return self.meta
+
+
+class ConverterCompoundTask(_BaseTask):
+    """
+    A `ConverterCompoundTask` task is the same as a `CompoundTask`, but it
+    is executed differently in the Fractal backend.
+    """
+
+    executable_init: str
+    meta_init: Optional[dict[str, Any]] = None
+    type: Literal["converter_compound"] = "converter_compound"
 
     @property
     def executable_non_parallel(self) -> str:
@@ -53,6 +99,33 @@ class NonParallelTask(_BaseTask):
     may include the `meta` attribute.
     """
 
+    type: Literal["non_parallel"] = "non_parallel"
+
+    @property
+    def executable_non_parallel(self) -> str:
+        return self.executable
+
+    @property
+    def meta_non_parallel(self) -> Optional[dict[str, Any]]:
+        return self.meta
+
+    @property
+    def executable_parallel(self) -> None:
+        return None
+
+    @property
+    def meta_parallel(self) -> None:
+        return None
+
+
+class ConverterNonParallelTask(_BaseTask):
+    """
+    A `ConverterNonParallelTask` task is the same as a `NonParallelTask`, but
+    it is executed differently in the Fractal backend.
+    """
+
+    type: Literal["converter_non_parallel"] = "converter_non_parallel"
+
     @property
     def executable_non_parallel(self) -> str:
         return self.executable
@@ -76,6 +149,8 @@ class ParallelTask(_BaseTask):
     include the `meta` attribute.
     """
 
+    type: Literal["parallel"] = "parallel"
+
     @property
     def executable_non_parallel(self) -> None:
         return None

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9/src/fractal_task_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: fractal-task-tools
-Version: 0.0.8
+Version: 0.0.9
 Summary: Shared tools for Fractal tasks
 Author-email: Tommaso Comparin <tommaso.comparin@exact-lab.it>
 License: BSD-3-Clause
@@ -17,6 +17,14 @@ Requires-Dist: bumpver==2024.1130; extra == "dev"
 Requires-Dist: devtools==0.12.2; extra == "dev"
 Requires-Dist: pytest<9.0.0,>=8.3.0; extra == "dev"
 Requires-Dist: coverage<7.7.0,>=7.6.0; extra == "dev"
+Requires-Dist: mkdocs==1.5.2; extra == "dev"
+Requires-Dist: mkdocs-material==9.1.21; extra == "dev"
+Requires-Dist: mkdocs-literate-nav==0.5.0; extra == "dev"
+Requires-Dist: mkdocs-gen-files==0.4.0; extra == "dev"
+Requires-Dist: mkdocs-section-index==0.3.5; extra == "dev"
+Requires-Dist: mkdocstrings[python]==0.25.2; extra == "dev"
+Requires-Dist: mkdocs-include-markdown-plugin<6.0.0,>=5.0.0; extra == "dev"
+Dynamic: license-file
 
 # Fractal task tools
 

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/src/fractal_task_tools.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/fractal_task_tools/_descriptions.py
 src/fractal_task_tools/_package_name_tools.py
 src/fractal_task_tools/_pydantic_generatejsonschema.py
 src/fractal_task_tools/_signature_constraints.py
+src/fractal_task_tools/_task_arguments.py
 src/fractal_task_tools/_task_docs.py
 src/fractal_task_tools/_titles.py
 src/fractal_task_tools/task_models.py
@@ -29,4 +30,5 @@ tests/test_extract_function.py
 tests/test_normalize_package_name.py
 tests/test_task_models.py
 tests/test_task_wrapper.py
-tests/test_unit_lib_descriptions.py
+tests/test_unit_lib_descriptions.py
+tests/test_validate_arguments.py

fractal_task_tools-0.0.9/src/fractal_task_tools.egg-info/requires.txt

@@ -0,0 +1,15 @@
+pydantic<=2.8.2,>=2.0.0
+docstring-parser==0.15
+
+[dev]
+bumpver==2024.1130
+devtools==0.12.2
+pytest<9.0.0,>=8.3.0
+coverage<7.7.0,>=7.6.0
+mkdocs==1.5.2
+mkdocs-material==9.1.21
+mkdocs-literate-nav==0.5.0
+mkdocs-gen-files==0.4.0
+mkdocs-section-index==0.3.5
+mkdocstrings[python]==0.25.2
+mkdocs-include-markdown-plugin<6.0.0,>=5.0.0

fractal_task_tools-0.0.9/tests/test_create_manifest.py

@@ -0,0 +1,68 @@
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from devtools import debug
+from fractal_task_tools._cli import check_manifest
+from fractal_task_tools._cli import write_manifest_to_file
+from fractal_task_tools._create_manifest import create_manifest
+from fractal_task_tools._create_manifest import MANIFEST_FILENAME
+
+
+def test_create_manifest(tmp_path: Path, caplog):
+    subprocess.check_call(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "./tests/fake-tasks",
+        ]
+    )
+
+    import fake_tasks
+
+    manifest = create_manifest(
+        raw_package_name="fake-tasks",
+        task_list_path="task_list",
+    )
+    debug(manifest)
+    write_manifest_to_file(
+        raw_package_name="fake-tasks",
+        manifest=manifest,
+    )
+
+    check_manifest(
+        raw_package_name="fake-tasks",
+        manifest=manifest,
+        ignore_keys_order=False,
+    )
+
+    MANIFEST_PATH = Path(fake_tasks.__file__).parent / MANIFEST_FILENAME
+    with MANIFEST_PATH.open("w") as f:
+        json.dump(dict(fake="manifest"), f)
+
+    caplog.clear()
+    with pytest.raises(SystemExit):
+        check_manifest(
+            raw_package_name="fake-tasks",
+            manifest=manifest,
+            ignore_keys_order=False,
+        )
+    assert "On-disk manifest is not up to date." in caplog.text
+
+    # Clean up
+    MANIFEST_PATH.unlink()
+
+    subprocess.check_call(
+        [
+            sys.executable,
+            "-m",
+            "pip",
+            "uninstall",
+            "fake-tasks",
+            "--yes",
+        ]
+    )

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/tests/test_create_schema_for_single_task.py

@@ -131,7 +131,36 @@ def test_enum_argument():
         verbose=True,
     )
     debug(schema)
-    # FIXME: Add assertion
+    assert schema["$defs"]["ColorA"] == {
+        "enum": [
+            "this-is-red",
+            "this-is-green",
+        ],
+        "title": "ColorA",
+        "type": "string",
+        "description": "Missing description for ColorA.",
+    }
+    assert schema["$defs"]["ColorB"] == {
+        "enum": [
+            "this-is-red",
+            "this-is-green",
+        ],
+        "title": "ColorB",
+        "type": "string",
+        "description": "Missing description for ColorB.",
+    }
+    assert schema["properties"] == {
+        "arg_A": {
+            "$ref": "#/$defs/ColorA",
+            "title": "Arg A",
+            "description": "Description of arg_A.",
+        },
+        "arg_B": {
+            "$ref": "#/$defs/ColorB",
+            "title": "Arg B",
+            "description": "Description of arg_B.",
+        },
+    }
 
 
 @validate_call
@@ -199,4 +228,21 @@ def test_tuple_argument():
         verbose=True,
     )
     debug(schema)
-    # FIXME: Add assertion
+    assert schema["properties"] == {
+        "arg_A": {
+            "default": [1, 1],
+            "maxItems": 2,
+            "minItems": 2,
+            "prefixItems": [
+                {
+                    "type": "integer",
+                },
+                {
+                    "type": "integer",
+                },
+            ],
+            "title": "Arg A",
+            "type": "array",
+            "description": "Description of arg_A.",
+        },
+    }

{fractal_task_tools-0.0.8 → fractal_task_tools-0.0.9}/tests/test_task_models.py

@@ -1,4 +1,6 @@
 from fractal_task_tools.task_models import CompoundTask
+from fractal_task_tools.task_models import ConverterCompoundTask
+from fractal_task_tools.task_models import ConverterNonParallelTask
 from fractal_task_tools.task_models import NonParallelTask
 from fractal_task_tools.task_models import ParallelTask
 
@@ -22,6 +24,18 @@ def test_compound_task_model():
     assert t.executable_parallel == EXECUTABLE
     assert t.meta_parallel == META
 
+    t = ConverterCompoundTask(
+        name=NAME,
+        executable_init=EXECUTABLE_INIT,
+        meta_init=META_INIT,
+        executable=EXECUTABLE,
+        meta=META,
+    )
+    assert t.executable_non_parallel == EXECUTABLE_INIT
+    assert t.meta_non_parallel == META_INIT
+    assert t.executable_parallel == EXECUTABLE
+    assert t.meta_parallel == META
+
 
 def test_non_parallel_task_model():
     t = NonParallelTask(
@@ -34,6 +48,16 @@ def test_non_parallel_task_model():
     assert t.executable_parallel is None
     assert t.meta_parallel is None
 
+    t = ConverterNonParallelTask(
+        name=NAME,
+        executable=EXECUTABLE_INIT,
+        meta=META_INIT,
+    )
+    assert t.executable_non_parallel == EXECUTABLE_INIT
+    assert t.meta_non_parallel == META_INIT
+    assert t.executable_parallel is None
+    assert t.meta_parallel is None
+
 
 def test_parallel_task_model():
     t = ParallelTask(

fractal_task_tools-0.0.9/tests/test_unit_lib_descriptions.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import pytest
+from devtools import debug
+from fractal_task_tools._descriptions import _get_class_attrs_descriptions
+from fractal_task_tools._descriptions import (
+    _get_class_attrs_descriptions_from_file,
+)
+from fractal_task_tools._descriptions import _get_function_args_descriptions
+from pydantic import BaseModel
+
+
+class MyClass(BaseModel):
+    """
+    Init Args for MIP task.
+
+    Attributes:
+        arg1: Description of `arg1`.
+    """
+
+    arg1: str
+
+
+def test_get_function_args_descriptions():
+    args_descriptions = _get_function_args_descriptions(
+        package_name="fractal_task_tools",
+        module_path="_signature_constraints.py",
+        function_name="_extract_function",
+    )
+    debug(args_descriptions)
+    assert args_descriptions.keys() == set(
+        ("package_name", "module_relative_path", "function_name", "verbose")
+    )
+
+
+def test_get_class_attrs_descriptions_from_file():
+    attrs_descriptions = _get_class_attrs_descriptions_from_file(
+        module_path=Path(__file__),
+        class_name="MyClass",
+    )
+    debug(attrs_descriptions)
+    assert attrs_descriptions == {"arg1": "Description of `arg1`."}
+
+
+def test_failures():
+    with pytest.raises(ValueError, match="must end with '.py'"):
+        _get_class_attrs_descriptions(
+            package_name="fractal_task_tools",
+            module_relative_path="task_models",
+            class_name="MyClass",
+        )
+
+    with pytest.raises(RuntimeError, match="Cannot find class_name"):
+        _get_class_attrs_descriptions(
+            package_name="fractal_task_tools",
+            module_relative_path="task_models.py",
+            class_name="MyClass",
+        )

fractal_task_tools-0.0.9/tests/test_validate_arguments.py

@@ -0,0 +1,85 @@
+import pytest
+from fractal_task_tools._task_arguments import validate_arguments
+
+
+def _fake_schema(*args: list[str]):
+    return dict(properties={key: None for key in args})
+
+
+def test_validate_arguments():
+    with pytest.raises(ValueError, match="Invalid task_type="):
+        validate_arguments(
+            task_type="invalid",
+            executable_kind="non_parallel",
+            schema={},
+        )
+
+    with pytest.raises(ValueError, match="Invalid task_type="):
+        validate_arguments(
+            task_type="compound",
+            executable_kind="invalid",
+            schema={},
+        )
+
+    with pytest.raises(ValueError, match="Required arguments"):
+        validate_arguments(
+            task_type="non_parallel",
+            executable_kind="non_parallel",
+            schema=_fake_schema("zarr_dir", "arg1"),
+        )
+
+    with pytest.raises(ValueError, match="Forbidden arguments"):
+        validate_arguments(
+            task_type="non_parallel",
+            executable_kind="non_parallel",
+            schema=_fake_schema("zarr_urls", "zarr_dir", "zarr_url", "arg1"),
+        )
+
+    validate_arguments(
+        task_type="non_parallel",
+        executable_kind="non_parallel",
+        schema=_fake_schema("zarr_urls", "zarr_dir", "arg1"),
+    )
+
+    validate_arguments(
+        task_type="compound",
+        executable_kind="non_parallel",
+        schema=_fake_schema("zarr_urls", "zarr_dir", "arg1"),
+    )
+
+    validate_arguments(
+        task_type="compound",
+        executable_kind="parallel",
+        schema=_fake_schema("zarr_url", "init_args", "arg1"),
+    )
+
+    validate_arguments(
+        task_type="parallel",
+        executable_kind="parallel",
+        schema=_fake_schema("zarr_url", "arg1"),
+    )
+
+    with pytest.raises(ValueError, match="Forbidden arguments"):
+        validate_arguments(
+            task_type="converter_non_parallel",
+            executable_kind="non_parallel",
+            schema=_fake_schema("zarr_urls", "zarr_dir", "arg1"),
+        )
+
+    validate_arguments(
+        task_type="converter_non_parallel",
+        executable_kind="non_parallel",
+        schema=_fake_schema("zarr_dir", "arg1"),
+    )
+
+    validate_arguments(
+        task_type="converter_compound",
+        executable_kind="non_parallel",
+        schema=_fake_schema("zarr_dir", "arg1"),
+    )
+
+    validate_arguments(
+        task_type="converter_compound",
+        executable_kind="parallel",
+        schema=_fake_schema("zarr_url", "init_args", "arg1"),
+    )

fractal_task_tools-0.0.8/src/fractal_task_tools.egg-info/requires.txt

@@ -1,8 +0,0 @@
-pydantic<=2.8.2,>=2.0.0
-docstring-parser==0.15
-
-[dev]
-bumpver==2024.1130
-devtools==0.12.2
-pytest<9.0.0,>=8.3.0
-coverage<7.7.0,>=7.6.0

fractal_task_tools-0.0.8/tests/test_create_manifest.py

@@ -1,32 +0,0 @@
-import subprocess
-import sys
-
-from fractal_task_tools._create_manifest import create_manifest
-
-
-def test_create_manifest():
-    subprocess.check_call(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "install",
-            "./tests/fake-tasks",
-        ]
-    )
-
-    create_manifest(
-        raw_package_name="fake-tasks",
-        task_list_path="task_list",
-    )
-
-    subprocess.check_call(
-        [
-            sys.executable,
-            "-m",
-            "pip",
-            "uninstall",
-            "fake-tasks",
-            "--yes",
-        ]
-    )

fractal_task_tools-0.0.8/tests/test_unit_lib_descriptions.py

@@ -1,28 +0,0 @@
-import pytest
-from devtools import debug
-from fractal_task_tools._descriptions import _get_class_attrs_descriptions
-from fractal_task_tools._descriptions import _get_function_args_descriptions
-
-
-@pytest.mark.xfail(reason="FIXME: depends on fractal-tasks-core")
-def test_get_function_args_descriptions():
-    args_descriptions = _get_function_args_descriptions(
-        package_name="fractal_tasks_core",
-        module_path="dev/lib_signature_constraints.py",
-        function_name="_extract_function",
-    )
-    debug(args_descriptions)
-    assert args_descriptions.keys() == set(
-        ("package_name", "module_relative_path", "function_name", "verbose")
-    )
-
-
-@pytest.mark.xfail(reason="FIXME: depends on fractal-tasks-core")
-def test_get_class_attrs_descriptions():
-    attrs_descriptions = _get_class_attrs_descriptions(
-        package_name="fractal_tasks_core",
-        module_relative_path="channels.py",
-        class_name="ChannelInputModel",
-    )
-    debug(attrs_descriptions)
-    assert attrs_descriptions.keys() == set(("wavelength_id", "label"))