annofabcli 1.100.4__py3-none-any.whl → 1.101.0__py3-none-any.whl

annofabcli/__init__.py

@@ -1,5 +1,7 @@
-from .__version__ import __version__
+from importlib.metadata import PackageNotFoundError, version
 
-__all__ = [
-    "__version__",
-]
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    # `uv run annofabcli --version`では、メタデータからバージョン情報を取得できないため、fallbackしたバージョンを設定する
+    __version__ = "0.0.0"

annofabcli/annotation/change_annotation_attributes.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import functools
+import json
 import logging
 import multiprocessing
 import sys
@@ -345,7 +346,7 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     argument_parser.add_project_id()
     argument_parser.add_task_id()
 
-    EXAMPLE_ANNOTATION_QUERY = '{"label": "car", "attributes":{"occluded" true} }'  # noqa: N806
+    EXAMPLE_ANNOTATION_QUERY = {"label": "car", "attributes": {"occluded": True}}  # noqa: N806
     parser.add_argument(
         "-aq",
         "--annotation_query",
@@ -353,7 +354,7 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         required=True,
         help="変更対象のアノテーションを検索する条件をJSON形式で指定します。"
         "``file://`` を先頭に付けると、JSON形式のファイルを指定できます。"
-        f"(ex): ``{EXAMPLE_ANNOTATION_QUERY}``",
+        f"(ex): ``{json.dumps(EXAMPLE_ANNOTATION_QUERY)}``",
     )
 
     EXAMPLE_ATTRIBUTES = '{"occluded": false}'  # noqa: N806

annofabcli/annotation/change_annotation_properties.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import functools
+import json
 import logging
 import multiprocessing
 import sys
@@ -156,7 +157,7 @@ class ChangePropertiesOfAnnotationMain(CommandLineWithConfirm):
             return False
 
         logger.debug(
-            f"{logger_prefix}task_id={task_id}, phase={dict_task['phase']}, status={dict_task['status']}, "
+            f"{logger_prefix}task_id='{task_id}', phase={dict_task['phase']}, status={dict_task['status']}, "
             f"updated_datetime={dict_task['updated_datetime']}"
         )
 
@@ -202,10 +203,10 @@ class ChangePropertiesOfAnnotationMain(CommandLineWithConfirm):
 
         try:
             self.change_annotation_properties(task_id, annotation_list, properties)
-            logger.info(f"{logger_prefix}task_id={task_id}: アノテーションのプロパティを変更しました。")
+            logger.info(f"{logger_prefix}task_id='{task_id}' :: アノテーションのプロパティを変更しました。")
             return True  # noqa: TRY300
         except Exception:  # pylint: disable=broad-except
