liminal-orm 5.1.0__tar.gz → 5.1.3__tar.gz

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/.gitignore

@@ -20,4 +20,5 @@ site/
 test_liminal/
 
 .history/
-.cursor/
+.cursor/
+.envrc

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: liminal-orm
-Version: 5.1.0
+Version: 5.1.3
 Summary: An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync.
 Project-URL: Homepage, https://github.com/dynotx/liminal-orm
 Project-URL: Repository, https://github.com/dynotx/liminal-orm
 Project-URL: Documentation, https://dynotx.github.io/liminal-orm/
 Project-URL: Bug Tracker, https://github.com/dynotx/liminal-orm/issues
-Author-email: DynoTx Open Source <opensource@dynotx.com>
+Author: DynoTx Open Source
 License-File: LICENSE.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -21,8 +21,8 @@ Requires-Dist: numpy<2,>=1.26; python_version == '3.12'
 Requires-Dist: numpy<3,>=2.1; python_version == '3.13'
 Requires-Dist: pandas<3,>=1.5.3; python_version == '3.10'
 Requires-Dist: pandas<4,>=1.5.3; python_version == '3.11'
+Requires-Dist: pandas<4,>=2.1.1; python_version == '3.12'
 Requires-Dist: pandas<4,>=2.2.3; python_version == '3.13'
-Requires-Dist: pandas<4,>=2.2; python_version == '3.12'
 Requires-Dist: psycopg2-binary<3,>=2.9.10
 Requires-Dist: pydantic<=2.13,>=2
 Requires-Dist: rich<14,>=13.9.2
@@ -136,7 +136,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-3fu79tf06-oqL1000p8BAOG6B3yOOXNA)
-- Email: <opensource@dynotx.com>
+- Email: <ndamania00@gmail.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 
 ## [Acknowledgements](#acknowledgements)

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/README.md

@@ -103,7 +103,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-3fu79tf06-oqL1000p8BAOG6B3yOOXNA)
-- Email: <opensource@dynotx.com>
+- Email: <ndamania00@gmail.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 
 ## [Acknowledgements](#acknowledgements)

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/base/base_operation.py

@@ -16,10 +16,10 @@ Order of operations based on order class var:
     9. CreateEntitySchema
     10. UnarchiveEntitySchema
     11. CreateEntitySchemaField
-    12. UpdateEntitySchemaNameTemplate
-    13. UpdateEntitySchema
-    14. UnarchiveEntitySchemaField
-    15. UpdateEntitySchemaField
+    12. UpdateEntitySchema
+    13. UnarchiveEntitySchemaField
+    14. UpdateEntitySchemaField
+    15. UpdateEntitySchemaNameTemplate
     16. ArchiveEntitySchemaField
     17. ReorderEntitySchemaFields
     18. ArchiveEntitySchema

liminal_orm-5.1.3/liminal/base/compare_operation.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict
+
+from liminal.base.base_operation import BaseOperation
+
+
+class CompareOperation(BaseModel):
+    op: BaseOperation
+    reverse_op: BaseOperation
+    # Overrides op.order when this operation must run at a different point than its type's default.
+    order_override: int | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @property
+    def sort_order(self) -> int:
+        return self.op.order if self.order_override is None else self.order_override
+
+    def __lt__(self, other: "CompareOperation") -> bool:
+        return self.sort_order < other.sort_order

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/base/properties/base_field_properties.py

@@ -65,8 +65,6 @@ class BaseFieldProperties(BaseModel):
         non_multi_types = BenchlingFieldType.get_non_multi_select_types()
         if field_type in non_multi_types:
             unsupported.add("is_multi")
-        if not (has_entity_link and field_type == BenchlingFieldType.ENTITY_LINK):
-            unsupported.add("parent_link")
         if field_type not in BenchlingFieldType.get_number_field_types():
             unsupported.add("unit_name")
         if field_type != BenchlingFieldType.DECIMAL:
@@ -77,7 +75,7 @@ class BaseFieldProperties(BaseModel):
         self._archived = value
         return self
 
-    def set_warehouse_name(self, wh_name: str) -> BaseFieldProperties:
+    def set_warehouse_name(self, wh_name: str | None) -> BaseFieldProperties:
         self.warehouse_name = wh_name
         return self
 
@@ -96,6 +94,10 @@ class BaseFieldProperties(BaseModel):
             self.__pydantic_fields_set__.remove("unit_name")
         return self
 
