annofabcli 1.113.1__py3-none-any.whl → 1.114.1__py3-none-any.whl

annofabcli/__main__.py

@@ -26,6 +26,7 @@ import annofabcli.stat_visualization.subcommand_stat_visualization
 import annofabcli.statistics.subcommand_statistics
 import annofabcli.supplementary.subcommand_supplementary
 import annofabcli.task.subcommand_task
+import annofabcli.task_count.subcommand_task_count
 import annofabcli.task_history.subcommand_task_history
 import annofabcli.task_history_event.subcommand_task_history_event
 
@@ -121,6 +122,7 @@ def create_parser() -> argparse.ArgumentParser:
     annofabcli.stat_visualization.subcommand_stat_visualization.add_parser(subparsers)
     annofabcli.supplementary.subcommand_supplementary.add_parser(subparsers)
     annofabcli.task.subcommand_task.add_parser(subparsers)
+    annofabcli.task_count.subcommand_task_count.add_parser(subparsers)
     annofabcli.task_history.subcommand_task_history.add_parser(subparsers)
     annofabcli.task_history_event.subcommand_task_history_event.add_parser(subparsers)
 

annofabcli/comment/list_all_comment.py

@@ -39,21 +39,46 @@ class ListAllCommentMain:
         task_ids: Collection[str] | None,
         comment_type: CommentType | None,
         exclude_reply: bool,  # noqa: FBT001
+        temp_dir: Path | None,
     ) -> list[dict[str, Any]]:
         if comment_json is None:
             downloading_obj = DownloadingFile(self.service)
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                json_path = Path(str_temp_dir) / f"{project_id}__comment.json"
-                downloading_obj.download_comment_json(project_id, str(json_path))
-                with json_path.open(encoding="utf-8") as f:
-                    comment_list = json.load(f)
-
+            if temp_dir is not None:
+                json_path = downloading_obj.download_comment_json_to_dir(project_id, temp_dir)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    json_path = downloading_obj.download_comment_json_to_dir(project_id, Path(str_temp_dir))
+                    with json_path.open(encoding="utf-8") as f:
+                        comment_list = json.load(f)
+                        # 一時ディレクトリの場合はここでフィルタリング処理まで行う
+                        if task_ids is not None:
+                            task_id_set = set(task_ids)
+                            comment_list = [e for e in comment_list if e["task_id"] in task_id_set]
+
+                        if comment_type is not None:
+                            comment_list = [e for e in comment_list if e["comment_type"] == comment_type.value]
+
+                        # 返信回数を算出する
+                        reply_counter = create_reply_counter(comment_list)
+                        for c in comment_list:
+                            key = (c["task_id"], c["input_data_id"], c["comment_id"])
+                            c["reply_count"] = reply_counter.get(key, 0)
+
+                        if exclude_reply:
+                            # 返信コメントを除外する
+                            comment_list = [e for e in comment_list if e["comment_node"]["_type"] != "Reply"]
+
+                        visualize = AddProps(self.service, project_id)
+                        comment_list = [visualize.add_properties_to_comment(e) for e in comment_list]
+
+                        return comment_list
         else:
             json_path = comment_json
-            with json_path.open(encoding="utf-8") as f:
-                comment_list = json.load(f)
+
+        with json_path.open(encoding="utf-8") as f:
+            comment_list = json.load(f)
 
         if task_ids is not None:
             task_id_set = set(task_ids)
@@ -86,6 +111,7 @@ class ListAllComment(CommandLine):
 
         task_id_list = annofabcli.common.cli.get_list_from_args(args.task_id) if args.task_id is not None else None
         comment_type = CommentType(args.comment_type) if args.comment_type is not None else None
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
 
         main_obj = ListAllCommentMain(self.service)
         comment_list = main_obj.get_all_comment(
@@ -94,6 +120,7 @@ class ListAllComment(CommandLine):
             task_ids=task_id_list,
             comment_type=comment_type,
             exclude_reply=args.exclude_reply,
+            temp_dir=temp_dir,
         )
 
         logger.info(f"コメントの件数: {len(comment_list)}")
@@ -133,6 +160,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
 
     parser.add_argument("--exclude_reply", action="store_true", help="返信コメントを除外します。")
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--comment_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_format(
         choices=[
             FormatArgument.CSV,

annofabcli/common/download.py

@@ -404,3 +404,72 @@ class DownloadingFile:
             wait_options=wait_options,
         )
         return dest_path
+
+    def download_task_history_json_to_dir(
+        self,
+        project_id: str,
+        output_dir: Path,
+    ) -> Path:
+        """
+        タスク履歴JSONをoutput_dirに統一された命名規則でダウンロードする。
+
+        Args:
+            project_id: プロジェクトID
+            output_dir: 出力ディレクトリ
+
+        Returns:
+            ダウンロードされたファイルのパス
+        """
+        dest_path = output_dir / get_filename(project_id, "task_history", "json")
+
+        self.download_task_history_json(
+            project_id,
+            dest_path=str(dest_path),
+        )
+        return dest_path
+
+    def download_task_history_event_json_to_dir(
+        self,
+        project_id: str,
+        output_dir: Path,
+    ) -> Path:
+        """
+        タスク履歴イベントJSONをoutput_dirに統一された命名規則でダウンロードする。
+
+        Args:
+            project_id: プロジェクトID
+            output_dir: 出力ディレクトリ
+
+        Returns:
+            ダウンロードされたファイルのパス
+        """
+        dest_path = output_dir / get_filename(project_id, "task_history_event", "json")
+
+        self.download_task_history_event_json(
+            project_id,
+            dest_path=str(dest_path),
+        )
+        return dest_path
+
+    def download_comment_json_to_dir(
+        self,
+        project_id: str,
+        output_dir: Path,
+    ) -> Path:
+        """
+        コメントJSONをoutput_dirに統一された命名規則でダウンロードする。
+
+        Args:
+            project_id: プロジェクトID
+            output_dir: 出力ディレクトリ
+
+        Returns:
+            ダウンロードされたファイルのパス
+        """
+        dest_path = output_dir / get_filename(project_id, "comment", "json")
+
+        self.download_comment_json(
+            project_id,
+            dest_path=str(dest_path),
+        )
+        return dest_path

annofabcli/input_data/list_all_input_data.py

@@ -71,24 +71,39 @@ class ListInputDataWithJsonMain:
         contain_parent_task_id_list: bool = False,
         contain_supplementary_data_count: bool = False,
         is_latest: bool = False,
+        temp_dir: Path | None = None,
     ) -> list[dict[str, Any]]:
         if input_data_json is None:
             downloading_obj = DownloadingFile(self.service)
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                json_path = Path(str_temp_dir) / f"{project_id}__input_data.json"
-                downloading_obj.download_input_data_json(
-                    project_id,
-                    str(json_path),
-                    is_latest=is_latest,
-                )
-                with json_path.open(encoding="utf-8") as f:
-                    input_data_list = json.load(f)
+            if temp_dir is not None:
+                json_path = downloading_obj.download_input_data_json_to_dir(project_id, temp_dir, is_latest=is_latest)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    json_path = downloading_obj.download_input_data_json_to_dir(project_id, Path(str_temp_dir), is_latest=is_latest)
+                    with json_path.open(encoding="utf-8") as f:
+                        input_data_list = json.load(f)
+                        # 一時ディレクトリの場合はここでフィルタリング処理まで行う
+                        input_data_id_set = set(input_data_id_list) if input_data_id_list is not None else None
+                        filtered_input_data_list = [e for e in input_data_list if self.filter_input_data_list(e, input_data_query=input_data_query, input_data_id_set=input_data_id_set)]
+
+                        adding_obj = AddingDetailsToInputData(self.service, project_id)
+                        if contain_parent_task_id_list:
+                            adding_obj.add_parent_task_id_list_to_input_data_list(input_data_list)
+
+                        if contain_supplementary_data_count:
+                            adding_obj.add_supplementary_data_count_to_input_data_list(input_data_list)
+
+                        # 入力データの不要なキーを削除する
+                        for input_data in input_data_list:
+                            remove_unnecessary_keys_from_input_data(input_data)
+                        return filtered_input_data_list
         else:
             json_path = input_data_json
