liminal-orm 1.1.4__tar.gz → 2.0.0__tar.gz

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liminal-orm
-Version: 1.1.4
+Version: 2.0.0
 Summary: An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync.
 Home-page: https://github.com/dynotx/liminal-orm
 Author: DynoTx Open Source
@@ -41,13 +41,12 @@ Liminal ORM<sup>1</sup> is an open-source Python package that builds on [Benchli
 Liminal provides an ORM framework using [SQLAlchemy](https://github.com/sqlalchemy/sqlalchemy) along with a schema migration service inspired by [Alembic](https://alembic.sqlalchemy.org/en/latest/). This allows you to define your Benchling schemas in code and create a *single source of truth* that synchronizes between your upstream Benchling tenant(s) and downstream dependencies. By creating a standard interface and through using one-line CLI<sup>3</sup> commands, Liminal enables a code-first approach for managing Benchling tenants and accessing Benchling data. With the schemas defined in code, you can also take advantage of the additional capabilities that the Liminal toolkit provides. This includes:
 
 - The ability to run migrations to your Benchling tenant(s) through an easy to use CLI.
-- One source of truth defined in code for your Benchling schema model that your many Benchling tenants can stay in sync with.
 - Easy to implement validation rules to reflect business logic for all of your Benchling entities.
 - Strongly typed queries for all your Benchling entities.
 - CI/CD integration with GitHub Actions to ensure that your Benchling schemas and code are always in sync.
 - And more based on community contributions/feedback :)
 
-If you are a Benchling user, try out Liminal by following the [**Quick Start Guide**](https://dynotx.github.io/liminal-orm/getting-started/prerequisites/)! Reach out in the [Discussions](https://github.com/dynotx/liminal-orm/discussions) forum with any questions or to simply introduce yourself! If there is something blocking you from using Liminal or you're having trouble setting Liminal up, please share in [Issues](https://github.com/dynotx/liminal-orm/issues) or reach out directly (contact information below). You can expect responses within 48 hours :)
+If you are a Benchling user, try out Liminal by following the [**Quick Start Guide**](https://dynotx.github.io/liminal-orm/getting-started/prerequisites/)! Reach out in the [Slack community](https://join.slack.com/t/liminalorm/shared_invite/zt-2ujrp07s3-bctook4e~cAjn1LgOLVY~Q) (preferred method) with any questions or to simply introduce yourself! If there is something blocking you from using Liminal or you're having trouble setting Liminal up, please share in [Issues](https://github.com/dynotx/liminal-orm/issues) or reach out directly (info below).
 
 Benchling is an industry standard cloud platform for life sciences R&D. Liminal builds on top of Benchling's platform and assumes that you already have a Benchling tenant set up and have (or have access to) an admin user account. If not, learn more about getting started with Benchling [here](https://www.benchling.com/explore-benchling)!
 
@@ -67,6 +66,7 @@ If you or your organization use Liminal, please consider adding yourself or your
 - [Community](#community)
 - [Contributing](#contributing)
 - [License](#license)
+- [Direct Contact](#direct-contact)
 - [Acknowledgements](#acknowledgements)
 - [Footnotes](#footnotes)
 
@@ -83,22 +83,19 @@ With your schemas defined in code, you can now take advantage of the additional
 1. Entity validation: Easily create custom validation rules for your Benchling entities.
 
     ```python
-    from liminal.validation import BenchlingValidator, BenchlingValidatorReport, BenchlingReportLevel
-    from liminal.orm.base_model import BaseModel
-
-    class CookTempValidator(BenchlingValidator):
-        """Validates that a field value is a valid enum value for a Benchling entity"""
-
-        def validate(self, entity: type[BaseModel]) -> BenchlingValidatorReport:
-            valid = True
-            message = None
-            if entity.cook_time is not None and entity.cook_temp is None:
-                valid = False
-                message = "Cook temp is required if cook time is set"
-            if entity.cook_time is None and entity.cook_temp is not None:
-                valid = False
-                message = "Cook time is required if cook temp is set"
-            return self.create_report(valid, BenchlingReportLevel.MED, entity, message)
+    from liminal.validation import ValidationSeverity, liminal_validator
+
+    class Pizza(BaseModel, CustomEntityMixin):
+        ...
+
+        @liminal_validator(ValidationSeverity.MED)
+        def cook_time_and_temp_validator(self) -> None:
+            if self.cook_time is not None and self.cook_temp is None:
+                raise ValueError("Cook temp is required if cook time is set")
+            if self.cook_time is None and self.cook_temp is not None:
+                raise ValueError("Cook time is required if cook temp is set")
+
+    validation_reports = Pizza.validate(session)
     ```
 
 2. Strongly typed queries: Write type-safe queries using SQLAlchemy to access your Benchling entities.
@@ -106,7 +103,6 @@ With your schemas defined in code, you can now take advantage of the additional
     ```python
     with BenchlingSession(benchling_connection, with_db=True) as session:
         pizza = session.query(Pizza).filter(Pizza.name == "Margherita").first()
-        print(pizza)
     ```
 
 3. CI/CD integration: Use Liminal to automatically generate and apply your revision files to your Benchling tenant(s) as part of your CI/CD pipeline.
@@ -136,6 +132,7 @@ Liminal ORM is distributed under the [Apache License, Version 2.0](./LICENSE.md)
 
 ## [Direct Contact](#direct-contact)
 
+- Liminal Community Slack group: [Join here](https://join.slack.com/t/liminalorm/shared_invite/zt-2ujrp07s3-bctook4e~cAjn1LgOLVY~Q)
 - Email: <opensource@dynotx.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/README.md

@@ -10,13 +10,12 @@ Liminal ORM<sup>1</sup> is an open-source Python package that builds on [Benchli
 Liminal provides an ORM framework using [SQLAlchemy](https://github.com/sqlalchemy/sqlalchemy) along with a schema migration service inspired by [Alembic](https://alembic.sqlalchemy.org/en/latest/). This allows you to define your Benchling schemas in code and create a *single source of truth* that synchronizes between your upstream Benchling tenant(s) and downstream dependencies. By creating a standard interface and through using one-line CLI<sup>3</sup> commands, Liminal enables a code-first approach for managing Benchling tenants and accessing Benchling data. With the schemas defined in code, you can also take advantage of the additional capabilities that the Liminal toolkit provides. This includes:
 
 - The ability to run migrations to your Benchling tenant(s) through an easy to use CLI.
-- One source of truth defined in code for your Benchling schema model that your many Benchling tenants can stay in sync with.
 - Easy to implement validation rules to reflect business logic for all of your Benchling entities.
 - Strongly typed queries for all your Benchling entities.
 - CI/CD integration with GitHub Actions to ensure that your Benchling schemas and code are always in sync.
 - And more based on community contributions/feedback :)
 
-If you are a Benchling user, try out Liminal by following the [**Quick Start Guide**](https://dynotx.github.io/liminal-orm/getting-started/prerequisites/)! Reach out in the [Discussions](https://github.com/dynotx/liminal-orm/discussions) forum with any questions or to simply introduce yourself! If there is something blocking you from using Liminal or you're having trouble setting Liminal up, please share in [Issues](https://github.com/dynotx/liminal-orm/issues) or reach out directly (contact information below). You can expect responses within 48 hours :)
+If you are a Benchling user, try out Liminal by following the [**Quick Start Guide**](https://dynotx.github.io/liminal-orm/getting-started/prerequisites/)! Reach out in the [Slack community](https://join.slack.com/t/liminalorm/shared_invite/zt-2ujrp07s3-bctook4e~cAjn1LgOLVY~Q) (preferred method) with any questions or to simply introduce yourself! If there is something blocking you from using Liminal or you're having trouble setting Liminal up, please share in [Issues](https://github.com/dynotx/liminal-orm/issues) or reach out directly (info below).
 
 Benchling is an industry standard cloud platform for life sciences R&D. Liminal builds on top of Benchling's platform and assumes that you already have a Benchling tenant set up and have (or have access to) an admin user account. If not, learn more about getting started with Benchling [here](https://www.benchling.com/explore-benchling)!
 
@@ -36,6 +35,7 @@ If you or your organization use Liminal, please consider adding yourself or your
 - [Community](#community)
 - [Contributing](#contributing)
 - [License](#license)
+- [Direct Contact](#direct-contact)
 - [Acknowledgements](#acknowledgements)
 - [Footnotes](#footnotes)
 
@@ -52,22 +52,19 @@ With your schemas defined in code, you can now take advantage of the additional
 1. Entity validation: Easily create custom validation rules for your Benchling entities.
 
     ```python
-    from liminal.validation import BenchlingValidator, BenchlingValidatorReport, BenchlingReportLevel
-    from liminal.orm.base_model import BaseModel
-
-    class CookTempValidator(BenchlingValidator):
-        """Validates that a field value is a valid enum value for a Benchling entity"""
-
-        def validate(self, entity: type[BaseModel]) -> BenchlingValidatorReport:
-            valid = True
-            message = None
-            if entity.cook_time is not None and entity.cook_temp is None:
-                valid = False
-                message = "Cook temp is required if cook time is set"
-            if entity.cook_time is None and entity.cook_temp is not None:
-                valid = False
-                message = "Cook time is required if cook temp is set"
-            return self.create_report(valid, BenchlingReportLevel.MED, entity, message)
+    from liminal.validation import ValidationSeverity, liminal_validator
+
+    class Pizza(BaseModel, CustomEntityMixin):
+        ...
+
+        @liminal_validator(ValidationSeverity.MED)
+        def cook_time_and_temp_validator(self) -> None:
+            if self.cook_time is not None and self.cook_temp is None:
+                raise ValueError("Cook temp is required if cook time is set")
+            if self.cook_time is None and self.cook_temp is not None:
+                raise ValueError("Cook time is required if cook temp is set")
+
+    validation_reports = Pizza.validate(session)
     ```
 
 2. Strongly typed queries: Write type-safe queries using SQLAlchemy to access your Benchling entities.
@@ -75,7 +72,6 @@ With your schemas defined in code, you can now take advantage of the additional
     ```python
     with BenchlingSession(benchling_connection, with_db=True) as session:
         pizza = session.query(Pizza).filter(Pizza.name == "Margherita").first()
-        print(pizza)
     ```
 
 3. CI/CD integration: Use Liminal to automatically generate and apply your revision files to your Benchling tenant(s) as part of your CI/CD pipeline.
@@ -105,6 +101,7 @@ Liminal ORM is distributed under the [Apache License, Version 2.0](./LICENSE.md)
 
 ## [Direct Contact](#direct-contact)
 
+- Liminal Community Slack group: [Join here](https://join.slack.com/t/liminalorm/shared_invite/zt-2ujrp07s3-bctook4e~cAjn1LgOLVY~Q)
 - Email: <opensource@dynotx.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/base/base_operation.py

@@ -19,9 +19,10 @@ Order of operations based on order class var:
     12. UnarchiveField
     13. UpdateField
     14. ArchiveField
-    15. ReorderFields
-    16. ArchiveSchema
-    17. ArchiveDropdown
+    15. UpdateEntitySchemaNameTemplate
+    16. ReorderFields
+    17. ArchiveSchema
+    18. ArchiveDropdown
 """
 
 

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/base/base_validation_filters.py

@@ -7,6 +7,21 @@ class BaseValidatorFilters(BaseModel):
     """
     This class is used to pass base filters to benchling warehouse database queries.
     These columns are found on all tables in the benchling warehouse database.
+
+    Parameters
+    ----------
+    created_date_start: date | None
+        Start date for created date filter.
+    created_date_end: date | None
+        End date for created date filter.
+    updated_date_start: date | None
+        Start date for updated date filter.
+    updated_date_end: date | None
+        End date for updated date filter.
+    entity_ids: list[str] | None
+        List of entity IDs to filter by.
+    creator_full_names: list[str] | None
+        List of creator full names to filter by.
     """
 
     created_date_start: date | None = None

liminal_orm-2.0.0/liminal/base/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-1.1.4 → liminal_orm-2.0.0}/liminal/base/properties/base_field_properties.py

@@ -65,7 +65,7 @@ class BaseFieldProperties(BaseModel):
         self.warehouse_name = wh_name
         return self
 
-    def validate_column(self, wh_name: str) -> bool:
+    def validate_column_definition(self, wh_name: str) -> bool:
         """If the Field Properties are meant to represent a column in Benchling,
         this will validate the properties and ensure that the entity_link and dropdowns are valid names that exist in our code.
         """
@@ -122,4 +122,4 @@ class BaseFieldProperties(BaseModel):
 
     def __repr__(self) -> str:
         """Generates a string representation of the class so that it can be executed."""
-        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_defaults=True).items()])})"
+        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_unset=True, exclude_defaults=True).items()])})"

liminal_orm-2.0.0/liminal/base/properties/base_name_template.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from liminal.base.name_template_parts import NameTemplateParts
+
+
+class BaseNameTemplate(BaseModel):
+    """
+    This class is the generic class for defining the name template.
+    It is used to create a diff between the old and new name template.
+
+    Parameters
+    ----------
+    parts : list[NameTemplatePart] | None
+        The list of name template parts that make up the name template (order matters).
+    order_name_parts_by_sequence : bool | None
+        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.
+    """
+
+    parts: list[NameTemplateParts] | None = None
+    order_name_parts_by_sequence: bool | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def merge(self, new_props: BaseNameTemplate) -> dict[str, Any]:
+        """Creates a diff between the current name template and the new name template.
+        Sets value to None if the values are equal, otherwise sets the value to the new value.
+
+        Parameters
+        ----------
+        new_props : BaseNameTemplate
+            The new name template.
+
+        Returns
+        -------
+        dict[str, Any]
+            A dictionary of the differences between the old and new name template.
+        """
+        diff = {}
+        for field_name in self.model_fields:
+            new_val = getattr(new_props, field_name)
+            if getattr(self, field_name) != new_val:
+                diff[field_name] = new_val
+        return diff
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BaseNameTemplate):
+            return False
+        return self.model_dump() == other.model_dump()
+
+    def __str__(self) -> str:
+        parts_str = (
+            f"parts=[{', '.join(repr(part) for part in self.parts)}]"
+            if self.parts is not None
+            else None
+        )
+        order_name_parts_by_sequence_str = (
+            f"order_name_parts_by_sequence={self.order_name_parts_by_sequence}"
+            if self.order_name_parts_by_sequence is not None
+            else None
+        )
+        return ", ".join(filter(None, [parts_str, order_name_parts_by_sequence_str]))
+
+    def __repr__(self) -> str:
+        """Generates a string representation of the class so that it can be executed."""
+        model_dump = self.model_dump(exclude_defaults=True, exclude_unset=True)
+        props = []
+        if "parts" in model_dump:
+            parts_repr = (
+                f"[{', '.join(repr(part) for part in self.parts)}]"
+                if self.parts
+                else "[]"
+            )
+            props.append(f"parts={parts_repr}")
+        if "order_name_parts_by_sequence" in model_dump:
+            props.append(
+                f"order_name_parts_by_sequence={self.order_name_parts_by_sequence}"
+            )
+        return f"{self.__class__.__name__}({', '.join(props)})"

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/base/properties/base_schema_properties.py

@@ -57,8 +57,17 @@ class BaseSchemaProperties(BaseModel):
         The prefix to use for the schema.
     entity_type : BenchlingEntityType | None
         The entity type of the schema.
+    naming_strategies : set[BenchlingNamingStrategy] | None
+        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.
     """
@@ -69,6 +78,9 @@ class BaseSchemaProperties(BaseModel):
     entity_type: BenchlingEntityType | None = None
     naming_strategies: set[BenchlingNamingStrategy] | None = None
     mixture_schema_config: MixtureSchemaConfig | None = None
+    use_registry_id_as_label: bool | None = None
+    include_registry_id_in_chips: bool | None = None
+    constraint_fields: set[str] | None = None
     _archived: bool | None = None
 
     def __init__(self, **data: Any):
@@ -109,4 +121,4 @@ class BaseSchemaProperties(BaseModel):
 
     def __repr__(self) -> str:
         """Generates a string representation of the class so that it can be executed."""
-        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_defaults=True).items()])})"
+        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_unset=True, exclude_defaults=True).items()])})"

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/dropdowns/compare.py

@@ -1,3 +1,5 @@
+import logging
+
 from benchling_sdk.models import Dropdown
 
 from liminal.base.base_dropdown import BaseDropdown
@@ -13,6 +15,8 @@ from liminal.dropdowns.operations import (
 )
 from liminal.dropdowns.utils import get_benchling_dropdowns_dict
 
+LOGGER = logging.getLogger(__name__)
+
 
 def compare_dropdowns(
     benchling_service: BenchlingService, dropdown_names: set[str] | None = None
@@ -23,6 +27,10 @@ def compare_dropdowns(
     )
     processed_benchling_names = set()
     model_dropdowns = BaseDropdown.get_all_subclasses(dropdown_names)
+    if len(model_dropdowns) == 0 and len(benchling_dropdowns.keys()) > 0:
+        LOGGER.warning(
+            "WARNING: No dropdown classes found that inherit from BaseDropdown. Ensure that the dropdown classes are defined and imported correctly."
+        )
     if dropdown_names:
         benchling_dropdowns = {
             name: benchling_dropdowns[name]

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/dropdowns/operations.py

@@ -76,7 +76,7 @@ class CreateDropdown(BaseOperation):
 
 
 class ArchiveDropdown(BaseOperation):
-    order: ClassVar[int] = 190
+    order: ClassVar[int] = 180
 
     def __init__(self, dropdown_name: str) -> None:
         self.dropdown_name = dropdown_name

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/entity_schemas/api.py

@@ -75,3 +75,21 @@ def update_tag_schema(
         return await_queued_response(
             queued_response.json()["status_url"], benchling_service
         )
+
+
+def set_tag_schema_name_template(
+    benchling_service: BenchlingService, entity_schema_id: str, payload: dict[str, Any]
+) -> dict[str, Any]:
+    """
+    Update the tag schema name template. Must be in a separate endpoint compared to update_tag_schema.
+    """
+    with requests.Session() as session:
+        response = session.post(
+            f"https://{benchling_service.benchling_tenant}.benchling.com/1/api/tag-schemas/{entity_schema_id}/actions/set-name-template",
+            data=json.dumps(payload),
+            headers=benchling_service.custom_post_headers,
+            cookies=benchling_service.custom_post_cookies,
+        )
+        if not response.ok:
+            raise Exception("Failed to set tag schema name template:", response.content)
+        return response.json()

{liminal_orm-1.1.4 → liminal_orm-2.0.0}/liminal/entity_schemas/compare.py

@@ -1,5 +1,8 @@
+import logging
+
 from liminal.base.compare_operation import CompareOperation
 from liminal.base.properties.base_field_properties import BaseFieldProperties
+from liminal.base.properties.base_name_template import BaseNameTemplate
 from liminal.base.properties.base_schema_properties import BaseSchemaProperties
 from liminal.connection import BenchlingService
 from liminal.entity_schemas.operations import (
@@ -12,12 +15,15 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
+    UpdateEntitySchemaNameTemplate,
 )
 from liminal.entity_schemas.utils import get_converted_tag_schemas
 from liminal.orm.base_model import BaseModel
 from liminal.orm.column import Column
 from liminal.utils import to_snake_case
 
+LOGGER = logging.getLogger(__name__)
+
 
 def compare_entity_schemas(
     benchling_service: BenchlingService, schema_names: set[str] | None = None
@@ -46,13 +52,18 @@ def compare_entity_schemas(
         for m in BaseModel.get_all_subclasses(schema_names)
         if not m.__schema_properties__._archived
     ]
+    if len(models) == 0 and len(benchling_schemas) > 0:
+        LOGGER.warning(
+            "WARNING: No model classes found that inherit from BaseModel. Ensure that the model classes are defined and imported correctly."
+        )
+
     archived_benchling_schema_wh_names = [
-        s.warehouse_name for s, _ in benchling_schemas if s._archived is True
+        s.warehouse_name for s, _, _ in benchling_schemas if s._archived is True
     ]
     # Running list of schema names from benchling. As each model is checked, remove the schema name from this list.
     # This is used at the end to check if there are any schemas left (schemas that exist in benchling but not in code) and archive them if they are.
     running_benchling_schema_names = list(
-        [s.warehouse_name for s, _ in benchling_schemas]
+        [s.warehouse_name for s, _, _ in benchling_schemas]
     )
     # Iterate through each benchling model defined in code.
     for model in models:
@@ -61,15 +72,17 @@ def compare_entity_schemas(
             exclude_base_columns=True
         )
         # Validate the entity_link and dropdown_link reference an entity_schema or dropdown that exists in code.
-        model.validate_model()
+        model.validate_model_definition()
         # if the model table_name is found in the benchling schemas, check for changes...
         if (model_wh_name := model.__schema_properties__.warehouse_name) in [
-            s.warehouse_name for s, _ in benchling_schemas
+            s.warehouse_name for s, _, _ in benchling_schemas
         ]:
-            benchling_schema_props, benchling_schema_fields = next(
-                (s, lof)
-                for s, lof in benchling_schemas
-                if s.warehouse_name == model_wh_name
+            benchling_schema_props, benchling_name_template, benchling_schema_fields = (
+                next(
+                    (s, nt, lof)
+                    for s, nt, lof in benchling_schemas
+                    if s.warehouse_name == model_wh_name
+                )
             )
             archived_benchling_schema_fields = {
                 k: v for k, v in benchling_schema_fields.items() if v._archived is True
@@ -237,6 +250,23 @@ def compare_entity_schemas(
                         ),
                     ),
                 )
+            if benchling_name_template != model.__name_template__:
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchemaNameTemplate(
+                            model.__schema_properties__.warehouse_name,
+                            BaseNameTemplate(
+                                **benchling_name_template.merge(model.__name_template__)
+                            ),
+                        ),
+                        reverse_op=UpdateEntitySchemaNameTemplate(
+                            model.__schema_properties__.warehouse_name,
+                            BaseNameTemplate(
+                                **model.__name_template__.merge(benchling_name_template)
+                            ),
+                        ),
+                    )
+                )
         # If the model is not found as the benchling schema, Create.
         # Benchling api does not allow for setting a custom warehouse_name,
         # so we need to run another UpdateEntitySchema to set the warehouse_name if it is different from the snakecase version of the model name.
@@ -276,6 +306,30 @@ def compare_entity_schemas(
                         ),
                     )
                 )
+            benchling_given_name_template = BaseNameTemplate(
+                parts=[], order_name_parts_by_sequence=False
+            )
+            if benchling_name_template != model.__name_template__:
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchemaNameTemplate(
+                            model.__schema_properties__.warehouse_name,
+                            BaseNameTemplate(
+                                **benchling_given_name_template.merge(
+                                    model.__name_template__
+                                )
+                            ),
+                        ),
+                        reverse_op=UpdateEntitySchemaNameTemplate(
+                            model.__schema_properties__.warehouse_name,
+                            BaseNameTemplate(
+                                **benchling_given_name_template.merge(
+                                    model.__name_template__
+                                )
+                            ),
+                        ),
+                    )
+                )
 
         model_operations[model.__schema_properties__.warehouse_name] = ops
         running_benchling_schema_names = [