liminal-orm 3.0.1__tar.gz → 3.1.1__tar.gz

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liminal-orm
-Version: 3.0.1
+Version: 3.1.1
 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

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/base/properties/base_field_properties.py

@@ -77,18 +77,18 @@ class BaseFieldProperties(BaseModel):
                 for s in BenchlingBaseModel.get_all_subclasses()
             ]:
                 raise ValueError(
-                    f"Could not find {self.entity_link} as a warehouse name for any currently defined schemas."
+                    f"Field {wh_name}: could not find entity link {self.entity_link} as a warehouse name for any currently defined schemas."
                 )
         if self.dropdown_link:
             if self.dropdown_link not in [
                 d.__benchling_name__ for d in BaseDropdown.get_all_subclasses()
             ]:
                 raise ValueError(
-                    f"Could not find {self.dropdown_link} as a name to any defined dropdowns."
+                    f"Field {wh_name}: could not find dropdown link {self.dropdown_link} as a name to any defined dropdowns."
                 )
         if not is_valid_wh_name(wh_name):
             raise ValueError(
-                f"Invalid warehouse name '{wh_name}'. It should only contain alphanumeric characters and underscores."
+                f"Field {wh_name}: invalid warehouse name '{wh_name}'. It should only contain alphanumeric characters and underscores."
             )
         return True
 

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/cli/cli.py

@@ -16,9 +16,9 @@ from liminal.cli.live_test_dropdown_migration import mock_dropdown_full_migratio
 from liminal.cli.live_test_entity_schema_migration import (
     mock_entity_schema_full_migration,
 )
+from liminal.cli.utils import read_local_liminal_dir, update_env_revision_id
 from liminal.connection.benchling_service import BenchlingService
 from liminal.migrate.revisions_timeline import RevisionsTimeline
-from liminal.migrate.utils import read_local_env_file, update_env_revision_id
 
 
 class OrderCommands(TyperGroup):
@@ -34,8 +34,9 @@ app = typer.Typer(
     help="The Liminal CLI allows you to run revisions against different Benchling tenants and keep tenants in sync with dropdowns and schemas defined in code.",
 )
 
-ENV_FILE_PATH = Path("liminal/env.py")
-VERSIONS_DIR_PATH = Path("liminal/versions")
+LIMINAL_DIR_PATH = Path("liminal")
+ENV_FILE_PATH = LIMINAL_DIR_PATH / "env.py"
+VERSIONS_DIR_PATH = LIMINAL_DIR_PATH / "versions"
 
 
 @app.command(
@@ -44,8 +45,8 @@ VERSIONS_DIR_PATH = Path("liminal/versions")
 )
 def init() -> None:
     try:
-        Path("liminal").mkdir()
-        Path("liminal/versions").mkdir()
+        LIMINAL_DIR_PATH.mkdir()
+        VERSIONS_DIR_PATH.mkdir()
     except Exception:
         raise Exception(
             "Liminal CLI already initialized. liminal/ already exists. Please delete it before running init."
@@ -85,8 +86,8 @@ def generate_files(
         help="The path to write the generated files to.",
     ),
 ) -> None:
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, 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():
@@ -104,8 +105,8 @@ def current(
         ..., help="Benchling tenant (or alias) to connect to."
     ),
 ) -> None:
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, benchling_connection = read_local_liminal_dir(
+        LIMINAL_DIR_PATH, benchling_tenant
     )
     print(
         f"[blue]{benchling_connection.current_revision_id_var_name}: {current_revision_id}[/blue]"
@@ -125,8 +126,8 @@ def autogenerate(
         help="A description of the revision being generated. This will also be included in the file name.",
     ),
 ) -> None:
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, benchling_connection = read_local_liminal_dir(
+        LIMINAL_DIR_PATH, benchling_tenant
     )
     benchling_service = BenchlingService(benchling_connection, use_internal_api=True)
     autogenerate_revision_file(
@@ -148,8 +149,8 @@ def upgrade(
         help="Determines the revision files that get run. Pass in the 'revision_id' to upgrade to that revision. Pass in 'head' to upgrade to the latest revision. Pass in '+n' to make a relative revision based on the current revision id.",
     ),
 ) -> None:
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, benchling_connection = read_local_liminal_dir(
+        LIMINAL_DIR_PATH, benchling_tenant
     )
     benchling_service = BenchlingService(benchling_connection, use_internal_api=True)
     upgrade_revision_id = upgrade_benchling_tenant(
@@ -176,8 +177,8 @@ def downgrade(
         help="Determines the revision files that get run. Pass in the 'revision_id' to downgrade to that revision. Pass in '-n' to make a relative revision based on the current revision id.",
     ),
 ) -> None:
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, benchling_connection = read_local_liminal_dir(
+        LIMINAL_DIR_PATH, benchling_tenant
     )
     benchling_service = BenchlingService(benchling_connection, use_internal_api=True)
     downgrade_revision_id = downgrade_benchling_tenant(
@@ -216,8 +217,8 @@ def live_test(
         raise ValueError(
             "Only one of --entity-schema-migration or --dropdown-migration can be set."
         )
-    current_revision_id, benchling_connection = read_local_env_file(
-        ENV_FILE_PATH, benchling_tenant
+    current_revision_id, benchling_connection = read_local_liminal_dir(
+        LIMINAL_DIR_PATH, benchling_tenant
     )
     benchling_service = BenchlingService(benchling_connection, use_internal_api=True)
     if test_entity_schema_migration:

{liminal_orm-3.0.1/liminal/migrate → liminal_orm-3.1.1/liminal/cli}/utils.py

@@ -4,22 +4,41 @@ from pathlib import Path
 from liminal.connection.benchling_connection import BenchlingConnection
 
 
-def _check_env_file(env_file_path: Path) -> None:
-    """Raises an exception if the env.py file does not exist at the given path."""
-    if not env_file_path.exists():
+def _check_liminal_directory_initialized(liminal_dir_path: Path) -> None:
+    """Raises an exception if the liminal directory does not exist at the given path."""
+    if not liminal_dir_path.exists() or not liminal_dir_path.is_dir():
         raise Exception(
-            f"No {env_file_path} file found. Run `liminal init` or check your current working directory for liminal/env.py."
+            "Liminal directory not found at current working directory. Run `liminal init` or check your current working directory."
         )
+    else:
+        if not (liminal_dir_path / "env.py").exists():
+            raise Exception(
+                "No liminal/env.py file found. Run `liminal init` or check your current working directory for liminal/env.py."
+            )
+
+
+def read_local_liminal_dir(
+    liminal_dir_path: Path, benchling_tenant: str
+) -> tuple[str, BenchlingConnection]:
+    """Imports the env.py file from /liminal/env.py and returns the CURRENT_REVISION_ID variable along with the BenchlingConnection object.
+    The env.py file is expected to have the CURRENT_REVISION_ID variable set to the revision id you are currently on.
+    The BenchlingConnection object is expected to be defined and have connection information for the Benchling API client and internal API.
+    """
+    _check_liminal_directory_initialized(liminal_dir_path)
+    env_file_path = liminal_dir_path / "env.py"
+    current_revision_id, benchling_connection = _read_local_env_file(
+        env_file_path, benchling_tenant
+    )
+    return current_revision_id, benchling_connection
 
 
-def read_local_env_file(
+def _read_local_env_file(
     env_file_path: Path, benchling_tenant: str
 ) -> tuple[str, BenchlingConnection]:
     """Imports the env.py file from the current working directory and returns the CURRENT_REVISION_ID variable along with the BenchlingConnection object.
     The env.py file is expected to have the CURRENT_REVISION_ID variable set to the revision id you are currently on.
     The BenchlingConnection object is expected to be defined and have connection information for the Benchling API client and internal API.
     """
-    _check_env_file(env_file_path)
     module_path = Path.cwd() / env_file_path
     spec = importlib.util.spec_from_file_location(env_file_path.stem, module_path)
     if spec is None or spec.loader is None:

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/connection/benchling_connection.py

@@ -4,6 +4,19 @@ import re
 from pydantic import BaseModel, model_validator
 
 
+class TenantConfigFlags(BaseModel):
+    """Set of config flags that are configured on the tenant level. These can be updated on Benchling's end by contacting their support team.
+    Ask Benchling support to give you the full export of these flags.
+
+    Parameters
+    ----------
+    schemas_enable_change_warehouse_name: bool = False
+        If enabled, allows renaming schema and field warehouse names for all schema admins. Default value is False for Benchling
+    """
+
+    schemas_enable_change_warehouse_name: bool = False
+
+
 class BenchlingConnection(BaseModel):
     """Class that contains the connection information for a Benchling tenant.
 
@@ -27,11 +40,10 @@ 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.
     fieldsets: bool = False
         Whether your Benchling tenant has access to fieldsets.
+    config_flags: TenantConfigFlags = TenantConfigFlags()
+        Set of config flags that are configured on the tenant level. These can be updated on Benchling's end by contacting their support team.
     """
 
     tenant_name: str
@@ -42,14 +54,12 @@ class BenchlingConnection(BaseModel):
     warehouse_connection_string: str | None = None
     internal_api_admin_email: str | None = None
     internal_api_admin_password: str | None = None
-    warehouse_access: bool = False
     fieldsets: bool = False
+    config_flags: TenantConfigFlags = TenantConfigFlags()
 
     @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_orm-3.0.1 → liminal_orm-3.1.1}/liminal/dropdowns/generate_files.py

@@ -4,7 +4,7 @@ from rich import print
 
 from liminal.connection import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdowns_dict
-from liminal.utils import pascalize, to_snake_case
+from liminal.utils import to_pascal_case, to_snake_case
 
 
 def generate_all_dropdown_files(
@@ -24,7 +24,7 @@ def generate_all_dropdown_files(
     for dropdown_name, dropdown_options in dropdowns.items():
         dropdown_values = [option.name for option in dropdown_options.options]
         options_list = str(dropdown_values).replace("'", '"')
-        classname = pascalize(dropdown_name)
+        classname = to_pascal_case(dropdown_name)
         dropdown_content = f"""
 from liminal.base.base_dropdown import BaseDropdown
 

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/entity_schemas/generate_files.py

@@ -8,7 +8,7 @@ from liminal.entity_schemas.utils import get_converted_tag_schemas
 from liminal.enums import BenchlingEntityType, BenchlingFieldType
 from liminal.mappers import convert_benchling_type_to_python_type
 from liminal.orm.name_template import NameTemplate
-from liminal.utils import pascalize, to_snake_case
+from liminal.utils import to_pascal_case, to_snake_case
 
 
 def get_entity_mixin(entity_type: BenchlingEntityType) -> str:
@@ -59,18 +59,18 @@ def generate_all_entity_schema_files(
     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: pascalize(dropdown_name)
+        dropdown_name: to_pascal_case(dropdown_name)
         for dropdown_name in benchling_dropdowns.keys()
     }
     wh_name_to_classname: dict[str, str] = {
-        sp.warehouse_name: pascalize(sp.name) for sp, _, _ in models
+        sp.warehouse_name: to_pascal_case(sp.name) for sp, _, _ in models
     }
 
     for schema_properties, name_template, columns in models:
-        classname = pascalize(schema_properties.name)
+        classname = to_pascal_case(schema_properties.name)
 
     for schema_properties, name_template, columns in models:
-        classname = pascalize(schema_properties.name)
+        classname = to_pascal_case(schema_properties.name)
         filename = to_snake_case(schema_properties.name) + ".py"
         columns = {key: columns[key] for key in columns}
         import_strings = [

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/entity_schemas/operations.py

@@ -81,14 +81,13 @@ class CreateEntitySchema(BaseOperation):
 
     def validate(self, benchling_service: BenchlingService) -> None:
         if (
-            not benchling_service.connection.warehouse_access
+            benchling_service.connection.config_flags.schemas_enable_change_warehouse_name
+            is False
             and self._validated_schema_properties.warehouse_name
             != to_snake_case(self._validated_schema_properties.name)
         ):
             raise ValueError(
-                f"Warehouse access is required to set a custom field warehouse name. \
-                Either set warehouse_access to True in BenchlingConnection or set the schema warehouse_name to the given Benchling warehouse name: {to_snake_case(self._validated_schema_properties.name)}. \
-                Reach out to Benchling support if you need help setting up warehouse access."
+                f"{self._validated_schema_properties.name}: Tenant config flag SCHEMAS_ENABLE_CHANGE_WAREHOUSE_NAME is required to set a custom schema warehouse name. Reach out to Benchling support to turn this config flag to True and then set the flag to True in BenchlingConnection.config_flags. Otherwise, define the schema warehouse_name in code to be the given Benchling warehouse name: {to_snake_case(self._validated_schema_properties.name)}."
             )
         for field in self.fields:
             if (
@@ -225,20 +224,19 @@ class UpdateEntitySchema(BaseOperation):
         return update_tag_schema(benchling_service, tag_schema.id, update.model_dump())
 
     def describe_operation(self) -> str:
-        return f"Updating properties for entity schema {self.wh_schema_name}: {str(self.update_props)}."
+        return f"{self.wh_schema_name}: Updating schema properties to: {str(self.update_props)}."
 
     def describe(self) -> str:
-        return f"Schema properties for {self.wh_schema_name} are different in code versus Benchling: {str(self.update_props)}."
+        return f"{self.wh_schema_name}: Schema properties are different in code versus Benchling: {str(self.update_props)}."
 
     def validate(self, benchling_service: BenchlingService) -> None:
         if (
-            benchling_service.connection.warehouse_access
+            benchling_service.connection.config_flags.schemas_enable_change_warehouse_name
+            is False
             and self.update_props.warehouse_name is not None
         ):
             raise ValueError(
-                "Warehouse access is required to change the schema warehouse name. \
-                Either set warehouse_access to True in BenchlingConnection or do not change the warehouse name. \
-                Reach out to Benchling support if you need help setting up warehouse access."
+                f"{self.wh_schema_name}: Tenant config flag SCHEMAS_ENABLE_CHANGE_WAREHOUSE_NAME is required to update the schema warehouse_name to a custom name. Reach out to Benchling support to turn this config flag to True and then set the flag to True in BenchlingConnection.config_flags."
             )
 
     def _validate(self, benchling_service: BenchlingService) -> TagSchemaModel:
@@ -315,10 +313,15 @@ class CreateEntitySchemaField(BaseOperation):
         self.index = index
 
         self._wh_field_name: str
+        self._field_name: str
         if field_props.warehouse_name:
             self._wh_field_name = field_props.warehouse_name
         else:
             raise ValueError("Field warehouse name is required.")
+        if field_props.name:
+            self._field_name = field_props.name
+        else:
+            raise ValueError("Field name is required.")
 
     def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
         try:
@@ -385,13 +388,12 @@ class CreateEntitySchemaField(BaseOperation):
 
     def validate(self, benchling_service: BenchlingService) -> None:
         if (
-            not benchling_service.connection.warehouse_access
-            and self.field_props.warehouse_name != to_snake_case(self.field_props.name)
+            benchling_service.connection.config_flags.schemas_enable_change_warehouse_name
+            is False
+            and self.field_props.warehouse_name != to_snake_case(self._field_name)
         ):
             raise ValueError(
-                f"Warehouse access is required to set a custom field warehouse name. \
-                Either set warehouse_access to True in BenchlingConnection or set the column variable name to the given Benchling field warehouse name: {to_snake_case(self.field_props.name)}. \
-                Reach out to Benchling support if you need help setting up warehouse access."
+                f"{self.wh_schema_name}: Tenant config flag SCHEMAS_ENABLE_CHANGE_WAREHOUSE_NAME is required to set a custom field warehouse name. Reach out to Benchling support to turn this config flag to True and then set the flag to True in BenchlingConnection.config_flags. Otherwise, define the field warehouse_name in code to be the given Benchling warehouse name: {to_snake_case(self._field_name)}."
             )
         if (
             self.field_props.unit_name
@@ -538,13 +540,12 @@ class UpdateEntitySchemaField(BaseOperation):
             benchling_service, self.wh_schema_name
         )
         if (
-            not benchling_service.connection.warehouse_access
+            benchling_service.connection.config_flags.schemas_enable_change_warehouse_name
+            is False
             and self.update_props.warehouse_name is not None
         ):
             raise ValueError(
-                "Warehouse access is required to change the field warehouse name. \
-                Either set warehouse_access to True in BenchlingConnection or do not change the warehouse name. \
-                Reach out to Benchling support if you need help setting up warehouse access."
+                f"{self.wh_schema_name}: Tenant config flag SCHEMAS_ENABLE_CHANGE_WAREHOUSE_NAME is required to update the field warehouse_name to a custom name. Reach out to Benchling support to turn this config flag to True and then set the flag to True in BenchlingConnection.config_flags."
             )
         if "unit_name" in self.update_props.model_dump(exclude_unset=True):
             no_change_message = f"{self.wh_schema_name}: On field {self.wh_field_name}, updating unit name to {self.update_props.unit_name}. The unit of this field CANNOT be changed once it's been set."

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/orm/base_model.py

@@ -131,7 +131,7 @@ class BaseModel(Generic[T], Base):
                 for field_part in field_parts:
                     if field_part.wh_field_name not in column_wh_names:
                         raise ValueError(
-                            f"Field part {field_part.wh_field_name} is not a column on schema {cls.__schema_properties__.name}."
+                            f"{cls.__schema_properties__.warehouse_name}: Field name template part {field_part.wh_field_name} is not a column on field warehouse name on schema."
                         )
         cls._existing_schema_warehouse_names.add(warehouse_name)
         cls._existing_schema_names.add(cls.__schema_properties__.name)

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/utils.py

@@ -10,30 +10,25 @@ from liminal.connection.benchling_service import BenchlingService
 
 
 def generate_random_id(length: int = 8) -> str:
-    """Generate a random ID with only lowercase letters."""
+    """Generate a pseudo-random ID with only lowercase letters."""
     return "".join(random.choices(string.ascii_lowercase, k=length))
 
 
-def pascalize(input_string: str) -> str:
+def to_pascal_case(input_string: str) -> str:
     """
-    Convert a string to PascalCase.
+    Convert a string to PascalCase. Filters out any non-alphanumeric characters.
     """
-    return "".join(
-        re.sub(r"[\[\]{}():]", "", word).capitalize()
-        for word in re.split(r"[ /_\-]", input_string)
-    )
+    words = re.split(r"[ /_\-]", input_string)
+    # Then remove any non-alphanumeric characters and capitalize each word
+    return "".join(re.sub(r"[^a-zA-Z0-9]", "", word).capitalize() for word in words)
 
 
-def to_snake_case(input_string: str | None) -> str:
+def to_snake_case(input_string: str) -> str:
     """
-    Convert a string to snake_case.
+    Convert a string to snake_case. Filters out any non-alphanumeric characters.
     """
-    if input_string is None:
-        return ""
-    return "_".join(
-        re.sub(r"[\[\]{}():]", "", word).lower()
-        for word in re.split(r"[ /_\-]", input_string)
-    )
+    words = re.split(r"[ /_\-]", input_string)
+    return "_".join(re.sub(r"[^a-zA-Z0-9]", "", word).lower() for word in words)
 
 
 def to_string_val(input_val: Any) -> str:

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/liminal/validation/__init__.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Any, Callable
 
 from pydantic import BaseModel, ConfigDict
 
-from liminal.utils import pascalize
+from liminal.utils import to_pascal_case
 from liminal.validation.validation_severity import ValidationSeverity
 
 if TYPE_CHECKING:
@@ -137,14 +137,14 @@ def liminal_validator(
                 valid=False,
                 level=validator_level,
                 entity=self,
-                validator_name=validator_name or pascalize(func.__name__),
+                validator_name=validator_name or to_pascal_case(func.__name__),
                 message=str(e),
             )
         return BenchlingValidatorReport.create_validation_report(
             valid=True,
             level=validator_level,
             entity=self,
-            validator_name=validator_name or pascalize(func.__name__),
+            validator_name=validator_name or to_pascal_case(func.__name__),
         )
 
     setattr(wrapper, "_is_liminal_validator", True)

{liminal_orm-3.0.1 → liminal_orm-3.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "liminal-orm"
-version = "3.0.1"
+version = "3.1.1"
 description = "An ORM and toolkit that builds on top of Benchling's platform to keep your schemas and downstream code dependencies in sync."
 authors = ["DynoTx Open Source <opensource@dynotx.com>"]
 readme = "README.md"