liminal-orm 3.2.0__tar.gz → 4.0.0__tar.gz

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liminal-orm
-Version: 3.2.0
+Version: 4.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
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: benchling-sdk (>=1.8.0)
+Requires-Dist: benchling-sdk (>=1.21.2,<2.0.0)
 Requires-Dist: bs4 (>=0.0.2,<0.0.3)
 Requires-Dist: lxml (>=5.3.0,<6.0.0)
 Requires-Dist: numpy (>=1.23.5,<2.0.0)

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/base/name_template_parts.py

@@ -3,6 +3,6 @@ import warnings
 from liminal.orm.name_template_parts import *  # noqa: F403
 
 warnings.warn(
-    "Importing from 'liminal.base.name_template_parts' is deprecated. Please import from 'liminal.orm.name_template_parts' instead. This will be removed in v4.",
+    "Importing from 'liminal.base.name_template_parts' is deprecated. Please import from 'liminal.orm.name_template_parts' instead. This will be removed in v5.",
     FutureWarning,
 )

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/base/properties/base_field_properties.py

@@ -64,12 +64,31 @@ class BaseFieldProperties(BaseModel):
         self.warehouse_name = wh_name
         return self
 
+    def unset_tooltip(self) -> BaseFieldProperties:
+        if "tooltip" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("tooltip")
+        return self
+
     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.
         """
         return True
 
+    def column_dump(self) -> dict[str, Any]:
+        """This function returns a model dump or dictionary of the field properties.
+        However, it removes defaults based on the init in the Column class."""
+        column_props = self.model_dump(exclude_unset=True, exclude_none=True)
+        to_pop = []
+        for k, v in column_props.items():
+            if k == "is_multi" and v is False:
+                to_pop.append(k)
+            elif k == "parent_link" and v is False:
+                to_pop.append(k)
+        for k in to_pop:
+            column_props.pop(k)
+        return column_props
+
     def merge(self, new_props: BaseFieldProperties) -> dict[str, Any]:
         """Returns a diff of the two given Benchling FieldProperties as a dictionary.
         If the field is different, set it as the new field.

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/cli/cli.py

@@ -83,7 +83,7 @@ connection = BenchlingConnection(
 
 @app.command(
     name="generate-files",
-    help="Generates the dropdown and entity schema files from your Benchling tenant and writes to the given path.",
+    help="Generates the dropdown, entity schema, and results schema files from your Benchling tenant and writes to the given path. By default, this will overwrite any existing files within the {write_path}/dropdowns/, {write_path}/entity_schemas/, and {write_path}/results_schemas/ directories.",
 )
 def generate_files(
     benchling_tenant: str = typer.Argument(
@@ -95,13 +95,48 @@ def generate_files(
         "--write-path",
         help="The path to write the generated files to.",
     ),
+    entity_schemas_flag: bool = typer.Option(
+        False,
+        "-es",
+        "--entity-schemas",
+        help="Generate entity schema files.",
+    ),
+    dropdowns_flag: bool = typer.Option(
+        False,
+        "-d",
+        "--dropdowns",
+        help="Generate dropdown files.",
+    ),
+    results_schemas_flag: bool = typer.Option(
+        False,
+        "-rs",
+        "--results-schemas",
+        help="Generate results schema files.",
+    ),
+    overwrite: bool = typer.Option(
+        False,
+        "-o",
+        "--overwrite",
+        help="Overwrite existing files within the {write_path}/dropdowns/, {write_path}/entity_schemas/, and {write_path}/results_schemas/ directories.",
+    ),
 ) -> None:
     _, benchling_connection = read_local_liminal_dir(LIMINAL_DIR_PATH, benchling_tenant)
     benchling_service = BenchlingService(benchling_connection, use_internal_api=True)
     if not write_path.exists():
         write_path.mkdir()
         print(f"[green]Created directory: {write_path}")
-    generate_all_files(benchling_service, Path(write_path))
+    if not entity_schemas_flag and not dropdowns_flag and not results_schemas_flag:
+        entity_schemas_flag = True
+        dropdowns_flag = True
+        results_schemas_flag = True
+    generate_all_files(
+        benchling_service,
+        Path(write_path),
+        entity_schemas_flag,
+        dropdowns_flag,
+        results_schemas_flag,
+        overwrite,
+    )
 
 
 @app.command(
@@ -121,7 +156,7 @@ def current(
         remote_revision_id = benchling_service.get_remote_revision_id()
         if current_revision_id is not None:
             warnings.warn(
-                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v4 release.",
+                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v5 release.",
                 FutureWarning,
             )
         current_revision_id = remote_revision_id
@@ -165,7 +200,7 @@ def revision(
         remote_revision_id = benchling_service.get_remote_revision_id()
         if current_revision_id is not None:
             warnings.warn(
-                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v4 release.",
+                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v5 release.",
                 FutureWarning,
             )
         current_revision_id = remote_revision_id
@@ -194,7 +229,7 @@ def autogenerate(
     ),
 ) -> None:
     raise DeprecationWarning(
-        "CLI command `liminal autogenerate ...` is deprecated and will be removed in v4. Please use `liminal revision ...` instead."
+        "CLI command `liminal autogenerate ...` is deprecated and will be removed in v5. Please use `liminal revision ...` instead."
     )
 
 
@@ -221,7 +256,7 @@ def upgrade(
         remote_revision_id = benchling_service.get_remote_revision_id()
         if current_revision_id is not None:
             warnings.warn(
-                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v4 release.",
+                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v5 release.",
                 FutureWarning,
             )
         current_revision_id = remote_revision_id
@@ -265,7 +300,7 @@ def downgrade(
         remote_revision_id = benchling_service.get_remote_revision_id()
         if current_revision_id is not None:
             warnings.warn(
-                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v4 release.",
+                f"Accessing and using the revision_id variable in {LIMINAL_DIR_PATH/'env.py'} is deprecated. Delete the variable set in the env.py file, the revision_id is now stored in your Benchling tenant within the '_liminal_remote' schema. Support for reading/writing the local revision_id will end with the v5 release.",
                 FutureWarning,
             )
         current_revision_id = remote_revision_id

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/cli/controller.py

@@ -7,12 +7,20 @@ from liminal.dropdowns.generate_files import generate_all_dropdown_files
 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
+from liminal.results_schemas.generate_files import generate_all_results_schema_files
 
 
-def generate_all_files(benchling_service: BenchlingService, write_path: Path) -> None:
-    """Initializes all the dropdown and entity schema files from your Benchling tenant and writes to the given path.
-    Creates and writes to the dropdowns/ and entity_schemas/ directories.
-    Note: This will overwrite any existing dropdowns or entity schemas that exist in the given path.
+def generate_all_files(
+    benchling_service: BenchlingService,
+    write_path: Path,
+    entity_schemas_flag: bool = True,
+    dropdowns_flag: bool = True,
+    results_schemas_flag: bool = True,
+    overwrite: bool = False,
+) -> None:
+    """Initializes all the dropdown, entity schema, and results schema files from your Benchling tenant and writes to the given path.
+    Creates and writes to the dropdowns/, entity_schemas/, and results_schemas/ directories.
+    Note: By default, this will overwrite any existing dropdowns, entity schemas, or results schemas that exist in the given path.
 
     Parameters
     ----------
@@ -20,9 +28,21 @@ def generate_all_files(benchling_service: BenchlingService, write_path: Path) ->
         The Benchling service object that is connected to a specified Benchling tenant.
     write_path : Path
         The path to write the generated files to.
+    entity_schemas_flag : bool
+        Whether to generate the entity schema files in the entity_schemas/ directory.
+    dropdowns_flag : bool
+        Whether to generate the dropdown files in the dropdowns/ directory.
+    results_schemas_flag : bool
+        Whether to generate the results schema files in the results_schemas/ directory.
+    overwrite : bool
+        Whether to overwrite existing the existing write_path directory.
     """
-    generate_all_dropdown_files(benchling_service, write_path)
-    generate_all_entity_schema_files(benchling_service, write_path)
+    if dropdowns_flag:
+        generate_all_dropdown_files(benchling_service, write_path, overwrite)
+    if entity_schemas_flag:
+        generate_all_entity_schema_files(benchling_service, write_path, overwrite)
+    if results_schemas_flag:
+        generate_all_results_schema_files(benchling_service, write_path, overwrite)
 
 
 def autogenerate_revision_file(

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/cli/live_test_dropdown_migration.py

@@ -29,9 +29,11 @@ def mock_dropdown_full_migration(
     dropdown_options = ["Option 1", "Option 2"]
     create_dropdown_op = CreateDropdown(test_dropdown_name, dropdown_options)
 
-    test_dropdown_name = f"{test_dropdown_name}_arch"
+    update_dropdown_op = UpdateDropdownName(
+        test_dropdown_name, f"{test_dropdown_name}_arch"
+    )
 
-    update_dropdown_op = UpdateDropdownName(test_dropdown_name, test_dropdown_name)
+    test_dropdown_name = f"{test_dropdown_name}_arch"
 
     create_dropdown_option_op = CreateDropdownOption(
         test_dropdown_name, "Option 3 New", 2

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/cli/utils.py

@@ -81,7 +81,7 @@ def _read_local_env_file(
 def update_env_revision_id(
     env_file_path: Path, benchling_env: str, revision_id: str
 ) -> None:
-    """Updates the CURRENT_REVISION_ID variable in the env.py file to the given revision id. REMOVE WITH v4 release."""
+    """Updates the CURRENT_REVISION_ID variable in the env.py file to the given revision id. REMOVE WITH v5 release."""
     env_file_content = env_file_path.read_text().split("\n")
     for i, line in enumerate(env_file_content):
         if f"{benchling_env}_CURRENT_REVISION_ID =" in line:

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/dropdowns/generate_files.py

@@ -1,3 +1,4 @@
+import shutil
 from pathlib import Path
 
 from rich import print
@@ -8,13 +9,24 @@ from liminal.utils import to_pascal_case, to_snake_case
 
 
 def generate_all_dropdown_files(
-    benchling_service: BenchlingService, write_path: Path
+    benchling_service: BenchlingService, write_path: Path, overwrite: bool = False
 ) -> None:
     """Generate all dropdown files from your Benchling tenant and writes to the given dropdowns/ path.
     This is used to initialize your code for Liminal and transfer the information from your Benchling tenant to your local codebase.
-    Note: This will overwrite any existing dropdowns that exist in the given path.
+
+    Parameters
+    ----------
+    benchling_service : BenchlingService
+        The Benchling service object that is connected to a specified Benchling tenant.
+    write_path : Path
+        The path to write the generated files to. dropdowns/ directory will be created within this path.
+    overwrite : bool
+        Whether to overwrite existing the existing dropdowns/ directory.
     """
     write_path = write_path / "dropdowns"
+    if write_path.exists() and overwrite:
+        shutil.rmtree(write_path)
+        print(f"[dim]Removed directory: {write_path}")
     if not write_path.exists():
         write_path.mkdir(parents=True, exist_ok=True)
         print(f"[green]Created directory: {write_path}")

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/entity_schemas/compare.py

@@ -272,10 +272,16 @@ def compare_entity_schemas(
         # 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.
         else:
-            model_props = [
+            field_props = [
                 col.properties.set_warehouse_name(wh_name)
                 for wh_name, col in model_columns.items()
             ]
+            tooltips_to_update = {
+                p.warehouse_name: p.tooltip
+                for p in field_props
+                if (p.tooltip and p.warehouse_name)
+            }
+            field_props = [f.unset_tooltip() for f in field_props]
             template_based_naming_strategies = {
                 s
                 for s in model.__schema_properties__.naming_strategies
@@ -286,19 +292,61 @@ def compare_entity_schemas(
                 for s in model.__schema_properties__.naming_strategies
                 if not BenchlingNamingStrategy.is_template_based(s)
             }
+            model_wh_name = model.__schema_properties__.warehouse_name
+            benchling_given_wh_name = to_snake_case(model.__schema_properties__.name)
             ops.append(
                 CompareOperation(
                     op=CreateEntitySchema(
                         BaseSchemaProperties(
-                            **model.__schema_properties__.model_dump()
+                            **model.__schema_properties__.set_warehouse_name(
+                                benchling_given_wh_name
+                            ).model_dump()
                         ),
-                        fields=model_props,
-                    ),
-                    reverse_op=ArchiveEntitySchema(
-                        model.__schema_properties__.warehouse_name
+                        fields=field_props,
                     ),
+                    reverse_op=ArchiveEntitySchema(benchling_given_wh_name),
                 )
             )
+            new_schema_props = BaseSchemaProperties()
+            rollback_schema_props = BaseSchemaProperties()
+            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 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_wh_name,
+                            rollback_schema_props,
+                        ),
+                    )
+                )
+            # Benchling api also does not allow for setting of field tooltips
+            # so we need to run another UpdateEntitySchemaField to set the tooltip after the schema is created
+            for wh_field_name, tooltip_value in tooltips_to_update.items():
+                ops.append(
+                    CompareOperation(
+                        op=UpdateEntitySchemaField(
+                            model_wh_name,
+                            wh_field_name,
+                            BaseFieldProperties(tooltip=tooltip_value),
+                        ),
+                        reverse_op=UpdateEntitySchemaField(
+                            model_wh_name,
+                            wh_field_name,
+                            BaseFieldProperties(tooltip=None),
+                        ),
+                    )
+                )
             benchling_given_name_template = BaseNameTemplate(
                 parts=[], order_name_parts_by_sequence=False
             )
@@ -306,7 +354,7 @@ def compare_entity_schemas(
                 ops.append(
                     CompareOperation(
                         op=UpdateEntitySchemaNameTemplate(
-                            model.__schema_properties__.warehouse_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **benchling_given_name_template.merge(
                                     model.__name_template__
@@ -314,7 +362,7 @@ def compare_entity_schemas(
                             ),
                         ),
                         reverse_op=UpdateEntitySchemaNameTemplate(
-                            model.__schema_properties__.warehouse_name,
+                            model_wh_name,
                             BaseNameTemplate(
                                 **model.__name_template__.merge(
                                     benchling_given_name_template
@@ -323,32 +371,6 @@ def compare_entity_schemas(
                         ),
                     )
                 )
-            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-3.2.0 → liminal_orm-4.0.0}/liminal/entity_schemas/generate_files.py

@@ -1,7 +1,9 @@
+import shutil
 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
@@ -45,23 +47,38 @@ def get_file_subdirectory(entity_type: BenchlingEntityType) -> str:
     return type_to_subdir_map[entity_type]
 
 
+TAB = "    "
+
+
 def generate_all_entity_schema_files(
-    benchling_service: BenchlingService, write_path: Path
+    benchling_service: BenchlingService, write_path: Path, overwrite: bool = False
 ) -> None:
+    """Generate all entity schema files from your Benchling tenant and writes to the given entity_schemas/ path.
+    This is used to initialize your code for Liminal and transfer the information from your Benchling tenant to your local codebase.
+
+    Parameters
+    ----------
+    benchling_service : BenchlingService
+        The Benchling service object that is connected to a specified Benchling tenant.
+    write_path : Path
+        The path to write the generated files to. entity_schemas/ directory will be created within this path.
+    overwrite : bool
+        Whether to overwrite existing the existing entity_schemas/ directory.
+    """
     write_path = write_path / "entity_schemas"
+    if write_path.exists() and overwrite:
+        shutil.rmtree(write_path)
+        print(f"[dim]Removed directory: {write_path}")
     if not write_path.exists():
         write_path.mkdir(parents=True, exist_ok=True)
         print(f"[green]Created directory: {write_path}")
 
     models = get_converted_tag_schemas(benchling_service)
-    tab = "    "
     has_date = False
     subdirectory_map: dict[str, list[tuple[str, str]]] = {}
-    benchling_dropdowns = get_benchling_dropdowns_dict(benchling_service)
-    dropdown_name_to_classname_map: dict[str, str] = {
-        dropdown_name: to_pascal_case(dropdown_name)
-        for dropdown_name in benchling_dropdowns.keys()
-    }
+    dropdown_name_to_classname_map = _get_dropdown_name_to_classname_map(
+        benchling_service
+    )
     wh_name_to_classname: dict[str, str] = {
         sp.warehouse_name: to_pascal_case(sp.name) for sp, _, _ in models
     }
@@ -81,21 +98,28 @@ def generate_all_entity_schema_files(
             "from liminal.enums import BenchlingEntityType, BenchlingFieldType, BenchlingNamingStrategy",
             f"from liminal.orm.mixins import {get_entity_mixin(schema_properties.entity_type)}",
         ]
-        init_strings = [f"{tab}def __init__(", f"{tab}self,"]
+        init_strings = [f"{TAB}def __init__(", f"{TAB}self,"]
         column_strings = []
         dropdowns = []
         relationship_strings = []
         for col_name, col in columns.items():
+            column_props = col.column_dump()
             dropdown_classname = None
             if col.dropdown_link:
                 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', unit_name="{col.unit_name}"' if col.unit_name else ''}{f', decimal_places={col.decimal_places}' if col.decimal_places is not None else ''})"""
-            )
+                column_props["dropdown_link"] = dropdown_classname
+            column_props_string = ""
+            for k, v in column_props.items():
+                if k == "dropdown_link":
+                    column_props_string += f"""dropdown={v},"""
+                else:
+                    column_props_string += f"""{k}={v.__repr__()},"""
+            column_string = f"""{TAB}{col_name}: SqlColumn = Column({column_props_string.rstrip(',')})"""
+            column_strings.append(column_string)
             if col.required and col.type:
                 init_strings.append(
-                    f"""{tab}{col_name}: {convert_benchling_type_to_python_type(col.type).__name__},"""
+                    f"""{TAB}{col_name}: {convert_benchling_type_to_python_type(col.type).__name__},"""
                 )
 
             if (
@@ -110,14 +134,14 @@ def generate_all_entity_schema_files(
             ):
                 if not col.is_multi:
                     relationship_strings.append(
-                        f"""{tab}{col_name}_entity = single_relationship("{wh_name_to_classname[col.entity_link]}", {col_name})"""
+                        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})"""
+                        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"
@@ -125,11 +149,11 @@ def generate_all_entity_schema_files(
         for col_name, col in columns.items():
             if not col.required and col.type:
                 init_strings.append(
-                    f"""{tab}{col_name}: {convert_benchling_type_to_python_type(col.type).__name__} | None = None,"""
+                    f"""{TAB}{col_name}: {convert_benchling_type_to_python_type(col.type).__name__} | None = None,"""
                 )
         init_strings.append("):")
         for col_name in columns.keys():
-            init_strings.append(f"{tab}self.{col_name} = {col_name}")
+            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():
@@ -141,7 +165,7 @@ def generate_all_entity_schema_files(
         for col_name, col in columns.items():
             if col.dropdown_link:
                 init_strings.append(
-                    tab
+                    TAB
                     + dropdown_name_to_classname_map[col.dropdown_link]
                     + f".validate({col_name})"
                 )
@@ -149,7 +173,7 @@ def generate_all_entity_schema_files(
         columns_string = "\n".join(column_strings)
         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 ""
+        init_string = f"\n{TAB}".join(init_strings) if len(columns) > 0 else ""
         full_content = f"""{import_string}
 
 
@@ -198,3 +222,23 @@ class {classname}(BaseModel, {get_entity_mixin(schema_properties.entity_type)}):
         print(
             f"[green]Generated {write_path / '__init__.py'} with {len(models)} entity schema imports."
         )
+
+
+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()
+        }
+    benchling_dropdowns = get_benchling_dropdowns_dict(benchling_service)
+    if len(benchling_dropdowns) > 0:
+        raise Exception(
+            "No dropdowns found locally. Please ensure your env.py file imports your dropdown classes or generate dropdowns from your Benchling tenant first."
+        )
+    return {}

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/entity_schemas/operations.py

@@ -536,9 +536,12 @@ 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
-        )
+        try:
+            tag_schema = TagSchemaModel.get_one_cached(
+                benchling_service, self.wh_schema_name
+            )
+        except Exception:
+            return
         if (
             benchling_service.connection.config_flags.schemas_enable_change_warehouse_name
             is False

{liminal_orm-3.2.0 → liminal_orm-4.0.0}/liminal/orm/base_model.py

@@ -306,8 +306,8 @@ class BaseModel(Generic[T], Base):
 
         Returns
         -------
-        list[T]
-            List of all entities from the database.
+        DataFrame
+            A pandas dataframe of all entities from the database.
         """
         query = cls.query(session)
         return pd.read_sql(query.statement, session.connection())