annofabcli 1.114.5__py3-none-any.whl → 1.114.7__py3-none-any.whl

annofabcli/comment/put_comment.py

@@ -9,6 +9,7 @@ from typing import Any
 import annofabapi
 import requests
 from annofabapi.models import CommentType, TaskPhase, TaskStatus
+from annofabapi.pydantic_models.input_data_type import InputDataType
 from dataclasses_json import DataClassJsonMixin
 
 from annofabcli.comment.utils import get_comment_type_name
@@ -18,6 +19,18 @@ from annofabcli.common.type_util import assert_noreturn
 
 logger = logging.getLogger(__name__)
 
+SUPPORTED_ANNOTATION_TYPES_FOR_INSPECTION_DATA = frozenset(
+    [
+        "user_bounding_box",
+        "bounding_box",
+        "polygon",
+        "polyline",
+        "point",
+        "range",
+    ]
+)
+"""検査コメントの座標情報（InspectionData形式）への変換をサポートしているアノテーションタイプ"""
+
 
 @dataclass
 class AddedComment(DataClassJsonMixin):
@@ -28,15 +41,18 @@ class AddedComment(DataClassJsonMixin):
     comment: str
     """コメントの中身"""
 
-    data: dict[str, Any] | None
+    data: dict[str, Any] | None = None
     """コメントを付与する位置や区間"""
 
-    annotation_id: str | None
+    annotation_id: str | None = None
     """コメントに紐付けるアノテーションID"""
 
-    phrases: list[str] | None
+    phrases: list[str] | None = None
     """参照している定型指摘ID"""
 
+    comment_id: str | None = None
+    """コメントID。省略時はUUIDv4が自動生成される。"""
+
 
 AddedCommentsForTask = dict[str, list[AddedComment]]
 """
@@ -51,6 +67,71 @@ keyはtask_id
 """
 
 
+def convert_annotation_body_to_inspection_data(  # noqa: PLR0911
+    annotation_body: dict[str, Any],
+    annotation_type: str,
+    input_data_type: InputDataType,
+) -> dict[str, Any]:
+    """
+    アノテーションのbody部分を、検査コメントの座標情報（`InspectionData`形式）に変換する。
+
+    Args:
+        annotation_body: Annotationの座標情報。AnnotationDetailContentOutputのdict形式
+        annotation_type: アノテーションタイプ。`SUPPORTED_ANNOTATION_TYPES_FOR_INSPECTION_DATA`のいずれかを指定すること。
+        input_data_type: プロジェクトの入力データタイプ。
+
+    Returns:
+        検査コメントの座標情報（`InspectionData`形式）
+    """
+    match input_data_type:
+        case InputDataType.MOVIE:
+            match annotation_type:
+                case "range":
+                    # 区間の開始位置をTime形式に変換
+                    return {"start": annotation_body["data"]["begin"], "end": annotation_body["data"]["end"], "_type": "Time"}
+                case _:
+                    # "Classification"など、Time形式以外のアノテーションタイプ
+                    return {"start": 0, "end": 100, "_type": "Time"}
+
+        case InputDataType.CUSTOM:
+            match annotation_type:
+                case "user_bounding_box":
+                    # 3次元バウンディングボックスの場合、data.dataの文字列をパースして返す
+                    return {"data": annotation_body["data"]["data"], "_type": "Custom"}
+                case _:
+                    # セグメントなど
+                    return {
+                        "data": '{"kind": "CUBOID", "shape": {"dimensions": {"width": 1.0, "height": 1.0, "depth": 1.0}, "location": {"x": 0.0, "y": 0.0, "z": 0.0}, "rotation": {"x": 0.0, "y": 0.0, "z": 0.0}, "direction": {"front": {"x": 1.0, "y": 0.0, "z": 0.0}, "up": {"x": 0.0, "y": 0.0, "z": 1.0}}}, "version": "2"}',  # noqa: E501
+                        "_type": "Custom",
+                    }
+
+        case InputDataType.IMAGE:
+            match annotation_type:
+                case "bounding_box":
+                    # 中心点を計算
+                    left_top = annotation_body["data"]["left_top"]
+                    right_bottom = annotation_body["data"]["right_bottom"]
+                    center_x = (left_top["x"] + right_bottom["x"]) / 2
+                    center_y = (left_top["y"] + right_bottom["y"]) / 2
+                    return {"x": center_x, "y": center_y, "_type": "Point"}
+                case "polygon" | "polyline":
+                    # 先頭の点を取得
+                    points = annotation_body["data"]["points"]
+                    assert len(points) > 0
+                    first_point = points[0]
+                    return {"x": first_point["x"], "y": first_point["y"], "_type": "Point"}
+                case "point":
+                    # 点の形式に変換（pointキーから取り出す）
+                    point = annotation_body["data"]["point"]
+                    return {"x": point["x"], "y": point["y"], "_type": "Point"}
+                case "range":
+                    # 区間の開始位置をTime形式に変換
+                    return {"start": annotation_body["data"]["begin"], "end": annotation_body["data"]["end"], "_type": "Time"}
+                case _:
+                    # 塗りつぶしや分類など
+                    return {"x": 0, "y": 0, "_type": "Point"}
+
+
 class PutCommentMain(CommandLineWithConfirm):
     def __init__(self, service: annofabapi.Resource, project_id: str, comment_type: CommentType, all_yes: bool = False) -> None:  # noqa: FBT001, FBT002
         self.service = service
