annofabcli 1.107.0__py3-none-any.whl → 1.108.0__py3-none-any.whl

annofabcli/input_data/update_input_data.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import argparse
+import enum
+import logging
+import multiprocessing
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from functools import partial
+from pathlib import Path
+from typing import Optional
+
+import annofabapi
+import pandas
+from dataclasses_json import DataClassJsonMixin
+
+import annofabcli
+import annofabcli.common.cli
+from annofabcli.common.cli import (
+    COMMAND_LINE_ERROR_STATUS_CODE,
+    PARALLELISM_CHOICES,
+    ArgumentParser,
+    CommandLine,
+    CommandLineWithConfirm,
+    build_annofabapi_resource_and_login,
+    get_json_from_args,
+)
+from annofabcli.common.facade import AnnofabApiFacade
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateResult(Enum):
+    """更新結果の種類"""
+
+    SUCCESS = enum.auto()
+    """更新に成功した"""
+    SKIPPED = enum.auto()
+    """更新を実行しなかった（存在しないinput_data_id、ユーザー拒否等）"""
+    FAILED = enum.auto()
+    """更新を試みたが例外で失敗"""
+
+
+@dataclass
+class UpdatedInputData(DataClassJsonMixin):
+    """
+    更新される入力データ
+    """
+
+    input_data_id: str
+    """更新対象の入力データを表すID"""
+    input_data_name: Optional[str] = None
+    """変更後の入力データ名（指定した場合のみ更新）"""
+    input_data_path: Optional[str] = None
+    """変更後の入力データパス（指定した場合のみ更新）"""
+
+
+class UpdateInputDataMain(CommandLineWithConfirm):
+    def __init__(self, service: annofabapi.Resource, *, all_yes: bool = False) -> None:
+        self.service = service
+        CommandLineWithConfirm.__init__(self, all_yes)
+
+    def update_input_data(
+        self,
+        project_id: str,
+        input_data_id: str,
+        *,
+        new_input_data_name: Optional[str] = None,
+        new_input_data_path: Optional[str] = None,
+        input_data_index: Optional[int] = None,
+    ) -> UpdateResult:
+        """
+        1個の入力データを更新します。
+        """
+        # ログメッセージの先頭の変数
+        log_prefix = f"input_data_id='{input_data_id}' :: "
+        if input_data_index is not None:
+            log_prefix = f"{input_data_index + 1}件目 :: {log_prefix}"
+
+        old_input_data = self.service.wrapper.get_input_data_or_none(project_id, input_data_id)
+        if old_input_data is None:
+            logger.warning(f"{log_prefix}入力データは存在しません。")
+            return UpdateResult.SKIPPED
+
+        # 更新する内容の確認メッセージを作成
+        changes = []
+        if new_input_data_name is not None:
+            changes.append(f"input_data_name='{old_input_data['input_data_name']}'を'{new_input_data_name}'に変更")
+        if new_input_data_path is not None:
+            changes.append(f"input_data_path='{old_input_data['input_data_path']}'を'{new_input_data_path}'に変更")
+
+        if len(changes) == 0:
+            logger.warning(f"{log_prefix}更新する内容が指定されていません。")
+            return UpdateResult.SKIPPED
+
+        change_message = "、".join(changes)
+        if not self.confirm_processing(f"{log_prefix}{change_message}しますか？"):
+            return UpdateResult.SKIPPED
+
+        request_body = old_input_data
+        request_body["last_updated_datetime"] = old_input_data["updated_datetime"]
+
+        if new_input_data_name is not None:
+            request_body["input_data_name"] = new_input_data_name
+        if new_input_data_path is not None:
+            request_body["input_data_path"] = new_input_data_path
+
+        self.service.api.put_input_data(project_id, input_data_id, request_body=request_body)
+        logger.debug(f"{log_prefix} :: 入力データを更新しました。 :: {changes}")
+        return UpdateResult.SUCCESS
+
+    def update_input_data_list_sequentially(
+        self,
+        project_id: str,
+        updated_input_data_list: list[UpdatedInputData],
+    ) -> None:
+        """複数の入力データを逐次的に更新します。"""
+        success_count = 0
+        skipped_count = 0  # 更新を実行しなかった個数
+        failed_count = 0  # 更新に失敗した個数
+
+        logger.info(f"{len(updated_input_data_list)} 件の入力データを更新します。")
+
+        for input_data_index, updated_input_data in enumerate(updated_input_data_list):
+            current_num = input_data_index + 1
+
+            # 進捗ログ出力
+            if current_num % 1000 == 0:
+                logger.info(f"{current_num} / {len(updated_input_data_list)} 件目の入力データを処理中...")
+
+            try:
+                result = self.update_input_data(
+                    project_id,
+                    updated_input_data.input_data_id,
+                    new_input_data_name=updated_input_data.input_data_name,
+                    new_input_data_path=updated_input_data.input_data_path,
+                    input_data_index=input_data_index,
+                )
+                if result == UpdateResult.SUCCESS:
+                    success_count += 1
+                elif result == UpdateResult.SKIPPED:
+                    skipped_count += 1
+            except Exception:
+                logger.warning(f"{current_num}件目 :: input_data_id='{updated_input_data.input_data_id}'の入力データを更新するのに失敗しました。", exc_info=True)
+                failed_count += 1
+                continue
+
+        logger.info(f"{success_count} / {len(updated_input_data_list)} 件の入力データを更新しました。（成功: {success_count}件, スキップ: {skipped_count}件, 失敗: {failed_count}件）")
+
+    def _update_input_data_wrapper(self, args: tuple[int, UpdatedInputData], project_id: str) -> UpdateResult:
+        index, updated_input_data = args
+        try:
+            return self.update_input_data(
+                project_id,
+                input_data_id=updated_input_data.input_data_id,
+                new_input_data_name=updated_input_data.input_data_name,
+                new_input_data_path=updated_input_data.input_data_path,
+                input_data_index=index,
+            )
+        except Exception:
+            logger.warning(f"{index + 1}件目 :: input_data_id='{updated_input_data.input_data_id}'の入力データを更新するのに失敗しました。", exc_info=True)
+            return UpdateResult.FAILED
+
+    def update_input_data_list_in_parallel(
+        self,
+        project_id: str,
+        updated_input_data_list: list[UpdatedInputData],
+        parallelism: int,
+    ) -> None:
+        """複数の入力データを並列的に更新します。"""
+
+        logger.info(f"{len(updated_input_data_list)} 件の入力データを更新します。{parallelism}個のプロセスを使用して並列実行します。")
+
+        partial_func = partial(self._update_input_data_wrapper, project_id=project_id)
+        with multiprocessing.Pool(parallelism) as pool:
+            result_list = pool.map(partial_func, enumerate(updated_input_data_list))
+            success_count = len([e for e in result_list if e == UpdateResult.SUCCESS])
+            skipped_count = len([e for e in result_list if e == UpdateResult.SKIPPED])
+            failed_count = len([e for e in result_list if e == UpdateResult.FAILED])
+
+        logger.info(f"{success_count} / {len(updated_input_data_list)} 件の入力データを更新しました。（成功: {success_count}件, スキップ: {skipped_count}件, 失敗: {failed_count}件）")
+
+
+def create_updated_input_data_list_from_dict(input_data_dict_list: list[dict[str, str]]) -> list[UpdatedInputData]:
+    return [UpdatedInputData.from_dict(e) for e in input_data_dict_list]
+
+
+def create_updated_input_data_list_from_csv(csv_file: Path) -> list[UpdatedInputData]:
+    """入力データの情報が記載されているCSVを読み込み、UpdatedInputDataのlistを返します。
+    CSVには以下の列が存在します。
+    * input_data_id (必須)
+    * input_data_name (任意)
+    * input_data_path (任意)
+
+    Args:
+        csv_file (Path): CSVファイルのパス
+
+    Returns:
+        更新対象の入力データのlist
+    """
+    df_input_data = pandas.read_csv(
+        csv_file,
+        # 文字列として読み込むようにする
+        dtype={"input_data_id": "string", "input_data_name": "string", "input_data_path": "string"},
+    )
+
+    input_data_dict_list = df_input_data.to_dict("records")
+    return [UpdatedInputData.from_dict(e) for e in input_data_dict_list]
+
+
+CLI_COMMON_MESSAGE = "annofabcli input_data update: error:"
+
+
+class UpdateInputData(CommandLine):
+    @staticmethod
+    def validate(args: argparse.Namespace) -> bool:
+        if args.parallelism is not None and not args.yes:
+            print(  # noqa: T201
+                f"{CLI_COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず ``--yes`` を指定してください。",
+                file=sys.stderr,
+            )
+            return False
+
+        return True
+
+    def main(self) -> None:
+        args = self.args
+        if not self.validate(args):
+            sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+        main_obj = UpdateInputDataMain(self.service, all_yes=self.all_yes)
+
+        if args.csv is not None:
+            updated_input_data_list = create_updated_input_data_list_from_csv(args.csv)
+
+        elif args.json is not None:
+            input_data_dict_list = get_json_from_args(args.json)
+            if not isinstance(input_data_dict_list, list):
+                print(f"{CLI_COMMON_MESSAGE} JSON形式が不正です。オブジェクトの配列を指定してください。", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+            updated_input_data_list = create_updated_input_data_list_from_dict(input_data_dict_list)
+        else:
+            raise RuntimeError("argparse により相互排他が保証されているため、ここには到達しません")
+
+        project_id: str = args.project_id
+        if args.parallelism is not None:
+            main_obj.update_input_data_list_in_parallel(project_id, updated_input_data_list=updated_input_data_list, parallelism=args.parallelism)
+        else:
+            main_obj.update_input_data_list_sequentially(project_id, updated_input_data_list=updated_input_data_list)
+
+
+def main(args: argparse.Namespace) -> None:
+    service = build_annofabapi_resource_and_login(args)
+    facade = AnnofabApiFacade(service)
+    UpdateInputData(service, facade, args).main()
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    argument_parser = ArgumentParser(parser)
+    argument_parser.add_project_id()
+
+    file_group = parser.add_mutually_exclusive_group(required=True)
+    file_group.add_argument(
+        "--csv",
+        type=Path,
+        help=(
+            "更新対象の入力データと更新後の値が記載されたCSVファイルのパスを指定します。\n"
+            "CSVのフォーマットは以下の通りです。"
+            "\n"
+            " * ヘッダ行あり, カンマ区切り\n"
+            " * input_data_id (required)\n"
+            " * input_data_name (optional)\n"
+            " * input_data_path (optional)\n"
+            "更新しないプロパティは、セルの値を空欄にしてください。\n"
+        ),
+    )
+
+    JSON_SAMPLE = '[{"input_data_id":"id1","input_data_name":"new_name1"},{"input_data_id":"id2","input_data_path":"new_path2"}]'  # noqa: N806
+    file_group.add_argument(
+        "--json",
+        type=str,
+        help=(
+            "更新対象の入力データと更新後の値をJSON形式で指定します。\n"
+            "JSONの各キーは ``--csv`` に渡すCSVの各列に対応しています。\n"
+            "``file://`` を先頭に付けるとjsonファイルを指定できます。\n"
+            f"(ex) ``{JSON_SAMPLE}`` \n"
+            "更新しないプロパティは、キーを記載しないか値をnullにしてください。\n"
+        ),
+    )
+
+    parser.add_argument(
+        "--parallelism",
+        type=int,
+        choices=PARALLELISM_CHOICES,
+        help="使用するプロセス数（並列度）。指定しない場合は、逐次的に処理します。指定する場合は ``--yes`` も一緒に指定する必要があります。",
+    )
+
+    parser.set_defaults(subcommand_func=main)
+
+
+def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
+    subcommand_name = "update"
+    subcommand_help = "入力データの名前または入力データのパスを更新します。"
+    epilog = "オーナロールを持つユーザで実行してください。"
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, epilog=epilog)
+    parse_args(parser)
+    return parser

