annofabcli 1.99.0__tar.gz → 100.2__tar.gz

{annofabcli-1.99.0 → annofabcli-100.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: annofabcli
-Version: 1.99.0
+Version: 100.2
 Summary: Utility Command Line Interface for AnnoFab
 Home-page: https://github.com/kurusugawa-computer/annofab-cli
 License: MIT

annofabcli-100.2/annofabcli/__version__.py

@@ -0,0 +1 @@
+__version__ = "100.2"  # `poetry-dynamic-versioning`を使ってGitHubのバージョンタグを取得している。変更不要

{annofabcli-1.99.0 → annofabcli-100.2}/annofabcli/annotation/change_annotation_attributes.py

@@ -138,12 +138,12 @@ class ChangeAnnotationAttributesMain(CommandLineWithConfirm):
 
         task: Task = Task.from_dict(dict_task)
         if task.status == TaskStatus.WORKING:
-            logger.warning(f"task_id={task_id}: タスクが作業中状態のため、スキップします。")
+            logger.warning(f"task_id='{task_id}': タスクが作業中状態のため、スキップします。")
             return False
 
         if not self.is_force:  # noqa: SIM102
             if task.status == TaskStatus.COMPLETE:
-                logger.warning(f"task_id={task_id}: タスクが完了状態のため、スキップします。")
+                logger.warning(f"task_id='{task_id}': タスクが完了状態のため、スキップします。")
                 return False
 
         annotation_list = self.get_annotation_list_for_task(task_id, annotation_query)

annofabcli-100.2/annofabcli/annotation_specs/add_attribute_restriction.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import logging
+import sys
+from typing import Any, Optional
+
+import annofabapi
+
+import annofabcli
+import annofabcli.common.cli
+from annofabcli.annotation_specs.attribute_restriction import AttributeRestrictionMessage, OutputFormat
+from annofabcli.common.cli import (
+    COMMAND_LINE_ERROR_STATUS_CODE,
+    CommandLine,
+    CommandLineWithConfirm,
+    build_annofabapi_resource_and_login,
+    get_json_from_args,
+)
+from annofabcli.common.facade import AnnofabApiFacade
+
+logger = logging.getLogger(__name__)
+
+
+def create_comment_from_restriction_text(restriction_text_list: list[str]) -> str:
+    """
+    属性制約のテキストから、アノテーション仕様変更時のコメントを生成する
+    """
+    return "以下の属性制約を追加しました。\n" + "\n".join(restriction_text_list)
+
+
+class AddAttributeRestrictionMain(CommandLineWithConfirm):
+    def __init__(
+        self,
+        service: annofabapi.Resource,
+        *,
+        project_id: str,
+        all_yes: bool,
+    ) -> None:
+        self.service = service
+        CommandLineWithConfirm.__init__(self, all_yes)
+        self.project_id = project_id
+
+    def add_restrictions(self, restrictions: list[dict[str, Any]], comment: Optional[str] = None) -> bool:
+        old_annotation_specs, _ = self.service.api.get_annotation_specs(self.project_id, query_params={"v": "3"})
+        old_restrictions = old_annotation_specs["restrictions"]
+
+        msg_obj = AttributeRestrictionMessage(
+            labels=old_annotation_specs["labels"],
+            additionals=old_annotation_specs["additionals"],
+            output_format=OutputFormat.TEXT,
+            raise_if_not_found=True,
+        )
+
+        new_restrictions = []
+        new_restriction_text_list = []
+        for index, restriction in enumerate(restrictions):
+            try:
+                restriction_text = msg_obj.get_restriction_text(restriction["additional_data_definition_id"], restriction["condition"])
+            except ValueError as e:
+                logger.warning(
+                    f"{index + 1}件目 :: 次の属性制約は存在しないIDが含まれていたため、アノテーション仕様に追加しません。 :: "
+                    f"restriction=`{restriction}`, error_message=`{e!s}`"
+                )
+                continue
+
+            if restriction in old_restrictions:
+                logger.warning(f"{index + 1}件目 :: 次の属性制約は既に存在するため、アノテーション仕様に追加しません。  :: `{restriction_text}`")
+                continue
+
+            if not self.confirm_processing(f"次の属性制約を追加しますか？ :: `{restriction_text}`"):
+                continue
+
+            logger.debug(f"{index + 1}件目 :: 次の属性制約を追加します。 :: `{restriction_text}`")
+            new_restrictions.append(restriction)
+            new_restriction_text_list.append(restriction_text)
+
+        if len(new_restrictions) == 0:
+            logger.info("追加する属性制約はないため、アノテーション仕様を変更しません。")
+            return False
+
+        if not self.confirm_processing(f"{len(new_restrictions)} 件の属性制約を追加して、アノテーション仕様を変更します。よろしいですか？ "):
+            return False
+
+        request_body = copy.deepcopy(old_annotation_specs)
+        request_body["restrictions"].extend(restrictions)
+        if comment is None:
+            comment = create_comment_from_restriction_text(new_restriction_text_list)
+        request_body["comment"] = comment
+        request_body["last_updated_datetime"] = old_annotation_specs["updated_datetime"]
+        self.service.api.put_annotation_specs(self.project_id, query_params={"v": "3"}, request_body=request_body)
+        logger.info(f"{len(new_restrictions)} 件の属性制約をアノテーション仕様に追加しました。")
+        return True
+
+
+class AddAttributeRestriction(CommandLine):
+    COMMON_MESSAGE = "annofabcli annotation_specs add_restriction: error:"
+
+    def get_history_id_from_before_index(self, project_id: str, before: int) -> Optional[str]:
+        histories, _ = self.service.api.get_annotation_specs_histories(project_id)
+        if before + 1 > len(histories):
+            logger.warning(f"アノテーション仕様の履歴は{len(histories)}個のため、最新より{before}個前のアノテーション仕様は見つかりませんでした。")
+            return None
+        history = histories[-(before + 1)]
+        return history["history_id"]
+
+    def main(self) -> None:
+        args = self.args
+
+        restrictions = get_json_from_args(args.json)
+        if not isinstance(restrictions, list):
+            print(f"{self.COMMON_MESSAGE}: error: JSON形式が不正です。オブジェクトの配列を指定してください。", file=sys.stderr)  # noqa: T201
+            sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
+
+        obj = AddAttributeRestrictionMain(self.service, project_id=args.project_id, all_yes=args.yes)
+        obj.add_restrictions(restrictions, comment=args.comment)
+
+
+def parse_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("-p", "--project_id", help="対象のプロジェクトのproject_idを指定します。", required=True)
+
+    sample_json = [
+        {
+            "additional_data_definition_id": "a1",
+            "condition": {"value": "true", "_type": "Equals"},
+        }
+    ]
+    parser.add_argument(
+        "--json",
+        type=str,
+        required=True,
+        help="追加する属性の制約情報のJSONを指定します。"
+        "JSON形式は ... を参照してください。\n"
+        f"(例) ``{json.dumps(sample_json)}``\n"
+        "``file://`` を先頭に付けるとjsonファイルを指定できます。",
+    )
+
+    parser.add_argument("--comment", type=str, help="アノテーション仕様の変更時に指定できるコメント。未指定の場合、自動でコメントが生成されます。")
+
+    parser.set_defaults(subcommand_func=main)
+
+
+def main(args: argparse.Namespace) -> None:
+    service = build_annofabapi_resource_and_login(args)
+    facade = AnnofabApiFacade(service)
+    AddAttributeRestriction(service, facade, args).main()
+
+
+def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
+    subcommand_name = "add_attribute_restriction"
+
+    subcommand_help = "アノテーション仕様に属性の制約を追加します。"
+    description = subcommand_help + "アノテーション仕様画面では設定できない「属性間の制約」を追加するときに有用です。"
+    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help, description=description)
+    parse_args(parser)
+    return parser

