liminal-orm 1.0.6__py3-none-any.whl → 1.1.0__py3-none-any.whl

liminal/entity_schemas/operations.py

@@ -23,6 +23,7 @@ from liminal.entity_schemas.utils import (
 )
 from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
 from liminal.orm.schema_properties import SchemaProperties
+from liminal.utils import to_snake_case
 
 
 class CreateEntitySchema(BaseOperation):
@@ -31,7 +32,7 @@ class CreateEntitySchema(BaseOperation):
     def __init__(
         self,
         schema_properties: BaseSchemaProperties,
-        fields: dict[str, BaseFieldProperties],
+        fields: list[BaseFieldProperties],
     ) -> None:
         self.schema_properties = schema_properties
         self.fields = fields
@@ -64,11 +65,23 @@ class CreateEntitySchema(BaseOperation):
         )
 
     def describe_operation(self) -> str:
-        return f"{self._validated_schema_properties.name}: Creating new entity schema with fields: {','.join(self.fields.keys())}."
+        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])}."
 
     def describe(self) -> str:
         return f"{self._validated_schema_properties.name}: Schema is defined in code but not in Benchling."
 
+    def validate(self, benchling_service: BenchlingService) -> None:
+        if (
+            not benchling_service.connection.warehouse_access
+            and self._validated_schema_properties.warehouse_name
+            != to_snake_case(self._validated_schema_properties.name)
+        ):
+            raise ValueError(
+                f"Warehouse access is required to set a custom field warehouse name. \
+                Either set warehouse_access to True in BenchlingConnection or set the schema warehouse_name to the given Benchling warehouse name: {to_snake_case(self._validated_schema_properties.name)}. \
+                Reach out to Benchling support if you need help setting up warehouse access."
+            )
+
     def _validate_create(self, benchling_service: BenchlingService) -> None:
         all_schemas = TagSchemaModel.get_all_json(benchling_service)
         if self._validated_schema_properties.name in [
@@ -79,12 +92,6 @@ class CreateEntitySchema(BaseOperation):
             )
         if self._validated_schema_properties.warehouse_name in [
             schema["sqlIdentifier"] for schema in all_schemas
-        ]:
-            raise ValueError(
-                f"Entity schema name {self._validated_schema_properties.name} already exists in Benchling."
-            )
-        if self._validated_schema_properties.warehouse_name in [
-            schema["sqlIdentifier"] for schema in all_schemas
         ]:
             raise ValueError(
                 f"Entity schema warehouse name {self._validated_schema_properties.warehouse_name} already exists in Benchling."
@@ -117,7 +124,7 @@ class CreateEntitySchema(BaseOperation):
         )
         if (
             self._validated_schema_properties != benchling_schema_props
-            or self.fields != benchling_fields_props
+            or self.fields != [f for _, f in benchling_fields_props.items()]
         ):
             raise ValueError(
                 f"Entity schema {self._validated_schema_properties.warehouse_name} is different in code versus Benchling. Cannot unarchive."
@@ -200,6 +207,17 @@ class UpdateEntitySchema(BaseOperation):
     def describe(self) -> str:
         return f"Schema properties for {self.wh_schema_name} are different in code versus Benchling: {str(self.update_props)}."
 
+    def validate(self, benchling_service: BenchlingService) -> None:
+        if (
+            benchling_service.connection.warehouse_access
+            and self.update_props.warehouse_name is not None
+        ):
+            raise ValueError(
+                "Warehouse access is required to change the schema warehouse name. \
+                Either set warehouse_access to True in BenchlingConnection or do not change the warehouse name. \
+                Reach out to Benchling support if you need help setting up warehouse access."
+            )
+
     def _validate(self, benchling_service: BenchlingService) -> TagSchemaModel:
         all_schemas = TagSchemaModel.get_all_json(benchling_service)
         tag_schema = TagSchemaModel.get_one(
@@ -235,69 +253,30 @@ class UpdateEntitySchema(BaseOperation):
         return tag_schema
 
 
-class UpdateEntitySchemaName(BaseOperation):
-    order: ClassVar[int] = 100
-
-    def __init__(
-        self,
-        old_wh_schema_name: str,
-        new_wh_schema_name: str,
-    ) -> None:
-        self.old_wh_schema_name = old_wh_schema_name
-        self.new_wh_schema_name = new_wh_schema_name
-
-    def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
-        tag_schema = self._validate(benchling_service)
-        update = UpdateTagSchemaModel(sqlIdentifier=self.new_wh_schema_name)
-        return update_tag_schema(
-            benchling_service, tag_schema.id, update.model_dump(exclude_unset=True)
-        )
-
-    def _validate(self, benchling_service: BenchlingService) -> TagSchemaModel:
-        all_schemas = TagSchemaModel.get_all(benchling_service)
-        tag_schema = next(
-            (s for s in all_schemas if s.sqlIdentifier == self.old_wh_schema_name), None
-        )
-        if tag_schema is None:
-            raise ValueError(
-                f"Entity schema {self.old_wh_schema_name} does not exist in Benchling."
-            )
-        new_tag_schema = next(
-            (s for s in all_schemas if s.sqlIdentifier == self.new_wh_schema_name), None
-        )
-        if new_tag_schema is not None:
-            raise ValueError(
-                f"Entity schema warehouse name {self.new_wh_schema_name} already exists in Benchling."
-            )
-        return tag_schema
-
-    def describe_operation(self) -> str:
-        return f"{self.old_wh_schema_name}: Renaming entity schema warehouse name to {self.new_wh_schema_name}."
-
-    def describe(self) -> str:
-        return f"{self.old_wh_schema_name}: Entity schema in Benchling has a different warehouse name than in code."
-
-
 class CreateEntitySchemaField(BaseOperation):
     order: ClassVar[int] = 120
 
     def __init__(
         self,
         wh_schema_name: str,
-        wh_field_name: str,
         field_props: BaseFieldProperties,
         index: int,
     ) -> None:
         self.wh_schema_name = wh_schema_name
-        self.wh_field_name = wh_field_name
         self.field_props = field_props
         self.index = index
 
+        self._wh_field_name: str
+        if field_props.warehouse_name:
+            self._wh_field_name = field_props.warehouse_name
+        else:
+            raise ValueError("Field warehouse name is required.")
+
     def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
         try:
             field = TagSchemaModel.get_one(
                 benchling_service, self.wh_schema_name
-            ).get_field(self.wh_field_name)
+            ).get_field(self._wh_field_name)
         except ValueError:
             field = None
         if field is None:
@@ -305,35 +284,35 @@ class CreateEntitySchemaField(BaseOperation):
         else:
             if field.archiveRecord is None:
                 raise ValueError(
-                    f"Field {self.wh_field_name} is already active on entity schema {self.wh_schema_name}."
+                    f"Field {self._wh_field_name} is already active on entity schema {self.wh_schema_name}."
                 )
             dropdowns_map = get_benchling_dropdown_id_name_map(benchling_service)
             if self.field_props == convert_tag_schema_field_to_field_properties(
                 field, dropdowns_map
             ):
                 return UnarchiveEntitySchemaField(
-                    self.wh_schema_name, self.wh_field_name, self.index
+                    self.wh_schema_name, self._wh_field_name, self.index
                 ).execute(benchling_service)
             else:
                 raise ValueError(
-                    f"Field {self.wh_field_name} on entity schema {self.wh_schema_name} is different in code versus Benchling."
+                    f"Field {self._wh_field_name} on entity schema {self.wh_schema_name} is different in code versus Benchling."
                 )
 
     def _execute_create(self, benchling_service: BenchlingService) -> dict[str, Any]:
         tag_schema = TagSchemaModel.get_one(benchling_service, self.wh_schema_name)
         existing_new_field = next(
-            (f for f in tag_schema.allFields if f.systemName == self.wh_field_name),
+            (f for f in tag_schema.allFields if f.systemName == self._wh_field_name),
             None,
         )
         if existing_new_field:
             raise ValueError(
-                f"Field {self.wh_field_name} already exists on entity schema {self.wh_schema_name} and is {'archived' if existing_new_field.archiveRecord is not None else 'active'} in Benchling."
+                f"Field {self._wh_field_name} already exists on entity schema {self.wh_schema_name} and is {'archived' if existing_new_field.archiveRecord is not None else 'active'} in Benchling."
             )
         index_to_insert = (
             self.index if self.index is not None else len(tag_schema.allFields)
         )
         new_field = CreateTagSchemaFieldModel.from_props(
-            self.wh_field_name, self.field_props, benchling_service
+            self.field_props, benchling_service
         )
         fields_for_update = tag_schema.allFields
         fields_for_update.insert(index_to_insert, new_field)  # type: ignore
@@ -344,10 +323,21 @@ class CreateEntitySchemaField(BaseOperation):
         )
 
     def describe_operation(self) -> str:
