liminal-orm 2.0.3a1__tar.gz → 3.0.0__tar.gz

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liminal-orm
-Version: 2.0.3a1
+Version: 3.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

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/base/base_operation.py

@@ -13,13 +13,13 @@ Order of operations based on order class var:
     6. ArchiveDropdownOption
     7. ReorderDropdownOptions
     8. CreateSchema
-    9. UpdateSchema
-    10. UnarchiveSchema
-    11. CreateField
-    12. UnarchiveField
-    13. UpdateField
-    14. ArchiveField
-    15. UpdateEntitySchemaNameTemplate
+    9. UnarchiveSchema
+    10. CreateField
+    11. UpdateEntitySchemaNameTemplate
+    12. UpdateSchema
+    13. UnarchiveField
+    14. UpdateField
+    15. ArchiveField
     16. ReorderFields
     17. ArchiveSchema
     18. ArchiveDropdown

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/base/properties/base_field_properties.py

@@ -49,6 +49,8 @@ class BaseFieldProperties(BaseModel):
     dropdown_link: str | None = None
     entity_link: str | None = None
     tooltip: str | None = None
+    decimal_places: int | None = None
+    unit_name: str | None = None
     _archived: bool | None = PrivateAttr(default=None)
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
@@ -122,4 +124,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_unset=True, exclude_defaults=True).items()])})"
+        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_unset=True).items()])})"

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/base/properties/base_schema_properties.py

@@ -66,8 +66,13 @@ class BaseSchemaProperties(BaseModel):
     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.
