annofabcli 1.106.8__tar.gz → 1.107.0__tar.gz

annofabcli-1.107.0/.github/copilot-instructions.md

@@ -0,0 +1,52 @@
+# copilot-instructions.md
+
+## プロジェクトの目的
+AnnofabのCLIです。
+
+## 開発でよく使うコマンド
+* コードのフォーマット: `make format`
+* Lintの実行: `make lint`
+* テストの実行: `make test`
+* ドキュメントの実行: `make docs`
+
+## 技術スタック
+* Python 3.9 以上
+* テストフレームワーク: Pytest v8 以上
+
+## ディレクトリ構造概要
+
+* `annofabcli/**`: アプリケーションのソースコード
+* `tests/**`: テストコード
+    * `tests/data/**`: テストコードが参照するリソース
+* `docs/*`: ドキュメント
+    * `docs/command_reference/**`: コマンドリファレンス
+
+## コーディングスタイル
+
+### Python
+* dictから値を取得する際、必須なキーならばブラケット記法を使う。キーが必須がどうか分からない場合は、必須とみなす。
+* できるだけ`os.path`でなく`pathlib.Path`を使う（Lint`flake8-use-pathlib`に従う）
+* Noneの判定、空文字列の判定、長さが0のコレクションの判定は、falsyとして判定するのでなく、`if a is not None:`のように判定内容を明記してください。
+
+### テストコード
+* Errorの確認は、`pytest.raises`を使用する。エラーメッセージの確認は行わない。
+* テストファイルは、`test_*.py`の形式で作成する。ディレクトリ構成は`src`と対応させる。
+* 一時ディレクトリを使用する場合は、`tmp_path` fixtureを利用する。
+
+### ドキュメント
+* コマンドのドキュメントは、`docs/command_reference/`に作成する。
+* コマンドの末尾には以下のように`.. argparse::`ディレクティブを追加して、`argparse`から自動生成されるUsage Detailsセクションを挿入する。
+
+```
+Usage Details
+=================================
+
+.. argparse::
+    :ref: annofabcli.comment.list_comment.add_parser
+    :prog: annofabcli comment list
+    :nosubcommands:
+    :nodefaultconst:
+```
+
+## レビュー
+* PRレビューの際は、日本語でレビューを行う