annofabcli-1.99.0/annofabcli/annotation_specs/list_attribute_restriction.py → annofabcli-100.2/annofabcli/annotation_specs/attribute_restriction.py

@@ -1,31 +1,16 @@
-from __future__ import annotations
-
-import argparse
-import json
 import logging
-import sys
 from collections.abc import Collection
 from enum import Enum
-from pathlib import Path
 from typing import Any, Optional
 
 from more_itertools import first_true
 
-import annofabcli
-import annofabcli.common.cli
-from annofabcli.common.cli import (
-    COMMAND_LINE_ERROR_STATUS_CODE,
-    ArgumentParser,
-    CommandLine,
-    build_annofabapi_resource_and_login,
-    get_list_from_args,
-)
 from annofabcli.common.facade import AnnofabApiFacade
 
 logger = logging.getLogger(__name__)
 
 
-class FormatArgument(Enum):
+class OutputFormat(Enum):
     """
     表示するフォーマット ``--format`` で指定できる値
 
@@ -38,13 +23,17 @@ class FormatArgument(Enum):
     DETAILED_TEXT = "detailed_text"
 
 
-class ListAttributeRestrictionMain:
+class AttributeRestrictionMessage:
     """
-    アノテーション仕様の制約から自然言語で書かれたメッセージを生成します。
+    アノテーション仕様の属性制約情報から、自然言語で書かれたメッセージを生成する
 
     Args:
         labels: アノテーション仕様のラベル情報
         additionals: アノテーション仕様の属性情報