-        return f"{self.wh_schema_name}: Creating entity schema field '{self.wh_field_name}' at index {self.index}."
+        return f"{self.wh_schema_name}: Creating entity schema field '{self._wh_field_name}' at index {self.index}."
 
     def describe(self) -> str:
-        return f"{self.wh_schema_name}: Entity schema field '{self.wh_field_name}' is not defined in Benchling but is defined in code."
+        return f"{self.wh_schema_name}: Entity schema field '{self._wh_field_name}' is not defined in Benchling but is defined in code."
+
+    def validate(self, benchling_service: BenchlingService) -> None:
+        if (
+            not benchling_service.connection.warehouse_access
+            and self.field_props.warehouse_name != to_snake_case(self.field_props.name)
+        ):
+            raise ValueError(
+                f"Warehouse access is required to set a custom field warehouse name. \
+                Either set warehouse_access to True in BenchlingConnection or set the column variable name to the given Benchling field warehouse name: {to_snake_case(self.field_props.name)}. \
+                Reach out to Benchling support if you need help setting up warehouse access."
+            )
 
 
 class ArchiveEntitySchemaField(BaseOperation):
@@ -480,6 +470,17 @@ class UpdateEntitySchemaField(BaseOperation):
     def describe(self) -> str:
         return f"{self.wh_schema_name}: Entity schema field '{self.wh_field_name}' in Benchling is different than in code: {str(self.update_props)}."
 