@@ -60,30 +141,68 @@ class PutCommentMain(CommandLineWithConfirm):
         self.comment_type = comment_type
         self.comment_type_name = get_comment_type_name(comment_type)
 
+        # プロジェクト情報を取得
+        project, _ = self.service.api.get_project(self.project_id)
+        self.input_data_type = InputDataType(project["input_data_type"])
+
+        # アノテーション仕様を取得
+        annotation_specs, _ = self.service.api.get_annotation_specs(self.project_id, query_params={"v": "3"})
+        self.dict_label_id_annotation_type = {label["label_id"]: label["annotation_type"] for label in annotation_specs["labels"]}
+
         CommandLineWithConfirm.__init__(self, all_yes)
 
     def _create_request_body(self, task: dict[str, Any], input_data_id: str, comments: list[AddedComment]) -> list[dict[str, Any]]:
         """batch_update_comments に渡すリクエストボディを作成する。"""
+        task_id = task["task_id"]
+
+        # annotation_idが指定されているがdataがNoneのコメントがあるか確認
+        need_annotation_data = any(c.annotation_id is not None and c.data is None for c in comments)
+
+        dict_annotation_id_label_id: dict[str, str] = {}
+        dict_annotation_id_data: dict[str, dict[str, Any]] = {}
 
-        def _create_dict_annotation_id() -> dict[str, str]:
-            content, _ = self.service.api.get_editor_annotation(self.project_id, task["task_id"], input_data_id, query_params={"v": "2"})
-            details = content["details"]
-            return {e["annotation_id"]: e["label_id"] for e in details}
+        if need_annotation_data:
+            # アノテーション詳細を取得
+            editor_annotation, _ = self.service.api.get_editor_annotation(self.project_id, task_id, input_data_id, query_params={"v": "2"})
+            details = editor_annotation["details"]
 
-        dict_annotation_id_label_id = _create_dict_annotation_id()
+            for detail in details:
+                annotation_id = detail["annotation_id"]
+                label_id = detail["label_id"]
+                dict_annotation_id_label_id[annotation_id] = label_id
+
+                # annotation_typeを取得
+                if label_id in self.dict_label_id_annotation_type:
+                    # アノテーション仕様に存在しないラベルを使っているアノテーション（アノテーションを作成してから仕様を変更した場合）もあるので、判定する
+                    annotation_type = self.dict_label_id_annotation_type[label_id]
+                    dict_annotation_id_data[annotation_id] = convert_annotation_body_to_inspection_data(detail["body"], annotation_type, input_data_type=self.input_data_type)
+        else:
+            # annotation_idからlabel_idを取得するためだけにAPIを呼ぶ
+            editor_annotation, _ = self.service.api.get_editor_annotation(self.project_id, task_id, input_data_id, query_params={"v": "2"})
+            details = editor_annotation["details"]
+            dict_annotation_id_label_id = {e["annotation_id"]: e["label_id"] for e in details}
 