+        raise_if_not_found: 属性やラベルが見つからなかった場合に例外を発生させるかどうか
+        format: 属性制約の表示フォーマット
+            - `text`: 属性IDを隠したシンプルなテキスト
+            - `detailed_text`: 属性IDなどの詳細情報を表示したテキスト
 
     """
 
@@ -52,20 +41,29 @@ class ListAttributeRestrictionMain:
         self,
         labels: list[dict[str, Any]],
         additionals: list[dict[str, Any]],
-        format: FormatArgument = FormatArgument.DETAILED_TEXT,  # noqa: A002 # pylint: disable=redefined-builtin
+        *,
+        raise_if_not_found: bool = False,
+        output_format: OutputFormat = OutputFormat.DETAILED_TEXT,  # pylint: disable=redefined-builtin
     ) -> None:
         self.attribute_dict = {e["additional_data_definition_id"]: e for e in additionals}
         self.label_dict = {e["label_id"]: e for e in labels}
-        self.format = format
+        self.output_format = output_format
+        self.raise_if_not_found = raise_if_not_found
 
     def get_labels_text(self, label_ids: Collection[str]) -> str:
         label_message_list = []
         for label_id in label_ids:
             label = self.label_dict.get(label_id)
-            label_name = AnnofabApiFacade.get_label_name_en(label) if label is not None else ""
+            if label is not None:
+                label_name = AnnofabApiFacade.get_label_name_en(label)
+            else:
+                logger.warning(f"ラベルIDが'{label_id}'であるラベルは存在しません。")
+                if self.raise_if_not_found:
+                    raise ValueError(f"ラベルIDが'{label_id}'であるラベルは存在しません。")
+                label_name = ""
 
             label_message = f"'{label_name}'"
-            if self.format == FormatArgument.DETAILED_TEXT:
+            if self.output_format == OutputFormat.DETAILED_TEXT:
                 label_message = f"{label_message} (id='{label_id}')"
             label_message_list.append(label_message)
 
@@ -89,11 +87,19 @@ class ListAttributeRestrictionMain:
             if choice is not None:
                 choice_name = AnnofabApiFacade.get_choice_name_en(choice)
                 tmp = f"'{value}'"
-                if self.format == FormatArgument.DETAILED_TEXT:
+                if self.output_format == OutputFormat.DETAILED_TEXT:
                     tmp = f"{tmp} (name='{choice_name}')"
                 return tmp
 
             else:
+                message = (
+                    f"選択肢IDが'{value}'である選択肢は存在しません。 :: "
+                    f"属性名='{AnnofabApiFacade.get_additional_data_definition_name_en(attribute)}', "
+                    f"属性ID='{attribute['additional_data_definition_id']}'"
+                )
+                logger.warning(message)
+                if self.raise_if_not_found:
+                    raise ValueError(message)
                 return f"'{value}'"
         else:
             return f"'{value}'"
@@ -120,12 +126,15 @@ class ListAttributeRestrictionMain:
         attribute = self.attribute_dict.get(attribute_id)
         if attribute is not None:
             subject = f"'{AnnofabApiFacade.get_additional_data_definition_name_en(attribute)}'"
-            if self.format == FormatArgument.DETAILED_TEXT:
+            if self.output_format == OutputFormat.DETAILED_TEXT:
                 subject = f"{subject} (id='{attribute_id}', type='{attribute['type']}')"
         else:
-            logger.warning(f"属性IDが'{attribute_id}'の属性は存在しません。")
+            logger.warning(f"属性IDが'{attribute_id}'である属性は存在しません。")
+            if self.raise_if_not_found:
+                raise ValueError(f"属性IDが'{attribute_id}'である属性は存在しません。")
+
             subject = "''"
-            if self.format == FormatArgument.DETAILED_TEXT:
+            if self.output_format == OutputFormat.DETAILED_TEXT:
                 subject = f"{subject} (id='{attribute_id}')"
 
         if str_type == "CanInput":
@@ -152,7 +161,7 @@ class ListAttributeRestrictionMain:
             verb = "DOES NOT MATCH"
             str_object = f"'{condition['value']}'"
         else:
-            raise RuntimeError(f"{str_type=}はサポートしていません。")
+            raise ValueError(f"condition._type='{str_type}'はサポートしていません。")
 
         tmp = f"{subject} {verb}"
         if str_object != "":
@@ -212,6 +221,14 @@ class ListAttributeRestrictionMain:
         target_attribute_names: Optional[Collection[str]] = None,
         target_label_names: Optional[Collection[str]] = None,
     ) -> list[str]:
+        """
+        複数の属性制約から自然言語で記載されたメッセージのlistを返します。
+
+        Args:
+            restrictions: 属性制約のリスト
+            target_attribute_names: 取得対象のラベル名（英語）のlist
+            target_label_names: 取得対象の属性名（英語）のlist
+        """
         if target_attribute_names is not None or target_label_names is not None:
             target_attribute_ids = self.get_target_attribute_ids(target_attribute_names=target_attribute_names, target_label_names=target_label_names)
             return [
@@ -221,130 +238,3 @@ class ListAttributeRestrictionMain:
             ]
         else:
             return [self.get_restriction_text(e["additional_data_definition_id"], e["condition"]) for e in restrictions]
-
-
-class ListAttributeRestriction(CommandLine):
-    COMMON_MESSAGE = "annofabcli annotation_specs list_restriction: error:"
-
-    def get_history_id_from_before_index(self, project_id: str, before: int) -> Optional[str]:
-        histories, _ = self.service.api.get_annotation_specs_histories(project_id)
-        if before + 1 > len(histories):
-            logger.warning(f"アノテーション仕様の履歴は{len(histories)}個のため、最新より{before}個前のアノテーション仕様は見つかりませんでした。")
-            return None
-        history = histories[-(before + 1)]
-        return history["history_id"]
-
-    def main(self) -> None:
-        args = self.args
-
-        if args.project_id is not None:
-            history_id = None
-            if args.history_id is not None:
-                history_id = args.history_id
-
-            if args.before is not None:
-                history_id = self.get_history_id_from_before_index(args.project_id, args.before)
-                if history_id is None:
-                    print(  # noqa: T201
-                        f"{self.COMMON_MESSAGE} argument --before: 最新より{args.before}個前のアノテーション仕様は見つかりませんでした。",
-                        file=sys.stderr,
-                    )
-                    sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
-
-            query_params = {"v": "3"}
-            if history_id is not None:
-                query_params["history_id"] = history_id
-
-            annotation_specs, _ = self.service.api.get_annotation_specs(args.project_id, query_params=query_params)
-        elif args.annotation_json_path is not None:
-            with args.annotation_json_path.open() as f:
-                annotation_specs = json.load(f)
-
-        else:
-            raise RuntimeError("'--project_id'か'--annotation_specs_json'のどちらかを指定する必要があります。")
-
-        main_obj = ListAttributeRestrictionMain(
-            labels=annotation_specs["labels"],
-            additionals=annotation_specs["additionals"],
-            format=FormatArgument(args.format),
-        )
-        target_attribute_names = get_list_from_args(args.attribute_name) if args.attribute_name is not None else None
-        target_label_names = get_list_from_args(args.label_name) if args.label_name is not None else None
-        restriction_text_list = main_obj.get_restriction_text_list(
-            annotation_specs["restrictions"],
-            target_attribute_names=target_attribute_names,
-            target_label_names=target_label_names,
-        )
-
-        annofabcli.common.utils.output_string("\n".join(restriction_text_list), args.output)
-
-
-def parse_args(parser: argparse.ArgumentParser) -> None:
-    argument_parser = ArgumentParser(parser)
-
-    required_group = parser.add_mutually_exclusive_group(required=True)
-    required_group.add_argument(
-        "-p", "--project_id", help="対象のプロジェクトのproject_idを指定します。APIで取得したアノテーション仕様情報を元に出力します。"
-    )
-    required_group.add_argument(
-        "--annotation_specs_json",
-        type=Path,
-        help="指定したアノテーション仕様のJSONファイルを指定します。"
-        "JSONファイルに記載された情報を元に出力します。ただしアノテーション仕様の ``format_version`` は ``3`` である必要があります。",
-    )
-
-    # 過去のアノテーション仕様を参照するためのオプション
-    old_annotation_specs_group = parser.add_mutually_exclusive_group()
-    old_annotation_specs_group.add_argument(
-        "--history_id",
-        type=str,
-        help=(
-            "出力したいアノテーション仕様のhistory_idを指定してください。 "
-            "history_idは ``annotation_specs list_history`` コマンドで確認できます。 "
-            "指定しない場合は、最新のアノテーション仕様が出力されます。 "
-        ),
-    )
-
-    old_annotation_specs_group.add_argument(
-        "--before",
-        type=int,
-        help=(
-            "出力したい過去のアノテーション仕様が、最新よりいくつ前のアノテーション仕様であるかを指定してください。  "
-            "たとえば ``1`` を指定した場合、最新より1個前のアノテーション仕様を出力します。 "
-            "指定しない場合は、最新のアノテーション仕様が出力されます。 "
-        ),
-    )
-
-    parser.add_argument("--attribute_name", type=str, nargs="+", help="指定した属性名（英語）の属性の制約を出力します。")
-    parser.add_argument("--label_name", type=str, nargs="+", help="指定したラベル名（英語）のラベルに紐づく属性の制約を出力します。")
-    argument_parser.add_output()
-
-    parser.add_argument(
-        "-f",
-        "--format",
-        type=str,
-        choices=[e.value for e in FormatArgument],
-        default=FormatArgument.TEXT.value,
-        help=f"出力フォーマット\n"
-        "\n"
-        f"* {FormatArgument.TEXT.value}: 英語名のみ出力する形式\n"
-        f"* {FormatArgument.DETAILED_TEXT.value}: 属性IDや属性種類などの詳細情報を出力する形式\n",
-    )
-
-    parser.set_defaults(subcommand_func=main)
-
-
-def main(args: argparse.Namespace) -> None:
-    service = build_annofabapi_resource_and_login(args)
-    facade = AnnofabApiFacade(service)
-    ListAttributeRestriction(service, facade, args).main()
-
-
-def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
-    subcommand_name = "list_attribute_restriction"
-
-    subcommand_help = "アノテーション仕様の属性の制約情報を出力します。"
-
-    parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help)
-    parse_args(parser)
-    return parser

{annofabcli-1.99.0 → annofabcli-100.2}/annofabcli/annotation_specs/list_annotation_specs_attribute.py

@@ -16,6 +16,7 @@ from dataclasses_json import DataClassJsonMixin
 
 import annofabcli
 import annofabcli.common.cli
+from annofabcli.common.annofab.annotation_specs import keybind_to_text
 from annofabcli.common.cli import (
     COMMAND_LINE_ERROR_STATUS_CODE,
     ArgumentParser,
@@ -24,15 +25,16 @@ from annofabcli.common.cli import (
 )
 from annofabcli.common.enums import FormatArgument
 from annofabcli.common.facade import AnnofabApiFacade
-from annofabcli.common.utils import print_csv
+from annofabcli.common.utils import print_according_to_format, print_csv
 
 logger = logging.getLogger(__name__)
 
 
 @dataclass
-class AttributeForCsv(DataClassJsonMixin):
+class FlattenAttribute(DataClassJsonMixin):
     """
