liminal-orm 1.1.3__py3-none-any.whl → 2.0.0__py3-none-any.whl

liminal/orm/base_model.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import inspect
 import logging
-from abc import abstractmethod
+from types import FunctionType
 from typing import TYPE_CHECKING, Any, Generic, Type, TypeVar  # noqa: UP035
 
 import pandas as pd  # type: ignore
@@ -11,13 +12,13 @@ from sqlalchemy.orm import Query, RelationshipProperty, Session, relationship
 from sqlalchemy.orm.decl_api import declared_attr
 
 from liminal.base.base_validation_filters import BaseValidatorFilters
+from liminal.base.name_template_parts import FieldPart
+from liminal.enums import BenchlingNamingStrategy
 from liminal.orm.base import Base
 from liminal.orm.base_tables.user import User
+from liminal.orm.name_template import NameTemplate
 from liminal.orm.schema_properties import SchemaProperties
-from liminal.validation import (
-    BenchlingValidator,
-    BenchlingValidatorReport,
-)
+from liminal.validation import BenchlingValidatorReport
 
 if TYPE_CHECKING:
     from liminal.orm.column import Column
@@ -32,20 +33,24 @@ class BaseModel(Generic[T], Base):
 
     __abstract__ = True
     __schema_properties__: SchemaProperties
+    __name_template__: NameTemplate = NameTemplate(
+        parts=[], order_name_parts_by_sequence=False
+    )
 
     _existing_schema_warehouse_names: set[str] = set()
     _existing_schema_names: set[str] = set()
-    _existing_schema_prefixes: set[str] = set()
+    _existing_schema_prefixes: list[str] = []
 
     def __init_subclass__(cls, **kwargs: Any):
         super().__init_subclass__(**kwargs)
+        warehouse_name = cls.__schema_properties__.warehouse_name
+        cls.__tablename__ = warehouse_name + "$raw"
         if "__schema_properties__" not in cls.__dict__ or not isinstance(
             cls.__schema_properties__, SchemaProperties
         ):
             raise NotImplementedError(
                 f"{cls.__name__} must define 'schema_properties' class attribute"
             )
-        warehouse_name = cls.__schema_properties__.warehouse_name
         if warehouse_name in cls._existing_schema_warehouse_names:
             raise ValueError(
                 f"Warehouse name '{warehouse_name}' is already used by another subclass."
@@ -54,15 +59,48 @@ class BaseModel(Generic[T], Base):
             raise ValueError(
                 f"Schema name '{cls.__schema_properties__.name}' is already used by another subclass."
             )
-        if cls.__schema_properties__.prefix.lower() in cls._existing_schema_prefixes:
-            raise ValueError(
-                f"Schema prefix '{cls.__schema_properties__.prefix}' is already used by another subclass."
-            )
-
+        column_wh_names = [
+            c[0] for c in cls.__dict__.items() if isinstance(c[1], SqlColumn)
+        ]
+        # Validate constraints
+        if cls.__schema_properties__.constraint_fields:
+            invalid_constraints = [
+                c
+                for c in cls.__schema_properties__.constraint_fields
+                if c not in (set(column_wh_names) | {"bases"})
+            ]
+            if invalid_constraints:
+                raise ValueError(
+                    f"Constraints {', '.join(invalid_constraints)} are not fields on schema {cls.__schema_properties__.name}."
+                )
+        # Validate naming strategies
+        if any(
+            BenchlingNamingStrategy.is_template_based(strategy)
+            for strategy in cls.__schema_properties__.naming_strategies
+        ):
+            if not cls.__name_template__.parts:
+                raise ValueError(
+                    "Name template must be set when using template-based naming strategies."
+                )
+        # Validate name template
+        if cls.__name_template__:
+            if not cls.__schema_properties__.entity_type.is_sequence():
+                if cls.__name_template__.order_name_parts_by_sequence is True:
+                    raise ValueError(
+                        "order_name_parts_by_sequence is only supported for sequence entities. Must be set to False if entity type is not a sequence."
+                    )
+            if cls.__name_template__.parts:
+                field_parts = [
+                    p for p in cls.__name_template__.parts if isinstance(p, FieldPart)
+                ]
+                for field_part in field_parts:
+                    if field_part.wh_field_name not in column_wh_names:
+                        raise ValueError(
+                            f"Field part {field_part.wh_field_name} is not a column on schema {cls.__schema_properties__.name}."
+                        )
         cls._existing_schema_warehouse_names.add(warehouse_name)
         cls._existing_schema_names.add(cls.__schema_properties__.name)
-        cls._existing_schema_prefixes.add(cls.__schema_properties__.prefix.lower())
-        cls.__tablename__ = warehouse_name + "$raw"
+        cls._existing_schema_prefixes.append(cls.__schema_properties__.prefix.lower())
 
     @declared_attr
     def creator_id(cls) -> SqlColumn:
@@ -130,13 +168,22 @@ class BaseModel(Generic[T], Base):
         return {c.name: c for c in columns}
 
     @classmethod
-    def validate_model(cls) -> bool:
+    def validate_model_definition(cls) -> bool:
         model_columns = cls.get_columns_dict(exclude_base_columns=True)
         properties = {n: c.properties for n, c in model_columns.items()}
         errors = []
+        if (
+            cls._existing_schema_prefixes.count(
+                cls.__schema_properties__.prefix.lower()
+            )
+            > 1
+        ):
+            logger.warning(
+                f"{cls.__name__}: schema prefix '{cls.__schema_properties__.prefix}' is already used by another subclass. Please ensure fieldsets=True in BenchlingConnection you are updating/creating this schema."
+            )
         for wh_name, field in properties.items():
             try:
-                field.validate_column(wh_name)
+                field.validate_column_definition(wh_name)
             except ValueError as e:
                 errors.append(str(e))
         if errors:
@@ -224,25 +271,33 @@ class BaseModel(Generic[T], Base):
         """
         return session.query(cls)
 
-    @abstractmethod
-    def get_validators(self) -> list[BenchlingValidator]:
-        """Abstract method that all subclasses must implement. Each subclass will have a differently defined list of
-        validators to validate the entity. These validators will be run on each entity returned from the query.
-        """
-        raise NotImplementedError
+    @classmethod
+    def get_validators(cls) -> list[FunctionType]:
+        """Returns a list of all validators defined on the class. Validators are functions that are decorated with @validator."""
+        validators = []
+        for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+            if hasattr(method, "_is_liminal_validator"):
+                validators.append(method)
+        return validators
 
     @classmethod
     def validate(
-        cls, session: Session, base_filters: BaseValidatorFilters | None = None
+        cls,
+        session: Session,
+        base_filters: BaseValidatorFilters | None = None,
+        only_invalid: bool = False,
     ) -> list[BenchlingValidatorReport]:
         """Runs all validators for all entities returned from the query and returns a list of reports.
+        This returns a report for each entity, validator pair, regardless of whether the validation passed or failed.
 
         Parameters
         ----------
         session : Session
             Benchling database session.
-        base_filters: BenchlingBaseValidatorFilters
+        base_filters: BaseValidatorFilters
             Filters to apply to the query.
+        only_invalid: bool
+            If True, only returns reports for entities that failed validation.
 
         Returns
         -------
@@ -254,15 +309,21 @@ class BaseModel(Generic[T], Base):
             cls.query(session), base_filters=base_filters
         ).all()
         logger.info(f"Validating {len(table)} entities for {cls.__name__}...")
+        validator_functions = cls.get_validators()
         for entity in table:
-            for validator in entity.get_validators():
-                report: BenchlingValidatorReport = validator.validate(entity)
+            for validator_func in validator_functions:
+                report: BenchlingValidatorReport = validator_func(entity)
+                if only_invalid and report.valid:
+                    continue
                 results.append(report)
         return results
 
     @classmethod
     def validate_to_df(
-        cls, session: Session, base_filters: BaseValidatorFilters | None = None
+        cls,
+        session: Session,
+        base_filters: BaseValidatorFilters | None = None,
+        only_invalid: bool = False,
     ) -> pd.DataFrame:
         """Runs all validators for all entities returned from the query and returns reports as a pandas dataframe.
 
@@ -270,7 +331,7 @@ class BaseModel(Generic[T], Base):
         ----------
         session : Session
             Benchling database session.
-        base_filters: BenchlingBaseValidatorFilters
+        base_filters: BaseValidatorFilters
             Filters to apply to the query.
 
         Returns
@@ -278,5 +339,5 @@ class BaseModel(Generic[T], Base):
         pd.Dataframe
             Dataframe of reports from running all validators on all entities returned from the query.
         """