-            logger.warning(f"task_id={task_id}: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
+            logger.warning(f"task_id='{task_id}' :: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
             return False
         finally:
             if changed_operator:
@@ -234,7 +235,7 @@ class ChangePropertiesOfAnnotationMain(CommandLineWithConfirm):
                 task_index=task_index,
             )
         except Exception:  # pylint: disable=broad-except
-            logger.warning(f"task_id={task_id}: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
+            logger.warning(f"task_id='{task_id}' :: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
             return False
 
     def change_annotation_properties_task_list(  # noqa: ANN201
@@ -277,7 +278,7 @@ class ChangePropertiesOfAnnotationMain(CommandLineWithConfirm):
                     if result:
                         success_count += 1
                 except Exception:  # pylint: disable=broad-except
-                    logger.warning(f"task_id={task_id}: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
+                    logger.warning(f"task_id='{task_id}' :: アノテーションのプロパティの変更に失敗しました。", exc_info=True)
                     continue
 
         logger.info(f"{success_count} / {len(task_id_list)} 件のタスクに対してアノテーションのプロパティを変更しました。")
@@ -359,14 +360,14 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     argument_parser.add_project_id()
     argument_parser.add_task_id()
 
-    EXAMPLE_ANNOTATION_QUERY = '{"label": "car", "attributes":{"occluded" true} }'  # noqa: N806
+    EXAMPLE_ANNOTATION_QUERY = {"label": "car", "attributes": {"occluded": True}}  # noqa: N806
 
     parser.add_argument(
         "-aq",
         "--annotation_query",
         type=str,
         required=False,
-        help=f"変更対象のアノテーションを検索する条件をJSON形式で指定します。(ex): ``{EXAMPLE_ANNOTATION_QUERY}``",
+        help=f"変更対象のアノテーションを検索する条件をJSON形式で指定します。(ex): ``{json.dumps(EXAMPLE_ANNOTATION_QUERY)}``",
     )
 
     EXAMPLE_PROPERTIES = '{"is_protected": true}'  # noqa: N806

annofabcli/annotation/copy_annotation.py

@@ -48,11 +48,11 @@ class CopyTarget(CopyTargetMixin, ABC):
 @dataclass(frozen=True)
 class CopyTargetByTask(CopyTarget):
     @property
-    def src(self):  # noqa: ANN201
+    def src(self) -> str:
         return f"{self.src_task_id}"
 
     @property
-    def dest(self):  # noqa: ANN201
+    def dest(self) -> str:
         return f"{self.dest_task_id}"
 
 
@@ -62,11 +62,11 @@ class CopyTargetByInputData(CopyTarget):
     dest_input_data_id: str
 
     @property
-    def src(self):  # noqa: ANN201
+    def src(self) -> str:
         return f"{self.src_task_id}/{self.src_input_data_id}"
 
     @property
-    def dest(self):  # noqa: ANN201
+    def dest(self) -> str:
         return f"{self.dest_task_id}/{self.dest_input_data_id}"
 
 

annofabcli/annotation/delete_annotation.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
 import argparse
+import json
 import logging
 import sys
+from collections import defaultdict
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional
 
 import annofabapi
+import pandas
 import requests
 from annofabapi.dataclass.task import Task
 from annofabapi.models import ProjectMemberRole, TaskStatus
@@ -27,6 +31,17 @@ from annofabcli.common.facade import AnnofabApiFacade
 logger = logging.getLogger(__name__)
 
 
+@dataclass(frozen=True)
+class DeletedAnnotationInfo:
+    """
+    削除対象のアノテーション情報
+    """
+
+    task_id: str
+    input_data_id: str
+    annotation_id: str
+
+
 class DeleteAnnotationMain(CommandLineWithConfirm):
     """アノテーション削除処理用のクラス
 
@@ -49,7 +64,7 @@ class DeleteAnnotationMain(CommandLineWithConfirm):
         self.project_id = project_id
         self.dump_annotation_obj = DumpAnnotationMain(service, project_id)
 
-    def delete_annotation_list(self, annotation_list: list[dict[str, Any]]):  # noqa: ANN201
+    def delete_annotation_list(self, annotation_list: list[dict[str, Any]]) -> None:
         """
         アノテーション一覧を削除する。
 
@@ -108,19 +123,22 @@ class DeleteAnnotationMain(CommandLineWithConfirm):
         """
         dict_task = self.service.wrapper.get_task_or_none(self.project_id, task_id)
         if dict_task is None:
-            logger.warning(f"task_id = '{task_id}' は存在しません。")
+            logger.warning(f"task_id='{task_id}'であるタスクは存在しません。")
             return
 
         task: Task = Task.from_dict(dict_task)
-        logger.info(f"task_id={task.task_id}, phase={task.phase.value}, status={task.status.value}, updated_datetime={task.updated_datetime}")
+        logger.info(f"task_id='{task.task_id}', phase='{task.phase.value}', status='{task.status.value}', updated_datetime='{task.updated_datetime}'")
 
         if task.status == TaskStatus.WORKING:
-            logger.warning(f"task_id={task_id}: タスクが作業中状態のため、スキップします。")
+            logger.info(f"task_id='{task_id}' :: タスクが作業中状態のため、スキップします。")
             return
 
         if not self.is_force:  # noqa: SIM102
             if task.status == TaskStatus.COMPLETE:
-                logger.warning(f"task_id={task_id}: タスクが完了状態のため、スキップします。")
+                logger.info(
+                    f"task_id='{task_id}' :: タスクが完了状態のため、スキップします。"
+                    f"完了状態のタスクのアノテーションを削除するには、`--force`オプションを指定してください。"
+                )
                 return
 
         annotation_list = self.get_annotation_list_for_task(task_id, annotation_query=annotation_query)
@@ -137,16 +155,16 @@ class DeleteAnnotationMain(CommandLineWithConfirm):
 
         try:
             self.delete_annotation_list(annotation_list=annotation_list)
-            logger.info(f"task_id={task_id}: アノテーションを削除しました。")
+            logger.info(f"task_id='{task_id}' :: アノテーションを削除しました。")
         except requests.HTTPError:
-            logger.warning(f"task_id={task_id}: アノテーションの削除に失敗しました。", exc_info=True)
+            logger.warning(f"task_id='{task_id}' :: アノテーションの削除に失敗しました。", exc_info=True)
 
-    def delete_annotation_for_task_list(  # noqa: ANN201
+    def delete_annotation_for_task_list(
         self,
         task_id_list: list[str],
         annotation_query: Optional[AnnotationQueryForAPI] = None,
         backup_dir: Optional[Path] = None,
-    ):
+    ) -> None:
         project_title = self.facade.get_project_title(self.project_id)
         logger.info(f"プロジェクト'{project_title}'に対して、タスク{len(task_id_list)} 件のアノテーションを削除します。")
 
@@ -161,6 +179,160 @@ class DeleteAnnotationMain(CommandLineWithConfirm):
                 backup_dir=backup_dir,
             )
 
+    def delete_annotation_by_annotation_ids(
+        self,
+        editor_annotation: dict[str, Any],
+        annotation_ids: set[str],
+    ) -> tuple[int, int]:
+        """
+        指定してフレームに対して、annotation_idのリストで指定されたアノテーションを削除する。
+
+        Returns:
+            削除したアノテーションの件数
+            削除しなかったアノテーションの件数
+        """
+        if not annotation_ids:
+            raise ValueError("`annotation_ids` に少なくとも1件のIDを指定してください。")
+
+        task_id = editor_annotation["task_id"]
+        input_data_id = editor_annotation["input_data_id"]
+        if len(editor_annotation["details"]) == 0:
+            logger.warning(
+                f"task_id='{task_id}', input_data_id='{input_data_id}' にはアノテーションが存在しません。以下のアノテーションの削除をスキップします。 :: "  # noqa: E501
+                f"annotation_ids={annotation_ids}"
+            )
+            return 0, len(annotation_ids)
+
+        # annotation_idでフィルタ
+        filtered_details = [e for e in editor_annotation["details"] if e["annotation_id"] in annotation_ids]
+        existent_annotation_ids = {detail["annotation_id"] for detail in filtered_details}
+        nonexistent_annotation_ids = annotation_ids - existent_annotation_ids
+
+        if len(nonexistent_annotation_ids) > 0:
+            logger.warning(
+                f"次のアノテーションは存在しないので、削除できません。 :: task_id='{task_id}', input_data_id='{input_data_id}', annotation_id='{nonexistent_annotation_ids}'"  # noqa: E501
+            )
+
+        if len(filtered_details) == 0:
+            logger.info(f"task_id='{task_id}', input_data_id='{input_data_id}' には削除対象のアノテーションが存在しないので、スキップします。")
+            return 0, len(annotation_ids)
+
+        try:
+
+            def _to_request_body_elm(detail: dict[str, Any]) -> dict[str, Any]:
+                return {
+                    "project_id": self.project_id,
+                    "task_id": task_id,
+                    "input_data_id": input_data_id,
+                    "updated_datetime": editor_annotation["updated_datetime"],
+                    "annotation_id": detail["annotation_id"],
+                    "_type": "Delete",
+                }
+
+            request_body = [_to_request_body_elm(detail) for detail in filtered_details]
+            # APIを呼び出してアノテーションを削除
+            self.service.api.batch_update_annotations(self.project_id, request_body=request_body, query_params={"v": "2"})
+
+            logger.info(f"task_id='{task_id}', input_data_id='{input_data_id}' に含まれるアノテーション {len(filtered_details)} 件を削除しました。")
+
+            return len(filtered_details), len(nonexistent_annotation_ids)
+
+        except requests.HTTPError:
+            logger.warning(f"task_id='{task_id}', input_data_id='{input_data_id}' :: アノテーションの削除に失敗しました。", exc_info=True)
+            # `batchUpdateAnnotations` APIでエラーになった場合、途中までは削除されるので、`len(annotation_ids)` 件削除に失敗したとは限らない。
+            # そのため、再度アノテーション情報を取得して、削除できたアノテーション数と削除できなかったアノテーション数を取得する。
+            new_editor_annotation, _ = self.service.api.get_editor_annotation(
+                self.project_id, task_id=task_id, input_data_id=input_data_id, query_params={"v": "2"}
+            )
+            new_annotation_ids = {e["annotation_id"] for e in new_editor_annotation["details"]}
+            deleted_annotation_count = len(existent_annotation_ids - new_annotation_ids)
+            failed_to_delete_annotation_count = len(existent_annotation_ids) - deleted_annotation_count
+            return deleted_annotation_count, failed_to_delete_annotation_count + len(nonexistent_annotation_ids)
+
+    def delete_annotation_by_id_list(
+        self,
+        annotation_list: list[DeletedAnnotationInfo],
+        backup_dir: Optional[Path] = None,
+    ) -> None:
+        """
+        task_id, input_data_id, annotation_id のリストで指定されたアノテーションのみ削除する
+
+        Args:
+            annotation_list: 削除対象のアノテーションlist
+            backup_dir: バックアップディレクトリ
+        """
+
+        # task_id, input_data_idごとにまとめる
+        grouped: dict[str, dict[str, list[str]]] = defaultdict(lambda: defaultdict(list))
+        for item in annotation_list:
+            grouped[item.task_id][item.input_data_id].append(item.annotation_id)
+
+        total = len(annotation_list)
+
+        deleted_annotation_count = 0
+        failed_to_delete_annotation_count = 0
+
+        task_count = len(grouped)
+        deleted_task_count = 0
+
+        logger.info(f"{task_count} 件のタスクに含まれるアノテーションを削除します。")
+
+        for task_id, sub_grouped in grouped.items():
+            annotation_count = sum(len(v) for v in sub_grouped.values())
+            task = self.service.wrapper.get_task_or_none(self.project_id, task_id)
+            if task is None:
+                logger.warning(f"task_id='{task_id}' :: タスクが存在しないため、アノテーション {annotation_count} 件の削除をスキップします。")
+                failed_to_delete_annotation_count += annotation_count
+                continue
+
+            if task["status"] == TaskStatus.WORKING.value:
+                logger.info(f"task_id='{task_id}' :: タスクが作業中状態のため、アノテーション {annotation_count} 件の削除をスキップします。")
+                failed_to_delete_annotation_count += annotation_count
+                continue
+
+            if not self.is_force:  # noqa: SIM102
+                if task["status"] == TaskStatus.COMPLETE.value:
+                    logger.info(
+                        f"task_id='{task_id}' :: タスクが完了状態のため、アノテーション {annotation_count} 件の削除をスキップします。"
+                        f"完了状態のタスクのアノテーションを削除するには、`--force`オプションを指定してください。"
+                    )
+                    failed_to_delete_annotation_count += annotation_count
+                    continue
+
+            if not self.confirm_processing(f"task_id='{task_id}'のタスクに含まれるアノテーション {annotation_count} 件を削除しますか？"):
+                failed_to_delete_annotation_count += annotation_count
+                continue
+
+            deleted_task_count += 1
+            for input_data_id, annotation_ids in sub_grouped.items():
+                # 指定input_data_idの全annotationを取得
+                # TODO どこかのタイミングで、"v=2"のアノテーションを取得するようにする
+                editor_annotation = self.service.wrapper.get_editor_annotation_or_none(
+                    self.project_id, task_id=task_id, input_data_id=input_data_id, query_params={"v": "1"}
+                )
+                if editor_annotation is None:
+                    logger.warning(
+                        f"task_id='{task_id}'のタスクに、input_data_id='{input_data_id}'の入力データが含まれていません。 アノテーションの削除をスキップします。 :: "  # noqa: E501
+                        f"annotation_ids={annotation_ids}"
+                    )
+                    failed_to_delete_annotation_count += len(annotation_ids)
+                    continue
+
+                if backup_dir is not None:
+                    (backup_dir / task_id).mkdir(exist_ok=True, parents=True)
+                    self.dump_annotation_obj.dump_editor_annotation(editor_annotation, json_path=backup_dir / task_id / f"{input_data_id}.json")
+
+                sub_deleted_annotation_count, sub_failed_to_delete_annotation_count = self.delete_annotation_by_annotation_ids(
+                    editor_annotation, set(annotation_ids)
+                )
+                deleted_annotation_count += sub_deleted_annotation_count
+                failed_to_delete_annotation_count += sub_failed_to_delete_annotation_count
+
+        logger.info(
+            f"{deleted_task_count}/{task_count} 件のタスクに含まれている {deleted_annotation_count}/{total} 件のアノテーションを削除しました。"
+            f"{failed_to_delete_annotation_count} 件のアノテーションは削除できませんでした。"
+        )
+
 
 class DeleteAnnotation(CommandLine):
     """
@@ -169,22 +341,9 @@ class DeleteAnnotation(CommandLine):
 
     COMMON_MESSAGE = "annofabcli annotation delete: error:"
 
-    def main(self) -> None:
+    def main(self) -> None:  # noqa: PLR0912
         args = self.args
         project_id = args.project_id
-        task_id_list = annofabcli.common.cli.get_list_from_args(args.task_id)
-
-        if args.annotation_query is not None:
-            annotation_specs, _ = self.service.api.get_annotation_specs(project_id, query_params={"v": "2"})
-            try:
-                dict_annotation_query = get_json_from_args(args.annotation_query)
-                annotation_query_for_cli = AnnotationQueryForCLI.from_dict(dict_annotation_query)
-                annotation_query = annotation_query_for_cli.to_query_for_api(annotation_specs)
-            except ValueError as e:
-                print(f"{self.COMMON_MESSAGE} argument '--annotation_query' の値が不正です。{e}", file=sys.stderr)  # noqa: T201
-                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
-        else:
-            annotation_query = None
 
         if args.backup is None:
             print(  # noqa: T201
@@ -198,9 +357,55 @@ class DeleteAnnotation(CommandLine):
             backup_dir = Path(args.backup)
 
         super().validate_project(project_id, [ProjectMemberRole.OWNER])
-
         main_obj = DeleteAnnotationMain(self.service, project_id, all_yes=args.yes, is_force=args.force)
-        main_obj.delete_annotation_for_task_list(task_id_list, annotation_query=annotation_query, backup_dir=backup_dir)
+
+        if args.json is not None:
+            dict_annotation_list = get_json_from_args(args.json)
+            if not isinstance(dict_annotation_list, list):
+                print(f"{self.COMMON_MESSAGE} argument --json: JSON形式が不正です。オブジェクトの配列を指定してください。", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+            try:
+                annotation_list = [DeletedAnnotationInfo(**eml) for eml in dict_annotation_list]
+            except TypeError as e:
+                print(f"{self.COMMON_MESSAGE} argument --json: 無効なオブジェクト形式です。{e}", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+            main_obj.delete_annotation_by_id_list(annotation_list, backup_dir=backup_dir)
+
+        elif args.csv is not None:
+            csv_path = Path(args.csv)
+            if not csv_path.exists():
+                print(f"{self.COMMON_MESSAGE} argument --csv: ファイルパスが存在しません。 '{args.csv}'", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+            df: pandas.DataFrame = pandas.read_csv(
+                args.csv,
+                dtype={"task_id": "string", "input_data_id": "string", "annotation_id": "string"},
+            )
+            required_cols = {"task_id", "input_data_id", "annotation_id"}
+            if not required_cols.issubset(df.columns):
+                print(f"{self.COMMON_MESSAGE} argument --csv: CSVに必須列がありません。{required_cols}", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+            annotation_list = [DeletedAnnotationInfo(**eml) for eml in df.to_dict(orient="records")]
+            main_obj.delete_annotation_by_id_list(annotation_list, backup_dir=backup_dir)
+
+        elif args.task_id is not None:
+            task_id_list = annofabcli.common.cli.get_list_from_args(args.task_id)
+
+            if args.annotation_query is not None:
+                annotation_specs, _ = self.service.api.get_annotation_specs(project_id, query_params={"v": "2"})
+                try:
+                    dict_annotation_query = get_json_from_args(args.annotation_query)
+                    annotation_query_for_cli = AnnotationQueryForCLI.from_dict(dict_annotation_query)
+                    annotation_query = annotation_query_for_cli.to_query_for_api(annotation_specs)
+                except ValueError as e:
+                    print(f"{self.COMMON_MESSAGE} argument '--annotation_query' の値が不正です。{e}", file=sys.stderr)  # noqa: T201
+                    sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+            else:
+                annotation_query = None
+
+            main_obj.delete_annotation_for_task_list(task_id_list, annotation_query=annotation_query, backup_dir=backup_dir)
 
 
 def main(args: argparse.Namespace) -> None:
@@ -213,21 +418,41 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     argument_parser = ArgumentParser(parser)
 
     argument_parser.add_project_id()
-    argument_parser.add_task_id()
 
-    EXAMPLE_ANNOTATION_QUERY = '{"label": "car", "attributes":{"occluded" true} }'  # noqa: N806
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "-t",
+        "--task_id",
+        type=str,
+        nargs="+",
+        help="削除対象のタスクのtask_idを指定します。 ``file://`` を先頭に付けると、task_idの一覧が記載されたファイルを指定できます。",
+    )
+
+    example_json = [{"task_id": "t1", "input_data_id": "i1", "annotation_id": "a1"}]
+    group.add_argument(
+        "--json",
+        type=str,
+        help=f"削除対象のアノテーションをJSON配列で指定します。例: ``{json.dumps(example_json)}``",
+    )
+    group.add_argument(
+        "--csv",
+        type=str,
+        help="削除対象のアノテーションを記載したCSVファイルを指定します。例: task_id,input_data_id,annotation_id",
+    )
 
+    EXAMPLE_ANNOTATION_QUERY = {"label": "car", "attributes": {"occluded": True}}  # noqa: N806
     parser.add_argument(
         "-aq",
         "--annotation_query",
         type=str,
         required=False,
         help="削除対象のアノテーションを検索する条件をJSON形式で指定します。"
+        "``--csv`` または ``--json`` を指定した場合は、このオプションは無視されます。"
         "``file://`` を先頭に付けると、JSON形式のファイルを指定できます。"
-        f"(ex): ``{EXAMPLE_ANNOTATION_QUERY}``",
+        f"(ex): ``{json.dumps(EXAMPLE_ANNOTATION_QUERY)}``",
     )
 
-    parser.add_argument("--force", action="store_true", help="完了状態のタスクのアノテーションを削除します。")
+    parser.add_argument("--force", action="store_true", help="指定した場合は、完了状態のタスクのアノテーションも削除します。")
     parser.add_argument(
         "--backup",
         type=str,

annofabcli/annotation/dump_annotation.py

@@ -6,7 +6,7 @@ import json
 import logging
 import multiprocessing
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 import annofabapi
 from annofabapi.models import AnnotationDataHoldingType
@@ -24,17 +24,19 @@ class DumpAnnotationMain:
         self.facade = AnnofabApiFacade(service)
         self.project_id = project_id
 
-    def dump_annotation_for_input_data(self, task_id: str, input_data_id: str, task_dir: Path) -> None:
-        annotation, _ = self.service.api.get_editor_annotation(self.project_id, task_id, input_data_id)
-        json_path = task_dir / f"{input_data_id}.json"
-        json_path.write_text(json.dumps(annotation, ensure_ascii=False), encoding="utf-8")
+    def dump_editor_annotation(self, editor_annotation: dict[str, Any], json_path: Path) -> None:
+        """
+        `getEditorAnnotation` APIのレスポンスをファイルに保存する。
+        """
+        json_path.write_text(json.dumps(editor_annotation, ensure_ascii=False), encoding="utf-8")
 
-        details = annotation["details"]
+        details = editor_annotation["details"]
         outer_details = [e for e in details if e["data_holding_type"] == AnnotationDataHoldingType.OUTER.value]
         if len(outer_details) == 0:
             return
 
-        outer_dir = task_dir / input_data_id
+        input_data_id = editor_annotation["input_data_id"]
+        outer_dir = json_path.parent / input_data_id
         outer_dir.mkdir(exist_ok=True, parents=True)
 
         # 塗りつぶし画像など外部リソースに保存されているファイルをダウンロードする
@@ -43,6 +45,11 @@ class DumpAnnotationMain:
             outer_file_path = outer_dir / f"{annotation_id}"
             self.service.wrapper.download(detail["url"], outer_file_path)
 
+    def dump_annotation_for_input_data(self, task_id: str, input_data_id: str, task_dir: Path) -> None:
+        editor_annotation, _ = self.service.api.get_editor_annotation(self.project_id, task_id, input_data_id)
+        json_path = task_dir / f"{input_data_id}.json"
+        self.dump_editor_annotation(editor_annotation=editor_annotation, json_path=json_path)
+
     def dump_annotation_for_task(self, task_id: str, output_dir: Path, *, task_index: Optional[int] = None) -> bool:
         """
         タスク配下のアノテーションをファイルに保存する。