eventsourcing 9.3.3__py3-none-any.whl → 9.3.5__py3-none-any.whl

eventsourcing/examples/cargoshipping/application.py

@@ -1,126 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Dict, List, cast
-
-from eventsourcing.application import Application
-from eventsourcing.examples.cargoshipping.domainmodel import (
-    REGISTERED_ROUTES,
-    Cargo,
-    HandlingActivity,
-    Itinerary,
-    Leg,
-    Location,
-)
-from eventsourcing.persistence import Transcoder, Transcoding
-
-if TYPE_CHECKING:  # pragma: nocover
-    from datetime import datetime
-    from uuid import UUID
-
-
-class LocationAsName(Transcoding):
-    type = Location
-    name = "location"
-
-    def encode(self, obj: Location) -> str:
-        return obj.name
-
-    def decode(self, data: str) -> Location:
-        assert isinstance(data, str)
-        return Location[data]
-
-
-class HandlingActivityAsName(Transcoding):
-    type = HandlingActivity
-    name = "handling_activity"
-
-    def encode(self, obj: HandlingActivity) -> str:
-        return obj.name
-
-    def decode(self, data: str) -> HandlingActivity:
-        assert isinstance(data, str)
-        return HandlingActivity[data]
-
-
-class ItineraryAsDict(Transcoding):
-    type = Itinerary
-    name = "itinerary"
-
-    def encode(self, obj: Itinerary) -> Dict[str, Any]:
-        return obj.__dict__
-
-    def decode(self, data: Dict[str, Any]) -> Itinerary:
-        assert isinstance(data, dict)
-        return Itinerary(**data)
-
-
-class LegAsDict(Transcoding):
-    type = Leg
-    name = "leg"
-
-    def encode(self, obj: Leg) -> Dict[str, Any]:
-        return obj.__dict__
-
-    def decode(self, data: Dict[str, Any]) -> Leg:
-        assert isinstance(data, dict)
-        return Leg(**data)
-
-
-class BookingApplication(Application):
-    def register_transcodings(self, transcoder: Transcoder) -> None:
-        super().register_transcodings(transcoder)
-        transcoder.register(LocationAsName())
-        transcoder.register(HandlingActivityAsName())
-        transcoder.register(ItineraryAsDict())
-        transcoder.register(LegAsDict())
-
-    def book_new_cargo(
-        self,
-        origin: Location,
-        destination: Location,
-        arrival_deadline: datetime,
-    ) -> UUID:
-        cargo = Cargo.new_booking(origin, destination, arrival_deadline)
-        self.save(cargo)
-        return cargo.id
-
-    def change_destination(self, tracking_id: UUID, destination: Location) -> None:
-        cargo = self.get_cargo(tracking_id)
-        cargo.change_destination(destination)
-        self.save(cargo)
-
-    def request_possible_routes_for_cargo(self, tracking_id: UUID) -> List[Itinerary]:
-        cargo = self.get_cargo(tracking_id)
-        from_location = (cargo.last_known_location or cargo.origin).value
-        to_location = cargo.destination.value
-        try:
-            possible_routes = REGISTERED_ROUTES[(from_location, to_location)]
-        except KeyError:
-            msg = f"Can't find routes from {from_location} to {to_location}"
-            raise ValueError(msg) from None
-
-        return possible_routes
-
-    def assign_route(self, tracking_id: UUID, itinerary: Itinerary) -> None:
-        cargo = self.get_cargo(tracking_id)
-        cargo.assign_route(itinerary)
-        self.save(cargo)
-
-    def register_handling_event(
-        self,
-        tracking_id: UUID,
-        voyage_number: str | None,
-        location: Location,
-        handing_activity: HandlingActivity,
-    ) -> None:
-        cargo = self.get_cargo(tracking_id)
-        cargo.register_handling_event(
-            tracking_id,
-            voyage_number,
-            location,
-            handing_activity,
-        )
-        self.save(cargo)
-
-    def get_cargo(self, tracking_id: UUID) -> Cargo:
-        return cast(Cargo, self.repository.get(tracking_id))

eventsourcing/examples/cargoshipping/domainmodel.py

