liminal-orm 4.6.2__tar.gz → 4.7.0a1__tar.gz

{liminal_orm-4.6.2 → liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/.uv-cache/archive-v0/eXa8KUkHhZHOAuoK}/liminal/orm/base_model.py

@@ -352,7 +352,8 @@ class BaseModel(Generic[T], Base):
             A pandas dataframe of all entities from the database.
         """
         query = cls.query(session)
-        return pd.read_sql(query.statement, session.connection())
+        result = session.connection().execute(query.statement)
+        return pd.DataFrame(result.fetchall(), columns=list(result.keys()))
 
     @classmethod
     def query(cls, session: Session) -> Query:

{liminal_orm-4.6.2 → liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/.uv-cache/archive-v0/eXa8KUkHhZHOAuoK}/liminal/orm/base_results_model.py

@@ -143,7 +143,8 @@ class BaseResultsModel(Generic[T], Base):
             A pandas dataframe of all results schema rows from the database.
         """
         query = cls.query(session)
-        return pd.read_sql(query.statement, session.connection())
+        result = session.connection().execute(query.statement)
+        return pd.DataFrame(result.fetchall(), columns=list(result.keys()))
 
     @classmethod
     def query(cls, session: Session) -> Query:

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/.uv-cache/archive-v0/eXa8KUkHhZHOAuoK/liminal/tests/test_dataframe_compatibility.py

@@ -0,0 +1,28 @@
+from unittest.mock import patch
+
+from sqlalchemy import Column, Integer, String, create_engine
+from sqlalchemy.orm import Session, declarative_base
+
+from liminal.orm.base_model import BaseModel
+
+
+def test_dataframe_query_supports_declared_pandas_and_sqlalchemy_versions() -> None:
+    test_base = declarative_base()
+
+    class ExampleRow(test_base):  # type: ignore[valid-type,misc]
+        __tablename__ = "example_rows"
+
+        id = Column(Integer, primary_key=True)
+        name = Column(String)
+
+    engine = create_engine("sqlite://")
+    test_base.metadata.create_all(engine)
+
+    with Session(engine) as session:
+        session.add(ExampleRow(name="example"))
+        session.commit()
+
+        with patch.object(BaseModel, "query", return_value=session.query(ExampleRow)):
+            dataframe = BaseModel.df(session)
+
+    assert dataframe.to_dict(orient="records") == [{"id": 1, "name": "example"}]

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/base_dropdown.py