-        def _convert(comment: AddedComment) -> dict[str, Any]:
+        def _convert(comment: AddedComment) -> dict[str, Any] | None:
+            data = comment.data
+            annotation_id = comment.annotation_id
+
+            # dataがNoneでannotation_idが指定されている場合、dataを補完
+            if data is None:
+                assert annotation_id is not None
+                data = dict_annotation_id_data[annotation_id]
+
+            assert data is not None
             return {
-                "comment_id": str(uuid.uuid4()),
+                "comment_id": comment.comment_id if comment.comment_id is not None else str(uuid.uuid4()),
                 "phase": task["phase"],
                 "phase_stage": task["phase_stage"],
                 "account_id": self.service.api.account_id,
                 "comment_type": self.comment_type.value,
                 "comment": comment.comment,
                 "comment_node": {
-                    "data": comment.data,
-                    "annotation_id": comment.annotation_id,
-                    "label_id": dict_annotation_id_label_id.get(comment.annotation_id) if comment.annotation_id is not None else None,
+                    "data": data,
+                    "annotation_id": annotation_id,
+                    "label_id": dict_annotation_id_label_id.get(annotation_id) if annotation_id is not None else None,
                     "status": "open",
                     "_type": "Root",
                 },
@@ -91,7 +210,8 @@ class PutCommentMain(CommandLineWithConfirm):
                 "_type": "Put",
             }
 
-        return [_convert(e) for e in comments]
+        converted_comments = [_convert(e) for e in comments]
+        return [c for c in converted_comments if c is not None]
 
     def change_to_working_status(self, project_id: str, task: dict[str, Any]) -> dict[str, Any]:
         """
@@ -129,8 +249,8 @@ class PutCommentMain(CommandLineWithConfirm):
                 logger.warning(f"task_id='{task_id}' :: フェーズが検査/受入でないため検査コメントを付与できません。 :: task_phase='{task['phase']}'")
                 return False
 
-        if task["status"] not in [TaskStatus.NOT_STARTED.value, TaskStatus.WORKING.value, TaskStatus.BREAK.value]:
-            logger.warning(f"task_id='{task_id}' :: タスクの状態が未着手,作業中,休憩中 以外の状態なので、コメントを付与できません。 :: task_status='{task['status']}'")
+        if task["status"] not in [TaskStatus.NOT_STARTED.value, TaskStatus.BREAK.value]:
+            logger.warning(f"task_id='{task_id}' :: タスクの状態が未着手,休憩中 以外の状態なので、コメントを付与できません。 :: task_status='{task['status']}'")
             return False
         return True
 
@@ -139,7 +259,7 @@ class PutCommentMain(CommandLineWithConfirm):
         task_id: str,
         comments_for_task: AddedCommentsForTask,
         task_index: int | None = None,
-    ) -> int:
+    ) -> tuple[int, int]:
         """
         タスクにコメントを付与します。
 
@@ -149,28 +269,29 @@ class PutCommentMain(CommandLineWithConfirm):
             task_index: タスクの連番
 
         Returns:
