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

liminal/base/base_operation.py

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

liminal/base/base_validation_filters.py

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

liminal/base/name_template_parts.py

@@ -0,0 +1,96 @@
+from typing import Any, ClassVar
+
+from pydantic import BaseModel, ConfigDict, field_validator
+
+from liminal.enums.name_template_part_type import NameTemplatePartType
+
+
+class NameTemplatePart(BaseModel):
+    """Base class for all name template parts. These are put together in a list (where order matters) to form a name template.
+
+    Parameters
+    ----------
+    component_type : NameTemplatePartType
+        The type of the component. One of the values in the NameTemplatePartType enum.
+
+    """
+
+    component_type: ClassVar[NameTemplatePartType]
+
+    _type_map: ClassVar[dict[NameTemplatePartType, type["NameTemplatePart"]]] = {}
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        cls._type_map[cls.component_type] = cls
+
+    @classmethod
+    def resolve_type(cls, type: NameTemplatePartType) -> type["NameTemplatePart"]:
+        if type not in cls._type_map:
+            raise ValueError(f"Invalid name template part type: {type}")
+        return cls._type_map[type]
+
+
+class SeparatorPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.SEPARATOR
+    value: str
+
+    @field_validator("value")
+    def validate_value(cls, v: str) -> str:
+        if not v:
+            raise ValueError("value cannot be empty")
+        return v
+
+
+class TextPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.TEXT
+    value: str
+
+    @field_validator("value")
+    def validate_value(cls, v: str) -> str:
+        if not v:
+            raise ValueError("value cannot be empty")
+        return v
+
+
+class CreationYearPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.CREATION_YEAR
+
+
+class CreationDatePart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.CREATION_DATE
+
+
+class FieldPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.FIELD
+    wh_field_name: str
+
+
+class ParentLotNumberPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = (
+        NameTemplatePartType.CHILD_ENTITY_LOT_NUMBER
+    )
+    wh_field_name: str
+
+
+class RegistryIdentifierNumberPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = (
+        NameTemplatePartType.REGISTRY_IDENTIFIER_NUMBER
+    )
+
+
+class ProjectPart(NameTemplatePart):
+    component_type: ClassVar[NameTemplatePartType] = NameTemplatePartType.PROJECT
+
+
+NameTemplateParts = (
+    SeparatorPart
+    | TextPart
+    | CreationYearPart
+    | CreationDatePart
+    | FieldPart
+    | RegistryIdentifierNumberPart
+    | ProjectPart
+    | ParentLotNumberPart
+)

liminal/base/properties/base_field_properties.py

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

liminal/base/properties/base_name_template.py

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

liminal/base/properties/base_schema_properties.py

@@ -57,8 +57,17 @@ class BaseSchemaProperties(BaseModel):
         The prefix to use for the schema.
     entity_type : BenchlingEntityType | None
         The entity type of the schema.
+    naming_strategies : set[BenchlingNamingStrategy] | None
+        The naming strategies of the schema.
     mixture_schema_config : MixtureSchemaConfig | None
         The mixture schema config of the schema.
+    use_registry_id_as_label : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will use the Registry ID as the main label for items.
+    include_registry_id_in_chips : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will include the Registry ID in the chip label.
+    constraint_fields : set[str] | None
+        Set of constraints for field values for the schema. Must be a set of column names that specify that their values must be a unique combination within an entity.
+        If the entity type is a Sequence, "bases" can be a constraint field.
     _archived : bool | None
         Whether the schema is archived in Benchling.
     """
@@ -69,6 +78,9 @@ class BaseSchemaProperties(BaseModel):
     entity_type: BenchlingEntityType | None = None
     naming_strategies: set[BenchlingNamingStrategy] | None = None
     mixture_schema_config: MixtureSchemaConfig | None = None
+    use_registry_id_as_label: bool | None = None
+    include_registry_id_in_chips: bool | None = None
+    constraint_fields: set[str] | None = None
     _archived: bool | None = None
 
     def __init__(self, **data: Any):
@@ -109,4 +121,4 @@ class BaseSchemaProperties(BaseModel):
 
     def __repr__(self) -> str:
         """Generates a string representation of the class so that it can be executed."""
-        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_defaults=True).items()])})"
+        return f"{self.__class__.__name__}({', '.join([f'{k}={v.__repr__()}' for k, v in self.model_dump(exclude_unset=True, exclude_defaults=True).items()])})"

liminal/dropdowns/compare.py

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

liminal/dropdowns/operations.py

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

liminal/entity_schemas/api.py

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

liminal/entity_schemas/compare.py

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

liminal/entity_schemas/entity_schema_models.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 from pydantic import BaseModel
 
 from liminal.base.properties.base_field_properties import BaseFieldProperties
@@ -18,6 +20,37 @@ class FieldLinkShortModel(BaseModel):
     folderItemType: str | None = None
 
 
+class EntitySchemaConstraint(BaseModel):
+    """
+    A class to define a constraint on an entity schema.
+    """
+
+    areUniqueResiduesCaseSensitive: bool | None = None
+    fields: dict[str, Any] | None = None
+    hasUniqueCanonicalSmilers: bool | None = None
+    hasUniqueResidues: bool | None = None
+
+    @classmethod
+    def from_constraint_fields(
+        cls, constraint_fields: set[str]
+    ) -> 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")
+            hasUniqueResidues = True
+        return cls(
+            fields=[{"name": f} for f in constraint_fields],
+            hasUniqueResidues=hasUniqueResidues,
+            hasUniqueCanonicalSmilers=False,
+            areUniqueResiduesCaseSensitive=False,
+        )
+
+
 class CreateEntitySchemaFieldModel(BaseModel):
     """A pydantic model to define a field for the create entity schema endpoint.
     This model is used as input for the benchling alpha create entity schema endpoint."""
@@ -98,7 +131,10 @@ class CreateEntitySchemaModel(BaseModel):
     registryId: str
     type: BenchlingEntityType
     mixtureSchemaConfig: MixtureSchemaConfig | None = None
+    includeRegistryIdInChips: bool | None = None
+    useOrganizationCollectionAliasForDisplayLabel: bool | None = None
     labelingStrategies: list[str] | None = None
+    constraint: EntitySchemaConstraint | None = None
 
     @classmethod
     def from_benchling_props(
@@ -129,7 +165,14 @@ class CreateEntitySchemaModel(BaseModel):
             registryId=benchling_service.registry_id,
             type=benchling_props.entity_type,
             mixtureSchemaConfig=benchling_props.mixture_schema_config,
+            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],
+            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/entity_schemas/generate_files.py

@@ -7,6 +7,7 @@ from liminal.dropdowns.utils import get_benchling_dropdowns_dict
 from liminal.entity_schemas.utils import get_converted_tag_schemas
 from liminal.enums import BenchlingEntityType, BenchlingFieldType
 from liminal.mappers import convert_benchling_type_to_python_type
+from liminal.orm.name_template import NameTemplate
 from liminal.utils import pascalize, to_snake_case
 
 
@@ -62,13 +63,13 @@ def generate_all_entity_schema_files(
         for dropdown_name in benchling_dropdowns.keys()
     }
     wh_name_to_classname: dict[str, str] = {
-        sp.warehouse_name: pascalize(sp.name) for sp, _ in models
+        sp.warehouse_name: pascalize(sp.name) for sp, _, _ in models
     }
 
-    for schema_properties, columns in models:
+    for schema_properties, name_template, columns in models:
         classname = pascalize(schema_properties.name)
 
-    for schema_properties, columns in models:
+    for schema_properties, name_template, columns in models:
         classname = pascalize(schema_properties.name)
         filename = to_snake_case(schema_properties.name) + ".py"
         columns = {key: columns[key] for key in columns}
@@ -78,7 +79,6 @@ def generate_all_entity_schema_files(
             "from liminal.orm.base_model import BaseModel",
             "from liminal.orm.schema_properties import SchemaProperties",
             "from liminal.enums import BenchlingEntityType, BenchlingFieldType, BenchlingNamingStrategy",
-            "from liminal.validation import BenchlingValidator",
             f"from liminal.orm.mixins import {get_entity_mixin(schema_properties.entity_type)}",
         ]
         init_strings = [f"{tab}def __init__(", f"{tab}self,"]
@@ -132,6 +132,12 @@ def generate_all_entity_schema_files(
             init_strings.append(f"{tab}self.{col_name} = {col_name}")
         if len(dropdowns) > 0:
             import_strings.append(f"from ...dropdowns import {', '.join(dropdowns)}")
+        if name_template != NameTemplate():
+            import_strings.append("from liminal.orm.name_template import NameTemplate")
+            parts_imports = [
+                f"from liminal.base.name_template_parts import {', '.join(set([part.__class__.__name__ for part in name_template.parts]))}"
+            ]
+            import_strings.extend(parts_imports)
         for col_name, col in columns.items():
             if col.dropdown_link:
                 init_strings.append(
@@ -144,15 +150,12 @@ def generate_all_entity_schema_files(
         relationship_string = "\n".join(relationship_strings)
         import_string = "\n".join(list(set(import_strings)))
         init_string = f"\n{tab}".join(init_strings) if len(columns) > 0 else ""
-        functions_string = """
-    def get_validators(self) -> list[BenchlingValidator]:
-        return []"""
-
-        content = f"""{import_string}
+        full_content = f"""{import_string}
 
 
 class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
     __schema_properties__ = {schema_properties.__repr__()}
+    {f"__name_template__ = {name_template.__repr__()}" if name_template != NameTemplate() else ""}
 
 {columns_string}
 
@@ -160,7 +163,6 @@ class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
 
 {init_string}
 
-{functions_string}
 """
         write_directory_path = write_path / get_file_subdirectory(
             schema_properties.entity_type
@@ -173,7 +175,7 @@ class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
         )
         write_directory_path.mkdir(exist_ok=True)
         with open(write_directory_path / filename, "w") as file:
-            file.write(content)
+            file.write(full_content)
 
     for subdir, names in subdirectory_map.items():
         init_content = (