annofabcli/project/subcommand_project.py

@@ -7,6 +7,7 @@ import annofabcli.project.copy_project
 import annofabcli.project.diff_projects
 import annofabcli.project.list_project
 import annofabcli.project.put_project
+import annofabcli.project.update_configuration
 from annofabcli.common.cli import add_parser as common_add_parser
 
 
@@ -20,6 +21,7 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     annofabcli.project.diff_projects.add_parser(subparsers)
     annofabcli.project.list_project.add_parser(subparsers)
     annofabcli.project.put_project.add_parser(subparsers)
+    annofabcli.project.update_configuration.add_parser(subparsers)
 
 
 def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:

annofabcli/project/update_configuration.py

@@ -0,0 +1,151 @@
+import argparse
+import copy
+import logging
+from typing import Any, Optional
+
+import annofabapi
+
+import annofabcli
+from annofabcli.common.cli import CommandLine, CommandLineWithConfirm, build_annofabapi_resource_and_login, get_json_from_args, get_list_from_args
+from annofabcli.common.facade import AnnofabApiFacade
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateProjectConfigurationMain(CommandLineWithConfirm):
+    def __init__(
+        self,
+        service: annofabapi.Resource,
+        *,
+        all_yes: bool = False,
+    ) -> None:
+        self.service = service
+        self.facade = AnnofabApiFacade(service)
+        super().__init__(all_yes)
+
+    def update_configuration_for_project(self, project_id: str, configuration: dict[str, Any], *, project_index: Optional[int] = None) -> bool:
+        """
+        指定されたプロジェクトの設定を更新する。
+
+        Args:
+            project_id: プロジェクトID
+            configuration: 更新する設定（既存設定に対する部分的な更新）
+            project_index: プロジェクトのインデックス（ログメッセージ用）
+
+        Returns:
+            True: プロジェクトの設定を更新した。
+            False: 何らかの理由でプロジェクトの設定を更新していない
+        """
+        # ログメッセージの先頭の変数
+        log_prefix = f"project_id='{project_id}' :: "
+        if project_index is not None:
+            log_prefix = f"{project_index + 1}件目 :: {log_prefix}"
+
+        project = self.service.wrapper.get_project_or_none(project_id)
+        if project is None:
+            logger.warning(f"{log_prefix}プロジェクトは存在しないので、スキップします。")
+            return False
+
+        project_name = project["title"]
+
+        # 既存の設定を取得し、新しい設定をマージする
+        current_configuration = project["configuration"]
+        updated_configuration = copy.deepcopy(current_configuration)
+        updated_configuration.update(configuration)
+
+        # 設定に変更がない場合はスキップ
+        if current_configuration == updated_configuration:
+            logger.debug(f"{log_prefix}プロジェクト設定に変更がないため、スキップします。 :: project_name='{project_name}'")
+            return False
+
+        if not self.confirm_processing(f"{log_prefix}プロジェクト設定を更新しますか？ :: project_name='{project_name}'"):
+            return False
+
+        request_body = copy.deepcopy(project)
+        request_body["configuration"] = updated_configuration
+        request_body["last_updated_datetime"] = project["updated_datetime"]
+        request_body["status"] = project["project_status"]
+
+        _, _ = self.service.api.put_project(project_id, request_body=request_body, query_params={"v": "2"})
+        logger.debug(f"{log_prefix}プロジェクト設定を更新しました。 :: project_name='{project_name}'")
+        return True
+
+    def update_configuration_for_project_list(self, project_id_list: list[str], configuration: dict[str, Any]) -> None:
+        """
+        複数のプロジェクトの設定を更新する。
+
+        Args:
+            project_id_list: プロジェクトIDのリスト
+            configuration: 更新する設定
+
+        """
+        logger.info(f"{len(project_id_list)} 件のプロジェクトの設定を更新します。")
+
+        success_count = 0
+        skip_count = 0
+        failure_count = 0
+
+        for index, project_id in enumerate(project_id_list):
+            try:
+                if (index + 1) % 1000 == 0:
+                    logger.info(f"{index + 1} / {len(project_id_list)} 件目のプロジェクトの設定を更新中...")
+
+                result = self.update_configuration_for_project(project_id, configuration, project_index=index - 1)
+                if result:
+                    success_count += 1
+                else:
+                    skip_count += 1
+
+            except Exception:
+                failure_count += 1
+                logger.warning(f"{index + 1}件目 :: project_id='{project_id}'の設定更新で予期しないエラーが発生しました。", exc_info=True)
+
+        logger.info(f"{success_count}/{len(project_id_list)}件のプロジェクトの設定の更新が完了しました。 :: スキップ: {skip_count}件, 失敗: {failure_count}件")
+
+
+class UpdateProjectConfiguration(CommandLine):
+    def main(self) -> None:
+        args = self.args
+        project_id_list = get_list_from_args(args.project_id)
+        configuration = get_json_from_args(args.configuration)
+
+        main_obj = UpdateProjectConfigurationMain(self.service, all_yes=args.yes)
+        main_obj.update_configuration_for_project_list(project_id_list=project_id_list, configuration=configuration)
+
+
+def main(args: argparse.Namespace) -> None:
+    service = build_annofabapi_resource_and_login(args)
+    facade = AnnofabApiFacade(service)
+    UpdateProjectConfiguration(service, facade, args).main()
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "-p",
+        "--project_id",
+        type=str,
+        required=True,
+        nargs="+",
+        help="変更対象プロジェクトのproject_idを指定します。 ``file://`` を先頭に付けると、project_idの一覧が記載されたファイルを指定できます。",
+    )
+
+    parser.add_argument(
+        "--configuration",
+        type=str,
+        required=True,
+        help="更新するプロジェクト設定をJSON形式で指定します。既存の設定に対して部分的な更新を行います。"
+        "JSONの構造については https://annofab.com/docs/api/#operation/putProject のリクエストボディ'configuration'を参照してください。\n"
+        "``file://`` を先頭に付けると、JSON形式のファイルを指定できます。",
+    )
+
+    parser.set_defaults(subcommand_func=main)
+
+
+def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
+    subcommand_name = "update_configuration"
+    subcommand_help = "複数のプロジェクトの設定を一括で更新します。"
+    epilog = "プロジェクトのオーナロールを持つユーザで実行してください。"
+
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, epilog=epilog)
+    parse_args(parser)
+    return parser

annofabcli/statistics/list_video_duration.py

@@ -85,9 +85,9 @@ class ListVideoDuration(CommandLine):
         output_format: FormatArgument,
         output_file: Optional[Path],
     ) -> None:
-        with task_json.open() as f:
+        with task_json.open(encoding="utf-8") as f:
             task_list = json.load(f)
-        with input_data_json.open() as f:
+        with input_data_json.open(encoding="utf-8") as f:
             input_data_list = json.load(f)
 
         video_duration_list = get_video_duration_list(task_list=task_list, input_data_list=input_data_list)

annofabcli/task/complete_tasks.py

@@ -217,10 +217,10 @@ class CompleteTasksMain(CommandLineWithConfirm):
 
         unanswered_comment_count_for_task = sum(len(e) for e in unanswered_comment_list_dict.values())
 
-        logger.debug(f"{task.task_id}: 未回答の検査コメントが {unanswered_comment_count_for_task} 件あります。")
+        logger.debug(f"task_id='{task.task_id}' :: 未回答の検査コメントが {unanswered_comment_count_for_task} 件あります。")
         if unanswered_comment_count_for_task > 0:  # noqa: SIM102
             if reply_comment is None:
-                logger.warning(f"{task.task_id}: 未回答の検査コメントに対する返信コメント（'--reply_comment'）が指定されていないので、スキップします。")
+                logger.warning(f"task_id='{task.task_id}' :: 未回答の検査コメントに対する返信コメント（'--reply_comment'）が指定されていないので、スキップします。")
                 return False
 
         if not self.confirm_processing(f"タスク'{task.task_id}'の教師付フェーズを次のフェーズに進めますか？"):
