liminal-orm 1.1.4__py3-none-any.whl → 2.0.1__py3-none-any.whl

liminal/entity_schemas/tag_schema_models.py

@@ -6,6 +6,7 @@ import requests
 from pydantic import BaseModel
 
 from liminal.base.properties.base_field_properties import BaseFieldProperties
+from liminal.base.properties.base_name_template import BaseNameTemplate
 from liminal.base.properties.base_schema_properties import BaseSchemaProperties
 from liminal.connection import BenchlingService
 from liminal.dropdowns.utils import get_benchling_dropdown_summary_by_name
@@ -15,10 +16,14 @@ from liminal.enums import (
     BenchlingFolderItemType,
     BenchlingSequenceType,
 )
+from liminal.enums.name_template_part_type import NameTemplatePartType
 from liminal.mappers import (
     convert_entity_type_to_api_entity_type,
     convert_field_type_to_api_field_type,
 )
+from liminal.orm.name_template_parts import (
+    NameTemplatePart,
+)
 from liminal.orm.schema_properties import MixtureSchemaConfig
 
 
@@ -32,6 +37,73 @@ class FieldRequiredLinkShortModel(BaseModel):
     storableSchema: dict[str, Any] | None = None
 
 
+class NameTemplatePartModel(BaseModel):
+    """A pydantic model to define a part of a name template."""
+
+    type: NameTemplatePartType
+    fieldId: str | None = None
+    text: str | None = None
+    datetimeFormat: str | None = None
+
+    @classmethod
+    def from_name_template_part(
+        cls, part: NameTemplatePart, fields: list[TagSchemaFieldModel] | None = None
+    ) -> NameTemplatePartModel:
+        data = part.model_dump()
+        field_id = None
+        if wh_field_name := data.get("wh_field_name"):
+            field = next((f for f in fields if f.systemName == wh_field_name), None)
+            if field is None:
+                raise ValueError(f"Field {wh_field_name} not found in fields")
+            field_id = field.id
+            if part.component_type == NameTemplatePartType.CHILD_ENTITY_LOT_NUMBER:
+                if not field.isParentLink:
+                    raise ValueError(
+                        f"Field {wh_field_name} is not a parent link field. The field for type {part.component_type} must be a parent link field."
+                    )
+        return cls(
+            type=part.component_type,
+            fieldId=field_id,
+            text=data.get("value"),
+        )
+
+    def to_name_template_part(
+        self, fields: list[TagSchemaFieldModel] | None = None
+    ) -> NameTemplatePart:
+        part_cls = NameTemplatePart.resolve_type(self.type)
+        if self.fieldId:
+            field = next((f for f in fields if f.apiId == self.fieldId), None)
+            if field is None:
+                raise ValueError(f"Field {self.fieldId} not found in fields")
+            return part_cls(wh_field_name=field.systemName, value=self.text)
+        return part_cls(value=self.text)
+
+
+class TagSchemaConstraint(BaseModel):
+    """
+    A class to define a constraint on an entity schema.
+    """
+
+    areUniqueResiduesCaseSensitive: bool | None = None
+    fields: list[TagSchemaFieldModel] | None = None
+    uniqueCanonicalSmilers: bool | None = None
+    uniqueResidues: bool | None = None
+
+    @classmethod
+    def from_constraint_fields(
+        cls, constraint_fields: list[TagSchemaFieldModel], bases: bool
+    ) -> TagSchemaConstraint:
+        """
+        Generates a Constraint object from a set of constraint fields to create a constraint on a schema.
+        """
+        return cls(
+            fields=constraint_fields,
+            uniqueResidues=bases,
+            uniqueCanonicalSmilers=False,
+            areUniqueResiduesCaseSensitive=False,
+        )
+
+
 class UpdateTagSchemaModel(BaseModel):
     """A pydantic model to define the input for the internal tag schema update endpoint."""
 
@@ -46,6 +118,9 @@ class UpdateTagSchemaModel(BaseModel):
     sequenceType: BenchlingSequenceType | None = None
     shouldCreateAsOligo: bool | None = None
     showResidues: bool | None = None
