annofabcli 1.99.0__py3-none-any.whl → 100.2__py3-none-any.whl

annofabcli/__version__.py

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

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/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/annotation_specs/attribute_restriction.py

@@ -0,0 +1,240 @@
+import logging
+from collections.abc import Collection
+from enum import Enum
+from typing import Any, Optional
+
+from more_itertools import first_true
+
+from annofabcli.common.facade import AnnofabApiFacade
+
+logger = logging.getLogger(__name__)
+
+
+class OutputFormat(Enum):
+    """
+    表示するフォーマット ``--format`` で指定できる値
+
+    Attributes:
+        TEXT: 属性IDや種類を隠したシンプルなテキスト
+        DETAILED_TEXT: 属性IDや属性種類などの詳細情報を表示したテキスト
+    """
+
+    TEXT = "text"
+    DETAILED_TEXT = "detailed_text"
+
+
+class AttributeRestrictionMessage:
+    """
+    アノテーション仕様の属性制約情報から、自然言語で書かれたメッセージを生成する
+
+    Args:
+        labels: アノテーション仕様のラベル情報
+        additionals: アノテーション仕様の属性情報
+        raise_if_not_found: 属性やラベルが見つからなかった場合に例外を発生させるかどうか
+        format: 属性制約の表示フォーマット
+            - `text`: 属性IDを隠したシンプルなテキスト
+            - `detailed_text`: 属性IDなどの詳細情報を表示したテキスト
+
+    """
+
+    def __init__(
+        self,
+        labels: list[dict[str, Any]],
+        additionals: list[dict[str, Any]],
+        *,
+        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.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)
+            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.output_format == OutputFormat.DETAILED_TEXT:
+                label_message = f"{label_message} (id='{label_id}')"
+            label_message_list.append(label_message)
+
+        return ", ".join(label_message_list)
+
+    def get_object_for_equals_or_notequals(self, value: str, attribute: Optional[dict[str, Any]]) -> str:
+        """制約条件が `Equals` or `NotEquals`のときの目的語を生成する。
+        属性の種類がドロップダウンかセレクトボックスのときは、選択肢の名前を返す。
+
+        Args:
+            value (str): _description_
+            attribute (Optional[dict[str,Any]]): _description_
+
+        Returns:
+            str: _description_
+        """
+        if attribute is not None and attribute["type"] in ["choice", "select"]:
+            # ラジオボタンかドロップダウンのとき
+            choices = attribute["choices"]
+            choice = first_true(choices, pred=lambda e: e["choice_id"] == value)
+            if choice is not None:
+                choice_name = AnnofabApiFacade.get_choice_name_en(choice)
+                tmp = f"'{value}'"
+                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}'"
+
+    def get_restriction_text(self, attribute_id: str, condition: dict[str, Any]) -> str:  # noqa: PLR0912
+        """制約情報のテキストを返します。
+
+        Args:
+            attribute_id (str): 属性ID
+            condition (dict[str, Any]): 制約条件
+
+        Returns:
+            str: 制約を表す文
+        """
+        str_type = condition["_type"]
+
+        if str_type == "Imply":
+            # 属性間の制約
+            premise = condition["premise"]
+            if_condition_text = self.get_restriction_text(premise["additional_data_definition_id"], premise["condition"])
+            then_text = self.get_restriction_text(attribute_id, condition["condition"])
+            return f"{then_text} IF {if_condition_text}"
+
+        attribute = self.attribute_dict.get(attribute_id)
+        if attribute is not None:
+            subject = f"'{AnnofabApiFacade.get_additional_data_definition_name_en(attribute)}'"
+            if self.output_format == OutputFormat.DETAILED_TEXT:
+                subject = f"{subject} (id='{attribute_id}', type='{attribute['type']}')"
+        else:
+            logger.warning(f"属性IDが'{attribute_id}'である属性は存在しません。")
+            if self.raise_if_not_found:
+                raise ValueError(f"属性IDが'{attribute_id}'である属性は存在しません。")
+
+            subject = "''"
+            if self.output_format == OutputFormat.DETAILED_TEXT:
+                subject = f"{subject} (id='{attribute_id}')"
+
+        if str_type == "CanInput":
+            verb = "CAN INPUT" if condition["enable"] else "CAN NOT INPUT"
+            str_object = ""
+
+        elif str_type == "HasLabel":
+            verb = "HAS LABEL"
+            str_object = self.get_labels_text(condition["labels"])
+
+        elif str_type == "Equals":
+            verb = "EQUALS"
+            str_object = self.get_object_for_equals_or_notequals(condition["value"], attribute)
+
+        elif str_type == "NotEquals":
+            verb = "DOES NOT EQUAL"
+            str_object = self.get_object_for_equals_or_notequals(condition["value"], attribute)
+
+        elif str_type == "Matches":
+            verb = "MATCHES"
+            str_object = f"'{condition['value']}'"
+
+        elif str_type == "NotMatches":
+            verb = "DOES NOT MATCH"
+            str_object = f"'{condition['value']}'"
+        else:
+            raise ValueError(f"condition._type='{str_type}'はサポートしていません。")
+
+        tmp = f"{subject} {verb}"
+        if str_object != "":
+            tmp = f"{tmp} {str_object}"
+        return tmp
+
+    def get_attribute_from_name(self, attribute_name: str) -> Optional[dict[str, Any]]:
+        tmp = [
+            attribute
+            for attribute in self.attribute_dict.values()
+            if AnnofabApiFacade.get_additional_data_definition_name_en(attribute) == attribute_name
+        ]
+        if len(tmp) == 1:
+            return tmp[0]
+        elif len(tmp) == 0:
+            logger.warning(f"属性名(英語)が'{attribute_name}'の属性は存在しません。")
+            return None
+        else:
+            logger.warning(f"属性名(英語)が'{attribute_name}'の属性は複数存在します。")
+            return None
+
+    def get_label_from_name(self, label_name: str) -> Optional[dict[str, Any]]:
+        tmp = [label for label in self.label_dict.values() if AnnofabApiFacade.get_label_name_en(label) == label_name]
+        if len(tmp) == 1:
+            return tmp[0]
+        elif len(tmp) == 0:
+            logger.warning(f"ラベル名(英語)が'{label_name}'のラベルは存在しません。")
+            return None
+        else:
+            logger.warning(f"ラベル名(英語)が'{label_name}'のラベルは複数存在します。")
+            return None
+
+    def get_target_attribute_ids(
+        self,
+        target_attribute_names: Optional[Collection[str]] = None,
+        target_label_names: Optional[Collection[str]] = None,
+    ) -> set[str]:
+        result: set[str] = set()
+
+        if target_attribute_names is not None:
+            tmp_attribute_list = [self.get_attribute_from_name(attribute_name) for attribute_name in target_attribute_names]
+            tmp_ids = {attribute["additional_data_definition_id"] for attribute in tmp_attribute_list if attribute is not None}
+            result = result | tmp_ids
+
+        if target_label_names is not None:
+            tmp_label_list = [self.get_label_from_name(label_name) for label_name in target_label_names]
+            tmp_ids_list = [label["additional_data_definitions"] for label in tmp_label_list if label is not None]
+            for attribute_ids in tmp_ids_list:
+                result = result | set(attribute_ids)
+
+        return result
+
+    def get_restriction_text_list(
+        self,
+        restrictions: list[dict[str, Any]],
+        *,
+        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 [
+                self.get_restriction_text(e["additional_data_definition_id"], e["condition"])
+                for e in restrictions
+                if e["additional_data_definition_id"] in target_attribute_ids
+            ]
+        else:
+            return [self.get_restriction_text(e["additional_data_definition_id"], e["condition"]) for e in restrictions]

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)