-            with json_path.open(encoding="utf-8") as f:
-                input_data_list = json.load(f)
+
+        with json_path.open(encoding="utf-8") as f:
+            input_data_list = json.load(f)
 
         input_data_id_set = set(input_data_id_list) if input_data_id_list is not None else None
         filtered_input_data_list = [e for e in input_data_list if self.filter_input_data_list(e, input_data_query=input_data_query, input_data_id_set=input_data_id_set)]
@@ -117,6 +132,7 @@ class ListAllInputData(CommandLine):
         super().validate_project(project_id, project_member_roles=[ProjectMemberRole.TRAINING_DATA_USER, ProjectMemberRole.OWNER])
 
         main_obj = ListInputDataWithJsonMain(self.service)
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
         input_data_list = main_obj.get_input_data_list(
             project_id=project_id,
             input_data_json=args.input_data_json,
@@ -125,6 +141,7 @@ class ListAllInputData(CommandLine):
             is_latest=args.latest,
             contain_parent_task_id_list=args.with_parent_task_id_list,
             contain_supplementary_data_count=args.with_supplementary_data_count,
+            temp_dir=temp_dir,
         )
 
         logger.debug(f"入力データ一覧の件数: {len(input_data_list)}")
@@ -195,6 +212,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
 
     parser.add_argument("--with_supplementary_data_count", action="store_true", help="入力データに紐づく補助情報の個数( ``supplementary_data_count`` )も出力します。")
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--input_data_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_format(
         choices=[
             FormatArgument.CSV,

annofabcli/task/list_all_tasks.py

@@ -47,21 +47,34 @@ class ListTasksWithJsonMain:
         task_id_list: list[str] | None = None,
         task_query: TaskQuery | None = None,
         is_latest: bool = False,  # noqa: FBT001, FBT002
+        temp_dir: Path | None = None,
     ) -> list[dict[str, Any]]:
         if task_json is None:
             downloading_obj = DownloadingFile(self.service)
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                json_path = Path(str_temp_dir) / f"{project_id}__task.json"
-                downloading_obj.download_task_json(project_id, str(json_path), is_latest=is_latest)
-                with json_path.open(encoding="utf-8") as f:
-                    task_list = json.load(f)
-
+            if temp_dir is not None:
+                json_path = downloading_obj.download_task_json_to_dir(project_id, temp_dir, is_latest=is_latest)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    json_path = downloading_obj.download_task_json_to_dir(project_id, Path(str_temp_dir), is_latest=is_latest)
+                    with json_path.open(encoding="utf-8") as f:
+                        task_list = json.load(f)
+                        # 一時ディレクトリの場合はここでフィルタリング処理まで行う
+                        if task_query is not None:
+                            task_query = self.facade.set_account_id_of_task_query(project_id, task_query)
+
+                        logger.debug("出力対象のタスクを抽出しています。")
+                        task_id_set = set(task_id_list) if task_id_list is not None else None
+                        filtered_task_list = [e for e in task_list if self.match_task_with_conditions(e, task_query=task_query, task_id_set=task_id_set)]
+
+                        visualize_obj = AddProps(self.service, project_id)
+                        return [visualize_obj.add_properties_to_task(e) for e in filtered_task_list]
         else:
             json_path = task_json
-            with json_path.open(encoding="utf-8") as f:
-                task_list = json.load(f)
+
+        with json_path.open(encoding="utf-8") as f:
+            task_list = json.load(f)
 
         if task_query is not None:
             task_query = self.facade.set_account_id_of_task_query(project_id, task_query)
@@ -85,12 +98,14 @@ class ListTasksWithJson(CommandLine):
         super().validate_project(project_id, project_member_roles=None)
 
         main_obj = ListTasksWithJsonMain(self.service)
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
         task_list = main_obj.get_task_list(
             project_id=project_id,
             task_json=args.task_json,
             task_id_list=task_id_list,
             task_query=task_query,
             is_latest=args.latest,
+            temp_dir=temp_dir,
         )
 
         logger.debug(f"タスク一覧の件数: {len(task_list)}")
@@ -133,6 +148,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "指定しない場合は、コマンドを実行した日の02:00(JST)頃のタスクの一覧が出力されます。",
     )
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--task_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_format(
         choices=[FormatArgument.CSV, FormatArgument.JSON, FormatArgument.PRETTY_JSON, FormatArgument.TASK_ID_LIST],
         default=FormatArgument.CSV,

annofabcli/task/list_all_tasks_added_task_history.py

@@ -60,31 +60,35 @@ class ListAllTasksAddedTaskHistoryMain:
 
         return task_list
 
-    def load_task_list(self, task_json_path: Path | None) -> list[dict[str, Any]]:
-        if task_json_path is not None:
-            with task_json_path.open(encoding="utf-8") as f:
-                return json.load(f)
-
-        # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
-        # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-        with tempfile.TemporaryDirectory() as str_temp_dir:
-            task_json_path = Path(str_temp_dir) / f"{self.project_id}__task.json"
-            self.downloading_obj.download_task_json(self.project_id, str(task_json_path))
-            with task_json_path.open(encoding="utf-8") as f:
-                return json.load(f)
-
-    def load_task_history_dict(self, task_history_json_path: Path | None) -> TaskHistoryDict:
-        if task_history_json_path is not None:
-            with task_history_json_path.open(encoding="utf-8") as f:
-                return json.load(f)
-        else:
+    def load_task_list(self, task_json_path: Path | None, temp_dir: Path | None) -> list[dict[str, Any]]:
+        if task_json_path is None:
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                task_history_json_path = Path(str_temp_dir) / f"{self.project_id}__task_history.json"
-                self.downloading_obj.download_task_history_json(self.project_id, str(task_history_json_path))
-                with task_history_json_path.open(encoding="utf-8") as f:
-                    return json.load(f)
+            if temp_dir is not None:
+                task_json_path = self.downloading_obj.download_task_json_to_dir(self.project_id, temp_dir)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    task_json_path = self.downloading_obj.download_task_json_to_dir(self.project_id, Path(str_temp_dir))
+                    with task_json_path.open(encoding="utf-8") as f:
+                        return json.load(f)
+
+        with task_json_path.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    def load_task_history_dict(self, task_history_json_path: Path | None, temp_dir: Path | None) -> TaskHistoryDict:
+        if task_history_json_path is None:
+            # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
+            # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
+            if temp_dir is not None:
+                task_history_json_path = self.downloading_obj.download_task_history_json_to_dir(self.project_id, temp_dir)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    task_history_json_path = self.downloading_obj.download_task_history_json_to_dir(self.project_id, Path(str_temp_dir))
+                    with task_history_json_path.open(encoding="utf-8") as f:
+                        return json.load(f)
+
+        with task_history_json_path.open(encoding="utf-8") as f:
+            return json.load(f)
 
     @staticmethod
     def match_task_with_conditions(
@@ -120,12 +124,13 @@ class ListAllTasksAddedTaskHistoryMain:
         task_history_json_path: Path | None,
         task_id_list: list[str] | None,
         task_query: TaskQuery | None,
+        temp_dir: Path | None,
     ):
         """
         タスク履歴情報を加えたタスク一覧を取得する。
         """
-        task_list = self.load_task_list(task_json_path)
-        task_history_dict = self.load_task_history_dict(task_history_json_path)
+        task_list = self.load_task_list(task_json_path, temp_dir)
+        task_history_dict = self.load_task_history_dict(task_history_json_path, temp_dir)
 
         filtered_task_list = self.filter_task_list(task_list, task_id_list=task_id_list, task_query=task_query)
 
@@ -163,11 +168,13 @@ class ListAllTasksAddedTaskHistory(CommandLine):
 
         self.validate_project(project_id, [ProjectMemberRole.OWNER, ProjectMemberRole.TRAINING_DATA_USER])
 
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
         task_list = ListAllTasksAddedTaskHistoryMain(self.service, project_id).get_task_list_added_task_history(
             task_json_path=args.task_json,
             task_history_json_path=args.task_history_json,
             task_id_list=task_id_list,
             task_query=task_query,
+            temp_dir=temp_dir,
         )
 
         logger.info(f"タスク一覧の件数: {len(task_list)}")
@@ -200,6 +207,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "JSONファイルは ``$ annofabcli task_history download`` コマンドで取得できます。",
     )
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--task_json`` と ``--task_history_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_output()
 
     argument_parser.add_format(

annofabcli/task_count/list_by_phase.py

@@ -0,0 +1,558 @@
+import argparse
+import json
+import logging
+import sys
+import tempfile
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+import isodate
+import pandas
+from annofabapi.models import ProjectMemberRole, Task, TaskPhase, TaskStatus
+from annofabapi.resource import Resource as AnnofabResource
+from annofabapi.utils import get_number_of_rejections
+
+import annofabcli.common
+from annofabcli.common.cli import (
+    COMMAND_LINE_ERROR_STATUS_CODE,
+    ArgumentParser,
+    CommandLine,
+    build_annofabapi_resource_and_login,
+)
+from annofabcli.common.download import DownloadingFile
+from annofabcli.common.facade import AnnofabApiFacade
+from annofabcli.common.type_util import assert_noreturn
+
+logger = logging.getLogger(__name__)
+
+
+class AggregationUnit(Enum):
+    """
+    集計の単位。
+    """
+
+    TASK = "task_count"
+    """タスク数"""
+    INPUT_DATA = "input_data_count"
+    """入力データ数"""
+    VIDEO_DURATION_HOUR = "video_duration_hour"
+    """動画の長さ（時間）"""
+    VIDEO_DURATION_MINUTE = "video_duration_minute"
+    """動画の長さ（分）"""
+
+
+def isoduration_to_second(duration: str) -> float:
+    """
+    ISO 8601 duration を 秒に変換する
+    """
+    return isodate.parse_duration(duration).total_seconds()
+
+
+class TaskStatusForSummary(Enum):
+    """
+    Annofabユーザーがタスクについて知りたい粒度でまとめて分解した、タスクの状態。
+    """
+
+    NEVER_WORKED_UNASSIGNED = "never_worked.unassigned"
+    """一度も作業していない状態かつ担当者未割り当て"""
+    NEVER_WORKED_ASSIGNED = "never_worked.assigned"
+    """一度も作業していない状態かつ担当者割り当て済み"""
+    WORKED_NOT_REJECTED = "worked.not_rejected"
+    """タスクのstatusは作業中または休憩中 AND 次のフェーズでまだ差し戻されていない（次のフェーズに進んでいない）"""
+    WORKED_REJECTED = "worked.rejected"
+    """タスクのstatusは作業中または休憩中 AND 次のフェーズで差し戻された"""
+    ON_HOLD = "on_hold"
+    """保留中"""
+    COMPLETE = "complete"
+    """完了"""
+
+    @staticmethod
+    def _get_not_started_status(task: Task, task_history_list: list[dict[str, Any]], not_worked_threshold_second: float) -> "TaskStatusForSummary":
+        """
+        NOT_STARTED状態のタスクについて、一度も作業されていないか、差し戻されて未着手かを判定する。
+
+        Args:
+            task: タスク情報
+            task_history_list: タスク履歴のリスト
+            not_worked_threshold_second: 作業していないとみなす作業時間の閾値（秒）。この値以下なら作業していないとみなす。
+        """
+        # `number_of_inspections=1`を指定する理由：多段検査を無視して、検査フェーズが１回目かどうかを知りたいため
+        step = get_step_for_current_phase(task, number_of_inspections=1)
+        if step == 1:
+            phase = task["phase"]
+            worktime_second = sum(isoduration_to_second(history["accumulated_labor_time_milliseconds"]) for history in task_history_list if history["phase"] == phase)
+            if worktime_second <= not_worked_threshold_second:
+                # 一度も作業されていない（または閾値以下の作業時間）
+                account_id = task["account_id"]
+                if account_id is None:
+                    return TaskStatusForSummary.NEVER_WORKED_UNASSIGNED
+                else:
+                    return TaskStatusForSummary.NEVER_WORKED_ASSIGNED
+            else:
+                return TaskStatusForSummary.WORKED_NOT_REJECTED
+        else:
+            return TaskStatusForSummary.WORKED_NOT_REJECTED
+
+    @staticmethod
+    def _get_working_or_break_status(task: Task) -> "TaskStatusForSummary":
+        """
+        WORKINGまたはBREAK状態のタスクについて、rejectされているかどうかを判定する。
+        """
+        # `number_of_inspections=1`を指定する理由：多段検査を無視して、検査フェーズが１回目かどうかを知りたいため
+        step = get_step_for_current_phase(task, number_of_inspections=1)
+        if step == 1:
+            return TaskStatusForSummary.WORKED_NOT_REJECTED
+        else:
+            return TaskStatusForSummary.WORKED_REJECTED
+
+    @staticmethod
+    def from_task(task: dict[str, Any], task_history_list: list[dict[str, Any]], not_worked_threshold_second: float = 0) -> "TaskStatusForSummary":
+        """
+        タスク情報(dict)からインスタンスを生成します。
+
+        Args:
+            task: APIから取得したタスク情報. 以下のkeyが必要です。
+                * status
+                * phase
+                * phase_stage
+                * histories_by_phase
+                * account_id
+            task_history_list: タスク履歴のリスト
+            not_worked_threshold_second: 作業していないとみなす作業時間の閾値（秒）。この値以下なら作業していないとみなす。
+
+        """
+        status = TaskStatus(task["status"])
+        match status:
+            case TaskStatus.COMPLETE:
+                return TaskStatusForSummary.COMPLETE
+
+            case TaskStatus.ON_HOLD:
+                return TaskStatusForSummary.ON_HOLD
+
+            case TaskStatus.NOT_STARTED:
+                return TaskStatusForSummary._get_not_started_status(task, task_history_list, not_worked_threshold_second)
+
+            case TaskStatus.BREAK | TaskStatus.WORKING:
+                return TaskStatusForSummary._get_working_or_break_status(task)
+
+            case _:
+                raise RuntimeError(f"'{status}'は対象外です。")
+
+
+def get_step_for_current_phase(task: Task, number_of_inspections: int) -> int:
+    """
+    今のフェーズが何回目かを取得する。
+
+    Args:
+        task: 対象タスクの情報。phase, phase_stage, histories_by_phase を含む。
+        number_of_inspections: 対象プロジェクトの検査フェーズの回数
+
+    Returns:
+        現在のフェーズのステップ数
+    """
+    current_phase = TaskPhase(task["phase"])
+    current_phase_stage = task["phase_stage"]
+    histories_by_phase = task["histories_by_phase"]
+
+    number_of_rejections_by_acceptance = get_number_of_rejections(histories_by_phase, phase=TaskPhase.ACCEPTANCE)
+    match current_phase:
+        case TaskPhase.ACCEPTANCE:
+            return number_of_rejections_by_acceptance + 1
+
+        case TaskPhase.ANNOTATION:
+            number_of_rejections_by_inspection = sum(
+                get_number_of_rejections(histories_by_phase, phase=TaskPhase.INSPECTION, phase_stage=phase_stage) for phase_stage in range(1, number_of_inspections + 1)
+            )
+            return number_of_rejections_by_inspection + number_of_rejections_by_acceptance + 1
+
+        case TaskPhase.INSPECTION:
+            number_of_rejections_by_inspection = sum(
+                get_number_of_rejections(histories_by_phase, phase=TaskPhase.INSPECTION, phase_stage=phase_stage) for phase_stage in range(current_phase_stage, number_of_inspections + 1)
+            )
+            return number_of_rejections_by_inspection + number_of_rejections_by_acceptance + 1
+
+        case _ as unreachable:
+            assert_noreturn(unreachable)
+
+
+def create_df_task(
+    task_list: list[dict[str, Any]],
+    task_history_dict: dict[str, list[dict[str, Any]]],
+    *,
+    not_worked_threshold_second: float = 0,
+    metadata_keys: list[str] | None = None,
+    input_data_dict: dict[str, dict[str, Any]] | None = None,
+) -> pandas.DataFrame:
+    """
+    以下の列が含まれたタスクのDataFrameを生成します。
+     * task_id
+     * phase
+     * task_status_for_summary
+     * input_data_count
+     * video_duration_hour
+     * video_duration_minute
+     * metadata.{key} (metadata_keysで指定された各キー)
+
+    Args:
+        task_list: タスク情報のlist
+        task_history_dict: タスクIDをキーとしたタスク履歴のdict
+        not_worked_threshold_second: 作業していないとみなす作業時間の閾値（秒）
+        metadata_keys: 集計対象のメタデータキーのリスト
+        input_data_dict: 入力データIDをキーとした入力データ情報のdict。動画時間を計算する場合に必要。
+
+    Returns:
+        タスク情報のDataFrame
+    """
+    metadata_keys = metadata_keys or []
+    input_data_dict = input_data_dict or {}
+
+    for task in task_list:
+        task_history = task_history_dict[task["task_id"]]
+        task["task_status_for_summary"] = TaskStatusForSummary.from_task(task, task_history, not_worked_threshold_second).value
+
+        # 入力データ数を計算
+        task["input_data_count"] = len(task["input_data_id_list"])
+
+        # 動画の長さを計算（時間）
+        video_duration_hour = 0
+        video_duration_minute = 0
+        for input_data_id in task["input_data_id_list"]:
+            if input_data_id in input_data_dict:
+                duration = input_data_dict[input_data_id]["system_metadata"]["input_duration"]
+                video_duration_hour += duration / 3600
+                video_duration_minute += duration / 60
+
+        task["video_duration_hour"] = video_duration_hour
+        task["video_duration_minute"] = video_duration_minute
+
+        # メタデータの値を抽出
+        metadata = task["metadata"]
+        for key in metadata_keys:
+            task[f"metadata.{key}"] = metadata[key]
+
+    columns = ["task_id", "phase", "input_data_count", "video_duration_hour", "video_duration_minute"] + [f"metadata.{key}" for key in metadata_keys] + ["task_status_for_summary"]
+    df = pandas.DataFrame(task_list, columns=columns)
+    return df
+
+
+def aggregate_df(df: pandas.DataFrame, metadata_keys: list[str] | None = None, unit: AggregationUnit = AggregationUnit.TASK) -> pandas.DataFrame:
+    """
+    タスクのフェーズとステータスごとに、指定された単位で集計する。
+
+    Args:
+        df: 以下の列を持つDataFrame
+            * phase
+            * task_status_for_summary
+            * input_data_count
+            * video_duration_hour
+            * video_duration_minute
+            * metadata.{key} (metadata_keysで指定された各キー)
+        metadata_keys: 集計対象のメタデータキーのリスト
+        unit: 集計の単位
+
+    Returns:
+        indexがphase(とmetadata.*列),列がtask_status_for_summaryであるDataFrame
+    """
+    metadata_keys = metadata_keys or []
+    metadata_columns = [f"metadata.{key}" for key in metadata_keys]
+
+    # 集計対象の列を選択
+    match unit:
+        case AggregationUnit.TASK:
+            df["_aggregate_value"] = 1
+        case AggregationUnit.INPUT_DATA:
+            df["_aggregate_value"] = df["input_data_count"]
+        case AggregationUnit.VIDEO_DURATION_HOUR:
+            df["_aggregate_value"] = df["video_duration_hour"]
+        case AggregationUnit.VIDEO_DURATION_MINUTE:
+            df["_aggregate_value"] = df["video_duration_minute"]
+        case _ as unreachable:
+            assert_noreturn(unreachable)
+
+    index_columns = ["phase", *metadata_columns]
+    df2 = df.pivot_table(values="_aggregate_value", index=index_columns, columns="task_status_for_summary", aggfunc="sum", fill_value=0)
+
+    # 列数を固定する
+    for status in TaskStatusForSummary:
+        if status.value not in df2.columns:
+            df2[status.value] = 0
+
+    # ソート処理
+    sorted_phase = [
+        TaskPhase.ANNOTATION.value,
+        TaskPhase.INSPECTION.value,
+        TaskPhase.ACCEPTANCE.value,
+    ]
+
+    if len(metadata_columns) > 0:
+        # メタデータ列がある場合は、phase列でソートし、その後メタデータ列でソート
+        df2 = df2.reset_index()
+        df2["_phase_order"] = df2["phase"].map(lambda x: sorted_phase.index(x) if x in sorted_phase else len(sorted_phase))
+        df2 = df2.sort_values(["_phase_order", *metadata_columns])
+        df2 = df2.drop(columns=["_phase_order"])
+    else:
+        # メタデータ列がない場合は既存のロジック
+        new_index = sorted(df2.index, key=lambda x: sorted_phase.index(x) if x in sorted_phase else len(sorted_phase))
+        df2 = df2.loc[new_index]
+        df2 = df2.reset_index()
+
+    # 列の順序を設定
+    result_columns = [
+        "phase",
+        *metadata_columns,
+        TaskStatusForSummary.NEVER_WORKED_UNASSIGNED.value,
+        TaskStatusForSummary.NEVER_WORKED_ASSIGNED.value,
+        TaskStatusForSummary.WORKED_NOT_REJECTED.value,
+        TaskStatusForSummary.WORKED_REJECTED.value,
+        TaskStatusForSummary.ON_HOLD.value,
+        TaskStatusForSummary.COMPLETE.value,
+    ]
+    df2 = df2[result_columns]
+    return df2
+
+
+class GettingTaskCountSummary:
+    """
+    タスク数のサマリーを取得するクラス
+    """
+
+    def __init__(
+        self,
+        annofab_service: AnnofabResource,
+        project_id: str,
+        temp_dir: Path,
+        *,
+        should_execute_get_tasks_api: bool = False,
+        not_worked_threshold_second: float = 0,
+        metadata_keys: list[str] | None = None,
+        unit: AggregationUnit = AggregationUnit.TASK,
+    ) -> None:
+        self.annofab_service = annofab_service
+        self.project_id = project_id
+        self.temp_dir = temp_dir
+        self.should_execute_get_tasks_api = should_execute_get_tasks_api
+        self.not_worked_threshold_second = not_worked_threshold_second
+        self.metadata_keys = metadata_keys or []
+        self.unit = unit
+
+    def create_df_task(self) -> pandas.DataFrame:
+        """
+        以下の列が含まれたタスクのDataFrameを生成します。
+        * task_id
+        * phase
+        * task_status_for_summary
+        * input_data_count
+        * video_duration_hour
+        * video_duration_minute
+        * metadata.{key} （metadata_keys で指定した各メタデータキーに対応する列）
+        """
+        if self.should_execute_get_tasks_api:
+            task_list = self.annofab_service.wrapper.get_all_tasks(self.project_id)
+            task_history_dict = {}
+            for index, task in enumerate(task_list, start=1):
+                task_id = task["task_id"]
+                task_history_dict[task_id], _ = self.annofab_service.api.get_task_histories(self.project_id, task_id)
+                if index % 100 == 0:
+                    logger.info(f"{index} 件目のタスク履歴を取得しました。")
+
+        else:
+            task_list = self.get_task_list_with_downloading()
+            task_history_dict = self.get_task_history_with_downloading()
+
+        # 動画時間を集計する場合は入力データJSONをダウンロード
+        input_data_dict = None
+        if self.unit in (AggregationUnit.VIDEO_DURATION_HOUR, AggregationUnit.VIDEO_DURATION_MINUTE):
+            input_data_dict = self.get_input_data_dict_with_downloading()
+
+        df = create_df_task(task_list, task_history_dict, not_worked_threshold_second=self.not_worked_threshold_second, metadata_keys=self.metadata_keys, input_data_dict=input_data_dict)
+        return df
+
+    def get_task_list_with_downloading(self) -> list[dict[str, Any]]:
+        """
+        タスク全件ファイルをダウンロードしてタスク情報を取得する。
+        """
+        downloading_obj = DownloadingFile(self.annofab_service)
+        task_json = downloading_obj.download_task_json_to_dir(self.project_id, self.temp_dir)
+        with task_json.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    def get_task_history_with_downloading(self) -> dict[str, list[dict[str, Any]]]:
+        """
+        タスク履歴全件ファイルをダウンロードしてタスク情報を取得する。
+        """
+        downloading_obj = DownloadingFile(self.annofab_service)
+        task_history_json = downloading_obj.download_task_history_json_to_dir(self.project_id, self.temp_dir)
+        with task_history_json.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    def get_input_data_dict_with_downloading(self) -> dict[str, dict[str, Any]]:
+        """
+        入力データJSONをダウンロードして、入力データIDをキーとした辞書を返す。
+        """
+        downloading_obj = DownloadingFile(self.annofab_service)
+        input_data_json = downloading_obj.download_input_data_json_to_dir(self.project_id, self.temp_dir)
+        with input_data_json.open(encoding="utf-8") as f:
+            input_data_list = json.load(f)
+        return {input_data["input_data_id"]: input_data for input_data in input_data_list}
+
+
+class ListTaskCountByPhase(CommandLine):
+    """
+    フェーズごとにタスク数や入力データ数などを集計し、CSV形式で出力する。
+    """
+
+    def list_task_count_by_phase(
+        self,
+        project_id: str,
+        *,
+        temp_dir: Path | None = None,
+        should_execute_get_tasks_api: bool = False,
+        not_worked_threshold_second: float = 0,
+        metadata_keys: list[str] | None = None,
+        unit: AggregationUnit = AggregationUnit.TASK,
+    ) -> None:
+        """
+        フェーズごとにタスク数や入力データ数などを集計し、CSV形式で出力する。
+
+        Args:
+            project_id: プロジェクトID
+            temp_dir: 一時ファイルの保存先ディレクトリ
+            should_execute_get_tasks_api: getTasks APIを実行するかどうか
+            not_worked_threshold_second: 作業していないとみなす作業時間の閾値（秒）
+            metadata_keys: 集計対象のメタデータキーのリスト
+            unit: 集計の単位
+        """
+
+        logger.info(f"project_id='{project_id}' :: フェーズごとの'{unit.value}'を集計します。")
+
+        if temp_dir is not None:
+            getting_obj = GettingTaskCountSummary(
+                self.service,
+                project_id,
+                temp_dir,
+                should_execute_get_tasks_api=should_execute_get_tasks_api,
+                not_worked_threshold_second=not_worked_threshold_second,
+                metadata_keys=metadata_keys,
+                unit=unit,
+            )
+            df_task = getting_obj.create_df_task()
+        else:
+            with tempfile.TemporaryDirectory() as str_temp_dir:
+                getting_obj = GettingTaskCountSummary(
+                    self.service,
+                    project_id,
+                    Path(str_temp_dir),
+                    should_execute_get_tasks_api=should_execute_get_tasks_api,
+                    not_worked_threshold_second=not_worked_threshold_second,
+                    metadata_keys=metadata_keys,
+                    unit=unit,
+                )
+                df_task = getting_obj.create_df_task()
+
+        if len(df_task) == 0:
+            logger.info("タスクが0件ですが、ヘッダ行を出力します。")
+            # aggregate_df関数と同じ列構成の空のDataFrameを作成
+            metadata_columns = [f"metadata.{key}" for key in (metadata_keys or [])]
+            result_columns = [
+                "phase",
+                *metadata_columns,
+                TaskStatusForSummary.NEVER_WORKED_UNASSIGNED.value,
+                TaskStatusForSummary.NEVER_WORKED_ASSIGNED.value,
+                TaskStatusForSummary.WORKED_NOT_REJECTED.value,
+                TaskStatusForSummary.WORKED_REJECTED.value,
+                TaskStatusForSummary.ON_HOLD.value,
+                TaskStatusForSummary.COMPLETE.value,
+            ]
+            df_summary = pandas.DataFrame(columns=result_columns)
+        else:
+            logger.info(f"{len(df_task)} 件のタスクを集計しました。")
+            df_summary = aggregate_df(df_task, metadata_keys, unit)
+
+        self.print_csv(df_summary)
+        logger.info(f"project_id='{project_id}' :: フェーズごとの'{unit.value}'をCSV形式で出力しました。")
+
+    def main(self) -> None:
+        args = self.args
+        project_id = args.project_id
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
+
+        unit = AggregationUnit(args.unit)
+
+        super().validate_project(project_id, project_member_roles=[ProjectMemberRole.OWNER, ProjectMemberRole.TRAINING_DATA_USER])
+
+        # 動画時間で集計する場合は、プロジェクトが動画プロジェクトかどうかをチェック
+        if unit in [AggregationUnit.VIDEO_DURATION_HOUR, AggregationUnit.VIDEO_DURATION_MINUTE]:
+            project, _ = self.service.api.get_project(project_id)
+            input_data_type = project["input_data_type"]
+            if input_data_type != "movie":
+                print(f"コマンドライン引数'--unit {unit.value}' は動画プロジェクトでのみ使用できます。現在のプロジェクトの入力データタイプは'{input_data_type}'です。", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+        self.list_task_count_by_phase(
+            project_id,
+            temp_dir=temp_dir,
+            should_execute_get_tasks_api=args.execute_get_tasks_api,
+            not_worked_threshold_second=args.not_worked_threshold_second,
+            metadata_keys=args.metadata_key,
+            unit=unit,
+        )
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    argument_parser = ArgumentParser(parser)
+
+    argument_parser.add_project_id()
+
+    parser.add_argument(
+        "--execute_get_tasks_api",
+        action="store_true",
+        help="タスク全件ファイルをダウンロードせずに、`getTasks` APIを実行してタスク一覧を取得します。`getTasks` APIを複数回実行するので、タスク全件ファイルをダウンロードするよりも時間がかかります。",
+    )
+
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="指定したディレクトリに、一時ファイルをダウンロードします。",
+    )
+
+    parser.add_argument(
+        "--not_worked_threshold_second",
+        type=float,
+        default=0,
+        help="作業していないとみなす作業時間の閾値を秒単位で指定します。この値以下の作業時間のタスクは、作業していないとみなします。",
+    )
+
+    parser.add_argument(
+        "--metadata_key",
+        type=str,
+        nargs="+",
+        help="集計対象のメタデータキーを指定します。指定したキーの値でグループ化してタスク数を集計します。",
+    )
+
+    parser.add_argument(
+        "--unit",
+        type=str,
+        choices=[e.value for e in AggregationUnit],
+        default=AggregationUnit.TASK.value,
+        help="集計の単位を指定します。task_count: タスク数、input_data_count: 入力データ数、video_duration_hour: 動画の長さ（時間）、video_duration_minute: 動画の長さ（分）。",
+    )
+
+    argument_parser.add_output()
+
+    parser.set_defaults(subcommand_func=main)
+
+
+def main(args: argparse.Namespace) -> None:
+    service = build_annofabapi_resource_and_login(args)
+    facade = AnnofabApiFacade(service)
+    ListTaskCountByPhase(service, facade, args).main()
+
+
+def add_parser(subparsers: argparse._SubParsersAction | None = None) -> argparse.ArgumentParser:
+    subcommand_name = "list_by_phase"
+    subcommand_help = "フェーズごとにタスク数や入力データ数などを集計し、CSV形式で出力します。"
+    epilog = "オーナロールまたはアノテーションユーザーロールを持つユーザで実行してください。"
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, epilog=epilog)
+    parse_args(parser)
+    return parser

