x4d-devkit 0.52.0rc1__tar.gz → 0.52.0rc2__tar.gz

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.52.0rc1
+Version: 0.52.0rc2
 Summary: Official X-4D external SDK and CLI for datasets, platform APIs, training bridges, and automation
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "x4d-devkit"
-version = "0.52.0rc1"
+version = "0.52.0rc2"
 description = "Official X-4D external SDK and CLI for datasets, platform APIs, training bridges, and automation"
 readme = "README.md"
 license = "Apache-2.0"

x4d_devkit-0.52.0rc2/tests/test_image_conditional_rules.py

@@ -0,0 +1,328 @@
+"""Closed conditional attribute rules, English terms and description coverage (#220)."""
+
+from __future__ import annotations
+
+import copy
+
+import pytest
+
+from x4d_devkit._image_contract import ImageContractError, fingerprint
+from x4d_devkit.image_clip import build_image_identity, parse_image_clip
+from x4d_devkit.image_schema import parse_image_schema_body
+from tests.image_fixtures import clip_payload, schema_body
+
+
+def enum(attribute_id, values, **extra):
+    return {
+        "id": attribute_id,
+        "display_name": attribute_id,
+        "type": "enum",
+        "required": False,
+        "scopes": ["object"],
+        "values": [{"id": value, "display_name": value} for value in values],
+        **extra,
+    }
+
+
+def boolean(attribute_id):
+    return {
+        "id": attribute_id,
+        "display_name": attribute_id,
+        "type": "boolean",
+        "required": False,
+        "scopes": ["object"],
+        "values": [],
+    }
+
+
+def directions():
+    return {
+        "id": "occlusion_directions",
+        "display_name": "occlusion directions",
+        "type": "enum_set",
+        "required": False,
+        "scopes": ["object"],
+        "values": [
+            {"id": side, "display_name": side} for side in ("top", "bottom", "left", "right")
+        ],
+        "min_items": 1,
+        "max_items": 4,
+    }
+
+
+SIGNAL_RULES = [
+    {
+        "id": "head_facts",
+        "attributes": ["head_type", "occlusion"],
+        "required": ["head_type", "occlusion"],
+    },
+    {
+        "id": "arrow",
+        "when": {"attribute": "head_type", "equals": "arrow"},
+        "attributes": ["arrow_direction"],
+        "required": ["arrow_direction"],
+    },
+    {
+        "id": "damaged",
+        "when": {"attribute": "head_type", "in": ["countdown", "countdown_damaged"]},
+        "attributes": ["digit_unclear"],
+        "required": ["digit_unclear"],
+    },
+    {
+        "id": "digit_countdown",
+        "when": {"attribute": "head_type", "equals": "countdown"},
+        "attributes": ["digit"],
+        "required": ["digit"],
+    },
+    {
+        "id": "digit_damaged_known",
+        "when": {
+            "all": [
+                {"attribute": "head_type", "equals": "countdown_damaged"},
+                {"attribute": "digit_unclear", "equals": False},
+            ]
+        },
+        "attributes": ["digit"],
+        "required": ["digit"],
+    },
+    {
+        "id": "digit_optional_when_unclear",
+        "when": {
+            "all": [
+                {"attribute": "head_type", "equals": "countdown_damaged"},
+                {"attribute": "digit_unclear", "equals": True},
+            ]
+        },
+        "attributes": ["digit"],
+        "required": [],
+    },
+    {
+        "id": "occluded",
+        "when": {"attribute": "occlusion", "equals": True},
+        "attributes": ["occlusion_directions", "occlusion_ratio"],
+        "required": ["occlusion_directions", "occlusion_ratio"],
+    },
+]
+
+
+def signal_category(rules=None):
+    return {
+        "id": "box",
+        "display_name": "Signal head",
+        "geometry_type": "box_2d",
+        "color": "#112233",
+        "attributes": [
+            enum("head_type", ["round", "arrow", "countdown", "countdown_damaged"]),
+            enum("arrow_direction", ["up", "left"]),
+            enum("digit", [str(digit) for digit in range(10)]),
+            boolean("digit_unclear"),
+            boolean("occlusion"),
+            directions(),
+            enum("occlusion_ratio", ["low", "medium", "high"]),
+        ],
+        "rules": copy.deepcopy(SIGNAL_RULES if rules is None else rules),
+    }
+
+
+def body(category=None, description_fields=None):
+    value = schema_body()
+    value["categories"][1] = category or signal_category()
+    if description_fields is not None:
+        value["task_views"][1]["category_ids"] = ["box"]
+        value["task_views"][1]["description_fields"] = description_fields
+    return value
+
+
+def box(object_id, attributes):
+    return {
+        "id": object_id,
+        "image_id": "image_a",
+        "view_id": "objects",
+        "category_id": "box",
+        "geometry": {
+            "geometry_type": "box_2d",
+            "box": {"x_min": 10, "y_min": 20, "x_max": 30, "y_max": 40},
+        },
+        "attributes": attributes,
+        "attribute_ranges": [],
+    }
+
+
+def clip(schema, objects, *, objects_state="complete", descriptions=(), text_state="unprocessed"):
+    value = clip_payload()
+    value["label_schema"]["body"] = schema
+    value["label_schema"]["identity"]["fingerprint"] = fingerprint(schema)
+    value["image_annotation"]["objects"] = objects
+    value["image_annotation"]["descriptions"] = list(descriptions)
+    states = {"objects": objects_state, "semantics": text_state}
+    for row in value["image_annotation"]["completion"]:
+        row["state"] = states[row["view_id"]]
+    value["identity"] = build_image_identity(value)
+    return parse_image_clip(value)
+
+
+def head(**attributes):
+    return box("head_a", {"occlusion": False, **attributes})
+
+
+@pytest.mark.parametrize(
+    "attributes",
+    [
+        {"head_type": "round"},
+        {"head_type": "arrow", "arrow_direction": "left"},
+        {"head_type": "countdown", "digit_unclear": False, "digit": "4"},
+        {"head_type": "countdown_damaged", "digit_unclear": True},
+        {"head_type": "countdown_damaged", "digit_unclear": True, "digit": "9"},
+        {"head_type": "countdown_damaged", "digit_unclear": False, "digit": "9"},
+        {
+            "head_type": "round",
+            "occlusion": True,
+            "occlusion_directions": ["top", "left"],
+            "occlusion_ratio": "medium",
+        },
+    ],
+)
+def test_completed_heads_satisfy_conditional_rules(attributes):
+    clip(body(), [head(**attributes)])
+
+
+@pytest.mark.parametrize(
+    ("attributes", "code", "attribute"),
+    [
+        ({}, "attribute_required_on_completion", "head_type"),
+        ({"head_type": "arrow"}, "attribute_required_on_completion", "arrow_direction"),
+        ({"head_type": "round", "arrow_direction": "up"}, "attribute_not_applicable", "arrow_direction"),
+        ({"head_type": "countdown", "digit_unclear": False}, "attribute_required_on_completion", "digit"),
+        ({"head_type": "countdown_damaged", "digit_unclear": False}, "attribute_required_on_completion", "digit"),
+        ({"head_type": "round", "digit": "3"}, "attribute_not_applicable", "digit"),
+        ({"head_type": "round", "occlusion": True, "occlusion_ratio": "low"}, "attribute_required_on_completion", "occlusion_directions"),
+        ({"head_type": "round", "occlusion_directions": ["top"]}, "attribute_not_applicable", "occlusion_directions"),
+    ],
+)
+def test_completed_heads_reject_missing_or_leftover_facts(attributes, code, attribute):
+    with pytest.raises(ImageContractError) as error:
+        clip(body(), [head(**attributes)])
+    assert error.value.code == code
+    assert error.value.path == f"image_annotation.objects.head_a.attributes.{attribute}"
+
+
+def test_drafts_may_pause_with_missing_or_leftover_facts_but_values_stay_typed():
+    clip(body(), [head(head_type="round", arrow_direction="up")], objects_state="unprocessed")
+    clip(body(), [box("head_a", {})], objects_state="unprocessed")
+    with pytest.raises(ImageContractError):
+        clip(body(), [head(head_type="round", arrow_direction="sideways")], objects_state="unprocessed")
+    with pytest.raises(ImageContractError):  # enum_set bounds apply to drafts too
+        clip(
+            body(),
+            [head(head_type="round", occlusion=True, occlusion_directions=[])],
+            objects_state="unprocessed",
+        )
+
+
+def test_rules_change_the_schema_fingerprint():
+    plain = parse_image_schema_body(body(signal_category(rules=SIGNAL_RULES[:1])))
+    full = parse_image_schema_body(body())
+    assert plain.identity.fingerprint != full.identity.fingerprint
+
+
+def _rule(**change):
+    rule = copy.deepcopy(SIGNAL_RULES[1])
+    rule.update(change)
+    return rule
+
+
+@pytest.mark.parametrize(
+    "rules",
+    [
+        [],
+        [_rule(attributes=["missing"], required=[])],
+        [_rule(required=["head_type"])],
+        [_rule(attributes=["arrow_direction", "arrow_direction"])],
+        [_rule(when={"attribute": "missing", "equals": "arrow"})],
+        [_rule(when={"attribute": "head_type", "equals": "triangle"})],
+        [_rule(when={"attribute": "head_type", "equals": True})],
+        [_rule(when={"attribute": "occlusion", "equals": "true"})],
+        [_rule(when={"attribute": "head_type", "in": []})],
+        [_rule(when={"attribute": "head_type", "in": ["arrow", "arrow"]})],
+        [_rule(when={"attribute": "head_type", "contains": "arrow"})],
+        [_rule(when={"attribute": "occlusion_directions", "equals": "top"})],
+        [_rule(when={"attribute": "head_type", "equals": "arrow", "in": ["arrow"]})],
+        [_rule(when={"all": [{"any": [{"attribute": "head_type", "equals": "arrow"}]}]})],
+        [_rule(when={"all": []})],
+        [_rule(when="head_type == 'arrow'")],
+        [_rule(), _rule()],
+        [
+            _rule(id="a", when={"attribute": "digit", "equals": "1"}, attributes=["arrow_direction"]),
+            _rule(id="b", when={"attribute": "arrow_direction", "equals": "up"}, attributes=["digit"], required=[]),
+        ],
+    ],
+)
+def test_schema_rejects_open_or_inconsistent_rules(rules):
+    with pytest.raises(ImageContractError):
+        parse_image_schema_body(body(signal_category(rules=rules)))
+
+
+def test_governed_attribute_cannot_also_be_always_required():
+    category = signal_category()
+    category["attributes"][1]["required"] = True
+    with pytest.raises(ImageContractError):
+        parse_image_schema_body(body(category))
+
+
+def test_enum_values_may_declare_english_terms():
+    category = signal_category()
+    category["attributes"][0]["values"][0]["term"] = {"singular": "round light", "plural": "round lights"}
+    category["attributes"][2]["values"][0]["term"] = {"singular": "zero"}
+    parse_image_schema_body(body(category))
+    for term in ({"singular": " "}, {"plural": "lights"}, {"singular": "x", "plural": ""}, {"singular": "x", "other": "y"}):
+        category["attributes"][0]["values"][0]["term"] = term
+        with pytest.raises(ImageContractError):
+            parse_image_schema_body(body(category))
+
+
+TEXT_FIELDS = [
+    {"id": "phrase", "display_name": "Phrase", "required": True, "target": "object"},
+    {"id": "caption", "display_name": "Caption", "required": True, "target": "image"},
+]
+
+
+def text(text_id, target, field, value="text"):
+    return {
+        "id": text_id,
+        "image_id": "image_a",
+        "view_id": "semantics",
+        "target_id": target,
+        "fields": {field: value},
+    }
+
+
+def test_completed_description_scope_covers_every_object_and_the_image():
+    schema = body(description_fields=TEXT_FIELDS)
+    objects = [head(head_type="round"), {**head(head_type="round"), "id": "head_b"}]
+    full = [
+        text("p_a", "head_a", "phrase"),
+        text("p_b", "head_b", "phrase"),
+        text("caption", None, "caption"),
+    ]
+    clip(schema, objects, descriptions=full, text_state="complete")
+    clip(schema, objects, descriptions=full[:1], text_state="unprocessed")
+    for missing in range(3):
+        partial = full[:missing] + full[missing + 1 :]
+        with pytest.raises(ImageContractError) as error:
+            clip(schema, objects, descriptions=partial, text_state="complete")
+        assert error.value.code == "description_coverage_incomplete"
+
+
+def test_description_targets_are_unique_and_fields_match_their_target():
+    schema = body(description_fields=TEXT_FIELDS)
+    objects = [head(head_type="round")]
+    with pytest.raises(ImageContractError):  # two phrases for one object
+        clip(schema, objects, descriptions=[text("p1", "head_a", "phrase"), text("p2", "head_a", "phrase")])
+    with pytest.raises(ImageContractError):  # caption field on an object description
+        clip(schema, objects, descriptions=[text("p1", "head_a", "caption")])
+    with pytest.raises(ImageContractError):  # phrase on the image-level description
+        clip(schema, objects, descriptions=[text("c", None, "phrase")])
+    with pytest.raises(ImageContractError):
+        parse_image_schema_body(
+            body(description_fields=[{**TEXT_FIELDS[0], "target": "region"}])
+        )

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/tests/test_sdk_api.py