-    CSV用の属性情報を格納するクラスです。
+    ネストされていないフラットな属性情報を格納するクラスです。
+    選択肢の一覧などは格納できません。
     """
 
     attribute_id: str
@@ -45,7 +47,7 @@ class AttributeForCsv(DataClassJsonMixin):
     attribute_name_en: Optional[str]
     attribute_name_ja: Optional[str]
     attribute_name_vi: Optional[str]
-    type: str
+    attribute_type: str
     """属性の種類"""
     default: Optional[Union[str, bool, int]]
     """デフォルト値"""
@@ -60,6 +62,7 @@ class AttributeForCsv(DataClassJsonMixin):
     """制約の個数"""
     reference_label_count: int
     """参照されているラベルの個数"""
+    keybind: Optional[str]
 
 
 def create_relationship_between_attribute_and_label(labels_v3: list[dict[str, Any]]) -> dict[str, set[str]]:
@@ -78,11 +81,11 @@ def create_relationship_between_attribute_and_label(labels_v3: list[dict[str, An
     return result
 
 
-def create_df_from_additionals(
+def create_flatten_attribute_list_from_additionals(
     additionals_v3: list[dict[str, Any]], labels_v3: list[dict[str, Any]], restrictions: list[dict[str, Any]]
-) -> pandas.DataFrame:
+) -> list[FlattenAttribute]:
     """
-    APIから取得した属性情報（v3版）から、pandas.DataFrameを生成します。
+    APIから取得した属性情報（v3版）から、属性情報の一覧を生成します。
 
     Args:
         additionals_v3: APIから取得した属性情報（v3版）
@@ -98,52 +101,60 @@ def create_df_from_additionals(
     # keyが属性ID、valueが属性に紐づくラベルのIDのsetであるdict
     dict_label_ids = create_relationship_between_attribute_and_label(labels_v3)
 
-    def dict_additional_to_dataclass(additional: dict[str, Any]) -> AttributeForCsv:
+    def dict_additional_to_dataclass(additional: dict[str, Any]) -> FlattenAttribute:
         """
         辞書の属性情報をDataClassのラベル情報に変換します。
         """
         attribute_id = additional["additional_data_definition_id"]
         additional_name = additional["name"]
-        return AttributeForCsv(
+        return FlattenAttribute(
             attribute_id=attribute_id,
             attribute_name_en=get_message_with_lang(additional_name, lang=Lang.EN_US),
             attribute_name_ja=get_message_with_lang(additional_name, lang=Lang.JA_JP),
             attribute_name_vi=get_message_with_lang(additional_name, lang=Lang.VI_VN),
-            type=additional["type"],
+            attribute_type=additional["type"],
             default=additional["default"],
             read_only=additional["read_only"],
             choice_count=len(additional["choices"]),
             restriction_count=dict_restriction_count[attribute_id],
             reference_label_count=len(dict_label_ids[attribute_id]),
+            keybind=keybind_to_text(additional["keybind"]),
         )
 
-    new_labels = [dict_additional_to_dataclass(e) for e in additionals_v3]
-
-    columns = [
-        "attribute_id",
-        "attribute_name_en",
-        "attribute_name_ja",
-        "attribute_name_vi",
-        "type",
-        "default",
-        "read_only",
-        "choice_count",
-        "restriction_count",
-        "reference_label_count",
-    ]
-
-    df = pandas.DataFrame(new_labels, columns=columns)
-    return df
+    return [dict_additional_to_dataclass(e) for e in additionals_v3]
 
 
 class PrintAnnotationSpecsAttribute(CommandLine):
     COMMON_MESSAGE = "annofabcli annotation_specs list_attribute: error:"
 
-    def print_annotation_specs_attribute(self, annotation_specs_v3: dict[str, Any], arg_format: str, output: Optional[str] = None) -> None:
-        if arg_format == FormatArgument.CSV.value:
-            df = create_df_from_additionals(annotation_specs_v3["additionals"], annotation_specs_v3["labels"], annotation_specs_v3["restrictions"])
+    def print_annotation_specs_attribute(
+        self, annotation_specs_v3: dict[str, Any], output_format: FormatArgument, output: Optional[str] = None
+    ) -> None:
+        attribute_list = create_flatten_attribute_list_from_additionals(
+            annotation_specs_v3["additionals"], annotation_specs_v3["labels"], annotation_specs_v3["restrictions"]
+        )
+        logger.info(f"{len(attribute_list)} 件の属性情報を出力します。")
+        if output_format == FormatArgument.CSV:
+            columns = [
+                "attribute_id",
+                "attribute_name_en",
+                "attribute_name_ja",
+                "attribute_name_vi",
+                "type",
+                "default",
+                "read_only",
+                "choice_count",
+                "restriction_count",
+                "reference_label_count",
+                "keybind",
+            ]
+
+            df = pandas.DataFrame(attribute_list, columns=columns)
             print_csv(df, output)
 
+        elif output_format in [FormatArgument.JSON, FormatArgument.PRETTY_JSON]:
+            print_according_to_format([e.to_dict() for e in attribute_list], format=output_format, output=output)
+
     def get_history_id_from_before_index(self, project_id: str, before: int) -> Optional[str]:
         histories, _ = self.service.api.get_annotation_specs_histories(project_id)
         if before + 1 > len(histories):
@@ -177,7 +188,7 @@ class PrintAnnotationSpecsAttribute(CommandLine):
         else:
             raise RuntimeError("'--project_id'か'--annotation_specs_json'のどちらかを指定する必要があります。")
 
-        self.print_annotation_specs_attribute(annotation_specs, arg_format=args.format, output=args.output)
+        self.print_annotation_specs_attribute(annotation_specs, output_format=FormatArgument(args.format), output=args.output)
 
 
 def parse_args(parser: argparse.ArgumentParser) -> None:
@@ -216,7 +227,14 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         ),
     )
 
-    parser.add_argument("-f", "--format", type=str, choices=[FormatArgument.CSV.value], default=FormatArgument.CSV.value, help="出力フォーマット ")
+    parser.add_argument(
+        "-f",
+        "--format",
+        type=str,
+        choices=[FormatArgument.CSV.value, FormatArgument.JSON.value, FormatArgument.PRETTY_JSON.value],
+        default=FormatArgument.CSV.value,
+        help="出力フォーマット ",
+    )
 
     argument_parser.add_output()
 
@@ -232,7 +250,7 @@ def main(args: argparse.Namespace) -> None:
 def add_parser(subparsers: Optional[argparse._SubParsersAction] = None) -> argparse.ArgumentParser:
     subcommand_name = "list_attribute"
 
-    subcommand_help = "アノテーション仕様の属性情報を出力する"
+    subcommand_help = "アノテーション仕様の属性情報を出力します。"
 
     parser = annofabcli.common.cli.add_parser(subparsers, subcommand_name, subcommand_help)
     parse_args(parser)