annofabcli/task_count/subcommand_task_count.py

@@ -0,0 +1,21 @@
+import argparse
+
+import annofabcli.common.cli
+import annofabcli.task_count.list_by_phase
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    subparsers = parser.add_subparsers(dest="subcommand_name")
+
+    # サブコマンドの定義
+    annofabcli.task_count.list_by_phase.add_parser(subparsers)
+
+
+def add_parser(subparsers: argparse._SubParsersAction | None = None) -> argparse.ArgumentParser:
+    subcommand_name = "task_count"
+    subcommand_help = "タスク数関係のサブコマンド"
+    description = "タスク数関係のサブコマンド"
+
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, description, is_subcommand=False)
+    parse_args(parser)
+    return parser

annofabcli/task_history/list_all_task_history.py

@@ -39,21 +39,34 @@ class ListTaskHistoryWithJsonMain:
                 filtered_task_history_dict[task_id] = task_history_list
         return filtered_task_history_dict
 
-    def get_task_history_dict(self, project_id: str, task_history_json: Path | None = None, task_id_list: list[str] | None = None) -> TaskHistoryDict:
+    def get_task_history_dict(self, project_id: str, task_history_json: Path | None = None, task_id_list: list[str] | None = None, temp_dir: Path | None = None) -> TaskHistoryDict:
         """出力対象のタスク履歴情報を取得する"""
         if task_history_json is None:
             downloading_obj = DownloadingFile(self.service)
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                tmp_json_path = Path(str_temp_dir) / "task_history.json"
-                downloading_obj.download_task_history_json(project_id, str(tmp_json_path))
-                with tmp_json_path.open(encoding="utf-8") as f:
-                    all_task_history_dict = json.load(f)
+            if temp_dir is not None:
+                tmp_json_path = downloading_obj.download_task_history_json_to_dir(project_id, temp_dir)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    tmp_json_path = downloading_obj.download_task_history_json_to_dir(project_id, Path(str_temp_dir))
+                    with tmp_json_path.open(encoding="utf-8") as f:
+                        all_task_history_dict = json.load(f)
+                        # 一時ディレクトリの場合はここでフィルタリング処理まで行う
+                        task_history_dict = self.filter_task_history_dict(all_task_history_dict, task_id_list)
+
+                        visualize = AddProps(self.service, project_id)
 
