liminal-orm 5.0.0__tar.gz → 5.1.2__tar.gz

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/.gitignore

@@ -19,4 +19,6 @@ site/
 # for local testing
 test_liminal/
 
-.history
+.history/
+.cursor/
+.envrc

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: liminal-orm
-Version: 5.0.0
+Version: 5.1.2
 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
 Project-URL: Documentation, https://dynotx.github.io/liminal-orm/
 Project-URL: Bug Tracker, https://github.com/dynotx/liminal-orm/issues
-Author-email: DynoTx Open Source <opensource@dynotx.com>
+Author: DynoTx Open Source
 License-File: LICENSE.md
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -21,8 +21,8 @@ Requires-Dist: numpy<2,>=1.26; python_version == '3.12'
 Requires-Dist: numpy<3,>=2.1; python_version == '3.13'
 Requires-Dist: pandas<3,>=1.5.3; python_version == '3.10'
 Requires-Dist: pandas<4,>=1.5.3; python_version == '3.11'
+Requires-Dist: pandas<4,>=2.1.1; python_version == '3.12'
 Requires-Dist: pandas<4,>=2.2.3; python_version == '3.13'
-Requires-Dist: pandas<4,>=2.2; python_version == '3.12'
 Requires-Dist: psycopg2-binary<3,>=2.9.10
 Requires-Dist: pydantic<=2.13,>=2
 Requires-Dist: rich<14,>=13.9.2
@@ -136,7 +136,7 @@ Liminal ORM is distributed under the [Apache License, Version 2.0](./LICENSE.md)
 ## [Direct Contact](#direct-contact)
 
 - Liminal Community Slack group: [Join here](https://join.slack.com/t/liminalorm/shared_invite/zt-3fu79tf06-oqL1000p8BAOG6B3yOOXNA)
-- Email: <opensource@dynotx.com>
+- Email: <ndamania00@gmail.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 
 ## [Acknowledgements](#acknowledgements)

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/README.md

@@ -103,7 +103,7 @@ Liminal ORM is distributed under the [Apache License, Version 2.0](./LICENSE.md)
 ## [Direct Contact](#direct-contact)
 
 - Liminal Community Slack group: [Join here](https://join.slack.com/t/liminalorm/shared_invite/zt-3fu79tf06-oqL1000p8BAOG6B3yOOXNA)
-- Email: <opensource@dynotx.com>
+- Email: <ndamania00@gmail.com>
 - LinkedIn: [Nirmit Damania](https://www.linkedin.com/in/nirmit-damania/)
 
 ## [Acknowledgements](#acknowledgements)

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/base/base_operation.py

@@ -16,10 +16,10 @@ Order of operations based on order class var:
     9. CreateEntitySchema
     10. UnarchiveEntitySchema
     11. CreateEntitySchemaField
-    12. UpdateEntitySchemaNameTemplate
-    13. UpdateEntitySchema
-    14. UnarchiveEntitySchemaField
-    15. UpdateEntitySchemaField
+    12. UpdateEntitySchema
+    13. UnarchiveEntitySchemaField
+    14. UpdateEntitySchemaField
+    15. UpdateEntitySchemaNameTemplate
     16. ArchiveEntitySchemaField
     17. ReorderEntitySchemaFields
     18. ArchiveEntitySchema

liminal_orm-5.1.2/liminal/base/compare_operation.py

@@ -0,0 +1,19 @@
+from pydantic import BaseModel, ConfigDict
+
+from liminal.base.base_operation import BaseOperation
+
+
+class CompareOperation(BaseModel):
+    op: BaseOperation
+    reverse_op: BaseOperation
+    # Overrides op.order when this operation must run at a different point than its type's default.
+    order_override: int | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @property
+    def sort_order(self) -> int:
+        return self.op.order if self.order_override is None else self.order_override
+
+    def __lt__(self, other: "CompareOperation") -> bool:
+        return self.sort_order < other.sort_order

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/base/properties/base_field_properties.py

@@ -65,8 +65,6 @@ class BaseFieldProperties(BaseModel):
         non_multi_types = BenchlingFieldType.get_non_multi_select_types()
         if field_type in non_multi_types:
             unsupported.add("is_multi")
-        if not (has_entity_link and field_type == BenchlingFieldType.ENTITY_LINK):
-            unsupported.add("parent_link")
         if field_type not in BenchlingFieldType.get_number_field_types():
             unsupported.add("unit_name")
         if field_type != BenchlingFieldType.DECIMAL:
@@ -96,6 +94,11 @@ class BaseFieldProperties(BaseModel):
             self.__pydantic_fields_set__.remove("unit_name")
         return self
 
+    def unset_parent_link(self) -> BaseFieldProperties:
+        if "parent_link" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("parent_link")
+        return self
+
     def set_type(self, new_type: BenchlingFieldType) -> BaseFieldProperties:
         self.type = new_type
         return self

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/base/properties/base_schema_properties.py

@@ -105,6 +105,11 @@ class BaseSchemaProperties(BaseModel):
         self.naming_strategies = value
         return self
 
+    def unset_naming_strategies(self) -> BaseSchemaProperties:
+        if "naming_strategies" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("naming_strategies")
+        return self
+
     def merge(self, new_props: BaseSchemaProperties) -> dict[str, Any]:
         """Creates a diff between the current schema properties and the new schema properties.
         Sets value to None if the values are equal, otherwise sets the value to the new value.

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/cli/cli.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
+import json
 from pathlib import Path
+import sys
 from typing import Any
 
 import typer
@@ -8,6 +10,7 @@ from typer.core import TyperGroup
 
 from liminal.cli.controller import (
     autogenerate_revision_file,
+    diff_benchling_tenant,
     downgrade_benchling_tenant,
     generate_all_files,
     upgrade_benchling_tenant,
@@ -120,7 +123,7 @@ def generate_files(
     benchling_connection = read_local_liminal_dir(LIMINAL_DIR_PATH, benchling_tenant)
     benchling_service = BenchlingService(benchling_connection)
     if not write_path.exists():
-        write_path.mkdir()
+        write_path.mkdir(parents=True)
         print(f"[green]Created directory: {write_path}")
     if not entity_schemas_flag and not dropdowns_flag and not results_schemas_flag:
         entity_schemas_flag = True
@@ -176,6 +179,71 @@ def head(
     print(f"[blue]{revision_timeline.get_latest_revision().id}: (head)[/blue]")
 
 
+@app.command(
+    name="diff",
+    help="Compares the locally defined dropdowns and entity schemas to the given Benchling tenant. Exit codes: 0=in sync, 1=error, 2=differences found.",
+)
+def diff(
+    benchling_tenant: str = typer.Argument(
+        ..., help="Benchling tenant (or alias) to connect to."
+    ),
+    dropdowns_flag: bool = typer.Option(
+        False,
+        "-d",
+        "--dropdowns",
+        help="Only compare dropdowns.",
+    ),
+    entity_schemas_flag: bool = typer.Option(
+        False,
+        "-es",
+        "--entity-schemas",
+        help="Only compare entity schemas.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Write a machine-readable comparison report to stdout.",
+    ),
+) -> None:
+    benchling_connection = read_local_liminal_dir(LIMINAL_DIR_PATH, benchling_tenant)
+    benchling_service = BenchlingService(benchling_connection)
+    if not dropdowns_flag and not entity_schemas_flag:
+        dropdowns_flag = True
+        entity_schemas_flag = True
+    report = diff_benchling_tenant(
+        benchling_service, dropdowns_flag, entity_schemas_flag
+    )
+    if json_output:
+        typer.echo(json.dumps(report, sort_keys=True))
+    else:
+        for key, label in (
+            ("dropdowns", "Dropdowns"),
+            ("entity_schemas", "Entity schemas"),
+        ):
+            section = report[key]
+            if not section["compared"]:
+                continue
+            if section["in_sync"]:
+                print(f"[bold green]{label} are in sync for {report['tenant']} tenant.")
+                continue
+            print(
+                f"[bold yellow]{label}: {len(section['differences'])} difference(s) for {report['tenant']} tenant."
+            )
+            for index, difference in enumerate(section["differences"], start=1):
+                print(f"  {index}. {difference['description']}")
+
+        if report["in_sync"]:
+            print(
+                f"[bold green]No differences found. {report['tenant']} is in sync with code."
+            )
+        else:
+            print(
+                f"[bold yellow]{report['total_differences']} total difference(s) found between code and {report['tenant']}. Run `liminal revision {report['tenant']} '<description>'` to generate a revision file that resolves them."
+            )
+    if not report["in_sync"]:
+        raise typer.Exit(code=2)
+
+
 @app.command(
     name="revision",
     help="Generates a revision file with a list of operations to bring the given Benchling tenant up to date with the locally defined schemas. Writes revision file to liminal/versions/.",
@@ -327,5 +395,5 @@ def live_test(
         )
 
 
-print("Starting Liminal CLI...")
+print("Starting Liminal CLI...", file=sys.stderr)
 app()

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/cli/controller.py

@@ -1,9 +1,13 @@
 from pathlib import Path
+from typing import Any
 
 from rich import print
 
+from liminal.base.compare_operation import CompareOperation
 from liminal.connection.benchling_service import BenchlingService
+from liminal.dropdowns.compare import compare_dropdowns
 from liminal.dropdowns.generate_files import generate_all_dropdown_files
+from liminal.entity_schemas.compare import compare_entity_schemas
 from liminal.entity_schemas.generate_files import generate_all_entity_schema_files
 from liminal.migrate.components import execute_operations, get_full_migration_operations
 from liminal.migrate.revisions_timeline import RevisionsTimeline
@@ -45,6 +49,68 @@ def generate_all_files(
         generate_all_results_schema_files(benchling_service, write_path, overwrite)
 
 
+def diff_benchling_tenant(
+    benchling_service: BenchlingService,
+    dropdowns_flag: bool = True,
+    entity_schemas_flag: bool = True,
+) -> dict[str, Any]:
+    """Compares locally defined schemas to a Benchling tenant.
+
+    This is read-only and does not make any changes to the Benchling tenant or
+    write any files.
+
+    Parameters
+    ----------
+    benchling_service : BenchlingService
+        The Benchling service object that is connected to a specified Benchling tenant.
+    dropdowns_flag : bool
+        Whether to compare dropdowns.
+    entity_schemas_flag : bool
+        Whether to compare entity schemas.
+
+    Returns
+    -------
+    dict[str, Any]
+        A machine-readable report of the comparison.
+    """
+    tenant = benchling_service.benchling_tenant
+    sections: dict[str, dict[str, list[CompareOperation]] | None] = {
+        "dropdowns": None,
+        "entity_schemas": None,
+    }
+    if dropdowns_flag:
+        sections["dropdowns"] = compare_dropdowns(benchling_service)
+    if entity_schemas_flag:
+        sections["entity_schemas"] = compare_entity_schemas(benchling_service)
+
+    report: dict[str, Any] = {"tenant": tenant, "total_differences": 0}
+    for section_name, comparison in sections.items():
+        compared = comparison is not None
+        differences = [
+            {
+                "name": name,
+                "operation": compare_op.op.__class__.__name__,
+                "description": compare_op.op.describe(),
+            }
+            for name, compare_op in sorted(
+                (
+                    (name, compare_op)
+                    for name, compare_ops in (comparison or {}).items()
+                    for compare_op in compare_ops
+                ),
+                key=lambda difference: difference[1],
+            )
+        ]
+        report[section_name] = {
+            "compared": compared,
+            "in_sync": len(differences) == 0 if compared else None,
+            "differences": differences,
+        }
+        report["total_differences"] += len(differences)
+    report["in_sync"] = report["total_differences"] == 0
+    return report
+
+
 def autogenerate_revision_file(
     benchling_service: BenchlingService,
     revisions_timeline: RevisionsTimeline,

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/dropdowns/generate_files.py

@@ -1,3 +1,4 @@
+import json
 import shutil
 from pathlib import Path
 
@@ -5,7 +6,7 @@ from rich import print
 
 from liminal.connection import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdowns_dict
-from liminal.utils import to_pascal_case, to_snake_case
+from liminal.utils import to_module_name, to_pascal_case
 
 
 def generate_all_dropdown_files(
@@ -36,17 +37,17 @@ def generate_all_dropdown_files(
     num_files_written = 0
     for dropdown_name, dropdown_options in dropdowns.items():
         dropdown_values = [option.name for option in dropdown_options.options]
-        options_list = str(dropdown_values).replace("'", '"')
+        options_list = json.dumps(dropdown_values, ensure_ascii=False)
         classname = to_pascal_case(dropdown_name)
         dropdown_content = f"""
 from liminal.base.base_dropdown import BaseDropdown
 
 
 class {classname}(BaseDropdown):
-    __benchling_name__ = "{dropdown_name}"
+    __benchling_name__ = {json.dumps(dropdown_name, ensure_ascii=False)}
     __allowed_values__ = {options_list}
 """
-        filename = to_snake_case(dropdown_name) + ".py"
+        filename = to_module_name(dropdown_name) + ".py"
         if overwrite or not (write_path / filename).exists():
             with open(write_path / filename, "w") as file:
                 file.write(dropdown_content)

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/entity_schemas/compare.py

@@ -26,6 +26,9 @@ from liminal.utils import to_snake_case
 
 LOGGER = logging.getLogger(__name__)
 
+# Template based naming strategies need the name template, so the order is overridden to be set right after it.
+NAME_TEMPLATE_NAMING_STRATEGY_ORDER = UpdateEntitySchemaNameTemplate.order + 1
+
 
 def compare_entity_schemas(
     benchling_service: BenchlingService, schema_names: set[str] | None = None
@@ -237,26 +240,50 @@ def compare_entity_schemas(
                         )
                     )
             if benchling_schema_props != model.__schema_properties__:
-                ops.append(
-                    CompareOperation(
-                        op=UpdateEntitySchema(
-                            model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
-                                **benchling_schema_props.merge(
-                                    model.__schema_properties__
-                                )
+                new_schema_props = BaseSchemaProperties(
+                    **benchling_schema_props.merge(model.__schema_properties__)
+                )
+                rollback_schema_props = BaseSchemaProperties(
+                    **model.__schema_properties__.merge(benchling_schema_props)
+                )
+                model_strategies = (
+                    model.__schema_properties__.naming_strategies or set()
+                )
+                benchling_strategies = benchling_schema_props.naming_strategies or set()
+                # A template based naming strategy needs the name template, which runs after UpdateEntitySchema.
+                # So when one is being added, set all the naming strategies in their own operation after the template.
+                if any(
+                    BenchlingNamingStrategy.is_template_based(s)
+                    for s in model_strategies - benchling_strategies
+                ):
+                    new_schema_props.unset_naming_strategies()
+                    rollback_schema_props.unset_naming_strategies()
+                    ops.append(
+                        CompareOperation(
+                            op=UpdateEntitySchema(
+                                model_wh_name,
+                                BaseSchemaProperties(
+                                    naming_strategies=model_strategies
+                                ),
                             ),
-                        ),
-                        reverse_op=UpdateEntitySchema(
-                            model.__schema_properties__.warehouse_name,
-                            BaseSchemaProperties(
-                                **model.__schema_properties__.merge(
-                                    benchling_schema_props
-                                )
+                            reverse_op=UpdateEntitySchema(
+                                model_wh_name,
+                                BaseSchemaProperties(
+                                    naming_strategies=benchling_strategies
+                                ),
+                            ),
+                            order_override=NAME_TEMPLATE_NAMING_STRATEGY_ORDER,
+                        )
+                    )
+                if new_schema_props.model_dump(exclude_unset=True) != {}:
+                    ops.append(
+                        CompareOperation(
+                            op=UpdateEntitySchema(model_wh_name, new_schema_props),
+                            reverse_op=UpdateEntitySchema(
+                                model_wh_name, rollback_schema_props
                             ),
                         ),
-                    ),
-                )
+                    )
             if benchling_name_template != model.__name_template__:
                 ops.append(
                     CompareOperation(
@@ -300,8 +327,24 @@ def compare_entity_schemas(
                 for p in field_props
                 if (p.unit_name and p.warehouse_name)
             }
+            # A link field is created without a target, and Benchling only accepts
+            # parent_link on a field that has one, so it is set with the target.
+            parent_links_to_update = {
+                p.warehouse_name
+                for p in field_props
+                if (p.parent_link and p.entity_link and p.warehouse_name)
+            }
             field_props = [
-                f.unset_tooltip().unset_entity_link().unset_unit_name()
+                f.unset_tooltip()
+                .unset_entity_link()
+                .unset_unit_name()
+                .unset_parent_link()
+                for f in field_props
+            ]
+            field_props = [
+                f.unset_parent_link()
+                if f.warehouse_name in parent_links_to_update
+                else f
                 for f in field_props
             ]
             field_props = [
@@ -337,32 +380,20 @@ def compare_entity_schemas(
                 )
             )
             # Benchling api does not allow for setting a custom warehouse_name.
-            # Benchling api also does not allow for setting the name template.
             # Because of this, we need to run a separate UpdateEntitySchema to set the warehouse_name if it is different from the snakecase version of the model name.
-            # We also need to set the template based naming_strategies separately, since the name template must first be set.
-            new_schema_props = BaseSchemaProperties()
-            rollback_schema_props = BaseSchemaProperties()
+            # Later operations on this schema use the model's warehouse_name.
             if model_wh_name != benchling_given_wh_name:
-                new_schema_props.warehouse_name = model_wh_name
-                rollback_schema_props.warehouse_name = benchling_given_wh_name
-            if (
-                model.__schema_properties__.naming_strategies
-                - standard_naming_strategies
-            ):
-                new_schema_props.naming_strategies = (
-                    model.__schema_properties__.naming_strategies
-                )
-                rollback_schema_props.naming_strategies = standard_naming_strategies
-            if new_schema_props.model_dump(exclude_unset=True) != {}:
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchema(
                             benchling_given_wh_name,
-                            new_schema_props,
+                            BaseSchemaProperties(warehouse_name=model_wh_name),
                         ),
                         reverse_op=UpdateEntitySchema(
                             model_wh_name,
-                            rollback_schema_props,
+                            BaseSchemaProperties(
+                                warehouse_name=benchling_given_wh_name
+                            ),
                         ),
                     )
                 )
@@ -382,6 +413,9 @@ def compare_entity_schemas(
                     )
                     rollback_field_props.entity_link = None
                     rollback_field_props.type = BenchlingFieldType.ENTITY_LINK
+                if wh_field_name in parent_links_to_update:
+                    new_field_props.parent_link = True
+                    rollback_field_props.parent_link = False
                 if tooltip_value := tooltips_to_update.get(wh_field_name):
                     new_field_props.tooltip = tooltip_value
                     rollback_field_props.tooltip = None
@@ -403,11 +437,12 @@ def compare_entity_schemas(
             )
             # Benchling api also does not allow for setting the name template when Creating an Entity Schema, since it is a different endpoint.
             # Because of this, we need to run a separate UpdateEntitySchemaNameTemplate using the name template endpoint to set the name template on the newly created Entity Schema.
+            # The name template update runs after the field updates above, since a part can need a link target or parent link set there.
             if benchling_given_name_template != model.__name_template__:
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchemaNameTemplate(
-                            benchling_given_wh_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **benchling_given_name_template.merge(
                                     model.__name_template__
@@ -415,7 +450,7 @@ def compare_entity_schemas(
                             ),
                         ),
                         reverse_op=UpdateEntitySchemaNameTemplate(
-                            benchling_given_wh_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **model.__name_template__.merge(
                                     benchling_given_name_template
@@ -424,6 +459,28 @@ def compare_entity_schemas(
                         ),
                     )
                 )
+            # Template based naming_strategies need the name template, so they are set right after it.
+            if (
+                model.__schema_properties__.naming_strategies
+                - standard_naming_strategies
+            ):
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchema(
+                            model_wh_name,
+                            BaseSchemaProperties(
+                                naming_strategies=model.__schema_properties__.naming_strategies
+                            ),
+                        ),
+                        reverse_op=UpdateEntitySchema(
+                            model_wh_name,
+                            BaseSchemaProperties(
+                                naming_strategies=standard_naming_strategies
+                            ),
+                        ),
+                        order_override=NAME_TEMPLATE_NAMING_STRATEGY_ORDER,
+                    )
+                )
 
         model_operations[model.__schema_properties__.warehouse_name] = ops
         running_benchling_schema_names = [

{liminal_orm-5.0.0 → liminal_orm-5.1.2}/liminal/entity_schemas/entity_schema_models.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from functools import lru_cache
 from typing import Any
 
@@ -129,18 +130,26 @@ class EntitySchemaFieldModel(BaseModel):
         self.description = (
             update_props.tooltip if "tooltip" in update_diff_names else self.description
         )
-        if "entity_link" in update_diff_names and update_props.entity_link:
-            if benchling_service is None:
-                raise ValueError(
-                    "Benchling SDK must be provided to update entity link field."
+        if "entity_link" in update_diff_names:
+            if update_props.entity_link is None:
+                self.linkDefinition = None
+                # Without a target schema the field is a generic entity link, not e.g. a CustomEntityLinkFieldDefinition.
+                if BenchlingFieldDefinitionType.is_entity_link(self.typename):
+                    self.typename = (
+                        BenchlingFieldDefinitionType.ANY_ENTITY_LINK_FIELD_DEFINITION
+                    )
+            else:
+                if benchling_service is None:
+                    raise ValueError(
+                        "Benchling SDK must be provided to update entity link field."
+                    )
+                linked_schema = EntitySchemaModel.get_one_cached(
+                    benchling_service, update_props.entity_link
+                )
+                self.linkDefinition = FieldLinkDefinitionModel(
+                    id=linked_schema.id,
+                    typename=BenchlingLinkDefinitionType(linked_schema.typename.value),
                 )
-            linked_schema = EntitySchemaModel.get_one_cached(
-                benchling_service, update_props.entity_link
-            )
-            self.linkDefinition = FieldLinkDefinitionModel(
-                id=linked_schema.id,
-                typename=BenchlingLinkDefinitionType(linked_schema.typename.value),
-            )
         if "type" in update_diff_names and update_props.type:
             linked_schema_type = (
                 BenchlingEntityTypeName(self.linkDefinition.typename.value)
@@ -484,7 +493,8 @@ class EntitySchemaModel(BaseModel):
     availableRegistrationNamingOptions: list[BenchlingNamingStrategy] | None = None
     constraint: EntitySchemaConstraintModel | None = None
     nameTemplate: NameTemplateModel | None = None
-    containerNameTemplate: NameTemplateModel | None = None
+    # TODO(#263): Add coverage for containerNameTemplate.
+    containerNameTemplate: dict[str, Any] | None = None
     showResidues: bool | None = None
     typedIconId: str | None = None
     allowMeasuredIngredients: bool | None = None
@@ -519,7 +529,10 @@ class EntitySchemaModel(BaseModel):
                 try:
                     filtered_schemas.append(cls.model_validate(schema))
                 except Exception as e:
-                    print(f"Error validating schema {schema['systemName']}: {e}")
+                    warnings.warn(
+                        f"Skipping schema {schema['systemName']}: failed validation: {e}",
+                        stacklevel=2,
+                    )
         return filtered_schemas
 
     @classmethod