@@ -229,7 +229,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
         task = self.change_to_working_status(task)
         if unanswered_comment_count_for_task > 0:
             assert reply_comment is not None
-            logger.debug(f"{task.task_id}: 未回答の検査コメント {unanswered_comment_count_for_task} 件に対して、返信コメントを付与します。")
+            logger.debug(f"task_id='{task.task_id}' :: 未回答の検査コメント {unanswered_comment_count_for_task} 件に対して、返信コメントを付与します。")
             for input_data_id, unanswered_comment_list in unanswered_comment_list_dict.items():
                 if len(unanswered_comment_list) == 0:
                     continue
@@ -241,7 +241,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
                 )
 
         self.service.wrapper.complete_task(task.project_id, task.task_id, last_updated_datetime=task.updated_datetime)
-        logger.info(f"{task.task_id}: 教師付フェーズをフェーズに進めました。")
+        logger.info(f"task_id='{task.task_id}' :: 教師付フェーズから次のフェーズに進めました。")
         return True
 
     def complete_task_for_inspection_acceptance_phase(
@@ -256,10 +256,10 @@ class CompleteTasksMain(CommandLineWithConfirm):
 
         unprocessed_inspection_count = sum(len(e) for e in unprocessed_inspection_list_dict.values())
 
-        logger.debug(f"{task.task_id}: 未処置の検査コメントが {unprocessed_inspection_count} 件あります。")
+        logger.debug(f"task_id='{task.task_id}' :: 未処置の検査コメントが {unprocessed_inspection_count} 件あります。")
         if unprocessed_inspection_count > 0:  # noqa: SIM102
             if inspection_status is None:
-                logger.warning(f"{task.task_id}: 未処置の検査コメントに対する対応方法（'--inspection_status'）が指定されていないので、スキップします。")
+                logger.warning(f"task_id='{task.task_id}' :: 未処置の検査コメントに対する対応方法（'--inspection_status'）が指定されていないので、スキップします。")
                 return False
 
         if not self.confirm_processing(f"タスク'{task.task_id}'の検査/受入フェーズを次のフェーズに進めますか？"):
@@ -269,7 +269,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
 
         if unprocessed_inspection_count > 0:
             assert inspection_status is not None
-            logger.debug(f"{task.task_id}: 未処置の検査コメント {unprocessed_inspection_count} 件を、{inspection_status.value} 状態にします。")
+            logger.debug(f"task_id='{task.task_id}' :: 未処置の検査コメント {unprocessed_inspection_count} 件を、{inspection_status.value} 状態にします。")
             for input_data_id, unprocessed_inspection_list in unprocessed_inspection_list_dict.items():
                 if len(unprocessed_inspection_list) == 0:
                     continue
@@ -282,21 +282,21 @@ class CompleteTasksMain(CommandLineWithConfirm):
                 )
 
         self.service.wrapper.complete_task(task.project_id, task.task_id, last_updated_datetime=task.updated_datetime)