+                        for task_history_list in task_history_dict.values():
+                            for task_history in task_history_list:
+                                visualize.add_properties_to_task_history(task_history)
+
+                        return task_history_dict
         else:
-            with task_history_json.open(encoding="utf-8") as f:
-                all_task_history_dict = json.load(f)
+            tmp_json_path = task_history_json
+
+        with tmp_json_path.open(encoding="utf-8") as f:
+            all_task_history_dict = json.load(f)
 
         task_history_dict = self.filter_task_history_dict(all_task_history_dict, task_id_list)
 
@@ -80,6 +93,7 @@ class ListTaskHistoryWithJson(CommandLine):
         task_history_json: Path | None,
         task_id_list: list[str] | None,
         arg_format: FormatArgument,
+        temp_dir: Path | None,
     ):
         """
         タスク一覧を出力する
@@ -95,7 +109,7 @@ class ListTaskHistoryWithJson(CommandLine):
         super().validate_project(project_id, project_member_roles=None)
 
         main_obj = ListTaskHistoryWithJsonMain(self.service)
-        task_history_dict = main_obj.get_task_history_dict(project_id, task_history_json=task_history_json, task_id_list=task_id_list)
+        task_history_dict = main_obj.get_task_history_dict(project_id, task_history_json=task_history_json, task_id_list=task_id_list, temp_dir=temp_dir)
         logger.debug(f"{len(task_history_dict)} 件のタスクの履歴情報を出力します。")
         if arg_format == FormatArgument.CSV:
             all_task_history_list = main_obj.to_all_task_history_list_from_dict(task_history_dict)
@@ -107,12 +121,14 @@ class ListTaskHistoryWithJson(CommandLine):
         args = self.args
 
         task_id_list = annofabcli.common.cli.get_list_from_args(args.task_id) if args.task_id is not None else None
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
 
         self.print_task_history_list(
             args.project_id,
             task_history_json=args.task_history_json,
             task_id_list=task_id_list,
             arg_format=FormatArgument(args.format),
+            temp_dir=temp_dir,
         )
 
 
@@ -141,6 +157,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "JSONファイルは ``$ annofabcli task_history download`` コマンドで取得できます。",
     )
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--task_history_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_format(
         choices=[FormatArgument.CSV, FormatArgument.JSON, FormatArgument.PRETTY_JSON],
         default=FormatArgument.CSV,

annofabcli/task_history_event/list_all_task_history_event.py

@@ -43,20 +43,32 @@ class ListTaskHistoryEventWithJsonMain:
 
         return task_history_event_list
 
-    def get_task_history_event_list(self, project_id: str, task_history_event_json: Path | None = None, task_id_list: list[str] | None = None) -> list[dict[str, Any]]:
+    def get_task_history_event_list(self, project_id: str, task_history_event_json: Path | None = None, task_id_list: list[str] | None = None, temp_dir: Path | None = None) -> list[dict[str, Any]]:
         if task_history_event_json is None:
             downloading_obj = DownloadingFile(self.service)
             # `NamedTemporaryFile`を使わない理由: Windowsで`PermissionError`が発生するため
             # https://qiita.com/yuji38kwmt/items/c6f50e1fc03dafdcdda0 参考
-            with tempfile.TemporaryDirectory() as str_temp_dir:
-                tmp_json_file = Path(str_temp_dir) / "task_history_event.json"
-                downloading_obj.download_task_history_event_json(project_id, str(tmp_json_file))
-                with tmp_json_file.open(encoding="utf-8") as f:
-                    all_task_history_event_list = json.load(f)
+            if temp_dir is not None:
+                tmp_json_file = downloading_obj.download_task_history_event_json_to_dir(project_id, temp_dir)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    tmp_json_file = downloading_obj.download_task_history_event_json_to_dir(project_id, Path(str_temp_dir))
+                    with tmp_json_file.open(encoding="utf-8") as f:
+                        all_task_history_event_list = json.load(f)
+                        # 一時ディレクトリの場合はここでフィルタリング処理まで行う
+                        filtered_task_history_event_list = self.filter_task_history_event(all_task_history_event_list, task_id_list)
+
+                        visualize = AddProps(self.service, project_id)
 
+                        for event in filtered_task_history_event_list:
+                            visualize.add_properties_to_task_history_event(event)
+
+                        return filtered_task_history_event_list
         else:
-            with task_history_event_json.open(encoding="utf-8") as f:
-                all_task_history_event_list = json.load(f)
+            tmp_json_file = task_history_event_json
+
+        with tmp_json_file.open(encoding="utf-8") as f:
+            all_task_history_event_list = json.load(f)
 
         filtered_task_history_event_list = self.filter_task_history_event(all_task_history_event_list, task_id_list)
 
@@ -75,11 +87,12 @@ class ListTaskHistoryEventWithJson(CommandLine):
         task_history_event_json: Path | None,
         task_id_list: list[str] | None,
         arg_format: FormatArgument,
+        temp_dir: Path | None,
     ) -> None:
         super().validate_project(project_id, project_member_roles=None)
 
         main_obj = ListTaskHistoryEventWithJsonMain(self.service)
-        task_history_event_list = main_obj.get_task_history_event_list(project_id, task_history_event_json=task_history_event_json, task_id_list=task_id_list)
+        task_history_event_list = main_obj.get_task_history_event_list(project_id, task_history_event_json=task_history_event_json, task_id_list=task_id_list, temp_dir=temp_dir)
 
         logger.debug(f"{len(task_history_event_list)} 件のタスク履歴イベントの情報を出力します。")
 
@@ -114,12 +127,14 @@ class ListTaskHistoryEventWithJson(CommandLine):
         args = self.args
 
         task_id_list = get_list_from_args(args.task_id) if args.task_id is not None else None
+        temp_dir = Path(args.temp_dir) if args.temp_dir is not None else None
 
         self.print_task_history_event_list(
             args.project_id,
             task_history_event_json=args.task_history_event_json,
             task_id_list=task_id_list,
             arg_format=FormatArgument(args.format),
+            temp_dir=temp_dir,
         )
 
     @staticmethod
@@ -156,6 +171,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "JSONファイルは ``$ annofabcli task_history_event download`` コマンドで取得できます。",
     )
 
+    parser.add_argument(
+        "--temp_dir",
+        type=str,
+        help="``--task_history_event_json`` を指定しなかった場合、ダウンロードしたJSONファイルの保存先ディレクトリを指定できます。指定しない場合は、一時ディレクトリに保存されます。",
+    )
+
     argument_parser.add_format(
         choices=[FormatArgument.CSV, FormatArgument.JSON, FormatArgument.PRETTY_JSON],
         default=FormatArgument.CSV,

{annofabcli-1.113.1.dist-info → annofabcli-1.114.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annofabcli
-Version: 1.113.1
+Version: 1.114.1
 Summary: Utility Command Line Interface for AnnoFab
 Author: Kurusugawa Computer Inc.
 License: MIT

{annofabcli-1.113.1.dist-info → annofabcli-1.114.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 annofabcli/__init__.py,sha256=fdBtxy5rOI8zi26jf0hmXS5KTBjQIsm2b9ZUSAIR558,319
-annofabcli/__main__.py,sha256=RetNbUDHGfmhdnVGhXUwPdMQ-jXLuzP0aTCu7-vLhXY,5400
+annofabcli/__main__.py,sha256=w3g-2v0rcR8yZwDglX2ZK3d2fZBY_RQ0VNZHGPzoAr8,5522
 annofabcli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annofabcli/annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annofabcli/annotation/annotation_query.py,sha256=iGpbg5L6sRona3ADsBfT4lyXmyEiD5i3ujYvPhiiTbM,15681
@@ -46,7 +46,7 @@ annofabcli/annotation_zip/validate_annotation.py,sha256=aiVEMi4tzTeCKbfsnVRtytEo
 annofabcli/comment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annofabcli/comment/delete_comment.py,sha256=4Fe6gQP2ZqgxCWg-ONCAp0-qLgFY3wA2p_WAQl3SdFQ,11324
 annofabcli/comment/download_comment_json.py,sha256=wB8U31G-7pkvN05N2erZch91bqx6oumGr9ziIXIyLuY,2392
-annofabcli/comment/list_all_comment.py,sha256=yBu3_FFtfnQ6VS2RUDzLKyfrP4uvn3Z25ystBCfAE58,6443
+annofabcli/comment/list_all_comment.py,sha256=K6eCARgTtERTKBDgtXAPE6blrnpPhpOSR9LPMw7ZOKY,8249
 annofabcli/comment/list_comment.py,sha256=ji9n3Mx54CelTeu0k9S0F9BUrfMQSTjafNvKRNsbTk0,6153
 annofabcli/comment/put_comment.py,sha256=PB2ODE6MGTxtOeYNv66NVEaNFEAWNGG25HDBUudjJf8,11967
 annofabcli/comment/put_comment_simply.py,sha256=-t7GiBjyBSo516M_JEqFJSwUch4SXtbKBvljv2roGjw,8125
@@ -60,7 +60,7 @@ annofabcli/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 annofabcli/common/bokeh.py,sha256=xXgWEehfFhLsLORVWNSddxOVlGwFRD1pMPEQl_4Ub1Y,1052
 annofabcli/common/cli.py,sha256=3usveVfEudPq1RLKDF6tyfwDVQ5O6hDWs34wLyl1SQI,21630
 annofabcli/common/dataclasses.py,sha256=FRDihsB-H5P5ioVE3kfJtorsS5EbSMySlHrp8BJ3ktg,385
-annofabcli/common/download.py,sha256=T3Catk_GzNJFY-rlSYI9YHr-00KI_bSg591e9ee5aIM,16960
+annofabcli/common/download.py,sha256=8fqnaaN2W-MfLAOw5JJgVSQlyw6tt6OSAZ4Hn9COtEY,18946
 annofabcli/common/enums.py,sha256=pnMZEk8ADK2qO2Hmujx6NxeCwvSAEDNhmgK4ajPSC9Q,1233
 annofabcli/common/exceptions.py,sha256=trgC5eqvy7jgqOQ41pbAOC__uxy19GgrM9NAgkH_lBw,2051
 annofabcli/common/facade.py,sha256=P1PfZ4VW2jUUB7IWUjy-Q5aHB0rB70LvOLwVxZEfNIk,19262
@@ -89,7 +89,7 @@ annofabcli/input_data/copy_input_data.py,sha256=XWvqXJLm1zi7zhLY59mP5YpY-_n8GMf9
 annofabcli/input_data/delete_input_data.py,sha256=rG5wzudBxP2czHZpFAvdBZZUnj6m1L_N3hZOfiYkktk,8611
 annofabcli/input_data/delete_metadata_key_of_input_data.py,sha256=L-fb2pz94547AHovsxAjbrWU_83bCtpP_5xn_AhC7IE,8289
 annofabcli/input_data/download_input_data_json.py,sha256=tiofL70qcYOjr0Ugl-VunbJJlXonFi5GReLQZ5VBxmo,2856
-annofabcli/input_data/list_all_input_data.py,sha256=byf6Y7uwqNf2z4wbmrbMguWz5MVt7r-nqAeKWxSYWgU,9731
+annofabcli/input_data/list_all_input_data.py,sha256=IqetKve6pGqgJxEbNKsqeb3B-qUJ0iU-g6BGeqxDPPc,11326
 annofabcli/input_data/list_all_input_data_merged_task.py,sha256=9t_A5TML_yxAExPgtfRYxleReOsxI-NWeVbDZmd3Gxg,12647
 annofabcli/input_data/list_input_data.py,sha256=LyncKIVwvaNBeVeKYdjF9hZ6SHntO8iy88VokxQbTH0,11327
 annofabcli/input_data/put_input_data.py,sha256=XW_rLKyAzqRPVT5xhg2ea8zDK1vl0fAfOKjTjzRyHUM,18944
@@ -205,8 +205,8 @@ annofabcli/task/copy_tasks.py,sha256=cOWtQAXqB1YBKatF2wGMMx9tqQ8RWL-AexrLBecqzqI
 annofabcli/task/delete_metadata_key_of_task.py,sha256=EywRT5LktrXzYM5H5I3EzbzbwdNOfaTFT0IOCPEmifQ,7962
 annofabcli/task/delete_tasks.py,sha256=221gB5gBNlZd4EOF0tkdIsbbsagx6fmPqavpnJwm2GI,13081
 annofabcli/task/download_task_json.py,sha256=_QJVNR2lsS7Nf5jTYOA1eaIbuXXbaKHff6on4rLGYOE,2879
-annofabcli/task/list_all_tasks.py,sha256=dgTn0_-f9OjQ4FYijsLc5eL8vYAK9Bb4kGraDY2ZzIs,6351
-annofabcli/task/list_all_tasks_added_task_history.py,sha256=w3nYCBxJ2nsxDDrZYBNqUWgPXS1qOB8NsZ9WkhISqqs,9552
+annofabcli/task/list_all_tasks.py,sha256=Vmby2uqslRArVRnlAKa6vWqAzUPhwd7-pSDRIRtIWyg,7714
+annofabcli/task/list_all_tasks_added_task_history.py,sha256=t2yP2sgaIgvepEErtPo8mjl8k45dbmBr_jK3YOQA01U,10314
 annofabcli/task/list_tasks.py,sha256=E4X6surGDZmAYiC7iGjLMIojZ7n2w2CJL9Ec01brXP8,10034
 annofabcli/task/list_tasks_added_task_history.py,sha256=KKXfJY-uuu5aj1vYfmFHhR_fY3YNKzF6m1UH5oA-WPA,22462
 annofabcli/task/put_tasks.py,sha256=-v6JIXX0hGjwDWTkHLnRYr60hDHRg77Y86d-dfPymoo,13641
@@ -214,18 +214,21 @@ annofabcli/task/put_tasks_by_count.py,sha256=6i7y-aH99pEDBQRWqsEQ5ESuSOL6v0SRNl3
 annofabcli/task/reject_tasks.py,sha256=lCpAfsU530O2TaYf8TbO4CeML7LoFgWwsCUCH6S_YC0,21924
 annofabcli/task/subcommand_task.py,sha256=vZIBXsHGc0203Q3yiSrQgNjov5MPSRyNLJ2qsFepVCA,2387
 annofabcli/task/update_metadata_of_task.py,sha256=Z0GF-LDt-brwgHhfz3aNYOsL4rHCf6qfzv-fzlnngOY,12817
+annofabcli/task_count/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annofabcli/task_count/list_by_phase.py,sha256=v3EZVCvh57BgbWILbadxT4luYcnXRGZ3Z08aBMN26Ek,23826
+annofabcli/task_count/subcommand_task_count.py,sha256=DDys_Qa4TxJarqSkJQB3zjQipSvGA7-WDNoN2HA-_JQ,735
 annofabcli/task_history/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annofabcli/task_history/download_task_history_json.py,sha256=mmQ0r0jGvQyeNahVeNXX8bUjOAYxP0vgBNA9Sf0QLu8,2424
-annofabcli/task_history/list_all_task_history.py,sha256=pjjLKy3Jglvi5R2x5O4TFJVtSJxiJDUtLF00tSkHltY,6680
+annofabcli/task_history/list_all_task_history.py,sha256=nfaMg9PoskjQRkoPr0nYEnLFfIawE1a7xr__u1TdBEM,7919
 annofabcli/task_history/list_task_history.py,sha256=PnIXNo8Tv8RUcoD0BX0-ZHzQybVIaYOhS6cAmPj82oM,6109
 annofabcli/task_history/subcommand_task_history.py,sha256=OECtQHEvheBuSUTHgDBH66UlW_T63zGU2m4Z_5B1e5Q,1017
 annofabcli/task_history_event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annofabcli/task_history_event/download_task_history_event_json.py,sha256=lWyOoS2ILoPNvdQxdZ5oRKVJD783_6BtVbOwbsUGVCk,2488
-annofabcli/task_history_event/list_all_task_history_event.py,sha256=M8FEeZpgIb1QK01feZRHPvAAoR6K3Ztif7GICGjZoV0,6813
+annofabcli/task_history_event/list_all_task_history_event.py,sha256=yNmvIEoNkfXXWPq9JZ3eAio82CrmELPSFg2M1yRHSzo,8017
 annofabcli/task_history_event/list_worktime.py,sha256=k6Hgy0pE2w5BtyUePN-LAyTbw0W2RMU4retwa6rC2uU,15497
 annofabcli/task_history_event/subcommand_task_history_event.py,sha256=dFllzpm8plnnwADwTV74h-R2LOA7rZW-xd2YnSkwTHo,1229
-annofabcli-1.113.1.dist-info/METADATA,sha256=Hv4z7jgkKuMPnAHF4jp-ecpL63KheapP0LR8_Gt-r0g,4949
-annofabcli-1.113.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-annofabcli-1.113.1.dist-info/entry_points.txt,sha256=C2uSUc-kkLJpoK_mDL5FEMAdorLEMPfwSf8VBMYnIFM,56
-annofabcli-1.113.1.dist-info/licenses/LICENSE,sha256=pcqWYfxFtxBzhvKp3x9MXNM4xciGb2eFewaRhXUNHlo,1081
-annofabcli-1.113.1.dist-info/RECORD,,
+annofabcli-1.114.1.dist-info/METADATA,sha256=YAxgPB0wyUWHZgC19UQm6HpQiTCnJkqzfVWe5uThbAU,4949
+annofabcli-1.114.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+annofabcli-1.114.1.dist-info/entry_points.txt,sha256=C2uSUc-kkLJpoK_mDL5FEMAdorLEMPfwSf8VBMYnIFM,56
+annofabcli-1.114.1.dist-info/licenses/LICENSE,sha256=pcqWYfxFtxBzhvKp3x9MXNM4xciGb2eFewaRhXUNHlo,1081
+annofabcli-1.114.1.dist-info/RECORD,,