+    includeRegistryIdInChips: bool | None = None
+    useOrganizationCollectionAliasForDisplayLabel: bool | None = None
+    constraint: TagSchemaConstraint | None = None
 
 
 class CreateTagSchemaFieldModel(BaseModel):
@@ -243,7 +318,7 @@ class TagSchemaModel(BaseModel):
     authParentOption: str | None
     batchSchemaId: str | None
     childEntitySchemaSummaries: list[Any] | None
-    constraint: Any | None
+    constraint: TagSchemaConstraint | None
     containableType: str | None
     fields: list[TagSchemaFieldModel]
     folderItemType: BenchlingFolderItemType
@@ -256,7 +331,7 @@ class TagSchemaModel(BaseModel):
     mixtureSchemaConfig: MixtureSchemaConfig | None
     name: str | None
     nameTemplateFields: list[str] | None
-    nameTemplateParts: list[Any] | None
+    nameTemplateParts: list[NameTemplatePartModel] | None
     permissions: dict[str, bool] | None
     prefix: str | None
     registryId: str | None
@@ -299,7 +374,11 @@ class TagSchemaModel(BaseModel):
                 if len(filtered_schemas) == len(wh_schema_names):
                     break
         else:
-            filtered_schemas = [cls.model_validate(schema) for schema in schemas_data]
+            for schema in schemas_data:
+                try:
+                    filtered_schemas.append(cls.model_validate(schema))
+                except Exception as e:
+                    print(f"Error validating schema {schema['sqlIdentifier']}: {e}")
         return filtered_schemas
 
     @classmethod
@@ -333,6 +412,11 @@ class TagSchemaModel(BaseModel):
                 return field
         raise ValueError(f"Field '{wh_field_name}' not found in schema")
 
+    def get_internal_name_template_parts(self) -> list[NameTemplatePart]:
+        return [
+            part.to_name_template_part(self.fields) for part in self.nameTemplateParts
+        ]
+
     def update_schema_props(self, update_diff: dict[str, Any]) -> TagSchemaModel:
         """Updates the schema properties given the schema properties defined in code."""
         update_diff_names = list(update_diff.keys())
@@ -347,6 +431,46 @@ class TagSchemaModel(BaseModel):
             self.labelingStrategies = [o.value for o in update_props.naming_strategies]
         if "mixture_schema_config" in update_diff_names:
             self.mixtureSchemaConfig = update_props.mixture_schema_config
