annofabcli 1.98.0__py3-none-any.whl → 1.100.0__py3-none-any.whl

annofabcli/__version__.py

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

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_attribute_restriction.py

@@ -4,15 +4,12 @@ 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
+from typing import Optional
 
 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,
     ArgumentParser,
@@ -25,204 +22,6 @@ from annofabcli.common.facade import AnnofabApiFacade
 logger = logging.getLogger(__name__)
 
 
-class FormatArgument(Enum):
-    """
-    表示するフォーマット ``--format`` で指定できる値
-
-    Attributes:
-        TEXT: 属性IDや種類を隠したシンプルなテキスト
-        DETAILED_TEXT: 属性IDや属性種類などの詳細情報を表示したテキスト
-    """
-
-    TEXT = "text"
-    DETAILED_TEXT = "detailed_text"
-
-
-class ListAttributeRestrictionMain:
-    """
-    アノテーション仕様の制約から自然言語で書かれたメッセージを生成します。
-
-    Args:
-        labels: アノテーション仕様のラベル情報
-        additionals: アノテーション仕様の属性情報
-
-    """
-
-    def __init__(
-        self,
-        labels: list[dict[str, Any]],
-        additionals: list[dict[str, Any]],
-        format: FormatArgument = FormatArgument.DETAILED_TEXT,  # noqa: A002 # 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
-
-    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 ""
-
-            label_message = f"'{label_name}'"
-            if self.format == FormatArgument.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.format == FormatArgument.DETAILED_TEXT:
-                    tmp = f"{tmp} (name='{choice_name}')"
-                return tmp
-
-            else:
-                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.format == FormatArgument.DETAILED_TEXT:
-                subject = f"{subject} (id='{attribute_id}', type='{attribute['type']}')"
-        else:
-            logger.warning(f"属性IDが'{attribute_id}'の属性は存在しません。")
-            subject = "''"
-            if self.format == FormatArgument.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 RuntimeError(f"{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]:
-        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]
-
-
 class ListAttributeRestriction(CommandLine):
     COMMON_MESSAGE = "annofabcli annotation_specs list_restriction: error:"
 
@@ -263,10 +62,10 @@ class ListAttributeRestriction(CommandLine):
         else:
             raise RuntimeError("'--project_id'か'--annotation_specs_json'のどちらかを指定する必要があります。")
 
-        main_obj = ListAttributeRestrictionMain(
+        main_obj = AttributeRestrictionMessage(
             labels=annotation_specs["labels"],
             additionals=annotation_specs["additionals"],
-            format=FormatArgument(args.format),
+            output_format=OutputFormat(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
@@ -323,12 +122,12 @@ def parse_args(parser: argparse.ArgumentParser) -> None:
         "-f",
         "--format",
         type=str,
-        choices=[e.value for e in FormatArgument],
-        default=FormatArgument.TEXT.value,
+        choices=[e.value for e in OutputFormat],
+        default=OutputFormat.TEXT.value,
         help=f"出力フォーマット\n"
         "\n"
-        f"* {FormatArgument.TEXT.value}: 英語名のみ出力する形式\n"
-        f"* {FormatArgument.DETAILED_TEXT.value}: 属性IDや属性種類などの詳細情報を出力する形式\n",
+        f"* {OutputFormat.TEXT.value}: 英語名のみ出力する形式\n"
+        f"* {OutputFormat.DETAILED_TEXT.value}: 属性IDや属性種類などの詳細情報を出力する形式\n",
     )
 
     parser.set_defaults(subcommand_func=main)

annofabcli/annotation_specs/put_label_color.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import logging
+import sys
 from dataclasses import dataclass
 from typing import Any, Optional
 
@@ -10,6 +11,7 @@ import annofabapi
 import annofabcli
 import annofabcli.common.cli
 from annofabcli.common.cli import (
+    COMMAND_LINE_ERROR_STATUS_CODE,
     ArgumentParser,
     CommandLine,
     CommandLineWithConfirm,
@@ -100,6 +102,9 @@ class PutLabelColor(CommandLine):
         args = self.args
         label_color = get_json_from_args(args.json)
 
+        if not isinstance(label_color, dict):
+            print("annofabcli annotation_specs put_label_color: error: JSON形式が不正です。オブジェクトを指定してください。", file=sys.stderr)  # noqa: T201
+            sys.exit(COMMAND_LINE_ERROR_STATUS_CODE)
         main_obj = PuttingLabelColorMain(service=self.service, project_id=args.project_id, all_yes=args.yes)
         main_obj.main(label_color, comment=args.comment)