Cherry-picked simplified domain models

Author: pboers1988

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.1-rc3
+current_version = 0.0.2-rc1
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\-(?P<release>[a-z]+)(?P<build>\d+))?

orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "0.0.1-rc3"
+__version__ = "0.0.2-rc1"
 
 from orchestrator.app import OrchestratorCore
 from orchestrator.settings import app_settings, oauth2_settings

orchestrator/api/api_v1/endpoints/subscriptions.py

@@ -13,7 +13,6 @@
 
 """Module that implements subscription related API endpoints."""
 
-from dataclasses import asdict
 from http import HTTPStatus
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
@@ -336,7 +335,7 @@ def subscription_details_by_id_with_domain_model(subscription_id: UUID) -> Dict[
         SubscriptionCustomerDescriptionTable.subscription_id == subscription_id
     ).all()
 
-    subscription = asdict(SubscriptionModel.from_subscription(subscription_id))
+    subscription = SubscriptionModel.from_subscription(subscription_id).dict()
 
     subscription["customer_descriptions"] = customer_descriptions
 

orchestrator/domain/base.py

@@ -12,16 +12,16 @@
 # limitations under the License.
 
 from collections import defaultdict
-from dataclasses import field
 from datetime import datetime
 from itertools import groupby, zip_longest
 from operator import attrgetter
-from typing import TYPE_CHECKING, Any, Callable, ClassVar, Dict, List, Optional, Set, Tuple, Type, TypeVar, Union
+from typing import Any, Callable, ClassVar, Dict, List, Optional, Set, Type, TypeVar, Union
 from uuid import UUID, uuid4
 
 import structlog
 from more_itertools import flatten, only
-from pydantic import ValidationError
+from pydantic import BaseModel, Field, ValidationError
+from pydantic.main import ModelMetaclass
 from pydantic.types import ConstrainedList
 from sqlalchemy import and_
 from sqlalchemy.orm import selectinload
@@ -35,19 +35,10 @@
     SubscriptionTable,
     db,
 )
-from orchestrator.domain.config import PydanticConfig
 from orchestrator.domain.lifecycle import ProductLifecycle, lookup_specialized_type, register_specialized_type
 from orchestrator.types import State, SubscriptionLifecycle, UUIDstr, is_list_type, is_of_type, is_optional_type
 from orchestrator.utils.docs import make_product_block_docstring, make_subscription_model_docstring
 
-if TYPE_CHECKING:
-    # Workaround for the fact that the pre-commit hook uses it's own env.
-    from dataclasses import dataclass
-else:
-    from pydantic.dataclasses import dataclass
-
-    DataclassType = Any
-
 logger = structlog.get_logger(__name__)
 
 
@@ -67,41 +58,22 @@ def _is_constrained_list_type(type: Type) -> bool:
 
 
 T = TypeVar("T")
-S = TypeVar("S", "SubscriptionModel", "SubscriptionModel")
-B = TypeVar("B", "ProductBlockModel", "ProductBlockModel")
-
-
-class DomainMeta(type):
-    __base_type__: "DomainMeta"
-
-    def __new__(metacls: Type[T], name: str, bases: Tuple[type, ...], namespace: Dict[str, Any], **kwds: Any) -> T:
-        """Create a new domain model type.
-
-        We make sure pydantic dataclasses are properly set up.
-
-        Each domain model is a pydantic dataclass. By calling it here we do
-        not require the decorator on every class definition.
-
-        Because of how python works just setting a field with a new annotation will not override
-        the runtime checks for that field by pydantic. We do that here explicitly using `dataclasses.field`
-        This has the desired effect of actually changing the validations
-        """
-        if name not in ("ProductBlockModel", "SubscriptionModel", "DomainModel"):
-            for field_name in namespace["__annotations__"]:
-                if field_name not in namespace:
-                    namespace[field_name] = field()
-
-        cls = super().__new__(metacls, name, bases, namespace, **kwds)  # type: ignore
-
-        return dataclass(cls, config=PydanticConfig)  # type: ignore
+S = TypeVar("S", bound="SubscriptionModel")
+B = TypeVar("B", bound="ProductBlockModel")
 
 
-class DomainModel(metaclass=DomainMeta):
+class DomainModel(BaseModel):
     """Base class for domain models.
 
     Contains all common Product block/Subscription instance code
     """
 
+    class Config:
+        validate_assignment = True
+        validate_all = True
+        arbitrary_types_allowed = True
+
+    __base_type__: ClassVar[Type["DomainModel"]]
     _product_block_fields_: ClassVar[Dict[str, Type]]
     _non_product_block_fields_: ClassVar[Dict[str, Type]]
 