-        logger.info(f"{task.task_id}: 検査/受入フェーズを次のフェーズに進めました。")
+        logger.info(f"task_id='{task.task_id}' :: 検査/受入フェーズを次のフェーズに進めました。")
         return True
 
     @staticmethod
     def _validate_task(task: Task, target_phase: TaskPhase, target_phase_stage: int, task_query: Optional[TaskQuery]) -> bool:
         if not (task.phase == target_phase and task.phase_stage == target_phase_stage):
-            logger.warning(f"{task.task_id} は操作対象のフェーズ、フェーズステージではないため、スキップします。")
+            logger.warning(f"task_id='{task.task_id}'のタスクは操作対象のフェーズ、フェーズステージではないため、スキップします。")
             return False
 
         if task.status in {TaskStatus.COMPLETE, TaskStatus.WORKING}:
-            logger.warning(f"{task.task_id} は作業中また完了状態であるため、スキップします。")
+            logger.warning(f"task_id='{task.task_id}'のタスクは作業中または完了状態であるため、スキップします。")
             return False
 
         if not match_task_with_query(task, task_query):
-            logger.debug(f"{task.task_id} は `--task_query` の条件にマッチしないため、スキップします。task_query={task_query}")
+            logger.debug(f"task_id='{task.task_id}' は `--task_query` の条件にマッチしないため、スキップします。 :: task_query={task_query}")
             return False
         return True
 