{annofabcli-1.106.8 → annofabcli-1.107.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annofabcli
-Version: 1.106.8
+Version: 1.107.0
 Summary: Utility Command Line Interface for AnnoFab
 Author: Kurusugawa Computer Inc.
 License: MIT
@@ -37,7 +37,6 @@ Description-Content-Type: text/markdown
 [Annofab](https://annofab.com/)のCLI(Command Line Interface)ツールです。
 「タスクの一括差し戻し」や、「タスク一覧出力」など、Annofabの画面で実施するには時間がかかる操作を、コマンドとして提供しています。
 
-[![Build Status](https://app.travis-ci.com/kurusugawa-computer/annofab-cli.svg?branch=main)](https://app.travis-ci.com/kurusugawa-computer/annofab-cli)
 [![PyPI version](https://badge.fury.io/py/annofabcli.svg)](https://badge.fury.io/py/annofabcli)
 [![Python Versions](https://img.shields.io/pypi/pyversions/annofabcli.svg)](https://pypi.org/project/annofabcli/)
 [![Documentation Status](https://readthedocs.org/projects/annofab-cli/badge/?version=latest)](https://annofab-cli.readthedocs.io/ja/latest/?badge=latest)

{annofabcli-1.106.8 → annofabcli-1.107.0}/README.md

@@ -2,7 +2,6 @@
 [Annofab](https://annofab.com/)のCLI(Command Line Interface)ツールです。
 「タスクの一括差し戻し」や、「タスク一覧出力」など、Annofabの画面で実施するには時間がかかる操作を、コマンドとして提供しています。
 
-[![Build Status](https://app.travis-ci.com/kurusugawa-computer/annofab-cli.svg?branch=main)](https://app.travis-ci.com/kurusugawa-computer/annofab-cli)
 [![PyPI version](https://badge.fury.io/py/annofabcli.svg)](https://badge.fury.io/py/annofabcli)
 [![Python Versions](https://img.shields.io/pypi/pyversions/annofabcli.svg)](https://pypi.org/project/annofabcli/)
 [![Documentation Status](https://readthedocs.org/projects/annofab-cli/badge/?version=latest)](https://annofab-cli.readthedocs.io/ja/latest/?badge=latest)

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/__main__.py

@@ -10,6 +10,7 @@ import pandas
 
 import annofabcli.annotation.subcommand_annotation
 import annofabcli.annotation_specs.subcommand_annotation_specs
+import annofabcli.annotation_zip.subcommand_annotation_zip
 import annofabcli.comment.subcommand_comment
 import annofabcli.common.cli
 import annofabcli.experimental.subcommand_experimental
@@ -107,6 +108,7 @@ def create_parser() -> argparse.ArgumentParser:
 
     annofabcli.annotation.subcommand_annotation.add_parser(subparsers)
     annofabcli.annotation_specs.subcommand_annotation_specs.add_parser(subparsers)
+    annofabcli.annotation_zip.subcommand_annotation_zip.add_parser(subparsers)
     annofabcli.comment.subcommand_comment.add_parser(subparsers)
     annofabcli.input_data.subcommand_input_data.add_parser(subparsers)
     annofabcli.instruction.subcommand_instruction.add_parser(subparsers)

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/annotation/annotation_query.py

@@ -270,7 +270,7 @@ class AnnotationQueryForCLI(DataClassJsonMixin):
 
     def to_query_for_api(self, annotation_specs: dict[str, Any]) -> AnnotationQueryForAPI:
         """
-        WebAPIのquery_params( https://annofab.com/docs/api/#section/AnnotationQuery )に渡すdictに変換する。
+        WebAPIのquery_params( https://annofab.com/docs/api/#tag/x-data-types/AnnotationQuery )に渡すdictに変換する。
 
         Args:
             annotation_specs: アノテーション仕様（V2,V3版）
@@ -306,7 +306,7 @@ class AnnotationQueryForCLI(DataClassJsonMixin):
 class AnnotationQueryForAPI(DataClassJsonMixin):
     """
     WebAPIでアノテーションを絞り込むためのクエリ。
-    https://annofab.com/docs/api/#section/AnnotationQuery に対応しています。
+    https://annofab.com/docs/api/#tag/x-data-types/AnnotationQuery に対応しています。
     """
 
     label_id: Optional[str] = None

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/annotation/download_annotation_zip.py

@@ -19,7 +19,7 @@ class DownloadingAnnotationZip(CommandLine):
         super().validate_project(project_id, [ProjectMemberRole.OWNER, ProjectMemberRole.TRAINING_DATA_USER])
 
         project_title = self.facade.get_project_title(project_id)
-        logger.info(f"{project_title} のアノテーションZIPをダウンロードします。")
+        logger.info(f"プロジェクト'{project_title}'のアノテーションZIPをダウンロードします。")
 
         obj = DownloadingFile(self.service)
         obj.download_annotation_zip(
@@ -28,7 +28,7 @@ class DownloadingAnnotationZip(CommandLine):
             is_latest=is_latest,
             should_download_full_annotation=should_download_full_annotation,
         )
-        logger.info(f"アノテーションZIPをダウンロードしました。output={output_zip}")
+        logger.info(f"アノテーションZIPをダウンロードして、'{output_zip}'に保存しました。")
 
     def main(self) -> None:
         args = self.args

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/annotation/import_annotation.py

@@ -419,19 +419,25 @@ class ImportAnnotationMain(CommandLineWithConfirm):
         self.is_overwrite = is_overwrite
         self.converter = converter
 
-    def put_annotation_for_input_data(self, parser: SimpleAnnotationParser) -> bool:
+    def put_annotation_for_input_data(self, parser: SimpleAnnotationParser) -> int:
+        """
+        1個の入力データに対してアノテーションを登録します。
+
+        Returns:
+            登録したアノテーションの個数
+        """
         task_id = parser.task_id
         input_data_id = parser.input_data_id
 
         simple_annotation: ImportedSimpleAnnotation = ImportedSimpleAnnotation.from_dict(parser.load_json())
         if len(simple_annotation.details) == 0:
             logger.debug(f"task_id='{task_id}', input_data_id='{input_data_id}' :: インポート元にアノテーションデータがないため、アノテーションの登録をスキップします。")
-            return False
+            return 0
 
         input_data = self.service.wrapper.get_input_data_or_none(self.project_id, input_data_id)
         if input_data is None:
             logger.warning(f"input_data_id='{input_data_id}'という入力データは存在しません。 :: task_id='{task_id}'")
-            return False
+            return 0
 
         old_annotation, _ = self.service.api.get_editor_annotation(self.project_id, task_id, input_data_id, query_params={"v": "2"})
         if len(old_annotation["details"]) > 0:  # noqa: SIM102
@@ -441,30 +447,44 @@ class ImportAnnotationMain(CommandLineWithConfirm):
                     f"インポート先のタスク内の入力データに既にアノテーションが存在するため、アノテーションの登録をスキップします。"
                     f"アノテーションをインポートする場合は、`--overwrite` または '--merge' を指定してください。"
                 )
-                return False
+                return 0
 
-        logger.info(f"task_id='{task_id}', input_data_id='{input_data_id}' :: {len(simple_annotation.details)} 件のアノテーションを登録します。")
         if self.is_merge:
             request_body = self.converter.convert_annotation_details(parser, simple_annotation.details, old_details=old_annotation["details"], updated_datetime=old_annotation["updated_datetime"])
         else:
             request_body = self.converter.convert_annotation_details(parser, simple_annotation.details, old_details=[], updated_datetime=old_annotation["updated_datetime"])
 
+        if len(request_body["details"]) == 0:
+            logger.warning(f"task_id='{task_id}', input_data_id='{input_data_id}' :: 登録できるアノテーション数が0/{len(simple_annotation.details)}件なので、アノテーションの登録をスキップします。")
+            return 0
         self.service.api.put_annotation(self.project_id, task_id, input_data_id, request_body=request_body, query_params={"v": "2"})
-        return True
+        success_annotation_count = len(request_body["details"])
+        logger.debug(f"task_id='{task_id}', input_data_id='{input_data_id}' :: {success_annotation_count}/{len(simple_annotation.details)} 件のアノテーションを登録しました。")
+        return success_annotation_count
 
-    def put_annotation_for_task(self, task_parser: SimpleAnnotationParserByTask) -> int:
-        success_count = 0
+    def put_annotation_for_task(self, task_parser: SimpleAnnotationParserByTask) -> tuple[int, int]:
+        """
+        1個のタスクに対して、アノテーションを登録します。
+
+        Returns:
+            tuple[0]: アノテーションを登録した入力データの個数
+            tuple[1]: 登録したアノテーションの個数
+        """
+        success_input_data_count = 0
+        success_annotation_count = 0
         for parser in task_parser.lazy_parse():
             try:
-                if self.put_annotation_for_input_data(parser):
-                    success_count += 1
+                tmp_success_annotation_count = self.put_annotation_for_input_data(parser)
+                if tmp_success_annotation_count > 0:
+                    success_input_data_count += 1
+                success_annotation_count += tmp_success_annotation_count
             except Exception:  # pylint: disable=broad-except
                 logger.warning(
                     f"task_id='{parser.task_id}', input_data_id='{parser.input_data_id}' のアノテーションのインポートに失敗しました。",
                     exc_info=True,
                 )
 
-        return success_count
+        return success_input_data_count, success_annotation_count
 
     def execute_task(self, task_parser: SimpleAnnotationParserByTask, task_index: Optional[int] = None) -> bool:
         """
@@ -515,8 +535,10 @@ class ImportAnnotationMain(CommandLineWithConfirm):
                 )
                 return False
 
-        result_count = self.put_annotation_for_task(task_parser)
-        logger.info(f"{logger_prefix}タスク'{task_parser.task_id}'の入力データ {result_count} 個に対してアノテーションをインポートしました。")
+        success_input_data_count, success_annotation_count = self.put_annotation_for_task(task_parser)
+        logger.info(
+            f"{logger_prefix}task_id='{task_parser.task_id}'のタスクに含まれる入力データ {success_input_data_count} 個に対して、アノテーション{success_annotation_count}個をインポートしました。"
+        )
 
         if changed_operator:
             logger.debug(f"タスク'{task_id}' の担当者を元に戻します。")
@@ -527,7 +549,7 @@ class ImportAnnotationMain(CommandLineWithConfirm):
                 last_updated_datetime=task["updated_datetime"],
             )
 
-        return result_count > 0
+        return success_input_data_count > 0
 
     def execute_task_wrapper(
         self,
@@ -617,7 +639,7 @@ class ImportAnnotation(CommandLine):
 
         if args.parallelism is not None and not args.yes:
             print(  # noqa: T201
-                f"{COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず '--yes' を指定してください。",
+                f"{COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、'--yes' を指定してください。",
                 file=sys.stderr,
             )
             return False

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/annotation/restore_annotation.py

@@ -305,7 +305,7 @@ class RestoreAnnotation(CommandLine):
     def validate(self, args: argparse.Namespace) -> bool:
         if args.parallelism is not None and not args.yes:
             print(  # noqa: T201
-                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず '--yes' を指定してください。",
+                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、'--yes' を指定してください。",
                 file=sys.stderr,
             )
             return False

annofabcli-1.107.0/annofabcli/annotation_zip/__init__.py

@@ -0,0 +1 @@
+"""アノテーションZIPに関するサブパッケージ"""

annofabcli-1.107.0/annofabcli/annotation_zip/list_annotation_bounding_box_2d.py

@@ -0,0 +1,324 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import sys
+import tempfile
+from collections.abc import Collection
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional
+
+import pandas
+from annofabapi.models import InputDataType, ProjectMemberRole
+from dataclasses_json import DataClassJsonMixin
+
+import annofabcli
+import annofabcli.common.cli
+from annofabcli.common.annofab.annotation_zip import lazy_parse_simple_annotation_by_input_data
+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.enums import FormatArgument
+from annofabcli.common.facade import (
+    AnnofabApiFacade,
+    TaskQuery,
+    match_annotation_with_task_query,
+)
+from annofabcli.common.utils import print_csv, print_json
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class AnnotationBoundingBoxInfo(DataClassJsonMixin):
+    project_id: str
+    task_id: str
+    task_status: str
+    task_phase: str
+    task_phase_stage: int
+
+    input_data_id: str
+    input_data_name: str
+
+    updated_datetime: Optional[str]
+    """アノテーションJSONに格納されているアノテーションの更新日時"""
+
+    label: str
+    annotation_id: str
+    left_top: dict[str, int]
+    right_bottom: dict[str, int]
+    width: int
+    height: int
+
+
+def get_annotation_bounding_box_info_list(simple_annotation: dict[str, Any]) -> list[AnnotationBoundingBoxInfo]:
+    result = []
+    for detail in simple_annotation["details"]:
+        if detail["data"]["_type"] == "BoundingBox":
+            left_top = detail["data"]["left_top"]
+            right_bottom = detail["data"]["right_bottom"]
+            width = abs(right_bottom["x"] - left_top["x"])
+            height = abs(right_bottom["y"] - left_top["y"])
+
+            result.append(
+                AnnotationBoundingBoxInfo(
+                    project_id=simple_annotation["project_id"],
+                    task_id=simple_annotation["task_id"],
+                    task_phase=simple_annotation["task_phase"],
+                    task_phase_stage=simple_annotation["task_phase_stage"],
+                    task_status=simple_annotation["task_status"],
+                    input_data_id=simple_annotation["input_data_id"],
+                    input_data_name=simple_annotation["input_data_name"],
+                    label=detail["label"],
+                    annotation_id=detail["annotation_id"],
+                    left_top=left_top,
+                    right_bottom=right_bottom,
+                    width=width,
+                    height=height,
+                    updated_datetime=simple_annotation["updated_datetime"],
+                )
+            )
+
+    return result
+
+
+def get_annotation_bounding_box_info_list_from_annotation_path(
+    annotation_path: Path,
+    *,
+    target_task_ids: Optional[Collection[str]] = None,
+    task_query: Optional[TaskQuery] = None,
+) -> list[AnnotationBoundingBoxInfo]:
+    annotation_bbox_list = []
+    target_task_ids = set(target_task_ids) if target_task_ids is not None else None
+    iter_parser = lazy_parse_simple_annotation_by_input_data(annotation_path)
+    logger.info(f"アノテーションZIPまたはディレクトリ'{annotation_path}'を読み込みます。")
+    for index, parser in enumerate(iter_parser):
+        if (index + 1) % 10000 == 0:
+            logger.info(f"{index + 1}  件目のJSONを読み込み中")
+        if target_task_ids is not None and parser.task_id not in target_task_ids:
+            continue
+        dict_simple_annotation = parser.load_json()
+        if task_query is not None and not match_annotation_with_task_query(dict_simple_annotation, task_query):
+            continue
+        sub_annotation_bbox_list = get_annotation_bounding_box_info_list(dict_simple_annotation)
+        annotation_bbox_list.extend(sub_annotation_bbox_list)
+    return annotation_bbox_list
+
+
+def create_df(
+    annotation_bbox_list: list[AnnotationBoundingBoxInfo],
+) -> pandas.DataFrame:
+    columns = [
+        "project_id",
+        "task_id",
+        "task_status",
+        "task_phase",
+        "task_phase_stage",
+        "input_data_id",
+        "input_data_name",
+        "updated_datetime",
+        "label",
+        "annotation_id",
+        "left_top.x",
+        "left_top.y",
+        "right_bottom.x",
+        "right_bottom.y",
+        "width",
+        "height",
+    ]
+    if len(annotation_bbox_list) > 0:
+        df = pandas.DataFrame(
+            [
+                {
+                    "project_id": e.project_id,
+                    "task_id": e.task_id,
+                    "task_status": e.task_status,
+                    "task_phase": e.task_phase,
+                    "task_phase_stage": e.task_phase_stage,
+                    "input_data_id": e.input_data_id,
+                    "input_data_name": e.input_data_name,
+                    "updated_datetime": e.updated_datetime,
+                    "label": e.label,
+                    "annotation_id": e.annotation_id,
+                    "left_top.x": e.left_top["x"],
+                    "left_top.y": e.left_top["y"],
+                    "right_bottom.x": e.right_bottom["x"],
+                    "right_bottom.y": e.right_bottom["y"],
+                    "width": e.width,
+                    "height": e.height,
+                }
+                for e in annotation_bbox_list
+            ]
+        )
+    else:
+        df = pandas.DataFrame(columns=columns)
+
+    return df[columns]
+
+
+def print_annotation_bounding_box(
+    annotation_path: Path,
+    output_file: Path,
+    output_format: FormatArgument,
+    *,
+    target_task_ids: Optional[Collection[str]] = None,
+    task_query: Optional[TaskQuery] = None,
+) -> None:
+    annotation_bbox_list = get_annotation_bounding_box_info_list_from_annotation_path(
+        annotation_path,
+        target_task_ids=target_task_ids,
+        task_query=task_query,
+    )
+
+    logger.info(f"{len(annotation_bbox_list)} 件のバウンディングボックスアノテーションの情報を出力します。 :: output='{output_file}'")
+
+    if output_format == FormatArgument.CSV:
+        df = create_df(annotation_bbox_list)
+        print_csv(df, output_file)
+
+    elif output_format in [FormatArgument.PRETTY_JSON, FormatArgument.JSON]:
+        json_is_pretty = output_format == FormatArgument.PRETTY_JSON
+        # DataClassJsonMixinを使用したtoJSON処理
+        print_json(
+            [e.to_dict(encode_json=True) for e in annotation_bbox_list],
+            is_pretty=json_is_pretty,
+            output=output_file,
+        )
+
+    else:
+        raise ValueError(f"出力形式 '{output_format}' はサポートされていません。")
+
+
+class ListAnnotationBoundingBox2d(CommandLine):
+    COMMON_MESSAGE = "annofabcli annotation_zip list_annotation_bounding_box_2d: error:"
+
+    def validate(self, args: argparse.Namespace) -> bool:
+        if args.project_id is None and args.annotation is None:
+            print(  # noqa: T201
+                f"{self.COMMON_MESSAGE} argument --project_id: '--annotation'が未指定のときは、'--project_id' を指定してください。",
+                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)
+
+        project_id: Optional[str] = args.project_id
+        if project_id is not None:
+            super().validate_project(project_id, project_member_roles=[ProjectMemberRole.OWNER, ProjectMemberRole.TRAINING_DATA_USER])
+            project, _ = self.service.api.get_project(project_id)
+            if project["input_data_type"] != InputDataType.IMAGE.value:
+                print(f"project_id='{project_id}'であるプロジェクトは画像プロジェクトでないので、終了します", file=sys.stderr)  # noqa: T201
+                sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+        annotation_path = Path(args.annotation) if args.annotation is not None else None
+
+        task_id_list = annofabcli.common.cli.get_list_from_args(args.task_id) if args.task_id is not None else None
+        task_query = TaskQuery.from_dict(annofabcli.common.cli.get_json_from_args(args.task_query)) if args.task_query is not None else None
+
+        output_file: Path = args.output
+        output_format = FormatArgument(args.format)
+
+        downloading_obj = DownloadingFile(self.service)
+
+        def download_and_print_annotation_bbox(project_id: str, temp_dir: Path, *, is_latest: bool) -> None:
+            annotation_path = temp_dir / f"{project_id}__annotation.zip"
+            downloading_obj.download_annotation_zip(
+                project_id,
+                dest_path=annotation_path,
+                is_latest=is_latest,
+            )
+            print_annotation_bounding_box(
+                annotation_path,
+                output_file,
+                output_format,
+                target_task_ids=task_id_list,
+                task_query=task_query,
+            )
+
+        if project_id is not None:
+            if args.temp_dir is not None:
+                download_and_print_annotation_bbox(project_id=project_id, temp_dir=args.temp_dir, is_latest=args.latest)
+            else:
+                with tempfile.TemporaryDirectory() as str_temp_dir:
+                    download_and_print_annotation_bbox(
+                        project_id=project_id,
+                        temp_dir=Path(str_temp_dir),
+                        is_latest=args.latest,
+                    )
+        else:
+            assert annotation_path is not None
+            print_annotation_bounding_box(
+                annotation_path,
+                output_file,
+                output_format,
+                target_task_ids=task_id_list,
+                task_query=task_query,
+            )
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    argument_parser = ArgumentParser(parser)
+
+    group = parser.add_mutually_exclusive_group(required=True)
+    group.add_argument(
+        "--annotation",
+        type=str,
+        help="アノテーションzip、またはzipを展開したディレクトリを指定します。",
+    )
+
+    group.add_argument("-p", "--project_id", type=str, help="project_id。アノテーションZIPをダウンロードします。")
+
+    argument_parser.add_format(
+        choices=[FormatArgument.CSV, FormatArgument.JSON, FormatArgument.PRETTY_JSON],
+        default=FormatArgument.CSV,
+    )
+
+    argument_parser.add_output()
+
+    parser.add_argument(
+        "-tq",
+        "--task_query",
+        type=str,
+        help="集計対象タスクを絞り込むためのクエリ条件をJSON形式で指定します。使用できるキーは task_id, status, phase, phase_stage です。"
+        " ``file://`` を先頭に付けると、JSON形式のファイルを指定できます。",
+    )
+    argument_parser.add_task_id(required=False)
+
+    parser.add_argument(
+        "--latest",
+        action="store_true",
+        help="``--annotation`` を指定しないとき、最新のアノテーションzipを参照します。このオプションを指定すると、アノテーションzipを更新するのに数分待ちます。",
+    )
+
+    parser.add_argument(
+        "--temp_dir",
+        type=Path,
+        help="指定したディレクトリに、アノテーションZIPなどの一時ファイルをダウンロードします。",
+    )
+
+    parser.set_defaults(subcommand_func=main)
+
+
+def main(args: argparse.Namespace) -> None:
+    service = build_annofabapi_resource_and_login(args)
+    facade = AnnofabApiFacade(service)
+    ListAnnotationBoundingBox2d(service, facade, args).main()
+
+
+def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
+    subcommand_name = "list_annotation_bounding_box_2d"
+    subcommand_help = "アノテーションZIPからバウンディングボックス（矩形）アノテーションの座標情報を出力します。"
+    epilog = "アノテーションZIPをダウンロードする場合は、オーナロールまたはアノテーションユーザロールを持つユーザで実行してください。"
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, description=subcommand_help, epilog=epilog)
+    parse_args(parser)
+    return parser

annofabcli-1.107.0/annofabcli/annotation_zip/subcommand_annotation_zip.py

@@ -0,0 +1,35 @@
+"""サブコマンド annotation_zip"""
+
+import argparse
+from typing import Optional
+
+import annofabcli
+from annofabcli.annotation_zip.list_annotation_bounding_box_2d import add_parser as add_parser_list_annotation_bounding_box_2d
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    """
+    サブコマンドの引数を定義する
+    Args:
+        parser: パーサー
+    """
+    subparsers = parser.add_subparsers(dest="subcommand_name")
+
+    # サブコマンドの定義
+    add_parser_list_annotation_bounding_box_2d(subparsers)
+
+
+def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
+    """
+    annotation_zipサブコマンドを追加する。
+    Args:
+        subparsers: 親パーサーのサブパーサー
+    Returns:
+        annotation_zipサブコマンドのパーサー
+    """
+    subcommand_name = "annotation_zip"
+    subcommand_help = "アノテーションZIPに対する操作を行うサブコマンド"
+
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, is_subcommand=False)
+    parse_args(parser)
+    return parser

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/comment/delete_comment.py

@@ -206,7 +206,7 @@ class DeleteComment(CommandLine):
     def validate(self, args: argparse.Namespace) -> bool:
         if args.parallelism is not None and not args.yes:
             print(  # noqa: T201
-                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず '--yes' を指定してください。",
+                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、'--yes' を指定してください。",
                 file=sys.stderr,
             )
             return False
@@ -254,7 +254,7 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "--parallelism",
         type=int,
         choices=PARALLELISM_CHOICES,
-        help="使用するプロセス数（並列度）を指定してください。指定する場合は必ず '--yes' を指定してください。指定しない場合は、逐次的に処理します。",
+        help="使用するプロセス数（並列度）を指定してください。指定する場合は'--yes' を指定してください。指定しない場合は、逐次的に処理します。",
     )
 
     parser.set_defaults(subcommand_func=main)

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/comment/put_inspection_comment.py

@@ -29,7 +29,7 @@ class PutInspectionComment(CommandLine):
     def validate(self, args: argparse.Namespace) -> bool:
         if args.parallelism is not None and not args.yes:
             print(  # noqa: T201
-                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず '--yes' を指定してください。",
+                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、'--yes' を指定してください。",
                 file=sys.stderr,
             )
             return False

{annofabcli-1.106.8 → annofabcli-1.107.0}/annofabcli/comment/put_inspection_comment_simply.py

@@ -29,7 +29,7 @@ class PutInspectionCommentSimply(CommandLine):
     def validate(self, args: argparse.Namespace) -> bool:
         if args.parallelism is not None and not args.yes:
             print(  # noqa: T201
-                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、必ず '--yes' を指定してください。",
+                f"{self.COMMON_MESSAGE} argument --parallelism: '--parallelism'を指定するときは、'--yes' を指定してください。",
                 file=sys.stderr,
             )
             return False