annofabapi 1.7.0__tar.gz → 1.7.2__tar.gz

{annofabapi-1.7.0 → annofabapi-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annofabapi
-Version: 1.7.0
+Version: 1.7.2
 Summary: Python Client Library of Annofab WebAPI (https://annofab.com/docs/api/)
 Project-URL: Repository, https://github.com/kurusugawa-computer/annofab-api-python-client
 Author: Kurusugawa Computer Inc.

{annofabapi-1.7.0 → annofabapi-1.7.2}/annofabapi/generated_api.py

@@ -131,7 +131,6 @@ class AbstractAnnofabApi(abc.ABC):
             query_params (dict[str, Any]): Query Parameters
                 page (int):  検索結果のうち、取得したいページの番号(1始まり）
                 limit (int):  1ページあたりの取得するデータ件数
-                aggregate_by_task_and_input (bool):  `true`を指定すると、「タスクIDと入力データIDの組」ごとに検索結果を集計します。
                 no_aggregate_label_and_input (bool):  `true`を指定すると、ラベルIDによるアノテーション検索数の集約結果、および属性IDによるアノテーション検索数の集約結果を取得しません。  このパラメーターを`true`に指定することで集約計算は行われなくなるので、アノテーションの検索が速くなる可能性があります。
                 query (str):  絞り込み条件([AnnotationQuery](#tag/x-data-types/AnnotationQuery))をJSON形式で表した文字列。
                 sort (str):  ソート順の指定。 以下のキーを使用できます。 * `task_id` * `input_data_id` * `detail.annotation_id` * `detail.account_id` * `detail.label_id` * `detail.data_holding_type` * `detail.created_datetime` * `detail.updated_datetime`   キーの先頭に`-`を付けると、降順でソートされます。  `,`でキーを区切ると、複数のキーでソートされます。先頭のキーから順に優先順位が割り振られます。
@@ -2034,7 +2033,7 @@ class AbstractAnnofabApi(abc.ABC):
         authorizations: ProjectDataUser
 
 
-        入力データ全件ファイルにアクセスするための、認証済み一時URLを取得します。 取得したURLは1時間で失効し、アクセスできなくなります。  入力データ全件ファイルは、すべての入力データが記載されたJSONファイルです。SON構造は、[InputData](#tag/x-data-types/InputData)の配列です。 ただしInputData中のurlは常にnullです。  毎日AM02:00(JST)頃に更新されます。 [postProjectInputsUpdate](#operation/postProjectInputsUpdate) APIを利用すれば、手動で入力データ全件ファイルを更新できます。
+        入力データ全件ファイルにアクセスするための、認証済み一時URLを取得します。 取得したURLは1時間で失効し、アクセスできなくなります。  入力データ全件ファイルは、すべての入力データが記載されたJSONファイルです。JSON構造は、[InputData](#tag/x-data-types/InputData)の配列です。 ただしInputData中のurlは常にnullです。  毎日AM02:00(JST)頃に更新されます。 [postProjectInputsUpdate](#operation/postProjectInputsUpdate) APIを利用すれば、手動で入力データ全件ファイルを更新できます。
 
         Args:
             project_id (str):  プロジェクトID (required)

{annofabapi-1.7.0 → annofabapi-1.7.2}/annofabapi/util/attribute_restrictions.py

@@ -32,7 +32,9 @@ from collections.abc import Collection
 from enum import Enum
 from typing import Any, NoReturn, cast
 
-from pydantic import BaseModel, ConfigDict, Field, field_serializer, model_validator
+from pydantic import BaseModel, ConfigDict, Field, GetJsonSchemaHandler, field_serializer, model_validator
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema
 
 from annofabapi.pydantic_models.additional_data_definition_type import AdditionalDataDefinitionType
 from annofabapi.util.annotation_specs import AnnotationSpecsAccessor, AttributeChoice, AttributeDefinition, get_choice, get_english_message
@@ -49,7 +51,7 @@ class RestrictionAstType(str, Enum):
     IS_EMPTY = "is_empty"
     """属性値が空であることを表すAST種別です。"""
     IS_NOT_EMPTY = "is_not_empty"
-    """属性値が空でないことを表すAST種別です。"""
+    """属性値が空でないことを表すAST種別です。必須制約に相当します。"""
     EQUALS_STRING = "equals_string"
     """文字列属性またはtracking属性が指定文字列と一致することを表すAST種別です。"""
     NOT_EQUALS_STRING = "not_equals_string"
@@ -76,6 +78,44 @@ class RestrictionAstType(str, Enum):
     def __str__(self) -> str:
         return self.value
 
+    @property
+    def description(self) -> str:
+        """AST種別の説明文を返します。"""
+        return _RESTRICTION_AST_TYPE_DESCRIPTIONS[self]
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, core_schema: CoreSchema, handler: GetJsonSchemaHandler) -> JsonSchemaValue:
+        """AST種別ごとの説明を含むJSON Schemaを返します。"""
+        json_schema = handler(core_schema)
+        json_schema["oneOf"] = [
+            {
+                "const": ast_type.value,
+                "title": ast_type.name,
+                "description": ast_type.description,
+            }
+            for ast_type in cls
+        ]
+        return json_schema
+
+
+_RESTRICTION_AST_TYPE_DESCRIPTIONS: dict[RestrictionAstType, str] = {
+    RestrictionAstType.CHECKED: "チェックボックス属性がチェックされていることを表すAST種別です。",
+    RestrictionAstType.UNCHECKED: "チェックボックス属性がチェックされていないことを表すAST種別です。",
+    RestrictionAstType.IS_EMPTY: "属性値が空であることを表すAST種別です。",
+    RestrictionAstType.IS_NOT_EMPTY: "属性値が空でないことを表すAST種別です。必須制約に相当します。",
+    RestrictionAstType.EQUALS_STRING: "文字列属性またはtracking属性が指定文字列と一致することを表すAST種別です。",
+    RestrictionAstType.NOT_EQUALS_STRING: "文字列属性またはtracking属性が指定文字列と一致しないことを表すAST種別です。",
+    RestrictionAstType.MATCHES_STRING: "文字列属性が指定した正規表現に一致することを表すAST種別です。",
+    RestrictionAstType.NOT_MATCHES_STRING: "文字列属性が指定した正規表現に一致しないことを表すAST種別です。",
+    RestrictionAstType.EQUALS_INTEGER: "整数属性が指定した整数値と一致することを表すAST種別です。",
+    RestrictionAstType.NOT_EQUALS_INTEGER: "整数属性が指定した整数値と一致しないことを表すAST種別です。",
+    RestrictionAstType.HAS_CHOICE: "選択属性で指定した選択肢が選ばれていることを表すAST種別です。",
+    RestrictionAstType.NOT_HAS_CHOICE: "選択属性で指定した選択肢が選ばれていないことを表すAST種別です。",
+    RestrictionAstType.HAS_LABEL: "リンク属性が指定したラベル群のいずれかを指すことを表すAST種別です。",
+    RestrictionAstType.CAN_INPUT: "属性が編集可能かどうかを表すAST種別です。",
+    RestrictionAstType.IMPLY: "前提を満たす場合に結論を要求する含意制約を表すAST種別です。",
+}
+
 
 class Restriction(ABC):
     """属性の制約を表すクラス。"""
@@ -119,16 +159,19 @@ class Restriction(ABC):
         accessor = AnnotationSpecsAccessor(annotation_specs)
         return _restriction_to_ast(self, accessor=accessor)
 
-    def to_human_readable(self, annotation_specs: dict[str, Any]) -> str:
+    def to_human_readable(self, annotation_specs: dict[str, Any], *, include_ids: bool = False) -> str:
         """
         Restrictionオブジェクトを、人にとって読みやすい文字列表現へ変換します。
 
         Args:
             annotation_specs: アノテーション仕様(v3)の情報です。
+            include_ids: Trueの場合、属性ID、選択肢ID、ラベルIDを文字列表現に含めます。
 
         Returns:
             CLIなどで表示しやすい文字列表現です。
         """
+        if include_ids:
+            return _restriction_to_human_readable_with_ids(self, accessor=AnnotationSpecsAccessor(annotation_specs))
         return self.to_ast(annotation_specs).to_human_readable()
 
     @classmethod
@@ -1040,6 +1083,210 @@ def _raise_invalid_restriction(*, attribute: AttributeDefinition, condition: dic
     raise ValueError(message)
 
 
+def _restriction_to_human_readable_with_ids(restriction: Restriction, *, accessor: AnnotationSpecsAccessor) -> str:  # noqa: PLR0915
+    """
+    `Restriction` をID付きの人間向け文字列へ変換します。
+
+    Args:
+        restriction: 変換元の `Restriction` です。
+        accessor: 属性名、選択肢名、ラベル名の解決に使う `AnnotationSpecsAccessor` です。
+
+    Returns:
+        属性ID、選択肢ID、ラベルIDを含む人間向け文字列表現です。
+
+    Raises:
+        ValueError: 人間向け文字列へ変換できない制約が含まれている場合
+    """
+
+    def format_attribute(attribute: AttributeDefinition) -> str:
+        """
+        属性名と属性IDを人間向け文字列へ変換します。
+
+        Args:
+            attribute: アノテーション仕様上の属性定義です。
+
+        Returns:
+            属性名と属性IDを含む文字列表現です。
+        """
+        attribute_name = get_english_message(attribute["name"])
+        attribute_id = attribute["additional_data_definition_id"]
+        return f"{attribute_name!r} [attribute_id={attribute_id!r}]"
+
+    def format_choice(choice: AttributeChoice) -> str:
+        """
+        選択肢名と選択肢IDを人間向け文字列へ変換します。
+
+        Args:
+            choice: アノテーション仕様上の選択肢定義です。
+
+        Returns:
+            選択肢名と選択肢IDを含む文字列表現です。
+        """
+        choice_name = get_english_message(choice["name"])
+        choice_id = choice["choice_id"]
+        return f"{choice_name!r} [choice_id={choice_id!r}]"
+
+    def format_label(label_id: str) -> str:
+        """
+        ラベル名とラベルIDを人間向け文字列へ変換します。
+
+        Args:
+            label_id: ラベルIDです。
+
+        Returns:
+            ラベル名とラベルIDを含む文字列表現です。
+        """
+        label = accessor.get_label(label_id=label_id)
+        label_name = get_english_message(label["label_name"])
+        return f"{label_name!r} [label_id={label_id!r}]"
+
+    def parse_integer_value(value: str, *, attribute: AttributeDefinition, condition: dict[str, Any]) -> int:
+        """
+        整数属性向けの文字列値を整数へ変換します。
+
+        Args:
+            value: 変換対象の文字列値です。
+            attribute: アノテーション仕様上の属性定義です。
+            condition: 元の条件辞書です。
+
+        Returns:
+            変換後の整数値です。
+
+        Raises:
+            ValueError: 整数へ変換できない場合
+        """
+        try:
+            return int(value)
+        except ValueError as exc:
+            _raise_invalid_restriction(attribute=attribute, condition=condition, detail="整数属性には整数値を指定してください。")
+            raise AssertionError("unreachable") from exc
+
+    def equals_restriction_to_text(
+        *, attribute: AttributeDefinition, attribute_text: str, attribute_type: AdditionalDataDefinitionType, value: str
+    ) -> str:
+        match attribute_type:
+            case "flag" if value == "true":
+                return f"{attribute_text} is checked"
+            case "text" | "comment" | "integer" | "link" | "tracking" | "choice" | "select" if value == "":
+                return f"{attribute_text} is empty"
+            case "text" | "comment" | "tracking":
+                return f"{attribute_text} is {value!r}"
+            case "integer":
+                integer_value = parse_integer_value(value, attribute=attribute, condition={"_type": "Equals", "value": value})
+                return f"{attribute_text} is {integer_value!r}"
+            case "choice" | "select":
+                choice = get_choice(cast(list[AttributeChoice], attribute["choices"]), choice_id=value)
+                return f"{attribute_text} is {format_choice(choice)}"
+            case _:
+                raise ValueError(
+                    f"Restrictionを人間向け文字列へ変換できません。 :: restriction_type='Equals', attribute_type='{attribute_type}', value={value!r}"
+                )
+
+    def not_equals_restriction_to_text(
+        *, attribute: AttributeDefinition, attribute_text: str, attribute_type: AdditionalDataDefinitionType, value: str
+    ) -> str:
+        match attribute_type:
+            case "flag" if value == "true":
+                return f"{attribute_text} is unchecked"
+            case "text" | "comment" | "integer" | "link" | "tracking" | "choice" | "select" if value == "":
+                return f"{attribute_text} is not empty"
+            case "text" | "comment" | "tracking":
+                return f"{attribute_text} is not {value!r}"
+            case "integer":
+                integer_value = parse_integer_value(value, attribute=attribute, condition={"_type": "NotEquals", "value": value})
+                return f"{attribute_text} is not {integer_value!r}"
+            case "choice" | "select":
+                choice = get_choice(cast(list[AttributeChoice], attribute["choices"]), choice_id=value)
+                return f"{attribute_text} is not {format_choice(choice)}"
+            case _:
+                restriction_type = "NotEquals"
+                raise ValueError(
+                    f"Restrictionを人間向け文字列へ変換できません。 :: restriction_type='{restriction_type}', "
+                    f"attribute_type='{attribute_type}', value={value!r}"
+                )
+
+    def atomic_restriction_to_text(restriction: Restriction, *, attribute: AttributeDefinition) -> str:
+        """
+        `imply` 以外の `Restriction` をID付きの人間向け文字列へ変換します。
+
+        Args:
+            restriction: 変換元の `Restriction` です。
+            attribute: 制約対象の属性定義です。
+
+        Returns:
+            ID付きの人間向け文字列表現です。
+        """
+        attribute_type = attribute["type"]
+        attribute_text = format_attribute(attribute)
+
+        match restriction:
+            case CanInput(enable=enable):
+                return f"{attribute_text} can be edited" if enable else f"{attribute_text} is read-only"
+            case Equals(value=value):
+                return equals_restriction_to_text(
+                    attribute=attribute,
+                    attribute_text=attribute_text,
+                    attribute_type=attribute_type,
+                    value=value,
+                )
+            case NotEquals(value=value):
+                return not_equals_restriction_to_text(
+                    attribute=attribute,
+                    attribute_text=attribute_text,
+                    attribute_type=attribute_type,
+                    value=value,
+                )
+            case Matches(value=value) if attribute_type in {"text", "comment"}:
+                return f"{attribute_text} matches {value!r}"
+            case NotMatches(value=value) if attribute_type in {"text", "comment"}:
+                return f"{attribute_text} does not match {value!r}"
+            case HasLabel(label_ids=label_ids) if attribute_type == "link":
+                return f"{attribute_text} has labels {', '.join(format_label(label_id) for label_id in label_ids)}"
+            case _:
+                _raise_invalid_restriction(attribute=attribute, condition=restriction.to_dict()["condition"])
+
+    def flatten_imply_conditions(restriction: Imply) -> tuple[list[Restriction], Restriction]:
+        """
+        右側にネストした `imply` を条件列と結論へ分解します。
+
+        Args:
+            restriction: `imply` 種別の制約です。
+
+        Returns:
+            条件制約の一覧と最終的な結論制約です。
+        """
+        conditions = [restriction.premise_restriction]
+        conclusion = restriction.conclusion_restriction
+        while isinstance(conclusion, Imply):
+            conditions.append(conclusion.premise_restriction)
+            conclusion = conclusion.conclusion_restriction
+        return conditions, conclusion
+
+    def to_human_condition_text(restriction: Restriction) -> str:
+        """
+        条件節で使う人間向け文字列表現へ変換します。
+
+        Args:
+            restriction: 変換対象の制約です。
+
+        Returns:
+            条件節で使いやすい文字列表現です。
+        """
+        if isinstance(restriction, Imply):
+            return f"({_restriction_to_human_readable_with_ids(restriction, accessor=accessor)})"
+        return _restriction_to_human_readable_with_ids(restriction, accessor=accessor)
+
+    match restriction:
+        case Imply():
+            conditions, conclusion = flatten_imply_conditions(restriction)
+            conditions_text = " and ".join(to_human_condition_text(condition) for condition in conditions)
+            conclusion_text = _restriction_to_human_readable_with_ids(conclusion, accessor=accessor)
+            return f"If {conditions_text}, {conclusion_text}."
+
+    attribute = accessor.get_attribute(attribute_id=restriction.attribute_id)
+    return atomic_restriction_to_text(restriction, attribute=attribute)
+
+
 def _restriction_to_ast(restriction: Restriction, *, accessor: AnnotationSpecsAccessor) -> RestrictionAst:
     """
     `Restriction` を意味ベースの `RestrictionAst` へ変換します。

{annofabapi-1.7.0 → annofabapi-1.7.2}/generate/partial-header/dataclass/annotation.py

@@ -7,7 +7,7 @@ from annofabapi.models import (
     TaskStatus,
 )
 
-AnnotationDataV1 = Union[str, dict[str, Any]]
+AnnotationDataV1 = str | dict[str, Any]
 FullAnnotationData = Any
 AdditionalDataValue = dict[str, Any]
 FullAnnotationAdditionalDataValue = dict[str, Any]

{annofabapi-1.7.0 → annofabapi-1.7.2}/generate/partial-header/dataclass/annotation_specs.py

@@ -1,6 +1,6 @@
 from annofabapi.models import AdditionalDataDefinitionType, AnnotationTypeFieldMinWarnRule
 
-AdditionalDataDefaultType = Union[bool, int, str]
+AdditionalDataDefaultType = bool | int | str
 
 AdditionalDataRestrictionCondition = dict[str, Any]
 

{annofabapi-1.7.0 → annofabapi-1.7.2}/generate/swagger/swagger.v2.yaml

@@ -115,7 +115,7 @@ info:
 
     上記例 `account_id_count` は、タスクのフィールド `account_id` でタスクを分類したところ「`account_id` が `c5eee002` であるタスクが9件、`9f110e48` であるタスクが5件、`b25dfeb3` であるタスクが1件」だったという結果を表しています。
 
-  version: 0.206.0
+  version: 0.210.0
   title: Annofab Web API
   x-logo:
     url: "https://annofab.com/resource/images/logo_landscape.png"

{annofabapi-1.7.0 → annofabapi-1.7.2}/generate/swagger/swagger.yaml

@@ -119,7 +119,7 @@ info:
     上記例 `account_id_count` は、タスクのフィールド `account_id` でタスクを分類したところ「`account_id` が `c5eee002` であるタスクが9件、`9f110e48` であるタスクが5件、`b25dfeb3` であるタスクが1件」だったという結果を表しています。
     また、AggregationResultの集約の件数は、合計で10000件以下に制限されており、それを超える件数がある場合は上位10000件が取得されます。もし、省略された部分を取得したい場合は、検索条件を縛って結果に上る集約の数を減らしてください。
 
-  version: 0.206.0
+  version: 0.210.0
   title: Annofab Web API
   x-logo:
     url: "https://annofab.com/resource/images/logo_landscape.png"
@@ -2094,7 +2094,7 @@ paths:
         入力データ全件ファイルにアクセスするための、認証済み一時URLを取得します。
         取得したURLは1時間で失効し、アクセスできなくなります。
 
-        入力データ全件ファイルは、すべての入力データが記載されたJSONファイルです。SON構造は、[InputData](#tag/x-data-types/InputData)の配列です。
+        入力データ全件ファイルは、すべての入力データが記載されたJSONファイルです。JSON構造は、[InputData](#tag/x-data-types/InputData)の配列です。
         ただしInputData中のurlは常にnullです。
 
         毎日AM02:00(JST)頃に更新されます。
@@ -4607,14 +4607,6 @@ paths:
           minimum: 0
           maximum: 200
           default: 30
-      - name: aggregate_by_task_and_input
-        in: query
-        description: |
-          `true`を指定すると、「タスクIDと入力データIDの組」ごとに検索結果を集計します。
-        required: false
-        schema:
-          type: boolean
-          default: false
       - name: no_aggregate_label_and_input
         in: query
         description: |

{annofabapi-1.7.0 → annofabapi-1.7.2}/pyproject.toml

@@ -48,7 +48,7 @@ test = [
 ]
 linter = [
     "ruff>=0.15 ; python_version >= '3.13'",
-    "mypy>=1,<2 ; python_version >= '3.13'",
+    "mypy>=2 ; python_version >= '3.13'",
     "types-requests",
     "types-python-dateutil",
     "types-dataclasses",

{annofabapi-1.7.0 → annofabapi-1.7.2}/tests/util/test_attribute_restrictions.py

@@ -281,6 +281,58 @@ class Test__Restriction:
 
         assert actual == "If 'occluded' is checked, 'note' is not empty."
 
+    def test__to_human_readable__include_idsがTrueなら属性IDを出力する(self):
+        restriction = Restriction.from_dict(
+            {
+                "additional_data_definition_id": "9b05648d-1e16-4ea2-ab79-48907f5eed00",
+                "condition": {
+                    "_type": "Imply",
+                    "premise": {
+                        "additional_data_definition_id": "2517f635-2269-4142-8ef4-16312b4cc9f7",
+                        "condition": {"_type": "Equals", "value": "true"},
+                    },
+                    "condition": {"_type": "NotEquals", "value": ""},
+                },
+            }
+        )
+
+        actual = restriction.to_human_readable(accessor.annotation_specs, include_ids=True)
+
+        assert (
+            actual == "If 'occluded' [attribute_id='2517f635-2269-4142-8ef4-16312b4cc9f7'] is checked, "
+            "'note' [attribute_id='9b05648d-1e16-4ea2-ab79-48907f5eed00'] is not empty."
+        )
+
+    def test__to_human_readable__include_idsがTrueなら選択肢IDを出力する(self):
+        restriction = Restriction.from_dict(
+            {
+                "additional_data_definition_id": "cbb0155f-1631-48e1-8fc3-43c5f254b6f2",
+                "condition": {"_type": "Equals", "value": "7512ee39-8073-4e24-9b8c-93d99b76b7d2"},
+            }
+        )
+
+        actual = restriction.to_human_readable(accessor.annotation_specs, include_ids=True)
+
+        assert (
+            actual == "'car_kind' [attribute_id='cbb0155f-1631-48e1-8fc3-43c5f254b6f2'] is "
+            "'general_car' [choice_id='7512ee39-8073-4e24-9b8c-93d99b76b7d2']"
+        )
+
+    def test__to_human_readable__include_idsがTrueならラベルIDを出力する(self):
+        restriction = Restriction.from_dict(
+            {
+                "additional_data_definition_id": "15ba8b9d-4882-40c2-bb31-ed3f68197c2e",
+                "condition": {"_type": "HasLabel", "labels": ["9d6cca8d-3f5a-4808-a6c9-0ae18a478176"]},
+            }
+        )
+
+        actual = restriction.to_human_readable(accessor.annotation_specs, include_ids=True)
+
+        assert (
+            actual == "'link_car' [attribute_id='15ba8b9d-4882-40c2-bb31-ed3f68197c2e'] has labels "
+            "'car' [label_id='9d6cca8d-3f5a-4808-a6c9-0ae18a478176']"
+        )
+
     def test__to_human_readable__右側にネストしたimplyは条件をまとめる(self):
         restriction = Restriction.from_dict(
             {
@@ -437,10 +489,22 @@ class Test__RestrictionAst:
     def test__model_json_schema(self):
         actual = RestrictionAst.model_json_schema()
         properties = actual["$defs"]["RestrictionAst"]["properties"]
+        ast_type_schema = actual["$defs"]["RestrictionAstType"]
 
         assert properties["type"]["description"] == "ASTノードの種類です。"
         assert properties["attribute_name"]["description"] == "対象属性の名前です。"
         assert properties["premise"]["description"] == "`imply` ノードの前提です。"
+        assert ast_type_schema["description"] == "属性制約ASTの種別です。"
+        assert {
+            "const": "checked",
+            "title": "CHECKED",
+            "description": "チェックボックス属性がチェックされていることを表すAST種別です。",
+        } in ast_type_schema["oneOf"]
+        assert {
+            "const": "imply",
+            "title": "IMPLY",
+            "description": "前提を満たす場合に結論を要求する含意制約を表すAST種別です。",
+        } in ast_type_schema["oneOf"]
 
 
 class Test__get_attribute_restriction_catalog: