liminal-orm 1.1.4__py3-none-any.whl → 2.0.1__py3-none-any.whl

liminal/orm/name_template_parts.py

@@ -0,0 +1,96 @@
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from liminal.enums.name_template_part_type import NameTemplatePartType
+
+
+class NameTemplatePart(BaseModel):
+    """Base class for all name template parts. These are put together in a list (where order matters) to form a name template.
+
+    Parameters
+    ----------
+    component_type : NameTemplatePartType
+        The type of the component. One of the values in the NameTemplatePartType enum.
+
+    """
+
+    component_type: ClassVar[NameTemplatePartType]
+
+    _type_map: ClassVar[dict[NameTemplatePartType, type["NameTemplatePart"]]] = {}
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        cls._type_map[cls.component_type] = cls
+
+    @classmethod
+    def resolve_type(cls, type: NameTemplatePartType) -> type["NameTemplatePart"]:
+        if type not in cls._type_map:
+            raise ValueError(f"Invalid name template part type: {type}")
+        return cls._type_map[type]
+
+
+class SeparatorPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.SEPARATOR
+    value: str
+
+    @field_validator("value")
+    def validate_value(cls, v: str) -> str:
+        if not v:
+            raise ValueError("value cannot be empty")
+        return v
+
+
+class TextPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.TEXT
+    value: str
+
+    @field_validator("value")
+    def validate_value(cls, v: str) -> str:
+        if not v:
+            raise ValueError("value cannot be empty")
+        return v
+
+
+class CreationYearPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.CREATION_YEAR
+
+
+class CreationDatePart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.CREATION_DATE
+
+
+class FieldPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.FIELD
+    wh_field_name: str
+
+
+class ParentLotNumberPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = (
+        NameTemplatePartType.CHILD_ENTITY_LOT_NUMBER
+    )
+    wh_field_name: str
+
+
+class RegistryIdentifierNumberPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = (
+        NameTemplatePartType.REGISTRY_IDENTIFIER_NUMBER
+    )
+
+
+class ProjectPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.PROJECT
+
+
+NameTemplateParts = (
+    SeparatorPart
+    | TextPart
+    | CreationYearPart
+    | CreationDatePart
+    | FieldPart
+    | RegistryIdentifierNumberPart
+    | ProjectPart
+    | ParentLotNumberPart
+)

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

@@ -13,8 +13,11 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
+    UpdateEntitySchemaNameTemplate,
 )
 from liminal.enums import BenchlingFieldType
+from liminal.orm.name_template import NameTemplate
+from liminal.orm.name_template_parts import TextPart
 
 
 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)

liminal/validation/__init__.py

@@ -1,13 +1,15 @@
-from abc import ABC, abstractmethod
+import inspect
 from datetime import datetime
-from typing import TYPE_CHECKING, Any
+from functools import wraps
+from typing import TYPE_CHECKING, Callable
 
 from pydantic import BaseModel, ConfigDict
 
-from liminal.enums import BenchlingReportLevel
+from liminal.utils import pascalize
+from liminal.validation.validation_severity import ValidationSeverity
 
 if TYPE_CHECKING:
-    from liminal.orm.base_model import BaseModel as BaseModelBenchling
+    from liminal.orm.base_model import BaseModel as BenchlingBaseModel
 
 
 class BenchlingValidatorReport(BaseModel):
@@ -20,7 +22,7 @@ class BenchlingValidatorReport(BaseModel):
         Indicates whether the validation passed or failed.
     model : str
         The name of the model being validated. (eg: NGSSample)
-    level : BenchlingReportLevel
+    level : ValidationSeverity
         The severity level of the validation report.
     validator_name : str | None
         The name of the validator that generated this report. (eg: BioContextValidator)
@@ -44,7 +46,7 @@ class BenchlingValidatorReport(BaseModel):
 
     valid: bool
     model: str
-    level: BenchlingReportLevel
+    level: ValidationSeverity
     validator_name: str | None = None
     entity_id: str | None = None
     registry_id: str | None = None
@@ -57,89 +59,35 @@ class BenchlingValidatorReport(BaseModel):
 
     model_config = ConfigDict(extra="allow")
 
-
-class BenchlingValidator(ABC):
-    """Base class for benchling validators."""
-
-    def __str__(self) -> str:
-        return self.__class__.__name__ + "()"
-
-    def _prefix(self) -> str:
-        """Creates a prefix for the formatted error message which includes the class name and any instance variables.
-        Ex: "BenchlingValidator(field_name=sample_code, field_value=123):"
-        """
-        prefix = f"{self.__class__.__name__}"
-        if vars(self):
-            prefix += "("
-            for key, val in vars(self).items():
-                prefix += f"{key}={self.truncate_msg(val, max_len=50)}, "
-            prefix = prefix[:-2] + "):"
-        else:
-            prefix += ":"
-        return prefix
-
-    @abstractmethod
-    def validate(self, entity: type["BaseModelBenchling"]) -> BenchlingValidatorReport:
-        """Abstract method that all validator subclass must implement. Each subclass will have a differently defined validation
-        function that runs on the given benchling entity.
-
-        Parameters
-        ----------
-        entity : type["BaseModelBenchling"]
-            The Benchling entity to validate.
-
-        Returns
-        -------
-        BenchlingValidatorReport
-            A report indicating whether the validation passed or failed, and any additional metadata.
-        """
-        raise NotImplementedError
-
-    def __getattribute__(self, name: str) -> Any:
-        attr = super().__getattribute__(name)
-        if name == "validate":
-            # Wrap the validate method in a try-except block to catch any unexpected errors that occur during validation.
-            # If an unexpected error occurs, return a BenchlingValidatorReport with the unexpected error message.
-            def try_except_wrapped_func(
-                *args: Any, **kwargs: dict
-            ) -> BenchlingValidatorReport:
-                try:
-                    return attr(*args, **kwargs)
-                except Exception as e:
-                    entity: type[BaseModelBenchling] = args[0]
-                    return BenchlingValidatorReport(
-                        valid=False,
-                        model=entity.__class__.__name__,
-                        validator_name=self.__class__.__name__,
-                        level=BenchlingReportLevel.UNEXPECTED,
-                        entity_id=entity.id,
-                        registry_id=entity.file_registry_id,
-                        entity_name=entity.name,
-                        web_url=entity.url if entity.url else None,
-                        creator_name=entity.creator.name if entity.creator else None,
-                        creator_email=entity.creator.email if entity.creator else None,
-                        updated_date=entity.modified_at,
-                        message=f"Unexpected exception: {e}",
-                    )
-
-            return try_except_wrapped_func
-        return attr
-
     @classmethod
-    def create_report(
+    def create_validation_report(
         cls,
         valid: bool,
-        level: BenchlingReportLevel,
-        entity: type["BaseModelBenchling"],
+        level: ValidationSeverity,
+        entity: type["BenchlingBaseModel"],
+        validator_name: str,
         message: str | None = None,
-        **kwargs: Any,
-    ) -> BenchlingValidatorReport:
-        """Creates a BenchlingValidatorReport with the given parameters."""
-        return BenchlingValidatorReport(
+    ) -> "BenchlingValidatorReport":
+        """Creates a BenchlingValidatorReport with the given parameters.
+
+        Parameters
+        ----------
+        valid: bool
+            Indicates whether the validation passed or failed.
+        level: ValidationSeverity
+            The severity level of the validation report.
+        entity: type[BenchlingBaseModel]
+            The entity being validated.
+        validator_name: str
+            The name of the validator that generated this report.
+        message: str | None
+            A message describing the result of the validation.
+        """
+        return cls(
             valid=valid,
             level=level,
             model=entity.__class__.__name__,
-            validator_name=cls.__name__,
+            validator_name=validator_name,
             entity_id=entity.id,
             registry_id=entity.file_registry_id,
             entity_name=entity.name,
@@ -148,31 +96,59 @@ class BenchlingValidator(ABC):
             creator_email=entity.creator.email if entity.creator else None,
             updated_date=entity.modified_at,
             message=message,
-            **kwargs,
         )
 
-    def format_err(self, *msgs: str | None) -> str:
-        """Creates a formatted error message from the given messages. The first message is prefixed with the class name and any instance variables.
-        Ex: "BenchlingValidator(field_name=sample_code, field_value=123): The field value is invalid | The field value is too long"
-        """
-        ret_val = ""
-        for ind, msg in enumerate(msgs):
-            if ind == 0:
-                if (msg is None) or (msg == ""):
-                    continue
-                elif not msg.startswith(self._prefix()):
-                    ret_val += f"{self._prefix()} {msg}"
-                else:
-                    ret_val += f"{msg}"
-            elif ((msgs[0] is None) or (msgs[0] == "")) and (ind == 1):
-                ret_val += f"{self._prefix()} {msg}"
-            else:
-                ret_val += f" | {msg}"
-        return ret_val
-
-    def truncate_msg(self, msg: Any, max_len: int = 150) -> str:
-        """Shortens the given message to the given max length. If the message is longer than the max length, it is truncated and an ellipsis is added to the end."""
-        msg = str(msg)
-        if len(msg) > max_len:
-            return f"{msg[:max_len]}..."
-        return msg
+
+def liminal_validator(
+    validator_level: ValidationSeverity = ValidationSeverity.LOW,
+    validator_name: str | None = None,
+) -> Callable:
+    """A decorator that validates a function that takes a Benchling entity as an argument and returns None.
+
+    Parameters:
+        validator_level: ValidationSeverity
+            The level of the validator.
+        validator_name: str | None
+            The name of the validator. Defaults to the pascalized name of the function.
+    """
+
+    def decorator(func: Callable[[type["BenchlingBaseModel"]], None]) -> Callable:
+        """Decorator that validates a function that takes a Benchling entity as an argument and returns None."""
+        sig = inspect.signature(func)
+        params = list(sig.parameters.values())
+        if not params or params[0].name != "self" or len(params) > 1:
+            raise TypeError(
+                "Validator must defined in a schema class, where the only argument to this validator must be 'self'."
+            )
+
+        if sig.return_annotation is not None:
+            raise TypeError("The return type must be None.")
+
+        nonlocal validator_name
+        if validator_name is None:
+            validator_name = pascalize(func.__name__)
+
+        @wraps(func)
+        def wrapper(self: type["BenchlingBaseModel"]) -> BenchlingValidatorReport:
+            """Wrapper that runs the validator function and returns a BenchlingValidatorReport."""
+            try:
+                func(self)
+            except Exception as e:
+                return BenchlingValidatorReport.create_validation_report(
+                    valid=False,
+                    level=validator_level,
+                    entity=self,
+                    validator_name=validator_name,
+                    message=str(e),
+                )
+            return BenchlingValidatorReport.create_validation_report(
+                valid=True,
+                level=validator_level,
+                entity=self,
+                validator_name=validator_name,
+            )
+
+        setattr(wrapper, "_is_liminal_validator", True)
+        return wrapper
+
+    return decorator