@@ -0,0 +1,93 @@
+from abc import ABC
+from typing import Any
+
+from liminal.connection.benchling_service import BenchlingService
+from liminal.dropdowns.utils import get_benchling_dropdown_summaries
+
+
+class BaseDropdown(ABC):
+    """_summary_
+
+    Parameters
+    ----------
+    __benchling_name__: str
+        The name of the dropdown in Benchling. There can be no duplicate dropdown names in Benchling.
+    __allowed_values__: list[str]
+        The list of values for the dropdown. Order matters and reflects the order of the dropdown in Benchling. Values must be unique.
+    """
+
+    __benchling_name__: str
+    __allowed_values__: list[str]
+
+    _existing_benchling_names: set[str] = set()
+
+    def __new__(cls, **kwargs: Any) -> "BaseDropdown":
+        if not hasattr(cls, "__allowed_values__"):
+            raise ValueError(f"{cls.__name__} must define __allowed_values__")
+        if not hasattr(cls, "__benchling_name__") or not cls.__benchling_name__:
+            raise ValueError(f"{cls.__name__} must define __benchling_name__")
+        if len(cls.__allowed_values__) != len(set(cls.__allowed_values__)):
+            raise ValueError(
+                f"{cls.__name__} must have unique values in __allowed_values__"
+            )
+
+        if cls.__benchling_name__ in cls._existing_benchling_names:
+            raise ValueError(
+                f"{cls.__benchling_name__} is already used as a benchling name."
+            )
+        cls._existing_benchling_names.add(cls.__benchling_name__)
+        return super().__new__(cls, **kwargs)
+
+    @classmethod
+    def get_id(cls, benchling_service: BenchlingService) -> str:
+        """Connects to Benchling and returns the id of the dropdown using the __benchling_name__.
+
+        Parameters
+        ----------
+        benchling_service : BenchlingService
+            The Benchling service to use.
+
+        Returns
+        -------
+        str
+            The id of the dropdown.
+        """
+        all_dropdowns = get_benchling_dropdown_summaries(benchling_service)
+        dropdowns_found_by_name = [
+            d for d in all_dropdowns if d.name == cls.__benchling_name__
+        ]
+        if len(dropdowns_found_by_name) == 0:
+            raise ValueError(f"No dropdowns found with name '{cls.__benchling_name__}'")
+        else:
+            dropdown = dropdowns_found_by_name[0]
+            return dropdown.id
+
+    @classmethod
+    def validate(cls, *values: str | None) -> None:
+        err_values = []
+        for value in values:
+            if value and value not in cls.__allowed_values__:
+                err_values.append(value)
+        if len(err_values) > 0:
+            raise ValueError(
+                f"{', '.join(err_values)} are not valid {cls.__benchling_name__} dropdown values."
+            )
+
+    @classmethod
+    def get_all_subclasses(
+        cls, names: set[str] | None = None
+    ) -> list[type["BaseDropdown"]]:
+        if names is None:
+            return cls.__subclasses__()
+        dropdowns = {
+            name: subclass
+            for subclass in cls.__subclasses__()
+            for name in names
+            if name in (subclass.__name__, subclass.__benchling_name__)
+        }
+        if len(dropdowns.keys()) != len(set(names)):
+            missing_dropdowns = set(names) - set(dropdowns.keys())
+            raise ValueError(
+                f"No dropdown subclass found for the following class names or warehouse names: {', '.join(missing_dropdowns)}"
+            )
+        return list(dropdowns.values())

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/base_operation.py

@@ -0,0 +1,97 @@
+from abc import ABC, abstractmethod
+from typing import Any, ClassVar
+
+from liminal.connection.benchling_service import BenchlingService
+
+"""
+Order of operations based on order class var:
+    1. CreateDropdown
+    2. UpdateDropdownName
+    3. UnarchiveDropdown
+    4. CreateDropdownOption
+    5. UpdateDropdownOption
+    6. ArchiveDropdownOption
+    7. ReorderDropdownOptions
+    8. CreateSchema
+    9. UnarchiveSchema
+    10. CreateField
+    11. UpdateEntitySchemaNameTemplate
+    12. UpdateSchema
+    13. UnarchiveField
+    14. UpdateField
+    15. ArchiveField
+    16. ReorderFields
+    17. ArchiveSchema
+    18. ArchiveDropdown
+"""
+
+
+class BaseOperation(ABC):
+    """A class that represents a callable operation to be run during a Benchling schema migration."""
+
+    order: ClassVar[int] = 0
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+    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
+
+    @abstractmethod
+    def execute(self, benchling_service: BenchlingService) -> dict[str, Any]:
+        """Execute the operation using the given Benchling SDK instance.
+
+        Parameters
+        ----------
+        benchling_service : BenchlingService
+            The BenchlingService to connect to the given Benchling tenant with.
+
+
+        Returns
+        -------
+        dict[str, Any]
+            The contents of the response from the operation.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def describe_operation(self) -> str:
+        """Returns a description of what the CallableOperation will do."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def describe(self) -> str:
+        """Returns a description of what the state of the comparison is."""
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        """Generates a string representation of the class so that it can be executed."""
+        args = []
+        for k, v in self.__dict__.items():
+            if k.startswith("_"):
+                continue
+            if isinstance(v, str):
+                args.append(f"'{v}'")
+            else:
+                args.append(f"{v.__repr__()}")
+        return f"{self.__class__.__name__}({', '.join(args)})"
+
+    def revision_file_string(self) -> str:
+        """Generates an exact string representation of the operation that can be evaluated.
+        Imports in external module as b so that it can be evaluated in the revision file."""
+        import liminal.external as b
+
+        liminal_imports = [c for c in dir(b) if not c.startswith("_")]
+        op_str = repr(self)
+        for i in liminal_imports:
+            if f"{i}(" in op_str:
+                op_str = op_str.replace(f"{i}(", f"b.{i}(")
+            if f"{i}." in op_str:
+                op_str = op_str.replace(f"{i}.", f"b.{i}.")
+        return op_str
+
+    def __lt__(self, other: "BaseOperation") -> bool:
+        return self.order < other.order

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/base_validation_filters.py

@@ -0,0 +1,32 @@
+from datetime import date
+
+from pydantic import BaseModel
+
+
+class BaseValidatorFilters(BaseModel):
+    """
+    This class is used to pass base filters to benchling warehouse database queries.
+    These columns are found on all tables in the benchling warehouse database.
+
+    Parameters
+    ----------
+    created_date_start: date | None
+        Start date for created date filter.
+    created_date_end: date | None
+        End date for created date filter.
+    updated_date_start: date | None
+        Start date for updated date filter.
+    updated_date_end: date | None
+        End date for updated date filter.
+    entity_ids: list[str] | None
+        List of entity IDs to filter by.
+    creator_full_names: list[str] | None
+        List of creator full names to filter by.
+    """
+
+    created_date_start: date | None = None
+    created_date_end: date | None = None
+    updated_date_start: date | None = None
+    updated_date_end: date | None = None
+    entity_ids: list[str] | None = None
+    creator_full_names: list[str] | None = None

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/compare_operation.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel, ConfigDict
+
+from liminal.base.base_operation import BaseOperation
+
+
+class CompareOperation(BaseModel):
+    op: BaseOperation
+    reverse_op: BaseOperation
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def __lt__(self, other: "CompareOperation") -> bool:
+        return self.op.order < other.op.order

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/name_template_parts.py