@@ -11,7 +11,7 @@ from x4d_devkit.eval.matching import MetricData
 
 
 def test_package_version_is_current_release():
-    assert x4d_devkit.__version__ == "0.52.0rc1"
+    assert x4d_devkit.__version__ == "0.52.0rc2"
 
 
 def test_loader_exposes_and_enforces_only_current_schema(tmp_path):

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/x4d_devkit/image_clip.py

@@ -261,6 +261,72 @@ def _attributes(values: Any, category: dict, scope: str, path: str) -> None:
             )
 
 
+def _condition_holds(condition: dict, values: dict) -> bool:
+    for combinator, test in (("all", all), ("any", any)):
+        if combinator in condition:
+            return test(_condition_holds(item, values) for item in condition[combinator])
+    name = condition["attribute"]
+    if name not in values:
+        return False
+    if "equals" in condition:
+        return values[name] == condition["equals"] and type(values[name]) is type(
+            condition["equals"]
+        )
+    if "in" in condition:
+        return values[name] in condition["in"]
+    return condition["contains"] in values[name]
+
+
+def _completed_rules(values: dict, category: dict, path: str) -> None:
+    """Completion-time requiredness and applicability from closed Schema rules."""
+
+    rules = category.get("rules", [])
+    governed = {name for rule in rules for name in rule["attributes"]}
+    applicable: set[str] = set()
+    for rule in rules:
+        if "when" not in rule or _condition_holds(rule["when"], values):
+            applicable.update(rule["attributes"])
+            for name in rule["required"]:
+                if name not in values:
+                    raise ImageContractError(
+                        code="attribute_required_on_completion",
+                        message=f"rule {rule['id']} requires this attribute",
+                        path=path + "." + name,
+                    )
+    for name in sorted(governed - applicable):
+        if name in values:
+            raise ImageContractError(
+                code="attribute_not_applicable",
+                message="attribute is not applicable to the completed object",
+                path=path + "." + name,
+            )
+
+
+def _description_coverage(
+    image_id: str, view: dict, objects: dict, described: set
+) -> None:
+    targets = {item.get("target") for item in view["description_fields"]}
+    path = f"image_annotation.completion.{image_id}.{view['id']}"
+    if "object" in targets:
+        for name, row in sorted(objects.items()):
+            if row["image_id"] != image_id or (
+                view["category_ids"] and row["category_id"] not in view["category_ids"]
+            ):
+                continue
+            if (view["id"], image_id, name) not in described:
+                raise ImageContractError(
+                    code="description_coverage_incomplete",
+                    message="every applicable object requires its description",
+                    path=path + "." + name,
+                )
+    if "image" in targets and (view["id"], image_id, None) not in described:
+        raise ImageContractError(
+            code="description_coverage_incomplete",
+            message="the completed image requires its image description",
+            path=path,
+        )
+
+
 def validate_image_annotations(
     value: Any, *, clip_id: str, images: dict, schema: dict, view_ids: list[str]
 ) -> ImageDocument:
@@ -363,6 +429,7 @@ def validate_image_annotations(
             categories=categories,
             result_ids=set(objects) | set(descriptions),
         )
+    described: set[tuple] = set()
     for name, row in descriptions.items():
         path = "image_annotation.descriptions." + name
         fields(row, {"id", "image_id", "view_id", "target_id", "fields"}, path)
@@ -398,12 +465,25 @@ def validate_image_annotations(
             path + ".target_id",
         )
         values = row["fields"]
-        definitions = {item["id"]: item for item in view["description_fields"]}
+        kind = "image" if target is None else "object"
+        definitions = {
+            item["id"]: item
+            for item in view["description_fields"]
+            if item.get("target", kind) == kind
+        }
         require(
             type(values) is dict and set(values) <= set(definitions),
             "unsupported description fields",
             path + ".fields",
         )
+        if any("target" in item for item in view["description_fields"]):
+            key = (row["view_id"], row["image_id"], target)
+            require(
+                key not in described,
+                "duplicate description for the same target",
+                path + ".target_id",
+            )
+            described.add(key)
         for key, item in values.items():
             require(
                 type(item) is str and bool(item.strip()),
@@ -454,6 +534,22 @@ def validate_image_annotations(
         "completion must cover every applicable image and view",
         "image_annotation.completion",
     )
+    complete = {
+        (row["image_id"], row["view_id"])
+        for row in value["completion"]
+        if row["state"] == "complete"
+    }
+    for name, row in objects.items():
+        if (row["image_id"], row["view_id"]) in complete:
+            _completed_rules(
+                row["attributes"],
+                categories[row["category_id"]],
+                "image_annotation.objects." + name + ".attributes",
+            )
+    for image_id, view_id in sorted(complete):
+        view = views[view_id]
+        if view["kind"] == "descriptions":
+            _description_coverage(image_id, view, objects, described)
     return document(value)
 
 

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/x4d_devkit/image_schema.py

@@ -128,6 +128,126 @@ class ImageSchemaRecord(ImageDocument):
         return parse_image_schema_body(self.body).task_view_by_id(view_id)
 
 
+def _term(value: Any, path: str) -> None:
+    fields(value, {"singular"}, path, optional={"plural"})
+    text(value["singular"], path + ".singular")
+    if "plural" in value:
+        text(value["plural"], path + ".plural")
+
+
+def _predicate(value: Any, attributes: dict, path: str) -> str:
+    require(type(value) is dict, "condition must be an object", path)
+    operators = [name for name in ("equals", "in", "contains") if name in value]
+    require(
+        len(operators) == 1 and set(value) == {"attribute", operators[0]},
+        "predicate requires attribute and exactly one of equals/in/contains",
+        path,
+    )
+    name, operator = value["attribute"], operators[0]
+    require(
+        type(name) is str and name in attributes and "object" in attributes[name]["scopes"],
+        "condition must reference an object attribute of this category",
+        path + ".attribute",
+    )
+    definition = attributes[name]
+    declared = {item["id"] for item in definition["values"]}
+    operand = value[operator]
+    kind = definition["type"]
+    if operator == "equals" and kind == "boolean":
+        ok = type(operand) is bool
+    elif operator == "equals" and kind == "enum":
+        ok = type(operand) is str and operand in declared
+    elif operator == "in" and kind == "enum":
+        ok = (
+            type(operand) is list
+            and len(operand) > 0
+            and all(type(item) is str and item in declared for item in operand)
+            and len(set(operand)) == len(operand)
+        )
+    elif operator == "contains" and kind == "enum_set":
+        ok = type(operand) is str and operand in declared
+    else:
+        ok = False
+    require(
+        ok,
+        "condition operand does not match the attribute type or values",
+        path + "." + operator,
+    )
+    return name
+
+
+def _condition(value: Any, attributes: dict, path: str) -> set[str]:
+    require(type(value) is dict, "condition must be an object", path)
+    for combinator in ("all", "any"):
+        if combinator in value:
+            require(set(value) == {combinator}, "combinator must be alone", path)
+            items = value[combinator]
+            require(
+                type(items) is list and bool(items),
+                "combinator needs predicates",
+                path + "." + combinator,
+            )
+            return {
+                _predicate(item, attributes, f"{path}.{combinator}[{index}]")
+                for index, item in enumerate(items)
+            }
+    return {_predicate(value, attributes, path)}
+
+
+def parse_attribute_rules(value: Any, attributes: dict, path: str) -> None:
+    """Closed conditional applicability/requiredness rules (x4d-devkit #220)."""
+
+    rules = unique_ids(value, path, nonempty=True)
+    depends: dict[str, set[str]] = {}
+    for rule_id, rule in rules.items():
+        target = f"{path}.{rule_id}"
+        fields(rule, {"id", "attributes", "required"}, target, optional={"when"})
+        governed = rows(rule["attributes"], target + ".attributes", nonempty=True)
+        require(
+            all(type(name) is str and name in attributes for name in governed)
+            and len(set(governed)) == len(governed),
+            "rule attributes must be unique attributes of this category",
+            target + ".attributes",
+        )
+        for name in governed:
+            definition = attributes[name]
+            require(
+                "object" in definition["scopes"] and not definition["required"],
+                "governed attributes must be optional object attributes",
+                target + ".attributes." + name,
+            )
+        required = rows(rule["required"], target + ".required")
+        require(
+            all(type(name) is str for name in required)
+            and len(set(required)) == len(required)
+            and set(required) <= set(governed),
+            "required must be a unique subset of attributes",
+            target + ".required",
+        )
+        reads = (
+            _condition(rule["when"], attributes, target + ".when")
+            if "when" in rule
+            else set()
+        )
+        for name in governed:
+            depends.setdefault(name, set()).update(reads)
+    visiting: set[str] = set()
+    done: set[str] = set()
+
+    def visit(name: str) -> None:
+        require(name not in visiting, "rule dependencies must be acyclic", path)
+        if name in done:
+            return
+        visiting.add(name)
+        for parent in sorted(depends.get(name, ())):
+            visit(parent)
+        visiting.discard(name)
+        done.add(name)
+
+    for name in sorted(depends):
+        visit(name)
+
+
 def parse_image_schema_body(value: Any) -> ImageSchemaBody:
     canonical(value)
     fields(
@@ -162,7 +282,7 @@ def parse_image_schema_body(value: Any) -> ImageSchemaBody:
             category,
             {"id", "display_name", "geometry_type", "color", "attributes"},
             path,
-            optional={"groupable"},
+            optional={"groupable", "rules"},
         )
         if "groupable" in category:
             require(
@@ -233,8 +353,12 @@ def parse_image_schema_body(value: Any) -> ImageSchemaBody:
                 target + ".values",
             )
             for item in values.values():
-                fields(item, {"id", "display_name"}, target + ".values")
+                fields(item, {"id", "display_name"}, target + ".values", optional={"term"})
                 text(item["display_name"], target + ".values.display_name")
+                if "term" in item:
+                    _term(item["term"], target + ".values." + item["id"] + ".term")
+        if "rules" in category:
+            parse_attribute_rules(category["rules"], attributes, path + ".rules")
     views = unique_ids(value["task_views"], "schema.task_views")
     used = set()
     for name, view in views.items():
@@ -275,7 +399,16 @@ def parse_image_schema_body(value: Any) -> ImageSchemaBody:
         )
         for item in descriptions.values():
             fields(
-                item, {"id", "display_name", "required"}, path + ".description_fields"
+                item,
+                {"id", "display_name", "required"},
+                path + ".description_fields",
+                optional={"target"},
+            )
+            require(
+                "target" not in item
+                or (type(item["target"]) is str and item["target"] in {"object", "image"}),
+                "description target must be object or image",
+                path + ".description_fields.target",
             )
             text(item["display_name"], path + ".description_fields.display_name")
             require(

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/x4d_devkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: x4d-devkit
-Version: 0.52.0rc1
+Version: 0.52.0rc2
 Summary: Official X-4D external SDK and CLI for datasets, platform APIs, training bridges, and automation
 Author: windzu
 License-Expression: Apache-2.0

{x4d_devkit-0.52.0rc1 → x4d_devkit-0.52.0rc2}/x4d_devkit.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_detection_eval.py
 tests/test_evaluate.py
 tests/test_export_bundle.py
 tests/test_image_clip.py
+tests/test_image_conditional_rules.py
 tests/test_image_enum_set.py
 tests/test_image_export.py
 tests/test_image_geometry.py