-        results = cls.validate(session, base_filters)
+        results = cls.validate(session, base_filters, only_invalid)
         return pd.DataFrame([r.model_dump() for r in results])

liminal/orm/name_template.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import ConfigDict, field_validator
+
+from liminal.base.name_template_parts import NameTemplateParts, SeparatorPart
+from liminal.base.properties.base_name_template import BaseNameTemplate
+
+
+class NameTemplate(BaseNameTemplate):
+    """
+    This class is the validated class that is public facing and inherits from the BaseNameTemplate class.
+    It has the same fields as the BaseNameTemplate class, but it is validated to ensure that the fields are valid.
+
+    Parameters
+    ----------
+    parts : list[NameTemplatePart] = []
+        The list of name template parts that make up the name template (order matters). Defaults to no parts, an empty list.
+    order_name_parts_by_sequence : bool = False
+        Whether to order the name parts by sequence. This can only be set to True for sequence enity types. If one or many part link fields are included in the name template,
+        list parts in the order they appear on the sequence map, sorted by start position and then end position.Defaults to False.
+    """
+
+    parts: list[NameTemplateParts] = []
+    order_name_parts_by_sequence: bool = False
+
+    @field_validator("parts")
+    def validate_parts(cls, v: list[NameTemplateParts]) -> list[NameTemplateParts]:
+        if len(v) > 0 and all(isinstance(part, SeparatorPart) for part in v):
+            raise ValueError(
+                "This name template will produce an empty name because it only includes separators. Please include at least one non-separator component."
+            )
+        return v
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")

liminal/orm/schema_properties.py

@@ -16,6 +16,30 @@ class SchemaProperties(BaseSchemaProperties):
     """
     This class is the validated class that is public facing and inherits from the BaseSchemaProperties class.
     It has the same fields as the BaseSchemaProperties class, but it is validated to ensure that the fields are valid.
+
+    Parameters
+    ----------
+    name : str
+        The name of the schema.
+    warehouse_name : str
+       The sql table name of the schema in the benchling warehouse.
+    prefix : str
+        The prefix to use for the schema.
+    entity_type : BenchlingEntityType
+        The entity type of the schema.
+    naming_strategies : set[BenchlingNamingStrategy]
+        The naming strategies of the schema.
+    mixture_schema_config : MixtureSchemaConfig | None
+        The mixture schema config of the schema.
+    use_registry_id_as_label : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will use the Registry ID as the main label for items.
+    include_registry_id_in_chips : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will include the Registry ID in the chip label.
+    constraint_fields : set[str] | None
+        Set of constraints for field values for the schema. Must be a set of column names that specify that their values must be a unique combination within an entity.
+        If the entity type is a Sequence, "bases" can be a constraint field.
+    _archived : bool | None
+        Whether the schema is archived in Benchling.
     """
 
     name: str
@@ -23,7 +47,10 @@ class SchemaProperties(BaseSchemaProperties):
     prefix: str
     entity_type: BenchlingEntityType
     naming_strategies: set[BenchlingNamingStrategy]
+    use_registry_id_as_label: bool | None = False
+    include_registry_id_in_chips: bool | None = False
     mixture_schema_config: MixtureSchemaConfig | None = None
+    constraint_fields: set[str] | None = None
     _archived: bool = False
 
     def __init__(self, **data: Any):
@@ -53,7 +80,6 @@ class SchemaProperties(BaseSchemaProperties):
             )
         is_valid_wh_name(self.warehouse_name)
         is_valid_prefix(self.prefix)
-        # TODO:if naming_strategies contains SET_FROM_NAME_PARTS or REPLACE_NAMES_FROM_PARTS, name template for schema must be set
         return self
 
     def set_archived(self, value: bool) -> SchemaProperties:

liminal/tests/conftest.py

@@ -12,6 +12,7 @@ from liminal.enums import BenchlingFieldType as Type
 from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
 from liminal.orm.base_model import BaseModel
 from liminal.orm.column import Column
+from liminal.orm.name_template import NameTemplate
 from liminal.orm.schema_properties import SchemaProperties
 
 FIXTURES = Path(__file__).parent / "fixtures"