@@ -315,11 +315,11 @@ class CompleteTasksMain(CommandLineWithConfirm):
 
         dict_task = self.service.wrapper.get_task_or_none(project_id, task_id)
         if dict_task is None:
-            logger.warning(f"{logging_prefix}: task_id='{task_id}'のタスクは存在しないので、スキップします。")
+            logger.warning(f"{logging_prefix} :: task_id='{task_id}'のタスクは存在しないので、スキップします。")
             return False
 
         task: Task = Task.from_dict(dict_task)
-        logger.info(f"{logging_prefix} : タスク情報 task_id='{task_id}', phase={task.phase.value}, phase_stage={task.phase_stage}, status={task.status.value}")
+        logger.info(f"{logging_prefix} :: タスク情報 task_id='{task_id}', phase={task.phase.value}, phase_stage={task.phase_stage}, status={task.status.value}")
         if not self._validate_task(task, target_phase=target_phase, target_phase_stage=target_phase_stage, task_query=task_query):
             return False
 
@@ -330,7 +330,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
                 return self.complete_task_for_inspection_acceptance_phase(task, inspection_status=inspection_status)
 
         except Exception:  # pylint: disable=broad-except
-            logger.warning(f"{task_id}: {task.phase} フェーズを完了状態にするのに失敗しました。", exc_info=True)
+            logger.warning(f"task_id='{task_id}' :: '{task.phase}'フェーズを次のフェーズへ進めるのに失敗しました。", exc_info=True)
             new_task: Task = Task.from_dict(self.service.wrapper.get_task_or_none(project_id, task_id))
             if new_task.status == TaskStatus.WORKING and new_task.account_id == self.service.api.account_id:
                 self.service.wrapper.change_task_status_to_break(project_id, task_id)