+        Set of constraints for field values for the schema. Must be a set of warehouse column names. This specifies that their entity field values must be a unique combination within an entity.
+        The following sequence constraints are also supported:
+        - bases: only supported for nucleotide sequence entity types. hasUniqueResidues=True
+        - amino_acids_ignore_case: only supported for amino acid sequence entity types. hasUniqueResidues=True
+        - amino_acids_exact_match: only supported for amino acid sequence entity types. hasUniqueResidues=True, areUniqueResiduesCaseSensitive=True
+    show_bases_in_expanded_view : bool | None
+        Whether the bases should be shown in the expanded view of the entity.
     _archived : bool | None
         Whether the schema is archived in Benchling.
     """
@@ -81,6 +86,7 @@ class BaseSchemaProperties(BaseModel):
     use_registry_id_as_label: bool | None = None
     include_registry_id_in_chips: bool | None = None
     constraint_fields: set[str] | None = None
+    show_bases_in_expanded_view: bool | None = None
     _archived: bool | None = None
 
     def __init__(self, **data: Any):

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/entity_schemas/compare.py

@@ -18,6 +18,7 @@ from liminal.entity_schemas.operations import (
     UpdateEntitySchemaNameTemplate,
 )
 from liminal.entity_schemas.utils import get_converted_tag_schemas
+from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
 from liminal.orm.base_model import BaseModel
 from liminal.orm.column import Column
 from liminal.utils import to_snake_case
@@ -275,6 +276,16 @@ def compare_entity_schemas(
                 col.properties.set_warehouse_name(wh_name)
                 for wh_name, col in model_columns.items()
             ]
+            template_based_naming_strategies = {
+                s
+                for s in model.__schema_properties__.naming_strategies
+                if BenchlingNamingStrategy.is_template_based(s)
+            }
+            model.__schema_properties__.naming_strategies = {
+                s
+                for s in model.__schema_properties__.naming_strategies
+                if not BenchlingNamingStrategy.is_template_based(s)
+            }
             ops.append(
                 CompareOperation(
                     op=CreateEntitySchema(
@@ -288,28 +299,10 @@ def compare_entity_schemas(
                     ),
                 )
             )
-            benchling_given_wh_name = to_snake_case(model.__schema_properties__.name)
-            if model.__schema_properties__.warehouse_name != benchling_given_wh_name:
-                ops.append(
-                    CompareOperation(
-                        op=UpdateEntitySchema(
-                            benchling_given_wh_name,
-                            BaseSchemaProperties(
-                                warehouse_name=model.__schema_properties__.warehouse_name
-                            ),
-                        ),
-                        reverse_op=UpdateEntitySchema(
-                            model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
-                                warehouse_name=benchling_given_wh_name
-                            ),
-                        ),
-                    )
-                )
             benchling_given_name_template = BaseNameTemplate(
                 parts=[], order_name_parts_by_sequence=False
             )
-            if benchling_name_template != model.__name_template__:
+            if benchling_given_name_template != model.__name_template__:
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchemaNameTemplate(
@@ -323,13 +316,39 @@ def compare_entity_schemas(
                         reverse_op=UpdateEntitySchemaNameTemplate(
                             model.__schema_properties__.warehouse_name,
                             BaseNameTemplate(
-                                **benchling_given_name_template.merge(
-                                    model.__name_template__
+                                **model.__name_template__.merge(
+                                    benchling_given_name_template
                                 )
                             ),
                         ),
                     )
                 )
+            benchling_given_wh_name = to_snake_case(model.__schema_properties__.name)
+            new_schema_props = BaseSchemaProperties()
+            rollback_schema_props = BaseSchemaProperties()
+            if model.__schema_properties__.warehouse_name != benchling_given_wh_name:
+                new_schema_props.warehouse_name = (
+                    model.__schema_properties__.warehouse_name
+                )
+                rollback_schema_props.warehouse_name = benchling_given_wh_name
+            if template_based_naming_strategies:
+                new_schema_props.naming_strategies = template_based_naming_strategies
+                rollback_schema_props.naming_strategies = (
+                    model.__schema_properties__.naming_strategies
+                )
+            if new_schema_props.model_dump(exclude_unset=True) != {}:
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchema(
+                            benchling_given_wh_name,
+                            new_schema_props,
+                        ),
+                        reverse_op=UpdateEntitySchema(
+                            model.__schema_properties__.warehouse_name,
+                            rollback_schema_props,
+                        ),
+                    )
+                )
 
         model_operations[model.__schema_properties__.warehouse_name] = ops
         running_benchling_schema_names = [

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/entity_schemas/entity_schema_models.py

@@ -9,8 +9,10 @@ from liminal.connection import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdown_summary_by_name
 from liminal.entity_schemas.tag_schema_models import TagSchemaModel
 from liminal.enums import BenchlingEntityType
+from liminal.enums.sequence_constraint import SequenceConstraint
 from liminal.mappers import convert_field_type_to_api_field_type
 from liminal.orm.schema_properties import MixtureSchemaConfig, SchemaProperties
+from liminal.unit_dictionary.utils import get_unit_id_from_name
 
 
 class FieldLinkShortModel(BaseModel):
@@ -26,28 +28,44 @@ class EntitySchemaConstraint(BaseModel):
     """
 
     areUniqueResiduesCaseSensitive: bool | None = None
-    fields: dict[str, Any] | None = None
-    hasUniqueCanonicalSmilers: bool | None = None
+    fields: list[dict[str, Any]] | None = None
+    hasUniqueCanonicalSmiles: bool | None = None
     hasUniqueResidues: bool | None = None
 
     @classmethod
     def from_constraint_fields(
-        cls, constraint_fields: set[str]
+        cls,
+        constraint_fields: set[str],
+        benchling_service: BenchlingService | None = None,
     ) -> EntitySchemaConstraint:
         """
         Generates a Constraint object from a set of constraint fields to create a constraint on a schema.
         """
-        if constraint_fields is None:
-            return None
         hasUniqueResidues = False
-        if "bases" in constraint_fields:
-            constraint_fields.discard("bases")
+        areUniqueResiduesCaseSensitive = False
+        if SequenceConstraint.BASES in constraint_fields:
+            constraint_fields.discard(SequenceConstraint.BASES)
+            hasUniqueResidues = True
+        elif SequenceConstraint.AMINO_ACIDS_IGNORE_CASE in constraint_fields:
+            constraint_fields.discard(SequenceConstraint.AMINO_ACIDS_IGNORE_CASE)
             hasUniqueResidues = True
+        elif SequenceConstraint.AMINO_ACIDS_EXACT_MATCH in constraint_fields:
+            constraint_fields.discard(SequenceConstraint.AMINO_ACIDS_EXACT_MATCH)
+            hasUniqueResidues = True
+            areUniqueResiduesCaseSensitive = True
+        fields = []
+        for field_name in constraint_fields:
+            if benchling_service is None:
+                raise ValueError(
+                    "Benchling SDK must be provided to update constraint fields."
+                )
+            field = TagSchemaModel.get_one(benchling_service, field_name)
+            fields.append({"name": field.name, "id": field.id})
         return cls(
-            fields=[{"name": f} for f in constraint_fields],
+            fields=fields,
             hasUniqueResidues=hasUniqueResidues,
-            hasUniqueCanonicalSmilers=False,
-            areUniqueResiduesCaseSensitive=False,
+            hasUniqueCanonicalSmiles=False,
+            areUniqueResiduesCaseSensitive=areUniqueResiduesCaseSensitive,
         )
 
 
@@ -63,6 +81,8 @@ class CreateEntitySchemaFieldModel(BaseModel):
     isParentLink: bool = False
     dropdownId: str | None = None
     link: FieldLinkShortModel | None = None
+    unitId: str | None = None
+    decimalPrecision: int | None = None
 
     @classmethod
     def from_benchling_props(
@@ -107,6 +127,11 @@ class CreateEntitySchemaFieldModel(BaseModel):
             dropdown_summary_id = get_benchling_dropdown_summary_by_name(
                 benchling_service, field_props.dropdown_link
             ).id
+        unit_id = None
+        if field_props.unit_name is not None:
+            if benchling_service is None:
+                raise ValueError("Benchling SDK must be provided to update unit field.")
+            unit_id = get_unit_id_from_name(benchling_service, field_props.unit_name)
         return CreateEntitySchemaFieldModel(
             name=field_props.name,
             systemName=field_props.warehouse_name,
@@ -118,6 +143,8 @@ class CreateEntitySchemaFieldModel(BaseModel):
             link=FieldLinkShortModel(
                 tagSchema=tag_schema, folderItemType=folder_item_type
             ),
+            unitId=unit_id,
+            decimalPrecision=field_props.decimal_places,
         )
 
 
@@ -135,6 +162,7 @@ class CreateEntitySchemaModel(BaseModel):
     useOrganizationCollectionAliasForDisplayLabel: bool | None = None
     labelingStrategies: list[str] | None = None
     constraint: EntitySchemaConstraint | None = None
+    showResidues: bool | None = None
 
     @classmethod
     def from_benchling_props(
@@ -168,11 +196,10 @@ class CreateEntitySchemaModel(BaseModel):
             includeRegistryIdInChips=benchling_props.include_registry_id_in_chips,
             useOrganizationCollectionAliasForDisplayLabel=benchling_props.use_registry_id_as_label,
             labelingStrategies=[s.value for s in benchling_props.naming_strategies],
+            showResidues=benchling_props.show_bases_in_expanded_view,
             constraint=EntitySchemaConstraint.from_constraint_fields(
                 benchling_props.constraint_fields
-            )
-            if benchling_props.constraint_fields
-            else None,
+            ),
             fields=[
                 CreateEntitySchemaFieldModel.from_benchling_props(
                     field_props, benchling_service

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/entity_schemas/generate_files.py

@@ -91,7 +91,7 @@ def generate_all_entity_schema_files(
                 dropdown_classname = dropdown_name_to_classname_map[col.dropdown_link]
                 dropdowns.append(dropdown_classname)
             column_strings.append(
-                f"""{tab}{col_name}: SqlColumn = Column(name="{col.name}", type={str(col.type)}, required={col.required}{', is_multi=True' if col.is_multi else ''}{', parent_link=True' if col.parent_link else ''}{f', entity_link="{col.entity_link}"' if col.entity_link else ''}{f', dropdown={dropdown_classname}' if dropdown_classname else ''}{f', tooltip="{col.tooltip}"' if col.tooltip else ''})"""
+                f"""{tab}{col_name}: SqlColumn = Column(name="{col.name}", type={str(col.type)}, required={col.required}{', is_multi=True' if col.is_multi else ''}{', parent_link=True' if col.parent_link else ''}{f', entity_link="{col.entity_link}"' if col.entity_link else ''}{f', dropdown={dropdown_classname}' if dropdown_classname else ''}{f', tooltip="{col.tooltip}"' if col.tooltip else ''}{f', unit_name="{col.unit_name}"' if col.unit_name else ''}{f', decimal_places={col.decimal_places}' if col.decimal_places is not None else ''})"""
             )
             if col.required and col.type:
                 init_strings.append(
@@ -105,7 +105,7 @@ def generate_all_entity_schema_files(
                 if not has_date:
                     import_strings.append("from datetime import datetime")
             if (
-                col.type == BenchlingFieldType.ENTITY_LINK
+                col.type in BenchlingFieldType.get_entity_link_types()
                 and col.entity_link is not None
             ):
                 if not col.is_multi:

{liminal_orm-2.0.3a1 → liminal_orm-3.0.0}/liminal/entity_schemas/operations.py

@@ -1,3 +1,4 @@
+import logging
 from typing import Any, ClassVar
 
 from liminal.base.base_operation import BaseOperation
@@ -25,8 +26,14 @@ from liminal.entity_schemas.utils import (
 )
 from liminal.enums import BenchlingNamingStrategy
 from liminal.orm.schema_properties import SchemaProperties
+from liminal.unit_dictionary.utils import (
+    get_unit_id_to_name_map,
+    get_unit_name_to_id_map,
+)
 from liminal.utils import to_snake_case
 
+LOGGER = logging.getLogger(__name__)
+
 
 class CreateEntitySchema(BaseOperation):
     order: ClassVar[int] = 80
@@ -39,7 +46,7 @@ class CreateEntitySchema(BaseOperation):
         self.schema_properties = schema_properties
         self.fields = fields
         self._validated_schema_properties = SchemaProperties(
-            **schema_properties.model_dump()
+            **schema_properties.model_dump(exclude_unset=True)
         )
 
     def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
@@ -83,6 +90,15 @@ class CreateEntitySchema(BaseOperation):
                 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."
             )
+        for field in self.fields:
+            if (
+                field.unit_name
+                and field.unit_name
+                not in get_unit_name_to_id_map(benchling_service).keys()
+            ):
+                raise ValueError(
+                    f"{self._validated_schema_properties.warehouse_name}: On field {field.warehouse_name}, unit {field.unit_name} not found in Benchling Unit Dictionary as a valid unit. Please check the field definition or your Unit Dictionary."
+                )
 
     def _validate_create(self, benchling_service: BenchlingService) -> None:
         all_schemas = TagSchemaModel.get_all_json(benchling_service)
@@ -123,8 +139,11 @@ class CreateEntitySchema(BaseOperation):
                 f"Entity schema {self._validated_schema_properties.warehouse_name} is already active in Benchling."
             )
         dropdowns_map = get_benchling_dropdown_id_name_map(benchling_service)
+        unit_id_to_name_map = get_unit_id_to_name_map(benchling_service)
         benchling_schema_props, _, benchling_fields_props = (
-            convert_tag_schema_to_internal_schema(schema, dropdowns_map)
+            convert_tag_schema_to_internal_schema(
+                schema, dropdowns_map, unit_id_to_name_map
+            )
         )
         if (
             self._validated_schema_properties != benchling_schema_props
@@ -162,7 +181,7 @@ class ArchiveEntitySchema(BaseOperation):
 
 
 class UnarchiveEntitySchema(BaseOperation):
-    order: ClassVar[int] = 100
+    order: ClassVar[int] = 90
 
     def __init__(self, wh_schema_name: str) -> None:
         self.wh_schema_name = wh_schema_name
@@ -187,7 +206,7 @@ class UnarchiveEntitySchema(BaseOperation):
 
 
 class UpdateEntitySchema(BaseOperation):
-    order: ClassVar[int] = 90
+    order: ClassVar[int] = 120
 
     def __init__(
         self,
@@ -251,7 +270,7 @@ class UpdateEntitySchema(BaseOperation):
 
 
 class UpdateEntitySchemaNameTemplate(BaseOperation):
-    order: ClassVar[int] = 150
+    order: ClassVar[int] = 110
 
     def __init__(
         self,
@@ -283,7 +302,7 @@ class UpdateEntitySchemaNameTemplate(BaseOperation):
 
 
 class CreateEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 110
+    order: ClassVar[int] = 100
 
     def __init__(
         self,
@@ -316,13 +335,20 @@ class CreateEntitySchemaField(BaseOperation):
                     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)
+            unit_id_to_name_map = get_unit_id_to_name_map(benchling_service)
             if self.field_props == convert_tag_schema_field_to_field_properties(
-                field, dropdowns_map
-            ):
+                field, dropdowns_map, unit_id_to_name_map
+            ).set_warehouse_name(self._wh_field_name):
                 return UnarchiveEntitySchemaField(
                     self.wh_schema_name, self._wh_field_name, self.index
                 ).execute(benchling_service)
             else:
+                print(self.field_props)
+                print(
+                    convert_tag_schema_field_to_field_properties(
+                        field, dropdowns_map, unit_id_to_name_map
+                    )
+                )
                 raise ValueError(
                     f"Field {self._wh_field_name} on entity schema {self.wh_schema_name} is different in code versus Benchling."
                 )
@@ -367,10 +393,18 @@ class CreateEntitySchemaField(BaseOperation):
                 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."
             )
+        if (
+            self.field_props.unit_name
+            and self.field_props.unit_name
+            not in get_unit_name_to_id_map(benchling_service).keys()
+        ):
+            raise ValueError(
+                f"{self.wh_schema_name}: On field {self._wh_field_name}, unit {self.field_props.unit_name} not found in Benchling Unit Dictionary as a valid unit. Please check the field definition or your Unit Dictionary."
+            )
 
 
 class ArchiveEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 140
+    order: ClassVar[int] = 150
 
     def __init__(
         self, wh_schema_name: str, wh_field_name: str, index: int | None = None
@@ -421,7 +455,7 @@ class ArchiveEntitySchemaField(BaseOperation):
 
 
 class UnarchiveEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 120
+    order: ClassVar[int] = 130
 
     def __init__(
         self, wh_schema_name: str, wh_field_name: str, index: int | None = None
@@ -468,7 +502,7 @@ class UnarchiveEntitySchemaField(BaseOperation):
 
 
 class UpdateEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 130
+    order: ClassVar[int] = 140
 
     def __init__(
         self,
@@ -500,6 +534,9 @@ class UpdateEntitySchemaField(BaseOperation):
         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:
+        tag_schema = TagSchemaModel.get_one_cached(
+            benchling_service, self.wh_schema_name
+        )
         if (
             not benchling_service.connection.warehouse_access
             and self.update_props.warehouse_name is not None
@@ -509,6 +546,19 @@ class UpdateEntitySchemaField(BaseOperation):
                 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."
             )
+        if "unit_name" in self.update_props.model_dump(exclude_unset=True):
+            no_change_message = f"{self.wh_schema_name}: On field {self.wh_field_name}, updating unit name to {self.update_props.unit_name}. The unit of this field CANNOT be changed once it's been set."
+            if tag_schema.get_field(self.wh_field_name).unitApiIdentifier:
+                raise ValueError(no_change_message)
+            else:
+                LOGGER.warning(no_change_message)
+            if (
+                self.update_props.unit_name
+                not in get_unit_name_to_id_map(benchling_service).keys()
+            ):
+                raise ValueError(
+                    f"{self.wh_schema_name}: On field {self.wh_field_name}, unit {self.update_props.unit_name} not found in Benchling Unit Dictionary as a valid unit. Please check the field definition or your Unit Dictionary."
+                )
 
     def _validate(self, benchling_service: BenchlingService) -> TagSchemaModel:
         tag_schema = TagSchemaModel.get_one(benchling_service, self.wh_schema_name)