-            コメントを付与した入力データの個数
+            (コメントを付与した入力データの個数, 付与したコメントの個数)のタプル
         """
         logging_prefix = f"{task_index + 1} 件目" if task_index is not None else ""
 
         task = self.service.wrapper.get_task_or_none(self.project_id, task_id)
         if task is None:
             logger.warning(f"{logging_prefix} :: task_id='{task_id}' のタスクは存在しないので、スキップします。")
-            return 0
+            return (0, 0)
 
         logger.debug(f"{logging_prefix} : task_id='{task['task_id']}', status='{task['status']}', phase='{task['phase']}'")
 
         if not self._can_add_comment(
             task=task,
         ):
-            return 0
+            return (0, 0)
 
         if not self.confirm_processing(f"task_id='{task_id}' のタスクに{self.comment_type_name}を付与しますか？"):
-            return 0
+            return (0, 0)
 
         # コメントを付与するには作業中状態にする必要がある
         changed_task = self.change_to_working_status(self.project_id, task)
-        added_comments_count = 0
+        added_input_data_count = 0
+        added_comment_count = 0
         for input_data_id, comments in comments_for_task.items():
             if input_data_id not in task["input_data_id_list"]:
                 logger.warning(f"{logging_prefix} :: task_id='{task_id}'のタスクに input_data_id='{input_data_id}'の入力データは存在しません。")
@@ -180,7 +301,8 @@ class PutCommentMain(CommandLineWithConfirm):
                 if len(comments) > 0:
                     request_body = self._create_request_body(task=changed_task, input_data_id=input_data_id, comments=comments)
                     self.service.api.batch_update_comments(self.project_id, task_id, input_data_id, request_body=request_body)
-                    added_comments_count += 1
+                    added_input_data_count += 1
+                    added_comment_count += len(comments)
                     logger.debug(f"{logging_prefix} :: task_id='{task_id}', input_data_id='{input_data_id}' :: {len(comments)}件のコメントを付与しました。")
             except Exception:  # pylint: disable=broad-except
                 logger.warning(
@@ -194,12 +316,12 @@ class PutCommentMain(CommandLineWithConfirm):
             self.service.wrapper.change_task_operator(self.project_id, task_id, task["account_id"])
             logger.debug(f"{logging_prefix} :: task_id='{task_id}' :: 担当者を元のユーザ( account_id='{task['account_id']}'）に戻しました。")
 
-        return added_comments_count
+        return (added_input_data_count, added_comment_count)
 
     def add_comments_for_task_wrapper(
         self,
         tpl: tuple[int, tuple[str, AddedCommentsForTask]],
-    ) -> int:
+    ) -> tuple[int, int]:
         task_index, (task_id, comments_for_task) = tpl
         return self.add_comments_for_task(task_id=task_id, comments_for_task=comments_for_task, task_index=task_index)
 
@@ -208,30 +330,45 @@ class PutCommentMain(CommandLineWithConfirm):
         comments_for_task_list: AddedComments,
         parallelism: int | None = None,
     ) -> None:
-        comments_count = sum(len(e) for e in comments_for_task_list.values())
-        logger.info(f"{self.comment_type_name}を付与するタスク数: {len(comments_for_task_list)}, {self.comment_type_name}を付与する入力データ数: {comments_count}")
+        tasks_count = len(comments_for_task_list)
+        input_data_count = sum(len(e) for e in comments_for_task_list.values())
+        total_comment_count = sum(len(comments) for comments_for_task in comments_for_task_list.values() for comments in comments_for_task.values())
+        logger.info(
+            f"{self.comment_type_name}を付与するタスク数: {tasks_count}, {self.comment_type_name}を付与する入力データ数: {input_data_count}, {self.comment_type_name}の総数: {total_comment_count}"
+        )
 
         if parallelism is not None:
             with multiprocessing.Pool(parallelism) as pool:
-                result_bool_list = pool.map(self.add_comments_for_task_wrapper, enumerate(comments_for_task_list.items()))
-                added_comments_count = sum(e for e in result_bool_list)
+                result_list = pool.map(self.add_comments_for_task_wrapper, enumerate(comments_for_task_list.items()))
+                added_input_data_count = sum(e[0] for e in result_list)
+                added_comment_count = sum(e[1] for e in result_list)
+                succeeded_tasks_count = sum(1 for e in result_list if e[0] > 0)
 
         else:
             # 逐次処理
-            added_comments_count = 0
+            added_input_data_count = 0
+            added_comment_count = 0
+            succeeded_tasks_count = 0
             for task_index, (task_id, comments_for_task) in enumerate(comments_for_task_list.items()):
                 try:
-                    result = self.add_comments_for_task(
+                    result_input_data, result_comment = self.add_comments_for_task(
                         task_id=task_id,
                         comments_for_task=comments_for_task,
                         task_index=task_index,
                     )
-                    added_comments_count += result
+                    added_input_data_count += result_input_data
+                    added_comment_count += result_comment
+                    if result_input_data > 0:
+                        succeeded_tasks_count += 1
                 except Exception:  # pylint: disable=broad-except
                     logger.warning(f"task_id='{task_id}' :: コメントの付与に失敗しました。", exc_info=True)
                     continue
 
-        logger.info(f"{added_comments_count} / {comments_count} 件の入力データに{self.comment_type_name}を付与しました。")
+        logger.info(
+            f"{succeeded_tasks_count} / {tasks_count} 件のタスク, "
+            f"{added_input_data_count} / {input_data_count} 件の入力データ, "
+            f"{added_comment_count} / {total_comment_count} 件の{self.comment_type_name}を付与しました。"
+        )
 
 
 def convert_cli_comments(dict_comments: dict[str, Any], *, comment_type: CommentType) -> AddedComments:
@@ -248,7 +385,7 @@ def convert_cli_comments(dict_comments: dict[str, Any], *, comment_type: Comment
         comment: str
         """コメントの中身"""
 
-        data: dict[str, Any]
+        data: dict[str, Any] | None = None
         """コメントを付与する位置や区間"""
 
         annotation_id: str | None = None
@@ -257,6 +394,9 @@ def convert_cli_comments(dict_comments: dict[str, Any], *, comment_type: Comment
         phrases: list[str] | None = None
         """参照している定型指摘ID"""
 
+        comment_id: str | None = None
+        """コメントID。省略時はUUIDv4が自動生成される。"""
+
     @dataclass
     class AddedOnholdComment(DataClassJsonMixin):
         """
@@ -269,13 +409,16 @@ def convert_cli_comments(dict_comments: dict[str, Any], *, comment_type: Comment
         annotation_id: str | None = None
         """コメントに紐付けるアノテーションID"""
 
+        comment_id: str | None = None
+        """コメントID。省略時はUUIDv4が自動生成される。"""
+
     def convert_inspection_comment(comment: dict[str, Any]) -> AddedComment:
         tmp = AddedInspectionComment.from_dict(comment)
-        return AddedComment(comment=tmp.comment, data=tmp.data, annotation_id=tmp.annotation_id, phrases=tmp.phrases)
+        return AddedComment(comment=tmp.comment, data=tmp.data, annotation_id=tmp.annotation_id, phrases=tmp.phrases, comment_id=tmp.comment_id)
 
     def convert_onhold_comment(comment: dict[str, Any]) -> AddedComment:
         tmp = AddedOnholdComment.from_dict(comment)
-        return AddedComment(comment=tmp.comment, annotation_id=tmp.annotation_id, data=None, phrases=None)
+        return AddedComment(comment=tmp.comment, annotation_id=tmp.annotation_id, data=None, phrases=None, comment_id=tmp.comment_id)
 
     if comment_type == CommentType.INSPECTION:
         func_convert = convert_inspection_comment

annofabcli/comment/put_comment_simply.py

@@ -31,6 +31,9 @@ class AddedSimpleComment:
     phrases: list[str] | None = None
     """参照している定型指摘ID"""
 
+    comment_id: str | None = None
+    """コメントID。省略時はUUIDv4が自動生成される。"""
+
 
 class PutCommentSimplyMain(CommandLineWithConfirm):
     def __init__(self, service: annofabapi.Resource, project_id: str, comment_type: CommentType, all_yes: bool = False) -> None:  # noqa: FBT001, FBT002
@@ -49,7 +52,7 @@ class PutCommentSimplyMain(CommandLineWithConfirm):
         def _convert(comment: AddedSimpleComment) -> dict[str, Any]:
             return {
                 "comment": comment.comment,
-                "comment_id": str(uuid.uuid4()),
+                "comment_id": comment.comment_id if comment.comment_id is not None else str(uuid.uuid4()),
                 "phase": task["phase"],
                 "phase_stage": task["phase_stage"],
                 "comment_type": self.comment_type.value,
@@ -90,11 +93,11 @@ class PutCommentSimplyMain(CommandLineWithConfirm):
 
         if self.comment_type == CommentType.INSPECTION:  # noqa: SIM102
             if task["phase"] == TaskPhase.ANNOTATION.value:
-                logger.warning(f"task_id='{task_id}': 教師付フェーズなので、検査コメントを付与できません。")
+                logger.warning(f"task_id='{task_id}' :: フェーズが検査/受入でないため検査コメントを付与できません。 :: task_phase='{task['phase']}'")
                 return False
 
-        if task["status"] not in [TaskStatus.NOT_STARTED.value, TaskStatus.WORKING.value, TaskStatus.BREAK.value]:
-            logger.warning(f"task_id='{task_id}' : タスクの状態が未着手,作業中,休憩中 以外の状態なので、コメントを付与できません。（task_status='{task['status']}'）")
+        if task["status"] not in [TaskStatus.NOT_STARTED.value, TaskStatus.BREAK.value]:
+            logger.warning(f"task_id='{task_id}' :: タスクの状態が未着手,休憩中 以外の状態なので、コメントを付与できません。 :: task_status='{task['status']}'")
             return False
         return True
 

annofabcli/comment/put_inspection_comment.py

@@ -68,7 +68,11 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--json",
         type=str,
-        help=(f"付与する検査コメントの内容をJSON形式で指定してください。``file://`` を先頭に付けると、JSON形式のファイルを指定できます。\n\n(ex)  ``{json.dumps(SAMPLE_JSON, ensure_ascii=False)}``"),
+        help=(
+            f"付与する検査コメントの内容をJSON形式で指定してください。``file://`` を先頭に付けると、JSON形式のファイルを指定できます。\n\n"
+            f"各コメントには ``comment_id`` を指定することができます。省略した場合は自動的にUUIDv4が生成されます。\n\n"
+            f"(ex)  ``{json.dumps(SAMPLE_JSON, ensure_ascii=False)}``"
+        ),
     )
 
     parser.add_argument(

annofabcli/comment/put_onhold_comment.py

@@ -69,7 +69,11 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument(
         "--json",
         type=str,
-        help=(f"付与する保留コメントの情報をJSON形式で指定してください。``file://`` を先頭に付けると、JSON形式のファイルを指定できます。\n\n(ex)  ``{json.dumps(SAMPLE_JSON, ensure_ascii=False)}``"),
+        help=(
+            f"付与する保留コメントの情報をJSON形式で指定してください。``file://`` を先頭に付けると、JSON形式のファイルを指定できます。\n\n"
+            f"各コメントには ``comment_id`` を指定することができます。省略した場合は自動的にUUIDv4が生成されます。\n\n"
+            f"(ex)  ``{json.dumps(SAMPLE_JSON, ensure_ascii=False)}``"
+        ),
     )
 
     parser.add_argument(

annofabcli/filesystem/draw_annotation.py

@@ -182,7 +182,7 @@ class DrawingAnnotationForOneImage:
                 image.save(output_file)
 
         elif image_size is not None:
-            image = Image.new("RGBA", image_size, color="black")
+            image = Image.new("RGBA", image_size, color="black")  # type: ignore[assignment]
             draw = ImageDraw.Draw(image)
             self._draw_annotations(draw, parser)
             output_file.parent.mkdir(parents=True, exist_ok=True)

annofabcli/input_data/list_all_input_data_merged_task.py

@@ -38,9 +38,9 @@ def _create_dict_tasks_by_input_data_id(task_list: list[dict[str, Any]]) -> dict
         for input_data_index, input_data_id in enumerate(task["input_data_id_list"]):
             new_task = {
                 "task_id": task["task_id"],
-                "task_status": task["status"],
                 "task_phase": task["phase"],
                 "task_phase_stage": task["phase_stage"],
+                "task_status": task["status"],
                 "frame_no": input_data_index + 1,
             }
             result[input_data_id].append(new_task)
@@ -70,7 +70,7 @@ def create_df_input_data_with_merged_task(input_data_list: list[dict[str, Any]])
     """
 
     def get_columns(columns: pandas.Index) -> list[str]:
-        task_columns = ["task_id", "task_status", "task_phase", "task_phase_stage", "frame_no"]
+        task_columns = ["task_id", "task_phase", "task_phase_stage", "task_status", "frame_no"]
         new_columns = columns.drop(task_columns)
         return list(new_columns) + task_columns
 
@@ -93,7 +93,7 @@ def create_df_input_data_with_merged_task(input_data_list: list[dict[str, Any]])
     # ネストしたオブジェクトを`system_metadata.input_duration`のような列名でアクセスできるようにするため
     df_input_data = pandas.json_normalize(new_input_data_list)
 
-    for column in ["task_id", "task_status", "task_phase", "task_phase_stage", "frame_no"]:
+    for column in ["task_id", "task_phase", "task_phase_stage", "task_status", "frame_no"]:
         if column not in df_input_data.columns:
             df_input_data[column] = pandas.NA
 

annofabcli/instruction/copy_instruction.py

@@ -31,7 +31,7 @@ class CopyInstruction(CommandLine):
     @staticmethod
     def get_instruction_image_id_from_url(url: str) -> str:
         # URL Queryを除いたURLを取得する
-        url_without_query = url.split("?")[0]
+        url_without_query = url.split("?", maxsplit=1)[0]
         return url_without_query.split("/")[-1]
 
     @staticmethod

annofabcli/statistics/histogram.py

@@ -34,7 +34,7 @@ def get_bin_edges(min_value: float, max_value: float, bin_width: float) -> numpy
     # stop引数に、`bin_width*2`を指定している理由：
     # 引数が小数のときは`len(bin_edges)``期待通りにならないときがあるので、ビンの数を少し増やしている
     # https://qiita.com/yuji38kwmt/items/ff00f3cb9083567d083f
-    bin_edges = numpy.arange(start=min_value, stop=max_value + bin_width * 2, step=bin_width)
+    bin_edges = numpy.arange(start=min_value, stop=max_value + bin_width * 2, step=bin_width)  # type: ignore[call-overload]
     return bin_edges
 
 

annofabcli/statistics/list_annotation_count.py

@@ -573,9 +573,9 @@ class AttributeCountCsv:
             basic_columns = [
                 ("project_id", "", ""),
                 ("task_id", "", ""),
-                ("task_status", "", ""),
                 ("task_phase", "", ""),
                 ("task_phase_stage", "", ""),
+                ("task_status", "", ""),
                 ("input_data_count", "", ""),
                 ("annotation_count", "", ""),
             ]
@@ -622,9 +622,9 @@ class AttributeCountCsv:
             basic_columns = [
                 ("project_id", "", ""),
                 ("task_id", "", ""),
-                ("task_status", "", ""),
                 ("task_phase", "", ""),
                 ("task_phase_stage", "", ""),
+                ("task_status", "", ""),
                 ("input_data_id", "", ""),
                 ("input_data_name", "", ""),
                 ("frame_no", "", ""),
@@ -708,9 +708,9 @@ class LabelCountCsv:
             basic_columns = [
                 "project_id",
                 "task_id",
-                "task_status",
                 "task_phase",
                 "task_phase_stage",
+                "task_status",
                 "input_data_count",
                 "annotation_count",
             ]
@@ -757,9 +757,9 @@ class LabelCountCsv:
             basic_columns = [
                 "project_id",
                 "task_id",
-                "task_status",
                 "task_phase",
                 "task_phase_stage",
+                "task_status",
                 "input_data_id",
                 "input_data_name",
                 "frame_no",

annofabcli/statistics/list_annotation_duration.py

@@ -109,9 +109,9 @@ class AnnotationDuration(DataClassJsonMixin):
 
     project_id: str
     task_id: str
-    task_status: TaskStatus
     task_phase: TaskPhase
     task_phase_stage: int
+    task_status: TaskStatus
 
     input_data_id: str
     input_data_name: str

annofabcli/statistics/list_video_duration.py

@@ -37,7 +37,7 @@ def get_video_duration_list(task_list: list[dict[str, Any]], input_data_list: li
     result = []
     for task in task_list:
         task_id = task["task_id"]
-        elm = {"project_id": task["project_id"], "task_id": task_id, "task_status": task["status"], "task_phase": task["phase"], "task_phase_stage": task["phase_stage"]}
+        elm = {"project_id": task["project_id"], "task_id": task_id, "task_phase": task["phase"], "task_phase_stage": task["phase_stage"], "task_status": task["status"]}
         input_data_id_list = task["input_data_id_list"]
         assert len(input_data_id_list) == 1, f"task_id='{task_id}'には複数の入力データが含まれています。"
         input_data_id = input_data_id_list[0]

annofabcli/task/change_operator.py

@@ -88,7 +88,7 @@ class ChangeOperatorMain:
 
         if task.status == TaskStatus.ON_HOLD and not self.include_on_hold:
             logger.warning(
-                f"{logging_prefix} :: task_id='{task_id}' :: タスクが保留中状態なので、担当者を変更できません。保留中状態のタスクの担当者も変更する場合は、'--include_on_hold'を指定してください。"
+                f"{logging_prefix} :: task_id='{task_id}' :: タスクが保留中状態なので、担当者を変更できません。保留中状態のタスクの担当者も変更する場合は、'--include_on_hold_task'を指定してください。"
             )
             return False
 
@@ -222,7 +222,7 @@ class ChangeOperator(CommandLine):
         project_id = args.project_id
         super().validate_project(project_id, [ProjectMemberRole.OWNER, ProjectMemberRole.ACCEPTER])
 
-        main_obj = ChangeOperatorMain(self.service, all_yes=self.all_yes, include_on_hold=args.include_on_hold)
+        main_obj = ChangeOperatorMain(self.service, all_yes=self.all_yes, include_on_hold=args.include_on_hold_task)
         main_obj.change_operator(
             project_id,
             task_id_list=task_id_list,
@@ -253,7 +253,7 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
     argument_parser.add_task_query()
 
     parser.add_argument(
-        "--include_on_hold",
+        "--include_on_hold_task",
         action="store_true",
         help="指定した場合、保留中のタスクの担当者も変更します。指定しない場合、保留中のタスクはスキップされます。",
     )

annofabcli/task/complete_tasks.py

@@ -179,9 +179,11 @@ class CompleteTasksMain(CommandLineWithConfirm):
             # 教師付フェーズになった日時より、後に付与された返信コメントを取得する
             answered_comment = first_true(
                 comment_list,
-                pred=lambda e: e["comment_node"]["_type"] == "Reply"
-                and e["comment_node"]["root_comment_id"] == parent_comment_id
-                and dateutil.parser.parse(e["created_datetime"]) >= dateutil.parser.parse(task_started_datetime),
+                pred=lambda e: (
+                    e["comment_node"]["_type"] == "Reply"
+                    and e["comment_node"]["root_comment_id"] == parent_comment_id
+                    and dateutil.parser.parse(e["created_datetime"]) >= dateutil.parser.parse(task_started_datetime)
+                ),
             )
             return answered_comment is not None
 

{annofabcli-1.114.5.dist-info → annofabcli-1.114.7.dist-info}/METADATA

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