+    def validate(self, benchling_service: BenchlingService) -> None:
+        if (
+            not benchling_service.connection.warehouse_access
+            and self.update_props.warehouse_name is not None
+        ):
+            raise ValueError(
+                "Warehouse access is required to change the field warehouse name. \
+                Either set warehouse_access to True in BenchlingConnection or do not change the warehouse name. \
+                Reach out to Benchling support if you need help setting up warehouse access."
+            )
+
     def _validate(self, benchling_service: BenchlingService) -> TagSchemaModel:
         tag_schema = TagSchemaModel.get_one(benchling_service, self.wh_schema_name)
         # Only if changing name of field
@@ -492,46 +493,20 @@ class UpdateEntitySchemaField(BaseOperation):
                 raise ValueError(
                     f"New field name {self.update_props.name} already exists on entity schema {self.wh_schema_name} and is {'archived' if existing_new_field.archiveRecord is not None else 'active'} in Benchling."
                 )
-        return tag_schema
-
-
-class UpdateEntitySchemaFieldName(BaseOperation):
-    order: ClassVar[int] = 150
-
-    def __init__(
-        self,
-        wh_schema_name: str,
-        old_wh_field_name: str,
-        new_wh_field_name: str,
-    ) -> None:
-        self.wh_schema_name = wh_schema_name
-        self.old_wh_field_name = old_wh_field_name
-        self.new_wh_field_name = new_wh_field_name
-
-    def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
-        tag_schema = TagSchemaModel.get_one(benchling_service, self.wh_schema_name)
-        existing_new_field = next(
-            (f for f in tag_schema.allFields if f.systemName == self.new_wh_field_name),
-            None,
-        )
-        if existing_new_field is not None:
-            raise ValueError(
-                f"Field {self.new_wh_field_name} already exists on entity schema {self.wh_schema_name}."
+        if self.update_props.warehouse_name:
+            existing_new_field = next(
+                (
+                    f
+                    for f in tag_schema.allFields
+                    if f.systemName == self.update_props.warehouse_name
+                ),
+                None,
             )
-        updated_tag_schema = tag_schema.update_field_wh_name(
-            self.old_wh_field_name, self.new_wh_field_name
-        )
-        return update_tag_schema(
-            benchling_service,
-            tag_schema.id,
-            {"fields": [f.model_dump() for f in updated_tag_schema.allFields]},
-        )
-
-    def describe_operation(self) -> str:
-        return f"{self.wh_schema_name}: Renaming entity schema field from '{self.old_wh_field_name}' to '{self.new_wh_field_name}'."
-
-    def describe(self) -> str:
-        return f"{self.wh_schema_name}: Entity schema field '{self.old_wh_field_name}' in Benchling has wh_name '{self.new_wh_field_name}' in code."
+            if existing_new_field:
+                raise ValueError(
+                    f"New field warehouse name {self.update_props.warehouse_name} already exists on entity schema {self.wh_schema_name} and is {'archived' if existing_new_field.archiveRecord is not None else 'active'} in Benchling."
+                )
+        return tag_schema
 
 
 class ReorderEntitySchemaFields(BaseOperation):

liminal/entity_schemas/tag_schema_models.py

@@ -64,7 +64,6 @@ class CreateTagSchemaFieldModel(BaseModel):
     @classmethod
     def from_props(
         cls,
-        wh_field_name: str,
         new_props: BaseFieldProperties,
         benchling_service: BenchlingService | None = None,
     ) -> CreateTagSchemaFieldModel:
@@ -112,7 +111,7 @@ class CreateTagSchemaFieldModel(BaseModel):
             ).id
         return cls(
             name=new_props.name,
-            systemName=wh_field_name,
+            systemName=new_props.warehouse_name,
             isMulti=new_props.is_multi,
             isRequired=new_props.required,
             isParentLink=new_props.parent_link,
@@ -180,6 +179,12 @@ class TagSchemaFieldModel(BaseModel):
         update_diff_names = list(update_diff.keys())
         update_props = BaseFieldProperties(**update_diff)
         self.name = update_props.name if "name" in update_diff_names else self.name
+        self.systemName = (
+            update_props.warehouse_name
+            if "warehouse_name" in update_diff_names
+            and update_props.warehouse_name is not None
+            else self.systemName
+        )
         self.isRequired = (
             update_props.required
             if "required" in update_diff_names

liminal/entity_schemas/utils.py

@@ -63,7 +63,8 @@ def convert_tag_schema_to_internal_schema(
                 BenchlingNamingStrategy(strategy)
                 for strategy in tag_schema.labelingStrategies
             ),
-        ).set_archived(tag_schema.archiveRecord is not None),
+            _archived=tag_schema.archiveRecord is not None,
+        ),
         {
             f.systemName: convert_tag_schema_field_to_field_properties(f, dropdowns_map)
             for f in all_fields
@@ -90,7 +91,8 @@ def convert_tag_schema_field_to_field_properties(
         if field.requiredLink and field.requiredLink.tagSchema
         else None,
         tooltip=field.tooltipText,
-    ).set_archived(field.archiveRecord is not None)
+        _archived=field.archiveRecord is not None,
+    )
 
 
 def get_benchling_entity_schemas(

liminal/enums/benchling_api_field_type.py

@@ -7,8 +7,11 @@ class BenchlingAPIFieldType(StrEnum):
 
     BLOB_LINK = "ft_blob_link"
     DATE = "ft_date"
+    DATETIME = "ft_datetime"
     ENTRY_LINK = "ft_entry_link"
     FILE_LINK = "ft_file_link"
+    PART_LINK = "ft_part_link"
+    TRANSLATION_LINK = "ft_translation_link"
     FLOAT = "ft_float"
     INTEGER = "ft_integer"
     LONG_TEXT = "ft_long_text"

liminal/enums/benchling_entity_type.py

@@ -12,3 +12,4 @@ class BenchlingEntityType(StrEnum):
     AA_SEQUENCE = "aa_sequence"
     ENTRY = "entry"
     MIXTURE = "mixture"
+    MOLECULE = "molecule"

liminal/enums/benchling_field_type.py

@@ -8,7 +8,10 @@ class BenchlingFieldType(StrEnum):
     BLOB_LINK = "blob_link"
     CUSTOM_ENTITY_LINK = "custom_entity_link"
     DATE = "date"
+    DATETIME = "datetime"
     DNA_SEQUENCE_LINK = "dna_sequence_link"
+    PART_LINK = "part_link"
+    TRANSLATION_LINK = "translation_link"
     DROPDOWN = "dropdown"
     ENTITY_LINK = "entity_link"
     ENTRY_LINK = "entry_link"
@@ -27,4 +30,5 @@ class BenchlingFieldType(StrEnum):
             cls.DECIMAL,
             cls.INTEGER,
             cls.DATE,
+            cls.DATETIME,
         ]

liminal/enums/benchling_folder_item_type.py

@@ -7,3 +7,4 @@ class BenchlingFolderItemType(StrEnum):
     SEQUENCE = "sequence"
     ENTRY = "entry"
     MIXTURE = "mixture"
+    MOLECULE = "molecule"

liminal/external/__init__.py

@@ -22,8 +22,6 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
-    UpdateEntitySchemaFieldName,
-    UpdateEntitySchemaName,
 )
 from liminal.enums import (
     BenchlingAPIFieldType,

liminal/mappers.py

@@ -16,6 +16,7 @@ from liminal.enums import (
 def convert_benchling_type_to_python_type(benchling_type: BenchlingFieldType) -> type:
     benchling_to_python_type_map = {
         BenchlingFieldType.DATE: datetime,
+        BenchlingFieldType.DATETIME: datetime,
         BenchlingFieldType.DECIMAL: float,
         BenchlingFieldType.INTEGER: int,
         BenchlingFieldType.BLOB_LINK: dict[str, Any],
@@ -27,6 +28,7 @@ def convert_benchling_type_to_python_type(benchling_type: BenchlingFieldType) ->
         BenchlingFieldType.MIXTURE_LINK: str,
         BenchlingFieldType.LONG_TEXT: str,
         BenchlingFieldType.STORAGE_LINK: str,
+        BenchlingFieldType.PART_LINK: str,
         BenchlingFieldType.TEXT: str,
     }
     if benchling_type in benchling_to_python_type_map:
@@ -40,6 +42,7 @@ def convert_benchling_type_to_sql_alchemy_type(
 ) -> TypeEngine:
     benchling_to_sql_alchemy_type_map = {
         BenchlingFieldType.DATE: DateTime,
+        BenchlingFieldType.DATETIME: DateTime,
         BenchlingFieldType.DECIMAL: Float,
         BenchlingFieldType.INTEGER: Integer,
         BenchlingFieldType.BLOB_LINK: JSON,
@@ -50,12 +53,13 @@ def convert_benchling_type_to_sql_alchemy_type(
         BenchlingFieldType.ENTRY_LINK: String,
         BenchlingFieldType.LONG_TEXT: String,
         BenchlingFieldType.STORAGE_LINK: String,
+        BenchlingFieldType.PART_LINK: String,
         BenchlingFieldType.MIXTURE_LINK: String,
         BenchlingFieldType.AA_SEQUENCE_LINK: String,
         BenchlingFieldType.TEXT: String,
     }
     if benchling_type in benchling_to_sql_alchemy_type_map:
-        return benchling_to_sql_alchemy_type_map[benchling_type]  # type: ignore
+        return benchling_to_sql_alchemy_type_map[benchling_type]
     else:
         raise ValueError(f"Benchling field type '{benchling_type}' is not supported.")
 
@@ -66,6 +70,7 @@ def convert_field_type_to_api_field_type(
     conversion_map = {
         BenchlingFieldType.BLOB_LINK: (BenchlingAPIFieldType.BLOB_LINK, None),
         BenchlingFieldType.DATE: (BenchlingAPIFieldType.DATE, None),
+        BenchlingFieldType.DATETIME: (BenchlingAPIFieldType.DATETIME, None),
         BenchlingFieldType.ENTRY_LINK: (BenchlingAPIFieldType.ENTRY_LINK, None),
         BenchlingFieldType.AA_SEQUENCE_LINK: (
             BenchlingAPIFieldType.FILE_LINK,
@@ -83,6 +88,14 @@ def convert_field_type_to_api_field_type(
             BenchlingAPIFieldType.FILE_LINK,
             BenchlingFolderItemType.SEQUENCE,
         ),
+        BenchlingFieldType.PART_LINK: (
+            BenchlingAPIFieldType.PART_LINK,
+            BenchlingFolderItemType.SEQUENCE,
+        ),
+        BenchlingFieldType.TRANSLATION_LINK: (
+            BenchlingAPIFieldType.TRANSLATION_LINK,
+            BenchlingFolderItemType.SEQUENCE,
+        ),
         BenchlingFieldType.ENTITY_LINK: (BenchlingAPIFieldType.FILE_LINK, None),
         BenchlingFieldType.DECIMAL: (BenchlingAPIFieldType.FLOAT, None),
         BenchlingFieldType.INTEGER: (BenchlingAPIFieldType.INTEGER, None),
@@ -104,6 +117,7 @@ def convert_api_field_type_to_field_type(
     conversion_map = {
         (BenchlingAPIFieldType.BLOB_LINK, None): BenchlingFieldType.BLOB_LINK,
         (BenchlingAPIFieldType.DATE, None): BenchlingFieldType.DATE,
+        (BenchlingAPIFieldType.DATETIME, None): BenchlingFieldType.DATETIME,
         (BenchlingAPIFieldType.ENTRY_LINK, None): BenchlingFieldType.ENTRY_LINK,
         (
             BenchlingAPIFieldType.FILE_LINK,
@@ -121,6 +135,14 @@ def convert_api_field_type_to_field_type(
             BenchlingAPIFieldType.FILE_LINK,
             BenchlingFolderItemType.PROTEIN,
         ): BenchlingFieldType.AA_SEQUENCE_LINK,
+        (
+            BenchlingAPIFieldType.PART_LINK,
+            BenchlingFolderItemType.SEQUENCE,
+        ): BenchlingFieldType.PART_LINK,
+        (
+            BenchlingAPIFieldType.TRANSLATION_LINK,
+            BenchlingFolderItemType.SEQUENCE,
+        ): BenchlingFieldType.TRANSLATION_LINK,
         (BenchlingAPIFieldType.FILE_LINK, None): BenchlingFieldType.ENTITY_LINK,
         (BenchlingAPIFieldType.FLOAT, None): BenchlingFieldType.DECIMAL,
         (BenchlingAPIFieldType.INTEGER, None): BenchlingFieldType.INTEGER,
@@ -146,6 +168,7 @@ def convert_api_entity_type_to_entity_type(
         ): BenchlingEntityType.CUSTOM_ENTITY,
         (BenchlingFolderItemType.ENTRY, None): BenchlingEntityType.ENTRY,
         (BenchlingFolderItemType.MIXTURE, None): BenchlingEntityType.MIXTURE,
+        (BenchlingFolderItemType.MOLECULE, None): BenchlingEntityType.MOLECULE,
         (BenchlingFolderItemType.PROTEIN, None): BenchlingEntityType.AA_SEQUENCE,
         (
             BenchlingFolderItemType.SEQUENCE,
@@ -182,6 +205,7 @@ def convert_entity_type_to_api_entity_type(
         ),
         BenchlingEntityType.ENTRY: (BenchlingFolderItemType.ENTRY, None),
         BenchlingEntityType.MIXTURE: (BenchlingFolderItemType.MIXTURE, None),
+        BenchlingEntityType.MOLECULE: (BenchlingFolderItemType.MOLECULE, None),
         BenchlingEntityType.AA_SEQUENCE: (BenchlingFolderItemType.PROTEIN, None),
         BenchlingEntityType.DNA_SEQUENCE: (
             BenchlingFolderItemType.SEQUENCE,

liminal/migrate/components.py

@@ -1,3 +1,5 @@
+import traceback
+
 from rich import print
 
 from liminal.base.base_operation import BaseOperation
@@ -64,7 +66,7 @@ def execute_operations(
 ) -> bool:
     """This runs the given operations. It validates the operations and then executes them."""
     for o in operations:
-        o.validate()
+        o.validate(benchling_service)
 
     print("[bold]Executing operations...")
     index = 1
@@ -73,17 +75,20 @@ def execute_operations(
         try:
             o.execute(benchling_service)
         except Exception as e:
-            print(f"[bold red]Error executing operation: {e}]")
+            traceback.print_exc()
+            print(f"[bold red]Error executing operation {o.__class__.__name__}: {e}]")
             return False
         index += 1
     return True
 
 
-def execute_operations_dry_run(operations: list[BaseOperation]) -> None:
+def execute_operations_dry_run(
+    benchling_service: BenchlingService, operations: list[BaseOperation]
+) -> None:
     """This runs the given operations in dry run mode. It only prints a description of the operations and validates them."""
     print("[bold]Executing dry run of operations...")
     index = 1
     for o in operations:
         print(f"{index}. {o.describe()}")
-        o.validate()
+        o.validate(benchling_service)
         index += 1

liminal/orm/base_model.py

@@ -72,9 +72,7 @@ class BaseModel(Generic[T], Base):
 
     @declared_attr
     def creator(cls) -> RelationshipProperty:
-        return relationship(
-            "User", foreign_keys=[cls.creator_id], uselist=False, lazy="joined"
-        )
+        return relationship("User", foreign_keys=[cls.creator_id])
 
     id = SqlColumn("id", String, nullable=True, primary_key=True)
     archived = SqlColumn("archived$", Boolean, nullable=True)
@@ -109,7 +107,9 @@ class BaseModel(Generic[T], Base):
         return list(models.values())
 
     @classmethod
-    def get_columns_dict(cls, exclude_base_columns: bool = False) -> dict[str, Column]:
+    def get_columns_dict(
+        cls, exclude_base_columns: bool = False, exclude_archived: bool = True
+    ) -> dict[str, Column]:
         """Returns a dictionary of all benchling columns in the class. Benchling Column saves an instance of itself to the sqlalchemy Column info property.
         This function retrieves the info property and returns a dictionary of the columns.
         """
@@ -125,6 +125,8 @@ class BaseModel(Generic[T], Base):
                 )
             fields_to_exclude.append("creator_id$")
         columns = [c for c in cls.__table__.columns if c.name not in fields_to_exclude]
+        if exclude_archived:
+            columns = [c for c in columns if not c.properties._archived]
         return {c.name: c for c in columns}
 
     @classmethod
@@ -206,9 +208,8 @@ class BaseModel(Generic[T], Base):
         return pd.read_sql(query.statement, session.connection())
 
     @classmethod
-    @abstractmethod
     def query(cls, session: Session) -> Query:
-        """Abstract method that all subclasses must implement. Each subclass will have a differently defined query
+        """Abstract method that users can override to define a specific query
         to retrieve entities from the database and cover any distinct relationships.
 
         Parameters
@@ -221,7 +222,7 @@ class BaseModel(Generic[T], Base):
         Query
             sqlalchemy query to retrieve entities from the database.
         """
-        raise NotImplementedError
+        return session.query(cls)
 
     @abstractmethod
     def get_validators(self) -> list[BenchlingValidator]:

liminal/orm/column.py

@@ -1,7 +1,8 @@
 from typing import Any, Type  # noqa: UP035
 
-from sqlalchemy import ARRAY, ForeignKey
-from sqlalchemy import Column as SqlColumn
+from sqlalchemy.sql.schema import Column as SqlColumn
+from sqlalchemy.sql.schema import ForeignKey
+from sqlalchemy.types import JSON
 
 from liminal.base.base_dropdown import BaseDropdown
 from liminal.base.properties.base_field_properties import BaseFieldProperties
@@ -43,6 +44,7 @@ class Column(SqlColumn):
         tooltip: str | None = None,
         dropdown: Type[BaseDropdown] | None = None,  # noqa: UP006
         entity_link: str | None = None,
+        _archived: bool = False,
         **kwargs: Any,
     ):
         """Initializes a Benchling Column object. Validates the type BenchlingFieldType maps to a valid sqlalchemy type.
@@ -56,11 +58,12 @@ class Column(SqlColumn):
             dropdown_link=dropdown.__benchling_name__ if dropdown else None,
             entity_link=entity_link,
             tooltip=tooltip,
+            _archived=_archived,
         )
         self.properties = properties
 
         nested_sql_type = convert_benchling_type_to_sql_alchemy_type(type)
-        sqlalchemy_type = ARRAY(nested_sql_type) if is_multi else nested_sql_type
+        sqlalchemy_type = JSON if is_multi else nested_sql_type
         if dropdown and type != BenchlingFieldType.DROPDOWN:
             raise ValueError("Dropdown can only be set if the field type is DROPDOWN.")
         if dropdown is None and type == BenchlingFieldType.DROPDOWN:

liminal/orm/mixins.py

@@ -87,3 +87,12 @@ class MixtureMixin:
     project_id = SqlColumn("project_id$", String, nullable=True)
     type = SqlColumn("type$", String, nullable=True)
     validation_status = SqlColumn("validation_status$", String, nullable=True)
+
+
+class MoleculeMixin:
+    canonical_smiles = SqlColumn("canonical_smiles$", String, nullable=True)
+    file_registry_id = SqlColumn("file_registry_id$", String, nullable=True)
+    is_registered = SqlColumn("is_registered$", Boolean, nullable=True)
+    project_id = SqlColumn("project_id$", String, nullable=True)
+    type = SqlColumn("type$", String, nullable=True)
+    validation_status = SqlColumn("validation_status$", String, nullable=True)

liminal/orm/schema_properties.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from pydantic import PrivateAttr, model_validator
+from typing import Any
+
+from pydantic import model_validator
 
 from liminal.base.properties.base_schema_properties import (
     BaseSchemaProperties,
@@ -22,7 +24,11 @@ class SchemaProperties(BaseSchemaProperties):
     entity_type: BenchlingEntityType
     naming_strategies: set[BenchlingNamingStrategy]
     mixture_schema_config: MixtureSchemaConfig | None = None
-    _archived: bool | None = PrivateAttr(default=None)
+    _archived: bool = False
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self._archived = data.get("_archived", False)
 
     @model_validator(mode="after")
     def validate_mixture_schema_config(self) -> SchemaProperties: