liminal-orm 4.4.6__tar.gz → 4.4.8__tar.gz

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: liminal-orm
-Version: 4.4.6
+Version: 4.4.8
 Summary: An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync.
 Project-URL: Homepage, https://github.com/dynotx/liminal-orm
 Project-URL: Repository, https://github.com/dynotx/liminal-orm

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/entity_schemas/compare.py

@@ -232,6 +232,28 @@ def compare_entity_schemas(
                         )
                     )
             if benchling_schema_props != model.__schema_properties__:
+                needs_constraint_clear = (
+                    benchling_schema_props.constraint_fields
+                    != model.__schema_properties__.constraint_fields
+                    and len(benchling_schema_props.constraint_fields) > 0
+                )
+                if needs_constraint_clear:
+                    ops.append(
+                        CompareOperation(
+                            op=UpdateEntitySchema(
+                                model.__schema_properties__.warehouse_name,
+                                BaseSchemaProperties(constraint_fields=set()),
+                            ),
+                            reverse_op=UpdateEntitySchema(
+                                model.__schema_properties__.warehouse_name,
+                                BaseSchemaProperties(
+                                    **model.__schema_properties__.merge(
+                                        benchling_schema_props
+                                    )
+                                ),
+                            ),
+                        )
+                    )
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchema(
@@ -244,7 +266,9 @@ def compare_entity_schemas(
                         ),
                         reverse_op=UpdateEntitySchema(
                             model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
+                            BaseSchemaProperties(constraint_fields=set())
+                            if needs_constraint_clear
+                            else BaseSchemaProperties(
                                 **model.__schema_properties__.merge(
                                     benchling_schema_props
                                 )

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/entity_schemas/generate_files.py

@@ -3,7 +3,6 @@ from pathlib import Path
 
 from rich import print
 
-from liminal.base.base_dropdown import BaseDropdown
 from liminal.connection.benchling_service import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdowns_dict
 from liminal.entity_schemas.utils import get_converted_tag_schemas
@@ -140,20 +139,22 @@ def generate_all_entity_schema_files(
                 col.type in BenchlingFieldType.get_entity_link_types()
                 and col.entity_link is not None
             ):
-                if not col.is_multi:
-                    relationship_strings.append(
-                        f"""{TAB}{col_name}_entity = single_relationship("{wh_name_to_classname[col.entity_link]}", {col_name})"""
-                    )
-                    import_strings.append(
-                        "from liminal.orm.relationship import single_relationship"
-                    )
-                else:
-                    relationship_strings.append(
-                        f"""{TAB}{col_name}_entities = multi_relationship("{wh_name_to_classname[col.entity_link]}", {col_name})"""
-                    )
-                    import_strings.append(
-                        "from liminal.orm.relationship import multi_relationship"
-                    )
+                entity_classname = wh_name_to_classname.get(col.entity_link)
+                if entity_classname is not None:
+                    if not col.is_multi:
+                        relationship_strings.append(
+                            f"""{TAB}{col_name}_entity = single_relationship("{wh_name_to_classname[col.entity_link]}", {col_name})"""
+                        )
+                        import_strings.append(
+                            "from liminal.orm.relationship import single_relationship"
+                        )
+                    else:
+                        relationship_strings.append(
+                            f"""{TAB}{col_name}_entities = multi_relationship("{wh_name_to_classname[col.entity_link]}", {col_name})"""
+                        )
+                        import_strings.append(
+                            "from liminal.orm.relationship import multi_relationship"
+                        )
         for col_name, col in columns.items():
             if not col.required and col.type:
                 init_strings.append(
@@ -241,15 +242,7 @@ class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
 def _get_dropdown_name_to_classname_map(
     benchling_service: BenchlingService,
 ) -> dict[str, str]:
-    """Gets the dropdown name to classname map.
-    If there are dropdowns imported, use BenchlingDropdown.get_all_subclasses()
-    Otherwise, it will query for Benchling dropdowns and use those.
-    """
-    if len(BaseDropdown.get_all_subclasses()) > 0:
-        return {
-            dropdown.__benchling_name__: dropdown.__name__
-            for dropdown in BaseDropdown.get_all_subclasses()
-        }
+    """Gets the dropdown name to classname map by querying Benchling dropdowns and using the dropdown name to create the classname."""
     benchling_dropdowns = get_benchling_dropdowns_dict(benchling_service)
     return {
         dropdown_name: to_pascal_case(dropdown_name)

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/entity_schemas/operations.py

@@ -18,7 +18,6 @@ from liminal.entity_schemas.entity_schema_models import CreateEntitySchemaModel
 from liminal.entity_schemas.tag_schema_models import (
     CreateTagSchemaFieldModel,
     TagSchemaModel,
-    UpdateTagSchemaModel,
 )
 from liminal.entity_schemas.utils import (
     convert_tag_schema_field_to_field_properties,
@@ -217,11 +216,12 @@ class UpdateEntitySchema(BaseOperation):
 
     def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
         tag_schema = self._validate(benchling_service)
-        updated_tag_schema = tag_schema.update_schema_props(
+        update = tag_schema.to_update_tag_schema_model(
             self.update_props.model_dump(exclude_unset=True)
         )
-        update = UpdateTagSchemaModel(**updated_tag_schema.model_dump())
-        return update_tag_schema(benchling_service, tag_schema.id, update.model_dump())
+        return update_tag_schema(
+            benchling_service, tag_schema.id, update.model_dump(exclude_unset=True)
+        )
 
     def describe_operation(self) -> str:
         return f"{self.wh_schema_name}: Updating schema properties to: {str(self.update_props)}."

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/entity_schemas/tag_schema_models.py

@@ -473,28 +473,39 @@ class TagSchemaModel(BaseModel):
             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."""
+    def to_update_tag_schema_model(
+        self, update_diff: dict[str, Any]
+    ) -> UpdateTagSchemaModel:
+        """Converts the tag schema model to an UpdateTagSchemaModel, with only the updated properties."""
         update_diff_names = list(update_diff.keys())
         update_props = BaseSchemaProperties(**update_diff)
+        update_tag_schema_model = UpdateTagSchemaModel()
         if update_props.entity_type and "entity_type" in update_diff_names:
             folder_item_type, sequence_type = convert_entity_type_to_api_entity_type(
                 update_props.entity_type
             )
-            self.folderItemType = folder_item_type
-            self.sequenceType = sequence_type
+            update_tag_schema_model.folderItemType = folder_item_type
+            update_tag_schema_model.sequenceType = sequence_type
         if "naming_strategies" in update_diff_names:
-            self.labelingStrategies = [o.value for o in update_props.naming_strategies]
+            update_tag_schema_model.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
+            update_tag_schema_model.mixtureSchemaConfig = (
+                update_props.mixture_schema_config
+            )
         if "use_registry_id_as_label" in update_diff_names:
-            self.useOrganizationCollectionAliasForDisplayLabel = (
+            update_tag_schema_model.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
+            update_tag_schema_model.includeRegistryIdInChips = (
+                update_props.include_registry_id_in_chips
+            )
         if "show_bases_in_expanded_view" in update_diff_names:
-            self.showResidues = update_props.show_bases_in_expanded_view
+            update_tag_schema_model.showResidues = (
+                update_props.show_bases_in_expanded_view
+            )
 
         if "constraint_fields" in update_diff_names:
             if update_props.constraint_fields:
@@ -516,25 +527,20 @@ class TagSchemaModel(BaseModel):
                     for f in self.fields
                     if f.systemName in update_props.constraint_fields
                 ]
-                self.constraint = TagSchemaConstraint.from_constraint_fields(
-                    constraint_fields, sequence_constraint
+                update_tag_schema_model.constraint = (
+                    TagSchemaConstraint.from_constraint_fields(
+                        constraint_fields, sequence_constraint
+                    )
                 )
             else:
-                self.constraint = None
-
-        self.prefix = (
-            update_props.prefix if "prefix" in update_diff_names else self.prefix
-        )
-
-        set_sql_identifier = (
-            update_props.warehouse_name
-            if "warehouse_name" in update_diff_names
-            else self.sqlIdentifier
-        )
-        assert type(set_sql_identifier) is str
-        self.sqlIdentifier = set_sql_identifier
-        self.name = update_props.name if "name" in update_diff_names else self.name
-        return self
+                update_tag_schema_model.constraint = None
+        if "prefix" in update_diff_names:
+            update_tag_schema_model.prefix = update_props.prefix
+        if "warehouse_name" in update_diff_names:
+            update_tag_schema_model.sqlIdentifier = update_props.warehouse_name
+        if "name" in update_diff_names:
+            update_tag_schema_model.name = update_props.name
+        return update_tag_schema_model
 
     def update_name_template(
         self, update_name_template: BaseNameTemplate

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/enums/benchling_field_type.py

@@ -39,6 +39,7 @@ class BenchlingFieldType(StrEnum):
             cls.DROPDOWN,
             cls.BLOB_LINK,
             cls.ENTRY_LINK,
+            cls.STORAGE_LINK,
             *cls.get_entity_types(),
         ]
 

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/results_schemas/generate_files.py

@@ -97,20 +97,24 @@ def generate_all_results_schema_files(
                 col.type in BenchlingFieldType.get_entity_link_types()
                 and col.entity_link is not None
             ):
-                if not col.is_multi:
-                    relationship_strings.append(
-                        f"""{TAB}{col_name}_entity = single_relationship("{entity_schemas_wh_name_to_classname[col.entity_link]}", {col_name})"""
-                    )
-                    import_strings.append(
-                        "from liminal.orm.relationship import single_relationship"
-                    )
-                else:
-                    relationship_strings.append(
-                        f"""{TAB}{col_name}_entities = multi_relationship("{entity_schemas_wh_name_to_classname[col.entity_link]}", {col_name})"""
-                    )
-                    import_strings.append(
-                        "from liminal.orm.relationship import multi_relationship"
-                    )
+                entity_classname = entity_schemas_wh_name_to_classname.get(
+                    col.entity_link
+                )
+                if entity_classname is not None:
+                    if not col.is_multi:
+                        relationship_strings.append(
+                            f"""{TAB}{col_name}_entity = single_relationship("{entity_classname}", {col_name})"""
+                        )
+                        import_strings.append(
+                            "from liminal.orm.relationship import single_relationship"
+                        )
+                    else:
+                        relationship_strings.append(
+                            f"""{TAB}{col_name}_entities = multi_relationship("{entity_classname}", {col_name})"""
+                        )
+                        import_strings.append(
+                            "from liminal.orm.relationship import multi_relationship"
+                        )
         for col_name, col in field_properties_dict.items():
             if not col.required and col.type:
                 init_strings.append(

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/results_schemas/models/results_schema_model.py

@@ -15,7 +15,6 @@ class ResultsSchemaModel(BaseModel):
 
     allFields: list[TagSchemaFieldModel]
     archiveRecord: dict[str, str] | None
-    derivedParent: Any | None
     fields: list[TagSchemaFieldModel]
     id: str
     name: str | None

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/results_schemas/utils.py

@@ -12,7 +12,7 @@ from liminal.unit_dictionary.utils import get_unit_id_to_name_map
 
 
 def get_converted_results_schemas(
-    benchling_service: BenchlingService,
+    benchling_service: BenchlingService, include_archived: bool = False
 ) -> list[tuple[ResultsSchemaProperties, dict[str, BaseFieldProperties]]]:
     """This functions gets all Results Schema schemas from Benchling and converts them to our internal representation of a schema and its fields.
     It parses the Results Schema and creates ResultsSchemaProperties and a list of FieldProperties for each field in the schema.
@@ -21,6 +21,8 @@ def get_converted_results_schemas(
     dropdowns_map = get_benchling_dropdown_id_name_map(benchling_service)
     unit_id_to_name_map = get_unit_id_to_name_map(benchling_service)
     results_schemas_list = []
+    if not include_archived:
+        results_schemas = [s for s in results_schemas if not s.archiveRecord]
     for schema in results_schemas:
         schema_properties = ResultsSchemaProperties(
             name=schema.name,

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/liminal/tests/test_entity_schema_compare.py

@@ -361,13 +361,21 @@ class TestCompareEntitySchemas:
                 benchling_mismatch_constraint_fields
             )
             invalid_models = compare_entity_schemas(mock_benchling_sdk)
-            assert len(invalid_models["mock_entity"]) == 1
+            assert len(invalid_models["mock_entity"]) == 2
             assert isinstance(invalid_models["mock_entity"][0].op, UpdateEntitySchema)
-            assert invalid_models["mock_entity"][
+            clear_props_dict = invalid_models["mock_entity"][
                 0
-            ].op.update_props.constraint_fields == {
-                "string_field_req",
-                "enum_field",
+            ].op.update_props.model_dump(exclude_unset=True)
+            assert clear_props_dict == {"constraint_fields": set()}
+            assert isinstance(invalid_models["mock_entity"][1].op, UpdateEntitySchema)
+            update_props_dict = invalid_models["mock_entity"][
+                1
+            ].op.update_props.model_dump(exclude_unset=True)
+            assert update_props_dict == {
+                "constraint_fields": {
+                    "string_field_req",
+                    "enum_field",
+                },
             }
 
             # Test when the Benchling schema has different display naming fields

{liminal_orm-4.4.6 → liminal_orm-4.4.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "liminal-orm"
-version = "4.4.6"
+version = "4.4.8"
 description = "An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync."
 authors = [{ name = "DynoTx Open Source", email = "opensource@dynotx.com" }]
 requires-python = ">=3.9,<4"