@@ -1,330 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta
-from enum import Enum
-from typing import Dict, List, Optional, Tuple, Union, cast
-from uuid import UUID, uuid4
-
-from eventsourcing.dispatch import singledispatchmethod
-from eventsourcing.domain import Aggregate
-
-
-class Location(Enum):
-    """
-    Locations in the world.
-    """
-
-    HAMBURG = "HAMBURG"
-    HONGKONG = "HONGKONG"
-    NEWYORK = "NEWYORK"
-    STOCKHOLM = "STOCKHOLM"
-    TOKYO = "TOKYO"
-
-    NLRTM = "NLRTM"
-    USDAL = "USDAL"
-    AUMEL = "AUMEL"
-
-
-class Leg:
-    """
-    Leg of an itinerary.
-    """
-
-    def __init__(
-        self,
-        origin: str,
-        destination: str,
-        voyage_number: str,
-    ):
-        self.origin: str = origin
-        self.destination: str = destination
-        self.voyage_number: str = voyage_number
-
-
-class Itinerary:
-    """
-    An itinerary along which cargo is shipped.
-    """
-
-    def __init__(
-        self,
-        origin: str,
-        destination: str,
-        legs: Tuple[Leg, ...],
-    ):
-        self.origin = origin
-        self.destination = destination
-        self.legs = legs
-
-
-class HandlingActivity(Enum):
-    RECEIVE = "RECEIVE"
-    LOAD = "LOAD"
-    UNLOAD = "UNLOAD"
-    CLAIM = "CLAIM"
-
-
-# Custom static types.
-LegDetails = Dict[str, str]
-
-ItineraryDetails = Dict[str, Union[str, List[LegDetails]]]
-
-NextExpectedActivity = Optional[Tuple[HandlingActivity, Location, str]]
-
-
-# Some routes from one location to another.
-REGISTERED_ROUTES = {
-    ("HONGKONG", "STOCKHOLM"): [
-        Itinerary(
-            origin="HONGKONG",
-            destination="STOCKHOLM",
-            legs=(
-                Leg(
-                    origin="HONGKONG",
-                    destination="NEWYORK",
-                    voyage_number="V1",
-                ),
-                Leg(
-                    origin="NEWYORK",
-                    destination="STOCKHOLM",
-                    voyage_number="V2",
-                ),
-            ),
-        )
-    ],
-    ("TOKYO", "STOCKHOLM"): [
-        Itinerary(
-            origin="TOKYO",
-            destination="STOCKHOLM",
-            legs=(
-                Leg(
-                    origin="TOKYO",
-                    destination="HAMBURG",
-                    voyage_number="V3",
-                ),
-                Leg(
-                    origin="HAMBURG",
-                    destination="STOCKHOLM",
-                    voyage_number="V4",
-                ),
-            ),
-        )
-    ],
-}
-
-
-class Cargo(Aggregate):
-    """
-    The Cargo aggregate is an event-sourced domain model aggregate that
-    specifies the routing from origin to destination, and can track what
-    happens to the cargo after it has been booked.
-    """
-
-    def __init__(
-        self,
-        origin: Location,
-        destination: Location,
-        arrival_deadline: datetime,
-    ):
-        self._origin: Location = origin
-        self._destination: Location = destination
-        self._arrival_deadline: datetime = arrival_deadline
-        self._transport_status: str = "NOT_RECEIVED"
-        self._routing_status: str = "NOT_ROUTED"
-        self._is_misdirected: bool = False
-        self._estimated_time_of_arrival: datetime | None = None
-        self._next_expected_activity: NextExpectedActivity = None
-        self._route: Itinerary | None = None
-        self._last_known_location: Location | None = None
-        self._current_voyage_number: str | None = None
-
-    @property
-    def origin(self) -> Location:
-        return self._origin
-
-    @property
-    def destination(self) -> Location:
-        return self._destination
-
-    @property
-    def arrival_deadline(self) -> datetime:
-        return self._arrival_deadline
-
-    @property
-    def transport_status(self) -> str:
-        return self._transport_status
-
-    @property
-    def routing_status(self) -> str:
-        return self._routing_status
-
-    @property
-    def is_misdirected(self) -> bool:
-        return self._is_misdirected
-
-    @property
-    def estimated_time_of_arrival(
-        self,
-    ) -> datetime | None:
-        return self._estimated_time_of_arrival
-
-    @property
-    def next_expected_activity(self) -> NextExpectedActivity:
-        return self._next_expected_activity
-
-    @property
-    def route(self) -> Itinerary | None:
-        return self._route
-
-    @property
-    def last_known_location(self) -> Location | None:
-        return self._last_known_location
-
-    @property
-    def current_voyage_number(self) -> str | None:
-        return self._current_voyage_number
-
-    @classmethod
-    def new_booking(
-        cls,
-        origin: Location,
-        destination: Location,
-        arrival_deadline: datetime,
-    ) -> Cargo:
-        return cls._create(
-            event_class=cls.BookingStarted,
-            id=uuid4(),
-            origin=origin,
-            destination=destination,
-            arrival_deadline=arrival_deadline,
-        )
-
-    class BookingStarted(Aggregate.Created):
-        origin: Location
-        destination: Location
-        arrival_deadline: datetime
-
-    class Event(Aggregate.Event):
-        def apply(self, aggregate: Aggregate) -> None:
-            cast(Cargo, aggregate).when(self)
-
-    @singledispatchmethod
-    def when(self, event: Event) -> None:
-        """
-        Default method to apply an aggregate event to the aggregate object.
-        """
-
-    def change_destination(self, destination: Location) -> None:
-        self.trigger_event(
-            self.DestinationChanged,
-            destination=destination,
-        )
-
-    class DestinationChanged(Event):
-        destination: Location
-
-    @when.register
-    def _(self, event: Cargo.DestinationChanged) -> None:
-        self._destination = event.destination
-
-    def assign_route(self, itinerary: Itinerary) -> None:
-        self.trigger_event(self.RouteAssigned, route=itinerary)
-
-    class RouteAssigned(Event):
-        route: Itinerary
-
-    @when.register
-    def _(self, event: Cargo.RouteAssigned) -> None:
-        self._route = event.route
-        self._routing_status = "ROUTED"
-        self._estimated_time_of_arrival = Cargo.Event.create_timestamp() + timedelta(
-            weeks=1
-        )
-        self._next_expected_activity = (HandlingActivity.RECEIVE, self.origin, "")
-        self._is_misdirected = False
-
-    def register_handling_event(
-        self,
-        tracking_id: UUID,
-        voyage_number: str | None,
-        location: Location,
-        handling_activity: HandlingActivity,
-    ) -> None:
-        self.trigger_event(
-            self.HandlingEventRegistered,
-            tracking_id=tracking_id,
-            voyage_number=voyage_number,
-            location=location,
-            handling_activity=handling_activity,
-        )
-
-    class HandlingEventRegistered(Event):
-        tracking_id: UUID
-        voyage_number: str
-        location: Location
-        handling_activity: str
-
-    @when.register
-    def _(self, event: Cargo.HandlingEventRegistered) -> None:
-        assert self.route is not None
-        if event.handling_activity == HandlingActivity.RECEIVE:
-            self._transport_status = "IN_PORT"
-            self._last_known_location = event.location
-            self._next_expected_activity = (
-                HandlingActivity.LOAD,
-                event.location,
-                self.route.legs[0].voyage_number,
-            )
-        elif event.handling_activity == HandlingActivity.LOAD:
-            self._transport_status = "ONBOARD_CARRIER"
-            self._current_voyage_number = event.voyage_number
-            for leg in self.route.legs:
-                if (
-                    leg.origin == event.location.value
-                    and leg.voyage_number == event.voyage_number
-                ):
-                    self._next_expected_activity = (
-                        HandlingActivity.UNLOAD,
-                        Location[leg.destination],
-                        event.voyage_number,
-                    )
-                    break
-            else:
-                msg = "Can't find leg with origin={} and voyage_number={}".format(
-                    event.location,
-                    event.voyage_number,
-                )
-                raise Exception(msg)
-
-        elif event.handling_activity == HandlingActivity.UNLOAD:
-            self._current_voyage_number = None
-            self._last_known_location = event.location
-            self._transport_status = "IN_PORT"
-            if event.location == self.destination:
-                self._next_expected_activity = (
-                    HandlingActivity.CLAIM,
-                    event.location,
-                    "",
-                )
-            elif event.location.value in [leg.destination for leg in self.route.legs]:
-                for i, leg in enumerate(self.route.legs):
-                    if leg.voyage_number == event.voyage_number:
-                        next_leg: Leg = self.route.legs[i + 1]
-                        assert Location[next_leg.origin] == event.location
-                        self._next_expected_activity = (
-                            HandlingActivity.LOAD,
-                            event.location,
-                            next_leg.voyage_number,
-                        )
-                        break
-            else:
-                self._is_misdirected = True
-                self._next_expected_activity = None
-
-        elif event.handling_activity == HandlingActivity.CLAIM:
-            self._next_expected_activity = None
-            self._transport_status = "CLAIMED"
-
-        else:
-            msg = f"Unsupported handling event: {event.handling_activity}"
-            raise Exception(msg)