@@ -359,7 +359,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
                 task_query=task_query,
             )
         except Exception:  # pylint: disable=broad-except
-            logger.warning(f"タスク'{task_id}'のフェーズを完了状態にするのに失敗しました。", exc_info=True)
+            logger.warning(f"task_id='{task_id}'のタスクのフェーズを完了状態にするのに失敗しました。", exc_info=True)
             return False
 
     def complete_task_list(  # noqa: ANN201
@@ -387,7 +387,7 @@ class CompleteTasksMain(CommandLineWithConfirm):
             task_query = self.facade.set_account_id_of_task_query(project_id, task_query)
 
         project_title = self.facade.get_project_title(project_id)
-        logger.info(f"{project_title} のタスク {len(task_id_list)} 件に対して、今のフェーズを完了状態にします。")
+        logger.info(f"{project_title} のタスク {len(task_id_list)} 件に対して、'{target_phase.value}'フェーズを次のフェーズに進めます。")
 
         success_count = 0
 
@@ -423,10 +423,10 @@ class CompleteTasksMain(CommandLineWithConfirm):
                     if result:
                         success_count += 1
                 except Exception:  # pylint: disable=broad-except
-                    logger.warning(f"タスク'{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)} 件のタスクに対して、今のフェーズを完了状態にしました。")
+        logger.info(f"{success_count} / {len(task_id_list)} 件のタスクに対して、'{target_phase.value}'フェーズを次のフェーズに進めました。")
 
 
 class CompleteTasks(CommandLine):
@@ -544,9 +544,9 @@ def main(args: argparse.Namespace) -> None:
 
 def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
     subcommand_name = "complete"
-    subcommand_help = "タスクを完了状態にして次のフェーズに進めます。（教師付の提出、検査/受入の合格）"
+    subcommand_help = "タスクを次のフェーズに進めます。（教師付の提出、検査/受入の合格）"
     description = (
-        "タスクを完了状態にして次のフェーズに進めます。（教師付の提出、検査/受入の合格） "
+        "タスクを次のフェーズに進めます。（教師付の提出、検査/受入の合格） "
         "教師付フェーズを完了にする場合は、未回答の検査コメントに対して返信することができます"
         "（未回答の検査コメントに対して返信しないと、タスクを提出できないため）。"
         "検査/受入フェーズを完了する場合は、未処置の検査コメントを対応完了/対応不要状態に変更できます"

{annofabcli-1.107.0.dist-info → annofabcli-1.108.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annofabcli
-Version: 1.107.0
+Version: 1.108.0
 Summary: Utility Command Line Interface for AnnoFab
 Author: Kurusugawa Computer Inc.
 License: MIT
@@ -17,7 +17,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
-Requires-Dist: annofabapi>=1.4.7
+Requires-Dist: annofabapi>=1.5.1
 Requires-Dist: bokeh<3.7,>=3.3
 Requires-Dist: dictdiffer
 Requires-Dist: isodate