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

liminal/entity_schemas/operations.py

@@ -2,12 +2,14 @@ from typing import Any, ClassVar
 
 from liminal.base.base_operation import BaseOperation
 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.dropdowns.utils import get_benchling_dropdown_id_name_map
 from liminal.entity_schemas.api import (
     archive_tag_schemas,
     create_entity_schema,
+    set_tag_schema_name_template,
     unarchive_tag_schemas,
     update_tag_schema,
 )
@@ -21,7 +23,7 @@ from liminal.entity_schemas.utils import (
     convert_tag_schema_field_to_field_properties,
     convert_tag_schema_to_internal_schema,
 )
-from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
+from liminal.enums import BenchlingNamingStrategy
 from liminal.orm.schema_properties import SchemaProperties
 from liminal.utils import to_snake_case
 
@@ -121,7 +123,7 @@ 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)
-        benchling_schema_props, benchling_fields_props = (
+        benchling_schema_props, _, benchling_fields_props = (
             convert_tag_schema_to_internal_schema(schema, dropdowns_map)
         )
         if (
@@ -135,7 +137,7 @@ class CreateEntitySchema(BaseOperation):
 
 
 class ArchiveEntitySchema(BaseOperation):
-    order: ClassVar[int] = 180
+    order: ClassVar[int] = 170
 
     def __init__(self, wh_schema_name: str) -> None:
         self.wh_schema_name = wh_schema_name
@@ -160,7 +162,7 @@ class ArchiveEntitySchema(BaseOperation):
 
 
 class UnarchiveEntitySchema(BaseOperation):
-    order: ClassVar[int] = 110
+    order: ClassVar[int] = 100
 
     def __init__(self, wh_schema_name: str) -> None:
         self.wh_schema_name = wh_schema_name
@@ -245,20 +247,43 @@ class UpdateEntitySchema(BaseOperation):
             raise ValueError(
                 f"Entity schema prefix {self.update_props.prefix} already exists in Benchling."
             )
-        if (
-            self.update_props.naming_strategies
-            and not BenchlingNamingStrategy.is_valid_set(
-                self.update_props.naming_strategies, bool(tag_schema.nameTemplateParts)
-            )
-        ):
-            raise ValueError(
-                "Invalid naming strategies for schema. The name template must be set on the schema through the UI when using template-based naming strategies."
-            )
         return tag_schema
 
 
+class UpdateEntitySchemaNameTemplate(BaseOperation):
+    order: ClassVar[int] = 150
+
+    def __init__(
+        self,
+        wh_schema_name: str,
+        update_name_template: BaseNameTemplate,
+    ) -> None:
+        self.wh_schema_name = wh_schema_name
+        self.update_name_template = update_name_template
+
+    def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
+        tag_schema = TagSchemaModel.get_one(benchling_service, self.wh_schema_name)
+        updated_schema = tag_schema.update_name_template(self.update_name_template)
+        return set_tag_schema_name_template(
+            benchling_service,
+            tag_schema.id,
+            {
+                "nameTemplateParts": [
+                    part.model_dump() for part in updated_schema.nameTemplateParts
+                ],
+                "shouldOrderNamePartsBySequence": updated_schema.shouldOrderNamePartsBySequence,
+            },
+        )
+
+    def describe_operation(self) -> str:
+        return f"{self.wh_schema_name}: Updating name template to {str(self.update_name_template)}."
+
+    def describe(self) -> str:
+        return f"{self.wh_schema_name}: Name template is different in code versus Benchling."
+
+
 class CreateEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 120
+    order: ClassVar[int] = 110
 
     def __init__(
         self,
@@ -345,7 +370,7 @@ class CreateEntitySchemaField(BaseOperation):
 
 
 class ArchiveEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 160
+    order: ClassVar[int] = 140
 
     def __init__(
         self, wh_schema_name: str, wh_field_name: str, index: int | None = None
@@ -396,7 +421,7 @@ class ArchiveEntitySchemaField(BaseOperation):
 
 
 class UnarchiveEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 130
+    order: ClassVar[int] = 120
 
     def __init__(
         self, wh_schema_name: str, wh_field_name: str, index: int | None = None
@@ -443,7 +468,7 @@ class UnarchiveEntitySchemaField(BaseOperation):
 
 
 class UpdateEntitySchemaField(BaseOperation):
-    order: ClassVar[int] = 140
+    order: ClassVar[int] = 130
 
     def __init__(
         self,
@@ -514,7 +539,7 @@ class UpdateEntitySchemaField(BaseOperation):
 
 
 class ReorderEntitySchemaFields(BaseOperation):
-    order: ClassVar[int] = 170
+    order: ClassVar[int] = 160
 
     def __init__(self, wh_schema_name: str, new_order: list[str]) -> None:
         self.wh_schema_name = wh_schema_name

liminal/entity_schemas/tag_schema_models.py

@@ -5,7 +5,11 @@ from typing import Any
 import requests
 from pydantic import BaseModel
 
+from liminal.base.name_template_parts import (
+    NameTemplatePart,
+)
 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.dropdowns.utils import get_benchling_dropdown_summary_by_name
@@ -15,6 +19,7 @@ from liminal.enums import (
     BenchlingFolderItemType,
     BenchlingSequenceType,
 )
+from liminal.enums.name_template_part_type import NameTemplatePartType
 from liminal.mappers import (
     convert_entity_type_to_api_entity_type,
     convert_field_type_to_api_field_type,
@@ -32,6 +37,73 @@ class FieldRequiredLinkShortModel(BaseModel):
     storableSchema: dict[str, Any] | None = None
 
 
+class NameTemplatePartModel(BaseModel):
+    """A pydantic model to define a part of a name template."""
+
+    type: NameTemplatePartType
+    fieldId: str | None = None
+    text: str | None = None
+    datetimeFormat: str | None = None
+
+    @classmethod
+    def from_name_template_part(
+        cls, part: NameTemplatePart, fields: list[TagSchemaFieldModel] | None = None
+    ) -> NameTemplatePartModel:
+        data = part.model_dump()
+        field_id = None
+        if wh_field_name := data.get("wh_field_name"):
+            field = next((f for f in fields if f.systemName == wh_field_name), None)
+            if field is None:
+                raise ValueError(f"Field {wh_field_name} not found in fields")
+            field_id = field.id
+            if part.component_type == NameTemplatePartType.CHILD_ENTITY_LOT_NUMBER:
+                if not field.isParentLink:
+                    raise ValueError(
+                        f"Field {wh_field_name} is not a parent link field. The field for type {part.component_type} must be a parent link field."
+                    )
+        return cls(
+            type=part.component_type,
+            fieldId=field_id,
+            text=data.get("value"),
+        )
+
+    def to_name_template_part(
+        self, fields: list[TagSchemaFieldModel] | None = None
+    ) -> NameTemplatePart:
+        part_cls = NameTemplatePart.resolve_type(self.type)
+        if self.fieldId:
+            field = next((f for f in fields if f.apiId == self.fieldId), None)
+            if field is None:
+                raise ValueError(f"Field {self.fieldId} not found in fields")
+            return part_cls(wh_field_name=field.systemName, value=self.text)
+        return part_cls(value=self.text)
+
+
+class TagSchemaConstraint(BaseModel):
+    """
+    A class to define a constraint on an entity schema.
+    """
+
+    areUniqueResiduesCaseSensitive: bool | None = None
+    fields: list[TagSchemaFieldModel] | None = None
+    uniqueCanonicalSmilers: bool | None = None
+    uniqueResidues: bool | None = None
+
+    @classmethod
+    def from_constraint_fields(
+        cls, constraint_fields: list[TagSchemaFieldModel], bases: bool
+    ) -> TagSchemaConstraint:
+        """
+        Generates a Constraint object from a set of constraint fields to create a constraint on a schema.
+        """
+        return cls(
+            fields=constraint_fields,
+            uniqueResidues=bases,
+            uniqueCanonicalSmilers=False,
+            areUniqueResiduesCaseSensitive=False,
+        )
+
+
 class UpdateTagSchemaModel(BaseModel):
     """A pydantic model to define the input for the internal tag schema update endpoint."""
 
@@ -46,6 +118,9 @@ class UpdateTagSchemaModel(BaseModel):
     sequenceType: BenchlingSequenceType | None = None
     shouldCreateAsOligo: bool | None = None
     showResidues: bool | None = None
+    includeRegistryIdInChips: bool | None = None
+    useOrganizationCollectionAliasForDisplayLabel: bool | None = None
+    constraint: TagSchemaConstraint | None = None
 
 
 class CreateTagSchemaFieldModel(BaseModel):
@@ -243,7 +318,7 @@ class TagSchemaModel(BaseModel):
     authParentOption: str | None
     batchSchemaId: str | None
     childEntitySchemaSummaries: list[Any] | None
-    constraint: Any | None
+    constraint: TagSchemaConstraint | None
     containableType: str | None
     fields: list[TagSchemaFieldModel]
     folderItemType: BenchlingFolderItemType
@@ -256,7 +331,7 @@ class TagSchemaModel(BaseModel):
     mixtureSchemaConfig: MixtureSchemaConfig | None
     name: str | None
     nameTemplateFields: list[str] | None
-    nameTemplateParts: list[Any] | None
+    nameTemplateParts: list[NameTemplatePartModel] | None
     permissions: dict[str, bool] | None
     prefix: str | None
     registryId: str | None
@@ -299,7 +374,11 @@ class TagSchemaModel(BaseModel):
                 if len(filtered_schemas) == len(wh_schema_names):
                     break
         else:
-            filtered_schemas = [cls.model_validate(schema) for schema in schemas_data]
+            for schema in schemas_data:
+                try:
+                    filtered_schemas.append(cls.model_validate(schema))
+                except Exception as e:
+                    print(f"Error validating schema {schema['sqlIdentifier']}: {e}")
         return filtered_schemas
 
     @classmethod
@@ -333,6 +412,11 @@ class TagSchemaModel(BaseModel):
                 return field
         raise ValueError(f"Field '{wh_field_name}' not found in schema")
 
+    def get_internal_name_template_parts(self) -> list[NameTemplatePart]:
+        return [
+            part.to_name_template_part(self.fields) for part in self.nameTemplateParts
+        ]
+
     def update_schema_props(self, update_diff: dict[str, Any]) -> TagSchemaModel:
         """Updates the schema properties given the schema properties defined in code."""
         update_diff_names = list(update_diff.keys())
@@ -347,6 +431,46 @@ class TagSchemaModel(BaseModel):
             self.labelingStrategies = [o.value for o in update_props.naming_strategies]
         if "mixture_schema_config" in update_diff_names:
             self.mixtureSchemaConfig = update_props.mixture_schema_config
+        if "use_registry_id_as_label" in update_diff_names:
+            self.useOrganizationCollectionAliasForDisplayLabel = (
+                update_props.use_registry_id_as_label
+            )
+        if "include_registry_id_in_chips" in update_diff_names:
+            self.includeRegistryIdInChips = update_props.include_registry_id_in_chips
+
+        if "constraint_fields" in update_diff_names:
+            if update_props.constraint_fields:
+                has_bases = False
+                if "bases" in update_props.constraint_fields:
+                    has_bases = True
+                    update_props.constraint_fields.discard("bases")
+                constraint_fields = [
+                    f
+                    for f in self.fields
+                    if f.systemName in update_props.constraint_fields
+                ]
+                self.constraint = TagSchemaConstraint.from_constraint_fields(
+                    constraint_fields, has_bases
+                )
+            else:
+                self.constraint = None
+
+        if "constraint_fields" in update_diff_names:
+            if update_props.constraint_fields:
+                has_bases = False
+                if "bases" in update_props.constraint_fields:
+                    has_bases = True
+                    update_props.constraint_fields.discard("bases")
+                constraint_fields = [
+                    f
+                    for f in self.fields
+                    if f.systemName in update_props.constraint_fields
+                ]
+                self.constraint = TagSchemaConstraint.from_constraint_fields(
+                    constraint_fields, has_bases
+                )
+            else:
+                self.constraint = None
 
         self.prefix = (
             update_props.prefix if "prefix" in update_diff_names else self.prefix
@@ -359,6 +483,25 @@ class TagSchemaModel(BaseModel):
         self.name = update_props.name if "name" in update_diff_names else self.name
         return self
 
+    def update_name_template(
+        self, update_name_template: BaseNameTemplate
+    ) -> TagSchemaModel:
+        update_diff_names = update_name_template.model_dump(exclude_unset=True).keys()
+        self.nameTemplateParts = (
+            [
+                NameTemplatePartModel.from_name_template_part(part, self.fields)
+                for part in update_name_template.parts
+            ]
+            if "parts" in update_diff_names
+            else self.nameTemplateParts
+        )
+        self.shouldOrderNamePartsBySequence = (
+            update_name_template.order_name_parts_by_sequence
+            if "order_name_parts_by_sequence" in update_diff_names
+            else self.shouldOrderNamePartsBySequence
+        )
+        return self
+
     def update_field(
         self,
         benchling_service: BenchlingService,

liminal/entity_schemas/utils.py

@@ -9,6 +9,7 @@ from liminal.mappers import (
     convert_api_entity_type_to_entity_type,
     convert_api_field_type_to_field_type,
 )
+from liminal.orm.name_template import NameTemplate
 from liminal.orm.schema_properties import MixtureSchemaConfig, SchemaProperties
 
 
@@ -16,7 +17,7 @@ def get_converted_tag_schemas(
     benchling_service: BenchlingService,
     include_archived: bool = False,
     wh_schema_names: set[str] | None = None,
-) -> list[tuple[SchemaProperties, dict[str, BaseFieldProperties]]]:
+) -> list[tuple[SchemaProperties, NameTemplate, dict[str, BaseFieldProperties]]]:
     """This functions gets all Tag schemas from Benchling and converts them to our internal representation of a schema and its fields.
     It parses the Tag Schema and creates SchemaProperties and a list of FieldProperties for each field in the schema.
     If include_archived is True, it will include archived schemas and archived fields.
@@ -40,10 +41,15 @@ def convert_tag_schema_to_internal_schema(
     tag_schema: TagSchemaModel,
     dropdowns_map: dict[str, str],
     include_archived_fields: bool = False,
-) -> tuple[SchemaProperties, dict[str, BaseFieldProperties]]:
+) -> tuple[SchemaProperties, NameTemplate, dict[str, BaseFieldProperties]]:
     all_fields = tag_schema.allFields
     if not include_archived_fields:
         all_fields = [f for f in all_fields if not f.archiveRecord]
+    constraint_fields: set[str] | None = None
+    if tag_schema.constraint:
+        constraint_fields = set([f.systemName for f in tag_schema.constraint.fields])
+        if tag_schema.constraint.uniqueResidues:
+            constraint_fields.add("bases")
     return (
         SchemaProperties(
             name=tag_schema.name,
@@ -63,7 +69,14 @@ def convert_tag_schema_to_internal_schema(
                 BenchlingNamingStrategy(strategy)
                 for strategy in tag_schema.labelingStrategies
             ),
+            constraint_fields=constraint_fields,
             _archived=tag_schema.archiveRecord is not None,
+            use_registry_id_as_label=tag_schema.useOrganizationCollectionAliasForDisplayLabel,
+            include_registry_id_in_chips=tag_schema.includeRegistryIdInChips,
+        ),
+        NameTemplate(
+            parts=tag_schema.get_internal_name_template_parts(),
+            order_name_parts_by_sequence=tag_schema.shouldOrderNamePartsBySequence,
         ),
         {
             f.systemName: convert_tag_schema_field_to_field_properties(f, dropdowns_map)

liminal/enums/__init__.py

@@ -4,5 +4,4 @@ from liminal.enums.benchling_entity_type import BenchlingEntityType
 from liminal.enums.benchling_field_type import BenchlingFieldType
 from liminal.enums.benchling_folder_item_type import BenchlingFolderItemType
 from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
-from liminal.enums.benchling_report_level import BenchlingReportLevel
 from liminal.enums.benchling_sequence_type import BenchlingSequenceType

liminal/enums/benchling_entity_type.py

@@ -13,3 +13,11 @@ class BenchlingEntityType(StrEnum):
     ENTRY = "entry"
     MIXTURE = "mixture"
     MOLECULE = "molecule"
+
+    def is_sequence(self) -> bool:
+        return self in [
+            self.DNA_SEQUENCE,
+            self.RNA_SEQUENCE,
+            self.DNA_OLIGO,
+            self.RNA_OLIGO,
+        ]

liminal/enums/name_template_part_type.py

@@ -0,0 +1,12 @@
+from liminal.base.str_enum import StrEnum
+
+
+class NameTemplatePartType(StrEnum):
+    SEPARATOR = "SEPARATOR"
+    TEXT = "TEXT"
+    CREATION_YEAR = "CREATED_AT_YEAR"
+    CREATION_DATE = "CREATED_AT_DATE"
+    FIELD = "FIELD"
+    REGISTRY_IDENTIFIER_NUMBER = "REGISTRY_IDENTIFIER_NUMBER"
+    PROJECT = "PROJECT"
+    CHILD_ENTITY_LOT_NUMBER = "CHILD_ENTITY_LOT_NUMBER"

liminal/external/__init__.py

@@ -1,6 +1,16 @@
 # flake8: noqa: F401
 from liminal.base.base_operation import BaseOperation
+from liminal.base.name_template_parts import (
+    CreationDatePart,
+    CreationYearPart,
+    FieldPart,
+    ProjectPart,
+    RegistryIdentifierNumberPart,
+    SeparatorPart,
+    TextPart,
+)
 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.dropdowns.operations import (
     ArchiveDropdown,
@@ -22,6 +32,7 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
+    UpdateEntitySchemaNameTemplate,
 )
 from liminal.enums import (
     BenchlingAPIFieldType,
@@ -29,6 +40,5 @@ from liminal.enums import (
     BenchlingFieldType,
     BenchlingFolderItemType,
     BenchlingNamingStrategy,
-    BenchlingReportLevel,
     BenchlingSequenceType,
 )

liminal/migrate/revisions_timeline.py

@@ -30,7 +30,8 @@ class RevisionsTimeline:
             )
         all_raw_revisions: list[Revision] = []
         for file_path in versions_dir_path.iterdir():
-            all_raw_revisions.append(Revision.parse_from_file(file_path))
+            if file_path.is_file() and file_path.suffix == ".py":
+                all_raw_revisions.append(Revision.parse_from_file(file_path))
         self.revisions_map = self.validate_revisions(all_raw_revisions)
 
     def get_first_revision(self) -> Revision: