liminal-orm 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

liminal/base/base_operation.py

@@ -14,16 +14,14 @@ Order of operations based on order class var:
     7. ReorderDropdownOptions
     8. CreateSchema
     9. UpdateSchema
-    10. UpdateSchemaName
-    11. UnarchiveSchema
-    12. CreateField
-    13. UnarchiveField
-    14. UpdateField
-    15. UpdateFieldName
-    16. ArchiveField
-    17. ReorderFields
-    18. ArchiveSchema
-    19. ArchiveDropdown
+    10. UnarchiveSchema
+    11. CreateField
+    12. UnarchiveField
+    13. UpdateField
+    14. ArchiveField
+    15. ReorderFields
+    16. ArchiveSchema
+    17. ArchiveDropdown
 """
 
 
@@ -36,7 +34,7 @@ class BaseOperation(ABC):
         self.args = args
         self.kwargs = kwargs
 
-    def validate(self) -> None:
+    def validate(self, benchling_service: BenchlingService) -> None:
         """Validate the operation before running it. This is not called at runtime,
         but is used to validate operations before a migration is run."""
         pass

liminal/base/properties/base_field_properties.py

@@ -18,6 +18,8 @@ class BaseFieldProperties(BaseModel):
     ----------
     name : str | None
         The external facing name of the field.
+    warehouse_name : str | None
+        The sql column name in the benchling warehouse.
     type : BenchlingFieldType | None
         The type of the field.
     required : bool | None
@@ -39,6 +41,7 @@ class BaseFieldProperties(BaseModel):
     """
 
     name: str | None = None
+    warehouse_name: str | None = None
     type: BenchlingFieldType | None = None
     required: bool | None = None
     is_multi: bool | None = None
@@ -50,10 +53,18 @@ class BaseFieldProperties(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self._archived = data.get("_archived", None)
+
     def set_archived(self, value: bool) -> BaseFieldProperties:
         self._archived = value
         return self
 
+    def set_warehouse_name(self, wh_name: str) -> BaseFieldProperties:
+        self.warehouse_name = wh_name
+        return self
+
     def validate_column(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.

liminal/base/properties/base_schema_properties.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from pydantic import BaseModel, ConfigDict, PrivateAttr, model_validator
+from pydantic import BaseModel, ConfigDict, model_validator
 
 from liminal.enums import BenchlingEntityType, BenchlingNamingStrategy
 
@@ -69,7 +69,11 @@ class BaseSchemaProperties(BaseModel):
     entity_type: BenchlingEntityType | None = None
     naming_strategies: set[BenchlingNamingStrategy] | None = None
     mixture_schema_config: MixtureSchemaConfig | None = None
-    _archived: bool | None = PrivateAttr(default=None)
+    _archived: bool | None = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self._archived = data.get("_archived", None)
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -97,3 +101,12 @@ class BaseSchemaProperties(BaseModel):
         if not isinstance(other, BaseSchemaProperties):
             return False
         return self.model_dump() == other.model_dump()
+
+    def __str__(self) -> str:
+        return ", ".join(
+            [f"{k}={v}" for k, v in self.model_dump(exclude_unset=True).items()]
+        )
+
+    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()])})"

liminal/cli/cli.py

@@ -79,7 +79,10 @@ def generate_files(
         ..., help="Benchling tenant (or alias) to connect to."
     ),
     write_path: Path = typer.Option(
-        Path("."), help="The path to write the generated files to."
+        Path("."),
+        "-p",
+        "--write-path",
+        help="The path to write the generated files to.",
     ),
 ) -> None:
     current_revision_id, benchling_connection = read_local_env_file(

liminal/cli/live_test_dropdown_migration.py

@@ -1,5 +1,3 @@
-import uuid
-
 from liminal.base.base_operation import BaseOperation
 from liminal.connection.benchling_service import BenchlingService
 from liminal.dropdowns.operations import (
@@ -13,6 +11,7 @@ from liminal.dropdowns.operations import (
     UpdateDropdownOption,
 )
 from liminal.migrate.components import execute_operations, execute_operations_dry_run
+from liminal.utils import generate_random_id
 
 
 def mock_dropdown_full_migration(
@@ -24,15 +23,15 @@ def mock_dropdown_full_migration(
     If dry_run is set to False, the operations will be executed.
     If dry_run is set to True, the operations will be executed in dry run mode and only the description of the operations will be printed.
     """
-    random_id = f"{str(uuid.uuid4())[0:8]}_arch"
+    random_id = generate_random_id()
+    test_dropdown_name = f"{test_dropdown_name}_{random_id}"
 
     dropdown_options = ["Option 1", "Option 2"]
     create_dropdown_op = CreateDropdown(test_dropdown_name, dropdown_options)
 
-    update_dropdown_op = UpdateDropdownName(
-        test_dropdown_name, f"{test_dropdown_name}_{random_id}"
-    )
-    test_dropdown_name = f"{test_dropdown_name}_{random_id}"
+    test_dropdown_name = f"{test_dropdown_name}_arch"
+
+    update_dropdown_op = UpdateDropdownName(test_dropdown_name, test_dropdown_name)
 
     create_dropdown_option_op = CreateDropdownOption(
         test_dropdown_name, "Option 3 New", 2
@@ -70,7 +69,7 @@ def mock_dropdown_full_migration(
         unarchive_dropdown_op,
         rearchive_dropdown_op,
     ]
-    execute_operations_dry_run(ops) if dry_run else execute_operations(
+    execute_operations_dry_run(
         benchling_service, ops
-    )
+    ) if dry_run else execute_operations(benchling_service, ops)
     print("Dry run migration complete!") if dry_run else print("Migration complete!")

liminal/cli/live_test_entity_schema_migration.py

@@ -1,5 +1,3 @@
-import uuid
-
 from liminal.base.base_operation import BaseOperation
 from liminal.base.properties.base_field_properties import BaseFieldProperties
 from liminal.base.properties.base_schema_properties import BaseSchemaProperties
@@ -14,7 +12,6 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
-    UpdateEntitySchemaFieldName,
 )
 from liminal.enums import (
     BenchlingEntityType,
@@ -23,6 +20,7 @@ from liminal.enums import (
 )
 from liminal.migrate.components import execute_operations, execute_operations_dry_run
 from liminal.orm.schema_properties import SchemaProperties
+from liminal.utils import generate_random_id
 
 
 def mock_entity_schema_full_migration(
@@ -34,8 +32,9 @@ def mock_entity_schema_full_migration(
     If dry_run is set to False, the operations will be executed.
     If dry_run is set to True, the operations will be executed in dry run mode and only the description of the operations will be printed.
     """
-    random_id = f"{str(uuid.uuid4())[0:8]}_arch"
-    if len(test_model_wh_name) + len(random_id) > 32:
+    random_id = generate_random_id()
+    test_model_wh_name = f"{test_model_wh_name}_{random_id}"
+    if len(test_model_wh_name) > 32:
         raise ValueError(
             f"Test model warehouse name is too long. Must be less than {32 - len(random_id)} characters."
         )
@@ -49,37 +48,37 @@ def mock_entity_schema_full_migration(
     )
     create_entity_schema_op = CreateEntitySchema(
         schema_properties=schema_properties,
-        fields={
-            "test_column_1": BaseFieldProperties(
+        fields=[
+            BaseFieldProperties(
                 name="Test Column 1",
+                warehouse_name="test_column_1",
                 type=BenchlingFieldType.TEXT,
                 required=False,
                 is_multi=False,
                 parent_link=False,
             ),
-            "test_column_2": BaseFieldProperties(
+            BaseFieldProperties(
                 name="Test Column 2",
+                warehouse_name="test_column_2",
                 type=BenchlingFieldType.INTEGER,
                 required=False,
                 is_multi=False,
                 parent_link=False,
             ),
-            "test_column_4": BaseFieldProperties(
+            BaseFieldProperties(
                 name="Test Column 4",
-                type=BenchlingFieldType.ENTITY_LINK,
-                entity_link="ngs_sample",
+                warehouse_name="test_column_4",
+                type=BenchlingFieldType.CUSTOM_ENTITY_LINK,
                 required=False,
                 is_multi=False,
-                parent_link=True,
+                parent_link=False,
             ),
-        },
+        ],
     )
 
-    test_model_wh_name = f"{test_model_wh_name}_{random_id}"
     update_schema_properties = BaseSchemaProperties(
-        warehouse_name=test_model_wh_name,
-        name=test_model_wh_name,
-        prefix=test_model_wh_name,
+        name=f"{test_model_wh_name}_arch",
+        prefix=f"{test_model_wh_name}_arch",
         entity_type=BenchlingEntityType.AA_SEQUENCE,
         naming_strategies=[
             BenchlingNamingStrategy.IDS_FROM_NAMES,
@@ -92,24 +91,23 @@ def mock_entity_schema_full_migration(
 
     test_column_3_field_properties = BaseFieldProperties(
         name="Test Column 3 New",
+        warehouse_name="test_column_3",
         type=BenchlingFieldType.TEXT,
         required=False,
         is_multi=False,
         parent_link=False,
     )
     create_entity_schema_field_op = CreateEntitySchemaField(
-        test_model_wh_name, "test_column_3_new", test_column_3_field_properties, 2
+        test_model_wh_name, test_column_3_field_properties, 2
     )
 
     update_test_column_3_field_properties = BaseFieldProperties(
-        type=BenchlingFieldType.CUSTOM_ENTITY_LINK, is_multi=True
+        type=BenchlingFieldType.CUSTOM_ENTITY_LINK,
+        is_multi=True,
+        name="Test Column 3",
     )
     update_entity_schema_field_op = UpdateEntitySchemaField(
-        test_model_wh_name, "test_column_3_new", update_test_column_3_field_properties
-    )
-
-    update_entity_schema_field_name_op = UpdateEntitySchemaFieldName(
-        test_model_wh_name, "test_column_3_new", "test_column_3"
+        test_model_wh_name, "test_column_3", update_test_column_3_field_properties
     )
 
     archive_entity_schema_field_op = ArchiveEntitySchemaField(
@@ -134,7 +132,6 @@ def mock_entity_schema_full_migration(
         update_entity_schema_op,
         create_entity_schema_field_op,
         update_entity_schema_field_op,
-        update_entity_schema_field_name_op,
         archive_entity_schema_field_op,
         unarchive_entity_schema_field_op,
         reorder_entity_schema_field_op,
@@ -142,7 +139,7 @@ def mock_entity_schema_full_migration(
         unarchive_entity_schema_op,
         rearchive_entity_schema_op,
     ]
-    execute_operations_dry_run(ops) if dry_run else execute_operations(
+    execute_operations_dry_run(
         benchling_service, ops
-    )
+    ) if dry_run else execute_operations(benchling_service, ops)
     print("Dry run migration complete!") if dry_run else print("Migration complete!")

liminal/connection/benchling_connection.py

@@ -27,20 +27,26 @@ class BenchlingConnection(BaseModel):
         The email of the internal API admin.
     internal_api_admin_password: str | None = None
         The password of the internal API admin.
+    warehouse_access: bool = False
+        Whether your Benchling tenant has access to the warehouse. If warehouse_connection_string is provided, this will default to True.
+        warehouse_access is required to set a custom warehouse names on entity schemas and their fields.
     """
 
     tenant_name: str
     tenant_alias: str | None = None
     current_revision_id_var_name: str = ""
-    api_client_id: str | None = None
-    api_client_secret: str | None = None
+    api_client_id: str
+    api_client_secret: str
     warehouse_connection_string: str | None = None
     internal_api_admin_email: str | None = None
     internal_api_admin_password: str | None = None
+    warehouse_access: bool = False
 
     @model_validator(mode="before")
     @classmethod
     def set_current_revision_id_var_name(cls, values: dict) -> dict:
+        if values.get("warehouse_connection_string"):
+            values["warehouse_access"] = True
         if not values.get("current_revision_id_var_name"):
             tenant_alias = values.get("tenant_alias")
             tenant_name = values.get("tenant_name")

liminal/connection/benchling_service.py

@@ -9,7 +9,12 @@ from bs4 import BeautifulSoup
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
 from sqlalchemy.orm import Session, configure_mappers
-from tenacity import retry, retry_if_exception_type, stop_after_attempt
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
 
 from liminal.connection.benchling_connection import BenchlingConnection
 
@@ -45,24 +50,17 @@ class BenchlingService(Benchling):
         self.use_api = use_api
         self.benchling_tenant = connection.tenant_name
         if use_api:
-            if connection.api_client_id and connection.api_client_secret:
-                retry_strategy = RetryStrategy(max_tries=10)
-                auth_method = ClientCredentialsOAuth2(
-                    client_id=connection.api_client_id,
-                    client_secret=connection.api_client_secret,
-                    token_url=f"https://{connection.tenant_name}.benchling.com/api/v2/token",
-                )
-                url = f"https://{connection.tenant_name}.benchling.com"
-                super().__init__(
-                    url=url, auth_method=auth_method, retry_strategy=retry_strategy
-                )
-                logger.info(
-                    f"Tenant {connection.tenant_name}: Connected to Benchling API."
-                )
-            else:
-                raise ValueError(
-                    "use_api is True but api_client_id and api_client_secret not provided in BenchlingConnection."
-                )
+            retry_strategy = RetryStrategy(max_tries=10)
+            auth_method = ClientCredentialsOAuth2(
+                client_id=connection.api_client_id,
+                client_secret=connection.api_client_secret,
+                token_url=f"https://{connection.tenant_name}.benchling.com/api/v2/token",
+            )
+            url = f"https://{connection.tenant_name}.benchling.com"
+            super().__init__(
+                url=url, auth_method=auth_method, retry_strategy=retry_strategy
+            )
+            logger.info(f"Tenant {connection.tenant_name}: Connected to Benchling API.")
         self.use_db = use_db
         if use_db:
             if connection.warehouse_connection_string:
@@ -144,6 +142,7 @@ class BenchlingService(Benchling):
     @retry(
         stop=stop_after_attempt(3),
         retry=retry_if_exception_type(ValueError),
+        wait=wait_exponential(multiplier=1, min=1, max=8),
         reraise=True,
     )
     def autogenerate_auth(

liminal/dropdowns/operations.py

@@ -87,7 +87,7 @@ class ArchiveDropdown(BaseOperation):
             raise ValueError(f"Dropdown {self.dropdown_name} is already archived.")
         return archive_dropdown(benchling_service, dropdown.id)
 
-    def validate(self) -> None:
+    def validate(self, benchling_service: BenchlingService) -> None:
         if schemas_with_dropdown := get_schemas_with_dropdown(self.dropdown_name):
             raise ValueError(
                 f"Dropdown {self.dropdown_name} is used in schemas {schemas_with_dropdown}. Cannot archive a dropdown that is in use in non-archived fields."

liminal/entity_schemas/compare.py

@@ -41,9 +41,13 @@ def compare_entity_schemas(
     )
     # If models are provided, filter the schemas from benchling so that only the models passed in are compared.
     # If you don't filter, it will compare to all the schemas in benchling and think that they are missing from code and should be archived.
-    models = BaseModel.get_all_subclasses(schema_names)
+    models = [
+        m
+        for m in BaseModel.get_all_subclasses(schema_names)
+        if not m.__schema_properties__._archived
+    ]
     archived_benchling_schema_wh_names = [
-        s[0].warehouse_name for s in benchling_schemas if s[0]._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.
@@ -63,7 +67,9 @@ def compare_entity_schemas(
             s.warehouse_name for s, _ in benchling_schemas
         ]:
             benchling_schema_props, benchling_schema_fields = next(
-                t for t in benchling_schemas if t[0].warehouse_name == model_wh_name
+                (s, lof)
+                for s, 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
@@ -193,12 +199,14 @@ def compare_entity_schemas(
                             )
                         )
                 else:
+                    new_field_props = model_columns[
+                        column_name
+                    ].properties.set_warehouse_name(column_name)
                     ops.append(
                         CompareOperation(
                             op=CreateEntitySchemaField(
                                 model_wh_name,
-                                column_name,
-                                field_props=model_columns[column_name].properties,
+                                field_props=new_field_props,
                                 index=list(model_columns.keys()).index(column_name),
                             ),
                             reverse_op=ArchiveEntitySchemaField(
@@ -233,8 +241,10 @@ 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 = {name: col.properties for name, col in model_columns.items()}
-
+            model_props = [
+                col.properties.set_warehouse_name(wh_name)
+                for wh_name, col in model_columns.items()
+            ]
             ops.append(
                 CompareOperation(
                     op=CreateEntitySchema(

liminal/entity_schemas/entity_schema_models.py

@@ -34,7 +34,6 @@ class CreateEntitySchemaFieldModel(BaseModel):
     @classmethod
     def from_benchling_props(
         cls,
-        wh_field_name: str,
         field_props: BaseFieldProperties,
         benchling_service: BenchlingService | None = None,
     ) -> CreateEntitySchemaFieldModel:
@@ -42,8 +41,6 @@ class CreateEntitySchemaFieldModel(BaseModel):
 
         Parameters
         ----------
-        wh_field_name : str
-            The warehouse name of the field.
         field_props : BaseFieldProperties
             The field properties.
         benchling_service : BenchlingService | None
@@ -79,7 +76,7 @@ class CreateEntitySchemaFieldModel(BaseModel):
             ).id
         return CreateEntitySchemaFieldModel(
             name=field_props.name,
-            systemName=wh_field_name,
+            systemName=field_props.warehouse_name,
             isMulti=field_props.is_multi,
             isRequired=field_props.required,
             isParentLink=field_props.parent_link,
@@ -107,7 +104,7 @@ class CreateEntitySchemaModel(BaseModel):
     def from_benchling_props(
         cls,
         benchling_props: SchemaProperties,
-        fields: dict[str, BaseFieldProperties],
+        fields: list[BaseFieldProperties],
         benchling_service: BenchlingService,
     ) -> CreateEntitySchemaModel:
         """Generates a CreateEntitySchemaModel from the given internal definition of benchling schema properties.
@@ -116,8 +113,8 @@ class CreateEntitySchemaModel(BaseModel):
         ----------
         benchling_props : Benchling SchemaProperties
             The schema properties.
-        fields : dict[str, Benchling FieldProperties]
-            Map of warehouse field names to field properties.
+        fields : list[Benchling FieldProperties]
+            List of field properties.
         benchling_service : BenchlingService | None
             The Benchling service instance used to fetch additional data if needed.
 
@@ -135,8 +132,8 @@ class CreateEntitySchemaModel(BaseModel):
             labelingStrategies=[s.value for s in benchling_props.naming_strategies],
             fields=[
                 CreateEntitySchemaFieldModel.from_benchling_props(
-                    field_name, field_props, benchling_service
+                    field_props, benchling_service
                 )
-                for field_name, field_props in fields.items()
+                for field_props in fields
             ],
         )

liminal/entity_schemas/generate_files.py

@@ -14,6 +14,7 @@ def get_entity_mixin(entity_type: BenchlingEntityType) -> str:
     type_to_mixin_map = {
         BenchlingEntityType.ENTRY: "EntryMixin",
         BenchlingEntityType.MIXTURE: "MixtureMixin",
+        BenchlingEntityType.MOLECULE: "MoleculeMixin",
         BenchlingEntityType.CUSTOM_ENTITY: "CustomEntityMixin",
         BenchlingEntityType.DNA_SEQUENCE: "DnaSequenceMixin",
         BenchlingEntityType.DNA_OLIGO: "DnaOligoMixin",
@@ -36,6 +37,7 @@ def get_file_subdirectory(entity_type: BenchlingEntityType) -> str:
         BenchlingEntityType.AA_SEQUENCE: "aa_sequences",
         BenchlingEntityType.ENTRY: "entries",
         BenchlingEntityType.MIXTURE: "mixtures",
+        BenchlingEntityType.MOLECULE: "molecules",
     }
     if entity_type not in type_to_subdir_map:
         raise ValueError(f"Unknown entity type: {entity_type}")
@@ -97,7 +99,10 @@ def generate_all_entity_schema_files(
                     f"""{tab}{col_name}: {convert_benchling_type_to_python_type(col.type).__name__},"""
                 )
 
-            if col.type == BenchlingFieldType.DATE:
+            if (
+                col.type == BenchlingFieldType.DATE
+                or col.type == BenchlingFieldType.DATETIME
+            ):
                 if not has_date:
                     import_strings.append("from datetime import datetime")
             if (
@@ -106,14 +111,14 @@ def generate_all_entity_schema_files(
             ):
                 if not col.is_multi:
                     relationship_strings.append(
-                        f"""{tab}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}multi_relationship("{wh_name_to_classname[col.entity_link]}", "{classname}", "{col_name}")"""
+                        f"""{tab}{col_name}_entities = multi_relationship("{wh_name_to_classname[col.entity_link]}", "{classname}", "{col_name}")"""
                     )
                     import_strings.append(
                         "from liminal.orm.relationship import multi_relationship"
@@ -140,11 +145,7 @@ 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 = f"""
-    @classmethod
-    def query(self, session: Session) -> Query:
-        return session.query({classname})
-
+        functions_string = """
     def get_validators(self) -> list[BenchlingValidator]:
         return []"""