+    def set_parent_link(self, value: bool) -> BaseFieldProperties:
+        self.parent_link = value
+        return self
+
     def set_type(self, new_type: BenchlingFieldType) -> BaseFieldProperties:
         self.type = new_type
         return self

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/base/properties/base_schema_properties.py

@@ -105,6 +105,11 @@ class BaseSchemaProperties(BaseModel):
         self.naming_strategies = value
         return self
 
+    def unset_naming_strategies(self) -> BaseSchemaProperties:
+        if "naming_strategies" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("naming_strategies")
+        return self
+
     def merge(self, new_props: BaseSchemaProperties) -> dict[str, Any]:
         """Creates a diff between the current schema properties and the new schema properties.
         Sets value to None if the values are equal, otherwise sets the value to the new value.

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/cli/cli.py

@@ -123,7 +123,7 @@ def generate_files(
     benchling_connection = read_local_liminal_dir(LIMINAL_DIR_PATH, benchling_tenant)
     benchling_service = BenchlingService(benchling_connection)
     if not write_path.exists():
-        write_path.mkdir()
+        write_path.mkdir(parents=True)
         print(f"[green]Created directory: {write_path}")
     if not entity_schemas_flag and not dropdowns_flag and not results_schemas_flag:
         entity_schemas_flag = True

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/dropdowns/generate_files.py

@@ -1,3 +1,4 @@
+import json
 import shutil
 from pathlib import Path
 
@@ -5,7 +6,7 @@ from rich import print
 
 from liminal.connection import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdowns_dict
-from liminal.utils import to_pascal_case, to_snake_case
+from liminal.utils import to_module_name, to_pascal_case
 
 
 def generate_all_dropdown_files(
@@ -36,17 +37,17 @@ def generate_all_dropdown_files(
     num_files_written = 0
     for dropdown_name, dropdown_options in dropdowns.items():
         dropdown_values = [option.name for option in dropdown_options.options]
-        options_list = str(dropdown_values).replace("'", '"')
+        options_list = json.dumps(dropdown_values, ensure_ascii=False)
         classname = to_pascal_case(dropdown_name)
         dropdown_content = f"""
 from liminal.base.base_dropdown import BaseDropdown
 
 
 class {classname}(BaseDropdown):