@@ -0,0 +1,8 @@
+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 v5.",
+    FutureWarning,
+)

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/properties/base_field_properties.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, PrivateAttr
+
+from liminal.enums import BenchlingFieldType
+
+
+class BaseFieldProperties(BaseModel):
+    """A class that represents the properties of a field on an entity schema in Benchling.
+    This is used to define properties in a benchling column and is used to generically define properties of a field.
+
+    Parameters
+    ----------
+    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
+        Whether the field is required.
+    is_multi : bool | None
+        Whether the field is a multi-value field.
+    parent_link : bool | None
+        Whether the entity link field is a parent of the entity schema.
+    dropdown : Type[BaseDropdown] | str | None
+        The dropdown for the field or the __benchling_name__ of the dropdown.
+        If a string gets passed in, it gets converted to the dropdown class.
+    entity_link : str | None
+        The warehouse name of the entity schema that the field links to.
+        If a string gets passed in, it gets converted to the entity schema class.
+    tooltip : str | None
+        The tooltip text for the field.
+    _archived : bool | None
+        Whether the field is archived in Benchling.
+    """
+
+    name: str | None = None
+    warehouse_name: str | None = None
+    type: BenchlingFieldType | None = None
+    required: bool | None = None
+    is_multi: bool | None = None
+    parent_link: bool | None = None
+    dropdown_link: str | None = None
+    entity_link: str | None = None
+    tooltip: str | None = None
+    decimal_places: int | None = None
+    unit_name: str | None = None
+    _archived: bool | None = PrivateAttr(default=None)
+
+    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 unset_tooltip(self) -> BaseFieldProperties:
+        if "tooltip" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("tooltip")
+        return self
+
+    def unset_entity_link(self) -> BaseFieldProperties:
+        if "entity_link" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("entity_link")
+        return self
+
+    def unset_unit_name(self) -> BaseFieldProperties:
+        if "unit_name" in self.__pydantic_fields_set__:
+            self.__pydantic_fields_set__.remove("unit_name")
+        return self
+
+    def set_type(self, new_type: BenchlingFieldType) -> BaseFieldProperties:
+        self.type = new_type
+        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.
+
+        Parameters
+        ----------
+        new_props : Benchling FieldProperties
+            The new properties of the field
+
+        Returns
+        -------
+        dict[str, Any]
+            The diff of the two given Benchling FieldProperties.
+        """
+        diff = {}
+        for new_field_name, new_val in new_props.model_dump().items():
+            if getattr(self, new_field_name) != new_val:
+                diff[new_field_name] = new_val
+        return diff
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BaseFieldProperties):
+            return NotImplemented
+        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_unset=True).items()])})"

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/properties/base_name_template.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from liminal.orm.name_template_parts import NameTemplateParts
+
+
+class BaseNameTemplate(BaseModel):
+    """
+    This class is the generic class for defining the name template.
+    It is used to create a diff between the old and new name template.
+
+    Parameters
+    ----------
+    parts : list[NameTemplatePart] | None
+        The list of name template parts that make up the name template (order matters).
+    order_name_parts_by_sequence : bool | None
+        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.
+    """
+
+    parts: list[NameTemplateParts] | None = None
+    order_name_parts_by_sequence: bool | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def merge(self, new_props: BaseNameTemplate) -> dict[str, Any]:
+        """Creates a diff between the current name template and the new name template.
+        Sets value to None if the values are equal, otherwise sets the value to the new value.
+
+        Parameters
+        ----------
+        new_props : BaseNameTemplate
+            The new name template.
+
+        Returns
+        -------
+        dict[str, Any]
+            A dictionary of the differences between the old and new name template.
+        """
+        diff = {}
+        for field_name in self.model_fields:
+            new_val = getattr(new_props, field_name)
+            if getattr(self, field_name) != new_val:
+                diff[field_name] = new_val
+        return diff
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BaseNameTemplate):
+            return False
+        return self.model_dump() == other.model_dump()
+
+    def __str__(self) -> str:
+        parts_str = (
+            f"parts=[{', '.join(repr(part) for part in self.parts)}]"
+            if self.parts is not None
+            else None
+        )
+        order_name_parts_by_sequence_str = (
+            f"order_name_parts_by_sequence={self.order_name_parts_by_sequence}"
+            if self.order_name_parts_by_sequence is not None
+            else None
+        )
+        return ", ".join(filter(None, [parts_str, order_name_parts_by_sequence_str]))
+
+    def __repr__(self) -> str:
+        """Generates a string representation of the class so that it can be executed."""
+        model_dump = self.model_dump(exclude_defaults=True, exclude_unset=True)
+        props = []
+        if "parts" in model_dump:
+            parts_repr = (
+                f"[{', '.join(repr(part) for part in self.parts)}]"
+                if self.parts
+                else "[]"
+            )
+            props.append(f"parts={parts_repr}")
+        if "order_name_parts_by_sequence" in model_dump:
+            props.append(
+                f"order_name_parts_by_sequence={self.order_name_parts_by_sequence}"
+            )
+        return f"{self.__class__.__name__}({', '.join(props)})"

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/properties/base_schema_properties.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, model_validator
+
+from liminal.enums import BenchlingEntityType, BenchlingNamingStrategy
+
+
+class MixtureSchemaConfig(BaseModel):
+    """
+    This class is used to define the properties of a mixture schema within our code and when retrieving data from the benchling api.
+    It is only used when the entity schema type is Mixture.
+    It can either be storage, text, or both if allowMeasuredIngredients is True. Otherwise, both must be false.
+
+    Parameters
+    ----------
+    allowMeasuredIngredients : bool | None
+        Whether the mixture schema allows measured ingredients.
+    componentLotStorageEnabled : bool | None
+        Whether the mixture schema allows component lot storage.
+    componentLotTextEnabled : bool | None
+        Whether the mixture schema allows component lot text.
+    """
+
+    allowMeasuredIngredients: bool = False
+    componentLotStorageEnabled: bool | None = None
+    componentLotTextEnabled: bool | None = None
+
+    @model_validator(mode="after")
+    def validate_mixture_schema_config(self) -> MixtureSchemaConfig:
+        if self.allowMeasuredIngredients:
+            if not (self.componentLotStorageEnabled or self.componentLotTextEnabled):
+                raise ValueError(
+                    "If allowMeasuredIngredients is True, either componentLotStorageEnabled or componentLotTextEnabled must be True."
+                )
+        elif self.allowMeasuredIngredients is False:
+            if self.componentLotStorageEnabled or self.componentLotTextEnabled:
+                raise ValueError(
+                    "If allowMeasuredIngredients is False, both componentLotStorageEnabled and componentLotTextEnabled must be False."
+                )
+        return self
+
+
+class BaseSchemaProperties(BaseModel):
+    """
+    This class is the generic class for defining the Benchling entity schema properties, where all fields are optional.
+    It is used to create a diff between the old and new schema properties.
+
+    Parameters
+    ----------
+    name : str | None
+        The name of the schema.
+    warehouse_name : str | None
+       The sql table name of the schema in the benchling warehouse.
+    prefix : str | None
+        The prefix to use for the schema.
+    entity_type : BenchlingEntityType | None
+        The entity type of the schema.
+    naming_strategies : set[BenchlingNamingStrategy] | None
+        The naming strategies of the schema.
+    mixture_schema_config : MixtureSchemaConfig | None
+        The mixture schema config of the schema.
+    use_registry_id_as_label : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will use the Registry ID as the main label for items.
+    include_registry_id_in_chips : bool | None = None
+        Flag for configuring the chip label for entities. Determines if the chip will include the Registry ID in the chip label.
+    constraint_fields : set[str] | None
+        Set of constraints for field values for the schema. Must be a set of warehouse column names. This specifies that their entity field values must be a unique combination within an entity.
+        The following sequence constraints are also supported:
+        - bases: only supported for nucleotide sequence entity types. hasUniqueResidues=True
+        - amino_acids_ignore_case: only supported for amino acid sequence entity types. hasUniqueResidues=True
+        - amino_acids_exact_match: only supported for amino acid sequence entity types. hasUniqueResidues=True, areUniqueResiduesCaseSensitive=True
+    show_bases_in_expanded_view : bool | None
+        Whether the bases should be shown in the expanded view of the entity.
+    _archived : bool | None
+        Whether the schema is archived in Benchling.
+    """
+
+    name: str | None = None
+    warehouse_name: str | None = None
+    prefix: str | None = None
+    entity_type: BenchlingEntityType | None = None
+    naming_strategies: set[BenchlingNamingStrategy] | None = None
+    mixture_schema_config: MixtureSchemaConfig | None = None
+    use_registry_id_as_label: bool | None = None
+    include_registry_id_in_chips: bool | None = None
+    constraint_fields: set[str] | None = None
+    show_bases_in_expanded_view: bool | None = None
+    _archived: bool | None = None
+
+    def __init__(self, **data: Any):
+        super().__init__(**data)
+        self._archived = data.get("_archived", None)  # TODO: WHY??
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def set_warehouse_name(self, value: str) -> BaseSchemaProperties:
+        self.warehouse_name = value
+        return self
+
+    def set_naming_strategies(
+        self, value: set[BenchlingNamingStrategy]
+    ) -> BaseSchemaProperties:
+        self.naming_strategies = value
+        return self
+
+    def merge(self, new_props: BaseSchemaProperties) -> dict[str, Any]:
+        """Creates a diff between the current schema properties and the new schema properties.
+        Sets value to None if the values are equal, otherwise sets the value to the new value.
+
+        Parameters
+        ----------
+        new_props : Benchling BaseSchemaProperties
+            The new schema properties.
+
+        Returns
+        -------
+        dict[str, Any]
+            A dictionary of the differences between the old and new schema properties.
+        """
+        diff = {}
+        for new_field_name, new_val in new_props.model_dump().items():
+            if getattr(self, new_field_name) != new_val:
+                diff[new_field_name] = new_val
+        return diff
+
+    def __eq__(self, other: object) -> bool:
+        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_unset=True, exclude_defaults=True).items()])})"

liminal_orm-4.7.0a1/.uv-cache/archive-v0/arvZabAJhner6mVH/liminal/base/str_enum.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class StrEnum(str, Enum):
+    def __repr__(self) -> str:
+        """
+        Returns the string representation of the enum. ex: 'StrEnum.VALUE'
+        """
+        return self.__str__()