@@ -328,7 +300,7 @@ def _save_instances(
         return saved_instances
 
 
-class ProductBlockModelMeta(DomainMeta):
+class ProductBlockModelMeta(ModelMetaclass):
     """Metaclass used to create product block instances.
 
     This metaclass is used to make sure the class contains product block metadata.
@@ -339,9 +311,13 @@ class ProductBlockModelMeta(DomainMeta):
     You can find some examples in: :ref:`domain-models`
     """
 
-    def __call__(  # type:ignore
-        self: Type[B], *args: Any, **kwargs: Any
-    ) -> B:
+    __names__: List[str]
+    name: str
+    product_block_id: UUID
+    description: str
+    tag: str
+
+    def __call__(self, *args: Any, **kwargs: Any) -> B:
 
         # Would have been nice to do this in __init_subclass__ but that runs outside the app context so we cant access the db
         # So now we do it just before we instantiate the instance
@@ -395,12 +371,8 @@ class ProductBlockModel(DomainModel, metaclass=ProductBlockModelMeta):
     description: ClassVar[str]
     tag: ClassVar[str]
 
-    # None of the fields defined here should have defaults.
-    # Python dataclasses prohibits subclasses dataclasses from using non-default fields when
-    # the superclass has a default field. To set a default add it to `new()`.
-    product_block_name: str
-    subscription_instance_id: UUID
-    label: Optional[str]
+    subscription_instance_id: UUID = Field(default_factory=uuid4)
+    label: Optional[str] = None
 
     def __init_subclass__(
         cls,
@@ -432,9 +404,7 @@ def new(cls: Type[B], **kwargs: Any) -> B:
         """
         sub_instances = cls._init_instances(list(kwargs.keys()))
 
-        return cls(  # type: ignore
-            subscription_instance_id=uuid4(), label=None, product_block_name=cls.name, **sub_instances, **kwargs
-        )
+        return cls(**sub_instances, **kwargs)  # type: ignore
 
     @classmethod
     def _load_instances_values(cls, instance_values: List[SubscriptionInstanceValueTable]) -> Dict[str, str]:
@@ -510,7 +480,6 @@ def from_db(
             return cls(  # type: ignore
                 subscription_instance_id=subscription_instance_id,
                 label=label,
-                product_block_name=cls.name,
                 **instance_values,
                 **sub_instances,
             )
@@ -688,10 +657,14 @@ def save(
         return children + [subscription_instance]
 
 
-@dataclass(config=PydanticConfig)  # type: ignore
-class ProductModel:
+class ProductModel(BaseModel):
     """Represent the product as defined in the database as a dataclass."""
 
+    class Config:
+        validate_assignment = True
+        validate_all = True
+        arbitrary_types_allowed = True
+
     product_id: UUID
     name: str
     description: str
@@ -700,7 +673,7 @@ class ProductModel:
     status: ProductLifecycle
 
 
-class SubscriptionModel(DomainModel, metaclass=DomainMeta):
+class SubscriptionModel(DomainModel):
     """Base class for all product subscription models.
 
     Define a subscription model:
@@ -725,18 +698,15 @@ class SubscriptionModel(DomainModel, metaclass=DomainMeta):
     >>> SubscriptionInactive.from_subscription(subscription_id)  # doctest:+SKIP
     """
 
-    # None of the fields defined here should have defaults.
-    # Python dataclasses prohibits subclasses dataclasses from using non-default fields when
-    # the superclass has a default field. To set a default add it to `from_product_id()`.
     product: ProductModel
     customer_id: UUID
-    subscription_id: UUID
-    description: str
-    status: SubscriptionLifecycle
-    insync: bool
-    start_date: Optional[datetime]
-    end_date: Optional[datetime]
-    note: Optional[str]
+    subscription_id: UUID = Field(default_factory=uuid4)
+    description: str = "Initial subscription"
+    status: SubscriptionLifecycle = SubscriptionLifecycle.INITIAL
+    insync: bool = False
+    start_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None
+    note: Optional[str] = None
 
     def __new__(cls, *args: Any, status: Optional[SubscriptionLifecycle] = None, **kwargs: Any) -> "SubscriptionModel":
 
@@ -777,7 +747,7 @@ def diff_product_in_database(cls, product_id: UUID) -> Dict[str, Any]:
             missing_fixed_inputs_in_model=missing_fixed_inputs_in_model,
         )
 
-        def find_product_block_in(cls: Type[Union[S, B]]) -> List[ProductBlockModel]:
+        def find_product_block_in(cls: Type[DomainModel]) -> List[ProductBlockModel]:
             product_blocks_in_model = []
             for product_block_field_type in cls._product_block_fields_.values():
                 if is_list_type(product_block_field_type) or is_optional_type(product_block_field_type):
@@ -866,12 +836,12 @@ def from_product_id(
         # Caller wants a new instance and provided a product_id and customer_id
         product_db = ProductTable.query.get(product_id)
         product = ProductModel(
-            product_db.product_id,
-            product_db.name,
-            product_db.description,
-            product_db.product_type,
-            product_db.tag,
-            product_db.status,
+            product_id=product_db.product_id,
+            name=product_db.name,
+            description=product_db.description,
+            product_type=product_db.product_type,
+            tag=product_db.tag,
+            status=product_db.status,
         )
 
         if description is None:
@@ -881,15 +851,14 @@ def from_product_id(
         instances = cls._init_instances()
 
         return cls(
-            product,
-            customer_id,
-            uuid4(),
-            description,
-            status,
-            insync,
-            start_date,
-            end_date,
-            note,
+            product=product,
+            customer_id=customer_id,  # type:ignore
+            description=description,
+            status=status,
+            insync=insync,
+            start_date=start_date,
+            end_date=end_date,
+            note=note,
             **fixed_inputs,
             **instances,
         )
@@ -905,12 +874,12 @@ def from_subscription(cls: Type[S], subscription_id: Union[UUID, UUIDstr]) -> S:
             selectinload(SubscriptionTable.instances).selectinload(SubscriptionInstanceTable.values),
         ).get(subscription_id)
         product = ProductModel(
-            subscription.product.product_id,
-            subscription.product.name,
-            subscription.product.description,
-            subscription.product.product_type,
-            subscription.product.tag,
-            subscription.product.status,
+            product_id=subscription.product.product_id,
+            name=subscription.product.name,
+            description=subscription.product.description,
+            product_type=subscription.product.product_type,
+            tag=subscription.product.tag,
+            status=subscription.product.status,
         )
         status = SubscriptionLifecycle(subscription.status)
 
@@ -920,7 +889,7 @@ def from_subscription(cls: Type[S], subscription_id: Union[UUID, UUIDstr]) -> S:
             # Import here to prevent cyclic imports
             from orchestrator.domain import SUBSCRIPTION_MODEL_REGISTRY
 
-            cls = SUBSCRIPTION_MODEL_REGISTRY.get(subscription.product.name, cls)
+            cls = SUBSCRIPTION_MODEL_REGISTRY.get(subscription.product.name, cls)  # type:ignore
             cls = lookup_specialized_type(cls, status)
             if cls != old_cls and not issubclass(cls, old_cls):
                 raise ValueError(
@@ -931,16 +900,16 @@ def from_subscription(cls: Type[S], subscription_id: Union[UUID, UUIDstr]) -> S:
         instances = cls._load_instances(subscription.instances, status)
 
         try:
-            return cls(
-                product,
-                subscription.customer_id,
-                subscription_id,
-                subscription.description,
-                status,
-                subscription.insync,
-                subscription.start_date,
-                subscription.end_date,
-                subscription.note,
+            return cls(  # type: ignore
+                product=product,
+                customer_id=subscription.customer_id,
+                subscription_id=subscription_id,  # type:ignore
+                description=subscription.description,
+                status=status,
+                insync=subscription.insync,
+                start_date=subscription.start_date,
+                end_date=subscription.end_date,
+                note=subscription.note,
                 **fixed_inputs,
                 **instances,
             )

orchestrator/domain/config.py

@@ -11,12 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from dataclasses import asdict
 from typing import Dict, List, Optional, Tuple, Type, TypeVar
 
 import structlog
 
-from orchestrator.types import SubscriptionLifecycle, is_list_type, is_optional_type, strEnum
+from orchestrator.types import SubscriptionLifecycle, strEnum
 from orchestrator.utils.datetime import nowtz
 
 logger = structlog.get_logger(__name__)
@@ -57,21 +56,12 @@ def lookup_specialized_type(block: Type, lifecycle: Optional[SubscriptionLifecyc
 
 def change_lifecycle(subscription: T, status: SubscriptionLifecycle) -> T:
     new_klass = lookup_specialized_type(subscription.__class__, status)
-    data = asdict(subscription)
+    data = subscription.dict()  # type:ignore
 
     data["status"] = status
     if data["start_date"] is None and status == SubscriptionLifecycle.ACTIVE:
         data["start_date"] = nowtz()
     if data["end_date"] is None and status == SubscriptionLifecycle.TERMINATED:
         data["end_date"] = nowtz()
 
-    for product_block_field_name, product_block_field_type in new_klass._product_block_fields_.items():
-        current = getattr(subscription, product_block_field_name)
-        if is_list_type(product_block_field_type):
-            data[product_block_field_name] = [asdict(item) for item in current]
-        elif is_optional_type(product_block_field_type) and current is None:
-            data[product_block_field_name] = None
-        else:
-            data[product_block_field_name] = asdict(current)
-
     return new_klass(**data)