-    __benchling_name__ = "{dropdown_name}"
+    __benchling_name__ = {json.dumps(dropdown_name, ensure_ascii=False)}
     __allowed_values__ = {options_list}
 """
-        filename = to_snake_case(dropdown_name) + ".py"
+        filename = to_module_name(dropdown_name) + ".py"
         if overwrite or not (write_path / filename).exists():
             with open(write_path / filename, "w") as file:
                 file.write(dropdown_content)

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/dropdowns/operations.py

@@ -24,7 +24,6 @@ from liminal.dropdowns.utils import (
     dropdown_exists_in_benchling,
     get_benchling_dropdown_by_name,
     get_benchling_dropdown_summary_by_name,
-    get_schemas_with_dropdown,
 )
 
 LOGGER = logging.getLogger(__name__)
@@ -74,7 +73,7 @@ class CreateDropdown(BaseOperation):
 
 
 class ArchiveDropdown(BaseOperation):
-    order: ClassVar[int] = 180
+    order: ClassVar[int] = 190
 
     def __init__(self, dropdown_name: str) -> None:
         self.dropdown_name = dropdown_name
@@ -85,12 +84,6 @@ class ArchiveDropdown(BaseOperation):
             raise ValueError(f"Dropdown {self.dropdown_name} is already archived.")
         return archive_dropdown(benchling_service, dropdown.id)
 
-    def validate(self, benchling_service: BenchlingService) -> None:
-        if schemas_with_dropdown := get_schemas_with_dropdown(self.dropdown_name):
-            raise ValueError(
-                f"Dropdown {self.dropdown_name} is used in schemas {schemas_with_dropdown}. Cannot archive a dropdown that is in use in non-archived fields."
-            )
-
     def describe_operation(self) -> str:
         return f"{self.dropdown_name}: Archiving dropdown."
 

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/entity_schemas/compare.py

@@ -26,6 +26,9 @@ from liminal.utils import to_snake_case
 
 LOGGER = logging.getLogger(__name__)
 
+# Template based naming strategies need the name template, so the order is overridden to be set right after it.
+NAME_TEMPLATE_NAMING_STRATEGY_ORDER = UpdateEntitySchemaNameTemplate.order + 1
+
 
 def compare_entity_schemas(
     benchling_service: BenchlingService, schema_names: set[str] | None = None
@@ -237,26 +240,50 @@ def compare_entity_schemas(
                         )
                     )
             if benchling_schema_props != model.__schema_properties__:
-                ops.append(
-                    CompareOperation(
-                        op=UpdateEntitySchema(
-                            model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
-                                **benchling_schema_props.merge(
-                                    model.__schema_properties__
-                                )
+                new_schema_props = BaseSchemaProperties(
+                    **benchling_schema_props.merge(model.__schema_properties__)
+                )
+                rollback_schema_props = BaseSchemaProperties(
+                    **model.__schema_properties__.merge(benchling_schema_props)
+                )
+                model_strategies = (
+                    model.__schema_properties__.naming_strategies or set()
+                )
+                benchling_strategies = benchling_schema_props.naming_strategies or set()
+                # A template based naming strategy needs the name template, which runs after UpdateEntitySchema.
+                # So when one is being added, set all the naming strategies in their own operation after the template.
+                if any(
+                    BenchlingNamingStrategy.is_template_based(s)
+                    for s in model_strategies - benchling_strategies
+                ):
+                    new_schema_props.unset_naming_strategies()
+                    rollback_schema_props.unset_naming_strategies()
+                    ops.append(
+                        CompareOperation(
+                            op=UpdateEntitySchema(
+                                model_wh_name,
+                                BaseSchemaProperties(
+                                    naming_strategies=model_strategies
+                                ),
                             ),
-                        ),
-                        reverse_op=UpdateEntitySchema(
-                            model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
-                                **model.__schema_properties__.merge(
-                                    benchling_schema_props
-                                )
+                            reverse_op=UpdateEntitySchema(
+                                model_wh_name,
+                                BaseSchemaProperties(
+                                    naming_strategies=benchling_strategies
+                                ),
+                            ),
+                            order_override=NAME_TEMPLATE_NAMING_STRATEGY_ORDER,
+                        )
+                    )
+                if new_schema_props.model_dump(exclude_unset=True) != {}:
+                    ops.append(
+                        CompareOperation(
+                            op=UpdateEntitySchema(model_wh_name, new_schema_props),
+                            reverse_op=UpdateEntitySchema(
+                                model_wh_name, rollback_schema_props
                             ),
                         ),
-                    ),
-                )
+                    )
             if benchling_name_template != model.__name_template__:
                 ops.append(
                     CompareOperation(
@@ -300,10 +327,23 @@ def compare_entity_schemas(
                 for p in field_props
                 if (p.unit_name and p.warehouse_name)
             }
+            # A link field is created without a target, and Benchling only accepts
+            # parent_link on a field that has one, so it is set with the target.
+            parent_links_to_update = {
+                p.warehouse_name
+                for p in field_props
+                if (p.parent_link and p.entity_link and p.warehouse_name)
+            }
             field_props = [
                 f.unset_tooltip().unset_entity_link().unset_unit_name()
                 for f in field_props
             ]
+            field_props = [
+                f.set_parent_link(False)
+                if f.warehouse_name in parent_links_to_update
+                else f
+                for f in field_props
+            ]
             field_props = [
                 f.set_type(BenchlingFieldType.ENTITY_LINK) if f.entity_link else f
                 for f in field_props
@@ -337,32 +377,20 @@ def compare_entity_schemas(
                 )
             )
             # Benchling api does not allow for setting a custom warehouse_name.
-            # Benchling api also does not allow for setting the name template.
             # Because of this, we need to run a separate UpdateEntitySchema to set the warehouse_name if it is different from the snakecase version of the model name.
-            # We also need to set the template based naming_strategies separately, since the name template must first be set.
-            new_schema_props = BaseSchemaProperties()
-            rollback_schema_props = BaseSchemaProperties()
+            # Later operations on this schema use the model's warehouse_name.
             if model_wh_name != benchling_given_wh_name:
-                new_schema_props.warehouse_name = model_wh_name
-                rollback_schema_props.warehouse_name = benchling_given_wh_name
-            if (
-                model.__schema_properties__.naming_strategies
-                - standard_naming_strategies
-            ):
-                new_schema_props.naming_strategies = (
-                    model.__schema_properties__.naming_strategies
-                )
-                rollback_schema_props.naming_strategies = standard_naming_strategies
-            if new_schema_props.model_dump(exclude_unset=True) != {}:
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchema(
                             benchling_given_wh_name,
-                            new_schema_props,
+                            BaseSchemaProperties(warehouse_name=model_wh_name),
                         ),
                         reverse_op=UpdateEntitySchema(
                             model_wh_name,
-                            rollback_schema_props,
+                            BaseSchemaProperties(
+                                warehouse_name=benchling_given_wh_name
+                            ),
                         ),
                     )
                 )
@@ -382,6 +410,9 @@ def compare_entity_schemas(
                     )
                     rollback_field_props.entity_link = None
                     rollback_field_props.type = BenchlingFieldType.ENTITY_LINK
+                if wh_field_name in parent_links_to_update:
+                    new_field_props.parent_link = True
+                    rollback_field_props.parent_link = False
                 if tooltip_value := tooltips_to_update.get(wh_field_name):
                     new_field_props.tooltip = tooltip_value
                     rollback_field_props.tooltip = None
@@ -403,11 +434,12 @@ def compare_entity_schemas(
             )
             # Benchling api also does not allow for setting the name template when Creating an Entity Schema, since it is a different endpoint.
             # Because of this, we need to run a separate UpdateEntitySchemaNameTemplate using the name template endpoint to set the name template on the newly created Entity Schema.
+            # The name template update runs after the field updates above, since a part can need a link target or parent link set there.
             if benchling_given_name_template != model.__name_template__:
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchemaNameTemplate(
-                            benchling_given_wh_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **benchling_given_name_template.merge(
                                     model.__name_template__
@@ -415,7 +447,7 @@ def compare_entity_schemas(
                             ),
                         ),
                         reverse_op=UpdateEntitySchemaNameTemplate(
-                            benchling_given_wh_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **model.__name_template__.merge(
                                     benchling_given_name_template
@@ -424,6 +456,28 @@ def compare_entity_schemas(
                         ),
                     )
                 )
+            # Template based naming_strategies need the name template, so they are set right after it.
+            if (
+                model.__schema_properties__.naming_strategies
+                - standard_naming_strategies
+            ):
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchema(
+                            model_wh_name,
+                            BaseSchemaProperties(
+                                naming_strategies=model.__schema_properties__.naming_strategies
+                            ),
+                        ),
+                        reverse_op=UpdateEntitySchema(
+                            model_wh_name,
+                            BaseSchemaProperties(
+                                naming_strategies=standard_naming_strategies
+                            ),
+                        ),
+                        order_override=NAME_TEMPLATE_NAMING_STRATEGY_ORDER,
+                    )
+                )
 
         model_operations[model.__schema_properties__.warehouse_name] = ops
         running_benchling_schema_names = [

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/entity_schemas/entity_schema_models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from functools import lru_cache
 from typing import Any
 
@@ -129,18 +130,26 @@ class EntitySchemaFieldModel(BaseModel):
         self.description = (
             update_props.tooltip if "tooltip" in update_diff_names else self.description
         )
-        if "entity_link" in update_diff_names and update_props.entity_link:
-            if benchling_service is None:
-                raise ValueError(
-                    "Benchling SDK must be provided to update entity link field."
+        if "entity_link" in update_diff_names:
+            if update_props.entity_link is None:
+                self.linkDefinition = None
+                # Without a target schema the field is a generic entity link, not e.g. a CustomEntityLinkFieldDefinition.
+                if BenchlingFieldDefinitionType.is_entity_link(self.typename):
+                    self.typename = (
+                        BenchlingFieldDefinitionType.ANY_ENTITY_LINK_FIELD_DEFINITION
+                    )
+            else:
+                if benchling_service is None:
+                    raise ValueError(
+                        "Benchling SDK must be provided to update entity link field."
+                    )
+                linked_schema = EntitySchemaModel.get_one_cached(
+                    benchling_service, update_props.entity_link
+                )
+                self.linkDefinition = FieldLinkDefinitionModel(
+                    id=linked_schema.id,
+                    typename=BenchlingLinkDefinitionType(linked_schema.typename.value),
                 )
-            linked_schema = EntitySchemaModel.get_one_cached(
-                benchling_service, update_props.entity_link
-            )
-            self.linkDefinition = FieldLinkDefinitionModel(
-                id=linked_schema.id,
-                typename=BenchlingLinkDefinitionType(linked_schema.typename.value),
-            )
         if "type" in update_diff_names and update_props.type:
             linked_schema_type = (
                 BenchlingEntityTypeName(self.linkDefinition.typename.value)
@@ -484,7 +493,8 @@ class EntitySchemaModel(BaseModel):
     availableRegistrationNamingOptions: list[BenchlingNamingStrategy] | None = None
     constraint: EntitySchemaConstraintModel | None = None
     nameTemplate: NameTemplateModel | None = None
-    containerNameTemplate: NameTemplateModel | None = None
+    # TODO(#263): Add coverage for containerNameTemplate.
+    containerNameTemplate: dict[str, Any] | None = None
     showResidues: bool | None = None
     typedIconId: str | None = None
     allowMeasuredIngredients: bool | None = None
@@ -519,7 +529,10 @@ class EntitySchemaModel(BaseModel):
                 try:
                     filtered_schemas.append(cls.model_validate(schema))
                 except Exception as e:
-                    print(f"Error validating schema {schema['systemName']}: {e}")
+                    warnings.warn(
+                        f"Skipping schema {schema['systemName']}: failed validation: {e}",
+                        stacklevel=2,
+                    )
         return filtered_schemas
 
     @classmethod

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/entity_schemas/generate_files.py

@@ -9,7 +9,7 @@ from liminal.entity_schemas.utils import get_converted_entity_schemas
 from liminal.enums import BenchlingEntityType, BenchlingFieldType
 from liminal.mappers import map_benchling_type_to_python_type
 from liminal.orm.name_template import NameTemplate
-from liminal.utils import to_pascal_case, to_snake_case
+from liminal.utils import to_module_name, to_python_identifier, to_pascal_case
 
 
 def get_entity_mixin(entity_type: BenchlingEntityType) -> str:
@@ -88,7 +88,7 @@ def generate_all_entity_schema_files(
 
     for schema_properties, name_template, columns in models:
         classname = to_pascal_case(schema_properties.name)
-        filename = to_snake_case(schema_properties.name) + ".py"
+        filename = to_module_name(schema_properties.name) + ".py"
         columns = {key: columns[key] for key in columns}
         import_strings = [
             "from sqlalchemy import Column as SqlColumn",
@@ -109,8 +109,11 @@ def generate_all_entity_schema_files(
         column_strings = []
         dropdowns = []
         relationship_strings = []
-        for col_name, col in columns.items():
+        for wh_col_name, col in columns.items():
+            col_name = to_python_identifier(wh_col_name)
             column_props = col.column_dump()
+            if col_name != wh_col_name:
+                column_props["_warehouse_name"] = wh_col_name
             dropdown_classname = None
             if col.dropdown_link:
                 dropdown_classname = dropdown_name_to_classname_map[col.dropdown_link]
@@ -155,13 +158,14 @@ def generate_all_entity_schema_files(
                         import_strings.append(
                             "from liminal.orm.relationship import multi_relationship"
                         )
-        for col_name, col in columns.items():
+        for wh_col_name, col in columns.items():
+            col_name = to_python_identifier(wh_col_name)
             if not col.required and col.type:
                 init_strings.append(
                     f"""{TAB}{col_name}: {map_benchling_type_to_python_type(col.type).__name__} | None = None,"""
                 )
         init_strings.append("):")
-        for col_name in columns.keys():
+        for col_name in [to_python_identifier(n) for n in columns.keys()]:
             init_strings.append(f"{TAB}self.{col_name} = {col_name}")
         if len(dropdowns) > 0:
             import_strings.append(f"from ...dropdowns import {', '.join(dropdowns)}")
@@ -171,7 +175,8 @@ def generate_all_entity_schema_files(
                 f"from liminal.orm.name_template_parts import {', '.join(sorted(set([part.__class__.__name__ for part in name_template.parts])))}"
             ]
             import_strings.extend(parts_imports)
-        for col_name, col in columns.items():
+        for wh_col_name, col in columns.items():
+            col_name = to_python_identifier(wh_col_name)
             if col.dropdown_link:
                 init_strings.append(
                     TAB

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/entity_schemas/operations.py

@@ -41,7 +41,7 @@ LOGGER = logging.getLogger(__name__)
 
 
 class CreateEntitySchema(BaseOperation):
-    order: ClassVar[int] = 80
+    order: ClassVar[int] = 90
 
     def __init__(
         self,
@@ -81,10 +81,10 @@ class CreateEntitySchema(BaseOperation):
         )
 
     def describe_operation(self) -> str:
-        return f"{self._validated_schema_properties.name}: Creating new entity schema with fields: {', '.join([f.warehouse_name for f in self.fields if f.warehouse_name is not None])}."
+        return f"{self._validated_schema_properties.warehouse_name}: Creating new entity schema with fields: {', '.join([f.warehouse_name for f in self.fields if f.warehouse_name is not None])}."
 
     def describe(self) -> str:
-        return f"{self._validated_schema_properties.name}: Schema is defined in code but not in Benchling."
+        return f"{self._validated_schema_properties.warehouse_name}: Schema is defined in code but not in Benchling."
 
     def validate(self, benchling_service: BenchlingService) -> None:
         if (
@@ -154,9 +154,13 @@ class CreateEntitySchema(BaseOperation):
                 schema, entity_schema_id_to_name_map, dropdowns_map, unit_id_to_name_map
             )
         )
+        # Warehouse name exists in the Liminal operation definition but not in Benchling converted list.
+        # Set the warehouse name to None for operation fields to compare properly.
+        cleaned_op_fields = [f.set_warehouse_name(None) for f in self.fields]
+        benchling_fields = [f for _, f in benchling_fields_props.items()]
         if (
             self._validated_schema_properties != benchling_schema_props
-            or self.fields != [f for _, f in benchling_fields_props.items()]
+            or cleaned_op_fields != benchling_fields
         ):
             raise ValueError(
                 f"Entity schema {self._validated_schema_properties.warehouse_name} is different in code versus Benchling. Cannot unarchive."
@@ -165,7 +169,7 @@ class CreateEntitySchema(BaseOperation):
 
 
 class ArchiveEntitySchema(BaseOperation):
-    order: ClassVar[int] = 170
+    order: ClassVar[int] = 180
 
     def __init__(self, wh_schema_name: str) -> None:
         self.wh_schema_name = wh_schema_name
@@ -193,7 +197,7 @@ class ArchiveEntitySchema(BaseOperation):
 
 
 class UnarchiveEntitySchema(BaseOperation):
-    order: ClassVar[int] = 90
+    order: ClassVar[int] = 100
 
     def __init__(self, wh_schema_name: str) -> None:
         self.wh_schema_name = wh_schema_name
@@ -290,7 +294,7 @@ class UpdateEntitySchema(BaseOperation):
 
 
 class UpdateEntitySchemaNameTemplate(BaseOperation):
-    order: ClassVar[int] = 110
+    order: ClassVar[int] = 150
 
     def __init__(
         self,
@@ -329,7 +333,7 @@ class UpdateEntitySchemaNameTemplate(BaseOperation):
 
 
 class CreateEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 100
+    order: ClassVar[int] = 110
 
     def __init__(
         self,
@@ -442,7 +446,7 @@ class CreateEntitySchemaField(BaseOperation):
 
 
 class ArchiveEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 150
+    order: ClassVar[int] = 160
 
     def __init__(
         self, wh_schema_name: str, wh_field_name: str, index: int | None = None
@@ -634,7 +638,7 @@ class UpdateEntitySchemaField(BaseOperation):
 
 
 class ReorderEntitySchemaFields(BaseOperation):
-    order: ClassVar[int] = 160
+    order: ClassVar[int] = 170
 
     def __init__(self, wh_schema_name: str, new_order: list[str]) -> None:
         self.wh_schema_name = wh_schema_name

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/entity_schemas/utils.py

@@ -164,7 +164,7 @@ def convert_entity_schema_field_to_field_properties(
         if field.linkDefinition
         and field.linkDefinition.typename == BenchlingLinkDefinitionType.DROPDOWN
         else None,
-        parent_link=field.isParent,
+        parent_link=field.isParent or False,
         entity_link=entity_schema_id_to_name_map.get(field.linkDefinition.id)
         if links_to_entity_schema
         else None,

{liminal_orm-5.1.0 → liminal_orm-5.1.3}/liminal/orm/column.py

@@ -104,9 +104,9 @@ class Column(SqlColumn):
             raise ValueError(
                 f"Column {name}: Entity link can only be set if the field type is one of {BenchlingFieldType.get_entity_link_types()}."
             )
-        if parent_link and type not in BenchlingFieldType.get_entity_link_types():
+        if parent_link and type != BenchlingFieldType.ENTITY_LINK:
             raise ValueError(
-                f"Column {name}: Parent link can only be set if the field type is one of {BenchlingFieldType.get_entity_link_types()}."
+                f"Column {name}: Parent link can only be set if the field type is ENTITY_LINK."
             )
         if type in BenchlingFieldType.get_non_multi_select_types() and is_multi is True:
             raise ValueError(