@@ -118,13 +119,16 @@ def mock_benchling_dropdowns_archived() -> dict[str, Dropdown]:
 @pytest.fixture
 def mock_benchling_schema(
     mock_benchling_dropdown: type[BaseDropdown],
-) -> list[tuple[SchemaProperties, dict[str, Props]]]:
+) -> list[tuple[SchemaProperties, NameTemplate, dict[str, Props]]]:
     schema_props = SchemaProperties(
         name="Mock Entity",
         warehouse_name="mock_entity",
         prefix="MockEntity",
         entity_type=BenchlingEntityType.CUSTOM_ENTITY,
         naming_strategies=[BenchlingNamingStrategy.NEW_IDS],
+        use_registry_id_as_label=True,
+        include_registry_id_in_chips=False,
+        constraint_fields={"enum_field", "string_field_req"},
     )
     fields = {
         "enum_field": Props(
@@ -234,13 +238,13 @@ def mock_benchling_schema(
             _archived=False,
         ),
     }
-    return [(schema_props, fields)]
+    return [(schema_props, NameTemplate(), fields)]
 
 
 @pytest.fixture
 def mock_benchling_schema_one(
     mock_benchling_dropdown: type[BaseDropdown],
-) -> list[tuple[SchemaProperties, dict[str, Props]]]:
+) -> list[tuple[SchemaProperties, NameTemplate, dict[str, Props]]]:
     schema_props = SchemaProperties(
         name="Mock Entity One",
         warehouse_name="mock_entity_one",
@@ -301,11 +305,13 @@ def mock_benchling_schema_one(
             _archived=False,
         ),
     }
-    return [(schema_props, fields)]
+    return [(schema_props, NameTemplate(), fields)]
 
 
 @pytest.fixture