eventsourcing/examples/cargoshipping/interface.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
-from uuid import UUID
-
-from eventsourcing.examples.cargoshipping.domainmodel import (
-    HandlingActivity,
-    Itinerary,
-    ItineraryDetails,
-    LegDetails,
-    Location,
-)
-
-if TYPE_CHECKING:  # pragma: nocover
-    from eventsourcing.examples.cargoshipping.application import BookingApplication
-
-NextExpectedActivityDetails = Optional[Tuple[str, ...]]
-CargoDetails = Dict[
-    str, Optional[Union[str, bool, datetime, NextExpectedActivityDetails]]
-]
-
-
-class BookingService:
-    """
-    Presents an application interface that uses
-    simple types of object (str, bool, datetime).
-    """
-
-    def __init__(self, app: BookingApplication):
-        self.app = app
-
-    def book_new_cargo(
-        self,
-        origin: str,
-        destination: str,
-        arrival_deadline: datetime,
-    ) -> str:
-        tracking_id = self.app.book_new_cargo(
-            Location[origin],
-            Location[destination],
-            arrival_deadline,
-        )
-        return str(tracking_id)
-
-    def get_cargo_details(self, tracking_id: str) -> CargoDetails:
-        cargo = self.app.get_cargo(UUID(tracking_id))
-
-        # Present 'next_expected_activity'.
-        next_expected_activity: NextExpectedActivityDetails
-        if cargo.next_expected_activity is None:
-            next_expected_activity = None
-        elif len(cargo.next_expected_activity) == 2:
-            next_expected_activity = (
-                cargo.next_expected_activity[0].value,
-                cargo.next_expected_activity[1].value,
-            )
-        elif len(cargo.next_expected_activity) == 3:
-            next_expected_activity = (
-                cargo.next_expected_activity[0].value,
-                cargo.next_expected_activity[1].value,
-                cargo.next_expected_activity[2],
-            )
-        else:
-            msg = f"Invalid next expected activity: {cargo.next_expected_activity}"
-            raise Exception(msg)
-
-        # Present 'last_known_location'.
-        if cargo.last_known_location is None:
-            last_known_location = None
-        else:
-            last_known_location = cargo.last_known_location.value
-
-        # Present the cargo details.
-        return {
-            "id": str(cargo.id),
-            "origin": cargo.origin.value,
-            "destination": cargo.destination.value,
-            "arrival_deadline": cargo.arrival_deadline,
-            "transport_status": cargo.transport_status,
-            "routing_status": cargo.routing_status,
-            "is_misdirected": cargo.is_misdirected,
-            "estimated_time_of_arrival": cargo.estimated_time_of_arrival,
-            "next_expected_activity": next_expected_activity,
-            "last_known_location": last_known_location,
-            "current_voyage_number": cargo.current_voyage_number,
-        }
-
-    def change_destination(self, tracking_id: str, destination: str) -> None:
-        self.app.change_destination(UUID(tracking_id), Location[destination])
-
-    def request_possible_routes_for_cargo(
-        self, tracking_id: str
-    ) -> List[ItineraryDetails]:
-        routes = self.app.request_possible_routes_for_cargo(UUID(tracking_id))
-        return [self.dict_from_itinerary(route) for route in routes]
-
-    def dict_from_itinerary(self, itinerary: Itinerary) -> ItineraryDetails:
-        legs_details = []
-        for leg in itinerary.legs:
-            leg_details: LegDetails = {
-                "origin": leg.origin,
-                "destination": leg.destination,
-                "voyage_number": leg.voyage_number,
-            }
-            legs_details.append(leg_details)
-        route_details: ItineraryDetails = {
-            "origin": itinerary.origin,
-            "destination": itinerary.destination,
-            "legs": legs_details,
-        }
-        return route_details
-
-    def assign_route(
-        self,
-        tracking_id: str,
-        route_details: ItineraryDetails,
-    ) -> None:
-        routes = self.app.request_possible_routes_for_cargo(UUID(tracking_id))
-        for route in routes:
-            if route_details == self.dict_from_itinerary(route):
-                self.app.assign_route(UUID(tracking_id), route)
-
-    def register_handling_event(
-        self,
-        tracking_id: str,
-        voyage_number: str | None,
-        location: str,
-        handling_activity: str,
-    ) -> None:
-        self.app.register_handling_event(
-            UUID(tracking_id),
-            voyage_number,
-            Location[location],
-            HandlingActivity[handling_activity],
-        )
-
-
-# Stub function that picks an itinerary from a list of possible itineraries.
-def select_preferred_itinerary(
-    itineraries: List[ItineraryDetails],
-) -> ItineraryDetails:
-    return itineraries[0]