+        if "use_registry_id_as_label" in update_diff_names:
+            self.useOrganizationCollectionAliasForDisplayLabel = (
+                update_props.use_registry_id_as_label
+            )
+        if "include_registry_id_in_chips" in update_diff_names:
+            self.includeRegistryIdInChips = update_props.include_registry_id_in_chips
+
+        if "constraint_fields" in update_diff_names:
+            if update_props.constraint_fields:
+                has_bases = False
+                if "bases" in update_props.constraint_fields:
+                    has_bases = True
+                    update_props.constraint_fields.discard("bases")
+                constraint_fields = [
+                    f
+                    for f in self.fields
+                    if f.systemName in update_props.constraint_fields
+                ]
+                self.constraint = TagSchemaConstraint.from_constraint_fields(
+                    constraint_fields, has_bases
+                )
+            else:
+                self.constraint = None
+
+        if "constraint_fields" in update_diff_names:
+            if update_props.constraint_fields:
+                has_bases = False
+                if "bases" in update_props.constraint_fields:
+                    has_bases = True
+                    update_props.constraint_fields.discard("bases")
+                constraint_fields = [
+                    f
+                    for f in self.fields
+                    if f.systemName in update_props.constraint_fields
+                ]
+                self.constraint = TagSchemaConstraint.from_constraint_fields(
+                    constraint_fields, has_bases
+                )
+            else:
+                self.constraint = None
 
         self.prefix = (
             update_props.prefix if "prefix" in update_diff_names else self.prefix
@@ -359,6 +483,25 @@ class TagSchemaModel(BaseModel):
         self.name = update_props.name if "name" in update_diff_names else self.name
         return self
 
+    def update_name_template(
+        self, update_name_template: BaseNameTemplate
+    ) -> TagSchemaModel:
+        update_diff_names = update_name_template.model_dump(exclude_unset=True).keys()
+        self.nameTemplateParts = (
+            [
+                NameTemplatePartModel.from_name_template_part(part, self.fields)
+                for part in update_name_template.parts
+            ]
+            if "parts" in update_diff_names
+            else self.nameTemplateParts
+        )
+        self.shouldOrderNamePartsBySequence = (
+            update_name_template.order_name_parts_by_sequence
+            if "order_name_parts_by_sequence" in update_diff_names
+            else self.shouldOrderNamePartsBySequence
+        )
+        return self
+
     def update_field(
         self,
         benchling_service: BenchlingService,

liminal/entity_schemas/utils.py

@@ -9,6 +9,7 @@ from liminal.mappers import (
     convert_api_entity_type_to_entity_type,
     convert_api_field_type_to_field_type,
 )
+from liminal.orm.name_template import NameTemplate
 from liminal.orm.schema_properties import MixtureSchemaConfig, SchemaProperties
 
 
@@ -16,7 +17,7 @@ def get_converted_tag_schemas(
     benchling_service: BenchlingService,
     include_archived: bool = False,
     wh_schema_names: set[str] | None = None,
-) -> list[tuple[SchemaProperties, dict[str, BaseFieldProperties]]]:
+) -> list[tuple[SchemaProperties, NameTemplate, dict[str, BaseFieldProperties]]]:
     """This functions gets all Tag schemas from Benchling and converts them to our internal representation of a schema and its fields.
     It parses the Tag Schema and creates SchemaProperties and a list of FieldProperties for each field in the schema.
     If include_archived is True, it will include archived schemas and archived fields.
@@ -40,10 +41,15 @@ def convert_tag_schema_to_internal_schema(
     tag_schema: TagSchemaModel,
     dropdowns_map: dict[str, str],
     include_archived_fields: bool = False,
-) -> tuple[SchemaProperties, dict[str, BaseFieldProperties]]:
+) -> tuple[SchemaProperties, NameTemplate, dict[str, BaseFieldProperties]]:
     all_fields = tag_schema.allFields
     if not include_archived_fields:
         all_fields = [f for f in all_fields if not f.archiveRecord]
+    constraint_fields: set[str] | None = None
+    if tag_schema.constraint:
+        constraint_fields = set([f.systemName for f in tag_schema.constraint.fields])
+        if tag_schema.constraint.uniqueResidues:
+            constraint_fields.add("bases")
     return (
         SchemaProperties(
             name=tag_schema.name,
@@ -63,7 +69,14 @@ def convert_tag_schema_to_internal_schema(
                 BenchlingNamingStrategy(strategy)
                 for strategy in tag_schema.labelingStrategies
             ),
+            constraint_fields=constraint_fields,
             _archived=tag_schema.archiveRecord is not None,
+            use_registry_id_as_label=tag_schema.useOrganizationCollectionAliasForDisplayLabel,
+            include_registry_id_in_chips=tag_schema.includeRegistryIdInChips,
+        ),
+        NameTemplate(
+            parts=tag_schema.get_internal_name_template_parts(),
+            order_name_parts_by_sequence=tag_schema.shouldOrderNamePartsBySequence,
         ),
         {
             f.systemName: convert_tag_schema_field_to_field_properties(f, dropdowns_map)

liminal/enums/__init__.py

@@ -4,5 +4,4 @@ from liminal.enums.benchling_entity_type import BenchlingEntityType
 from liminal.enums.benchling_field_type import BenchlingFieldType
 from liminal.enums.benchling_folder_item_type import BenchlingFolderItemType
 from liminal.enums.benchling_naming_strategy import BenchlingNamingStrategy
-from liminal.enums.benchling_report_level import BenchlingReportLevel
 from liminal.enums.benchling_sequence_type import BenchlingSequenceType

liminal/enums/benchling_entity_type.py

@@ -13,3 +13,11 @@ class BenchlingEntityType(StrEnum):
     ENTRY = "entry"
     MIXTURE = "mixture"
     MOLECULE = "molecule"
+
+    def is_sequence(self) -> bool:
+        return self in [
+            self.DNA_SEQUENCE,
+            self.RNA_SEQUENCE,
+            self.DNA_OLIGO,
+            self.RNA_OLIGO,
+        ]

liminal/enums/name_template_part_type.py

@@ -0,0 +1,12 @@
+from liminal.base.str_enum import StrEnum
+
+
+class NameTemplatePartType(StrEnum):
+    SEPARATOR = "SEPARATOR"
+    TEXT = "TEXT"
+    CREATION_YEAR = "CREATED_AT_YEAR"
+    CREATION_DATE = "CREATED_AT_DATE"
+    FIELD = "FIELD"
+    REGISTRY_IDENTIFIER_NUMBER = "REGISTRY_IDENTIFIER_NUMBER"
+    PROJECT = "PROJECT"
+    CHILD_ENTITY_LOT_NUMBER = "CHILD_ENTITY_LOT_NUMBER"

liminal/external/__init__.py

@@ -1,6 +1,7 @@
 # flake8: noqa: F401
 from liminal.base.base_operation import BaseOperation
 from liminal.base.properties.base_field_properties import BaseFieldProperties
+from liminal.base.properties.base_name_template import BaseNameTemplate
 from liminal.base.properties.base_schema_properties import BaseSchemaProperties
 from liminal.dropdowns.operations import (
     ArchiveDropdown,
@@ -22,6 +23,7 @@ from liminal.entity_schemas.operations import (
     UnarchiveEntitySchemaField,
     UpdateEntitySchema,
     UpdateEntitySchemaField,
+    UpdateEntitySchemaNameTemplate,
 )
 from liminal.enums import (
     BenchlingAPIFieldType,
@@ -29,6 +31,14 @@ from liminal.enums import (
     BenchlingFieldType,
     BenchlingFolderItemType,
     BenchlingNamingStrategy,
-    BenchlingReportLevel,
     BenchlingSequenceType,
 )
+from liminal.orm.name_template_parts import (
+    CreationDatePart,
+    CreationYearPart,
+    FieldPart,
+    ProjectPart,
+    RegistryIdentifierNumberPart,
+    SeparatorPart,
+    TextPart,
+)

liminal/migrate/revisions_timeline.py

@@ -30,7 +30,8 @@ class RevisionsTimeline:
             )
         all_raw_revisions: list[Revision] = []
         for file_path in versions_dir_path.iterdir():
-            all_raw_revisions.append(Revision.parse_from_file(file_path))
+            if file_path.is_file() and file_path.suffix == ".py":
+                all_raw_revisions.append(Revision.parse_from_file(file_path))
         self.revisions_map = self.validate_revisions(all_raw_revisions)
 
     def get_first_revision(self) -> Revision:

liminal/orm/base_model.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
+import inspect
 import logging
-from abc import abstractmethod
+from types import FunctionType
 from typing import TYPE_CHECKING, Any, Generic, Type, TypeVar  # noqa: UP035
 
 import pandas as pd  # type: ignore
@@ -11,13 +12,13 @@ from sqlalchemy.orm import Query, RelationshipProperty, Session, relationship
 from sqlalchemy.orm.decl_api import declared_attr
 
 from liminal.base.base_validation_filters import BaseValidatorFilters
+from liminal.enums import BenchlingNamingStrategy
 from liminal.orm.base import Base
 from liminal.orm.base_tables.user import User
+from liminal.orm.name_template import NameTemplate
+from liminal.orm.name_template_parts import FieldPart
 from liminal.orm.schema_properties import SchemaProperties
-from liminal.validation import (
-    BenchlingValidator,
-    BenchlingValidatorReport,
-)
+from liminal.validation import BenchlingValidatorReport
 
 if TYPE_CHECKING:
     from liminal.orm.column import Column
@@ -32,20 +33,24 @@ class BaseModel(Generic[T], Base):
 
     __abstract__ = True
     __schema_properties__: SchemaProperties
+    __name_template__: NameTemplate = NameTemplate(
+        parts=[], order_name_parts_by_sequence=False
+    )
 
     _existing_schema_warehouse_names: set[str] = set()
     _existing_schema_names: set[str] = set()
-    _existing_schema_prefixes: set[str] = set()
+    _existing_schema_prefixes: list[str] = []
 
     def __init_subclass__(cls, **kwargs: Any):
         super().__init_subclass__(**kwargs)
+        warehouse_name = cls.__schema_properties__.warehouse_name
+        cls.__tablename__ = warehouse_name + "$raw"
         if "__schema_properties__" not in cls.__dict__ or not isinstance(
             cls.__schema_properties__, SchemaProperties
         ):
             raise NotImplementedError(
                 f"{cls.__name__} must define 'schema_properties' class attribute"
             )
-        warehouse_name = cls.__schema_properties__.warehouse_name
         if warehouse_name in cls._existing_schema_warehouse_names:
             raise ValueError(
                 f"Warehouse name '{warehouse_name}' is already used by another subclass."
@@ -54,15 +59,48 @@ class BaseModel(Generic[T], Base):
             raise ValueError(
                 f"Schema name '{cls.__schema_properties__.name}' is already used by another subclass."
             )
-        if cls.__schema_properties__.prefix.lower() in cls._existing_schema_prefixes:
-            logger.warning(
-                f"Schema prefix '{cls.__schema_properties__.prefix}' is already used by another subclass. Please ensure fieldsets=True in BenchlingConnection you are updating/creating this schema."
-            )
-
+        column_wh_names = [
+            c[0] for c in cls.__dict__.items() if isinstance(c[1], SqlColumn)
+        ]
+        # Validate constraints
+        if cls.__schema_properties__.constraint_fields:
+            invalid_constraints = [
+                c
+                for c in cls.__schema_properties__.constraint_fields
+                if c not in (set(column_wh_names) | {"bases"})
+            ]
+            if invalid_constraints:
+                raise ValueError(
+                    f"Constraints {', '.join(invalid_constraints)} are not fields on schema {cls.__schema_properties__.name}."
+                )
+        # Validate naming strategies
+        if any(
+            BenchlingNamingStrategy.is_template_based(strategy)
+            for strategy in cls.__schema_properties__.naming_strategies
+        ):
+            if not cls.__name_template__.parts:
+                raise ValueError(
+                    "Name template must be set when using template-based naming strategies."
+                )
+        # Validate name template
+        if cls.__name_template__:
+            if not cls.__schema_properties__.entity_type.is_sequence():
+                if cls.__name_template__.order_name_parts_by_sequence is True:
+                    raise ValueError(
+                        "order_name_parts_by_sequence is only supported for sequence entities. Must be set to False if entity type is not a sequence."
+                    )
+            if cls.__name_template__.parts:
+                field_parts = [
+                    p for p in cls.__name_template__.parts if isinstance(p, FieldPart)
+                ]
+                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}."
+                        )
         cls._existing_schema_warehouse_names.add(warehouse_name)
         cls._existing_schema_names.add(cls.__schema_properties__.name)
-        cls._existing_schema_prefixes.add(cls.__schema_properties__.prefix.lower())
-        cls.__tablename__ = warehouse_name + "$raw"
+        cls._existing_schema_prefixes.append(cls.__schema_properties__.prefix.lower())
 
     @declared_attr
     def creator_id(cls) -> SqlColumn:
@@ -130,13 +168,22 @@ class BaseModel(Generic[T], Base):
         return {c.name: c for c in columns}
 
     @classmethod
-    def validate_model(cls) -> bool:
+    def validate_model_definition(cls) -> bool:
         model_columns = cls.get_columns_dict(exclude_base_columns=True)
         properties = {n: c.properties for n, c in model_columns.items()}
         errors = []
+        if (
+            cls._existing_schema_prefixes.count(
+                cls.__schema_properties__.prefix.lower()
+            )
+            > 1
+        ):
+            logger.warning(
+                f"{cls.__name__}: schema prefix '{cls.__schema_properties__.prefix}' is already used by another subclass. Please ensure fieldsets=True in BenchlingConnection you are updating/creating this schema."
+            )
         for wh_name, field in properties.items():
             try:
-                field.validate_column(wh_name)
+                field.validate_column_definition(wh_name)
             except ValueError as e:
                 errors.append(str(e))
         if errors:
@@ -224,25 +271,33 @@ class BaseModel(Generic[T], Base):
         """
         return session.query(cls)
 
-    @abstractmethod
-    def get_validators(self) -> list[BenchlingValidator]:
-        """Abstract method that all subclasses must implement. Each subclass will have a differently defined list of
-        validators to validate the entity. These validators will be run on each entity returned from the query.
-        """
-        raise NotImplementedError
+    @classmethod
+    def get_validators(cls) -> list[FunctionType]:
+        """Returns a list of all validators defined on the class. Validators are functions that are decorated with @validator."""
+        validators = []
+        for name, method in inspect.getmembers(cls, predicate=inspect.isfunction):
+            if hasattr(method, "_is_liminal_validator"):
+                validators.append(method)
+        return validators
 
     @classmethod
     def validate(
-        cls, session: Session, base_filters: BaseValidatorFilters | None = None
+        cls,
+        session: Session,
+        base_filters: BaseValidatorFilters | None = None,
+        only_invalid: bool = False,
     ) -> list[BenchlingValidatorReport]:
         """Runs all validators for all entities returned from the query and returns a list of reports.
+        This returns a report for each entity, validator pair, regardless of whether the validation passed or failed.
 
         Parameters
         ----------
         session : Session
             Benchling database session.
-        base_filters: BenchlingBaseValidatorFilters
+        base_filters: BaseValidatorFilters
             Filters to apply to the query.
+        only_invalid: bool
+            If True, only returns reports for entities that failed validation.
 
         Returns
         -------
@@ -254,15 +309,21 @@ class BaseModel(Generic[T], Base):
             cls.query(session), base_filters=base_filters
         ).all()
         logger.info(f"Validating {len(table)} entities for {cls.__name__}...")
+        validator_functions = cls.get_validators()
         for entity in table:
-            for validator in entity.get_validators():
-                report: BenchlingValidatorReport = validator.validate(entity)
+            for validator_func in validator_functions:
+                report: BenchlingValidatorReport = validator_func(entity)
+                if only_invalid and report.valid:
+                    continue
                 results.append(report)
         return results
 
     @classmethod
     def validate_to_df(
-        cls, session: Session, base_filters: BaseValidatorFilters | None = None
+        cls,
+        session: Session,
+        base_filters: BaseValidatorFilters | None = None,
+        only_invalid: bool = False,
     ) -> pd.DataFrame:
         """Runs all validators for all entities returned from the query and returns reports as a pandas dataframe.
 
@@ -270,7 +331,7 @@ class BaseModel(Generic[T], Base):
         ----------
         session : Session
             Benchling database session.
-        base_filters: BenchlingBaseValidatorFilters
+        base_filters: BaseValidatorFilters
             Filters to apply to the query.
 
         Returns
@@ -278,5 +339,5 @@ class BaseModel(Generic[T], Base):
         pd.Dataframe
             Dataframe of reports from running all validators on all entities returned from the query.
         """
-        results = cls.validate(session, base_filters)
+        results = cls.validate(session, base_filters, only_invalid)
         return pd.DataFrame([r.model_dump() for r in results])

liminal/orm/name_template.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import ConfigDict, field_validator
+
+from liminal.base.properties.base_name_template import BaseNameTemplate
+from liminal.orm.name_template_parts import NameTemplateParts, SeparatorPart
+
+
+class NameTemplate(BaseNameTemplate):
+    """
+    This class is the validated class that is public facing and inherits from the BaseNameTemplate class.
+    It has the same fields as the BaseNameTemplate class, but it is validated to ensure that the fields are valid.
+
+    Parameters
+    ----------
+    parts : list[NameTemplatePart] = []
+        The list of name template parts that make up the name template (order matters). Defaults to no parts, an empty list.
+    order_name_parts_by_sequence : bool = False
+        Whether to order the name parts by sequence. This can only be set to True for sequence enity types. If one or many part link fields are included in the name template,
+        list parts in the order they appear on the sequence map, sorted by start position and then end position. Defaults to False.
+    """
+
+    parts: list[NameTemplateParts] = []
+    order_name_parts_by_sequence: bool = False
+
+    @field_validator("parts")
+    def validate_parts(cls, v: list[NameTemplateParts]) -> list[NameTemplateParts]:
+        if len(v) > 0 and all(isinstance(part, SeparatorPart) for part in v):
+            raise ValueError(
+                "This name template will produce an empty name because it only includes separators. Please include at least one non-separator component."
+            )
+        return v
+
+    def __init__(self, **data: Any) -> None:
+        super().__init__(**data)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")