-def mock_benchling_schema_archived() -> list[tuple[SchemaProperties, dict[str, Props]]]:
+def mock_benchling_schema_archived() -> (
+    list[tuple[SchemaProperties, NameTemplate, dict[str, Props]]]
+):
     schema_props = SchemaProperties(
         name="Mock Entity Small",
         warehouse_name="mock_entity_small",
@@ -335,7 +341,7 @@ def mock_benchling_schema_archived() -> list[tuple[SchemaProperties, dict[str, P
             _archived=False,
         ),
     }
-    return [(schema_props, fields)]
+    return [(schema_props, NameTemplate(), fields)]
 
 
 @pytest.fixture
@@ -347,6 +353,9 @@ def mock_benchling_subclass(mock_benchling_dropdown) -> list[type[BaseModel]]:
             prefix="MockEntity",
             entity_type=BenchlingEntityType.CUSTOM_ENTITY,
             naming_strategies=[BenchlingNamingStrategy.NEW_IDS],
+            use_registry_id_as_label=True,
+            include_registry_id_in_chips=False,
+            constraint_fields={"enum_field", "string_field_req"},
         )
         enum_field: SqlColumn = Column(
             name="Enum Field",
@@ -420,7 +429,7 @@ def mock_benchling_subclass(mock_benchling_dropdown) -> list[type[BaseModel]]:
             self.datetime_field = datetime_field
             self.list_dropdown_field = list_dropdown_field
 
-    return [MockEntity]  # type: ignore[type-abstract]
+    return [MockEntity]
 
 
 @pytest.fixture
@@ -437,7 +446,7 @@ def mock_benchling_subclass_small() -> list[type[BaseModel]]:
             name="String Field Required", type=Type.TEXT, required=True, is_multi=False
         )
 
-    return [MockEntitySmall]  # type: ignore[type-abstract]
+    return [MockEntitySmall]
 
 
 @pytest.fixture
@@ -530,4 +539,4 @@ def mock_benchling_subclasses(mock_benchling_dropdown) -> list[type[BaseModel]]:
             self.datetime_field = datetime_field
             self.list_dropdown_field = list_dropdown_field
 
-    return [MockEntityOne, MockEntityTwo]  # type: ignore[type-abstract]
+    return [MockEntityOne, MockEntityTwo]

liminal/tests/test_entity_schema_compare.py

@@ -1,6 +1,7 @@
 import copy
 from unittest.mock import Mock, patch
 
+from liminal.base.name_template_parts import TextPart
 from liminal.base.properties.base_field_properties import BaseFieldProperties
 from liminal.entity_schemas.compare import compare_entity_schemas
 from liminal.entity_schemas.operations import (
@@ -13,8 +14,10 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
+    UpdateEntitySchemaNameTemplate,
 )
 from liminal.enums import BenchlingFieldType
+from liminal.orm.name_template import NameTemplate
 
 
 class TestCompareEntitySchemas:
@@ -145,7 +148,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema is missing a field compared to the table model
             missing_field = copy.deepcopy(mock_benchling_schema)
-            missing_field[0][1].pop("string_field_req")
+            missing_field[0][2].pop("string_field_req")
             mock_get_benchling_entity_schemas.return_value = missing_field
             invalid_models = compare_entity_schemas(mock_benchling_sdk)
             assert len(invalid_models["mock_entity"]) == 1
@@ -162,7 +165,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has an extra field compared to the table model
             extra_field = copy.deepcopy(mock_benchling_schema)
-            extra_field[0][1]["extra_field"] = BaseFieldProperties(
+            extra_field[0][2]["extra_field"] = BaseFieldProperties(
                 name="Extra Field",
                 type=BenchlingFieldType.TEXT,
                 required=False,
@@ -181,7 +184,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has a required field and the model field is nullable (not required)
             benchling_switched_required_field = copy.deepcopy(mock_benchling_schema)
-            benchling_switched_required_field[0][1]["enum_field"].required = True
+            benchling_switched_required_field[0][2]["enum_field"].required = True
             mock_get_benchling_entity_schemas.return_value = (
                 benchling_switched_required_field
             )
@@ -198,7 +201,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has a non required field and the model field is not nullable (required)
             benchling_switched_required_field = copy.deepcopy(mock_benchling_schema)
-            benchling_switched_required_field[0][1]["string_field_req"].required = False
+            benchling_switched_required_field[0][2]["string_field_req"].required = False
             mock_get_benchling_entity_schemas.return_value = (
                 benchling_switched_required_field
             )
@@ -215,7 +218,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has a non multi field and the model field is a list
             benchling_switched_multi_field = copy.deepcopy(mock_benchling_schema)
-            benchling_switched_multi_field[0][1]["list_dropdown_field"].is_multi = False
+            benchling_switched_multi_field[0][2]["list_dropdown_field"].is_multi = False
             mock_get_benchling_entity_schemas.return_value = (
                 benchling_switched_multi_field
             )
@@ -232,7 +235,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has a multi field and the model field is not a list
             benchling_switched_multi_field = copy.deepcopy(mock_benchling_schema)
-            benchling_switched_multi_field[0][1]["enum_field"].is_multi = True
+            benchling_switched_multi_field[0][2]["enum_field"].is_multi = True
             mock_get_benchling_entity_schemas.return_value = (
                 benchling_switched_multi_field
             )
@@ -249,7 +252,7 @@ class TestCompareEntitySchemas:
 
             # Test when the multi field in the Benchling schema has a different entity type than the model field
             benchling_false_entity_type = copy.deepcopy(mock_benchling_schema)
-            benchling_false_entity_type[0][1][
+            benchling_false_entity_type[0][2][
                 "list_dropdown_field"
             ].type = BenchlingFieldType.INTEGER
             mock_get_benchling_entity_schemas.return_value = benchling_false_entity_type
@@ -266,7 +269,7 @@ class TestCompareEntitySchemas:
 
             # Test when enum field in the Benchling schema has a different enum than the model field
             benchling_false_enum = copy.deepcopy(mock_benchling_schema)
-            benchling_false_enum[0][1][
+            benchling_false_enum[0][2][
                 "enum_field"
             ].dropdown_link = mock_false_benchling_dropdown.__benchling_name__
             mock_get_benchling_entity_schemas.return_value = benchling_false_enum
@@ -299,7 +302,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema has an archived field that is in the model
             create_existing_field_schema = copy.deepcopy(mock_benchling_schema)
-            create_existing_field_schema[0][1]["string_field_req"].set_archived(True)
+            create_existing_field_schema[0][2]["string_field_req"].set_archived(True)
             mock_get_benchling_entity_schemas.return_value = (
                 create_existing_field_schema
             )
@@ -311,7 +314,7 @@ class TestCompareEntitySchemas:
 
             # Test when Benchling schema fields are out of order
             benchling_unordered_fields_schema = copy.deepcopy(mock_benchling_schema)
-            fields = benchling_unordered_fields_schema[0][1]
+            fields = benchling_unordered_fields_schema[0][2]
             keys = list(fields.keys())
             idx1, idx2 = (
                 keys.index("string_field_req"),
@@ -320,7 +323,7 @@ class TestCompareEntitySchemas:
             keys[idx1], keys[idx2] = keys[idx2], keys[idx1]
             new_fields = {k: fields[k] for k in keys}
             new_benchling_unordered_fields_schema = [
-                (benchling_unordered_fields_schema[0][0], new_fields)
+                (benchling_unordered_fields_schema[0][0], NameTemplate(), new_fields)
             ]
             mock_get_benchling_entity_schemas.return_value = (
                 new_benchling_unordered_fields_schema
@@ -333,7 +336,7 @@ class TestCompareEntitySchemas:
 
             # Test when the Benchling schema archived field becomes unarchived
             benchling_rearchived_field = copy.deepcopy(mock_benchling_schema)
-            benchling_rearchived_field[0][1]["archived_field"].set_archived(False)
+            benchling_rearchived_field[0][2]["archived_field"].set_archived(False)
             mock_get_benchling_entity_schemas.return_value = benchling_rearchived_field
             invalid_models = compare_entity_schemas(mock_benchling_sdk)
             assert len(invalid_models["mock_entity"]) == 1
@@ -341,3 +344,49 @@ class TestCompareEntitySchemas:
                 invalid_models["mock_entity"][0].op, ArchiveEntitySchemaField
             )
             assert invalid_models["mock_entity"][0].op.wh_field_name == "archived_field"
+
+            # Test when the Benchling schema has different constraint fields
+            benchling_mismatch_constraint_fields = copy.deepcopy(mock_benchling_schema)
+            benchling_mismatch_constraint_fields[0][0].constraint_fields = {
+                "string_field_req"
+            }
+            mock_get_benchling_entity_schemas.return_value = (
+                benchling_mismatch_constraint_fields
+            )
+            invalid_models = compare_entity_schemas(mock_benchling_sdk)
+            assert len(invalid_models["mock_entity"]) == 1
+            assert isinstance(invalid_models["mock_entity"][0].op, UpdateEntitySchema)
+            assert invalid_models["mock_entity"][
+                0
+            ].op.update_props.constraint_fields == {
+                "string_field_req",
+                "enum_field",
+            }
+
+            # Test when the Benchling schema has different display naming fields
+            benchling_mismatch_display_fields = copy.deepcopy(mock_benchling_schema)
+            benchling_mismatch_display_fields[0][0].use_registry_id_as_label = False
+            mock_get_benchling_entity_schemas.return_value = (
+                benchling_mismatch_display_fields
+            )
+            invalid_models = compare_entity_schemas(mock_benchling_sdk)
+            assert len(invalid_models["mock_entity"]) == 1
+            assert isinstance(invalid_models["mock_entity"][0].op, UpdateEntitySchema)
+            assert invalid_models["mock_entity"][
+                0
+            ].op.update_props.use_registry_id_as_label
+
+            # Test when the Benchling schema has a name template and the schema defined in code does not
+            benchling_mismatch_display_fields = copy.deepcopy(mock_benchling_schema)
+            benchling_mismatch_display_fields[0][1].parts = [
+                TextPart(value="name_template_text")
+            ]
+            mock_get_benchling_entity_schemas.return_value = (
+                benchling_mismatch_display_fields
+            )
+            invalid_models = compare_entity_schemas(mock_benchling_sdk)
+            assert len(invalid_models["mock_entity"]) == 1
+            assert isinstance(
+                invalid_models["mock_entity"][0].op, UpdateEntitySchemaNameTemplate
+            )
+            assert invalid_models["mock_entity"][0].op.update_name_template.parts == []

liminal/utils.py

@@ -15,6 +15,9 @@ def generate_random_id(length: int = 8) -> str:
 
 
 def pascalize(input_string: str) -> str:
+    """
+    Convert a string to PascalCase.
+    """
     return "".join(
         re.sub(r"[\[\]{}():]", "", word).capitalize()
         for word in re.split(r"[ /_\-]", input_string)
@@ -22,6 +25,9 @@ def pascalize(input_string: str) -> str:
 
 
 def to_snake_case(input_string: str | None) -> str:
+    """
+    Convert a string to snake_case.
+    """
     if input_string is None:
         return ""
     return "_".join(
@@ -31,6 +37,9 @@ def to_snake_case(input_string: str | None) -> str:
 
 
 def to_string_val(input_val: Any) -> str:
+    """
+    Convert a value to a string.
+    """
     if isinstance(input_val, list) or isinstance(input_val, set):
         return f'[{", ".join(input_val)}]'
     return str(input_val)