* Now using "self.__iter__(...)" instead of "self.as_dict()" method. #49

jinete/algorithms/utils/breeders/flips.py

@@ -13,7 +13,7 @@
 class FlipBreeder(Breeder):
 
     def improve(self) -> Result:
-        for route in self.planning:
+        for route in self.planning.routes:
             cost = self.objective.optimization_function(route)
 
             for i in range(1, len(route.stops) - 1):

jinete/models/abc.py

@@ -1,15 +1,27 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
-from typing import Any, Dict
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import (
+        Any,
+        Generator,
+        Tuple,
+    )
 
 
 class Model(ABC):
     def __repr__(self):
-        return self._print(self.as_dict())
+        return self._print(dict(self))
 
     def _print(self, values):
         values = ', '.join(f'{key}={value}' for key, value in values.items())
         return f'{self.__class__.__name__}({values})'
 
+    def _print_key_value(self, key: str, value: Any):
+        return f'{key}={value}'
+
     @abstractmethod
-    def as_dict(self) -> Dict[str, Any]:
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
         pass

jinete/models/jobs.py

@@ -14,7 +14,8 @@
     from typing import (
         Set,
         Any,
-        Dict,
+        Generator,
+        Tuple,
         Type,
         Optional,
     )
@@ -45,16 +46,11 @@ def objective(self) -> Objective:
             self._objective = self.objective_cls(*self.args, **self.kwargs)
         return self._objective
 
-    def __iter__(self):
-        yield from self.trips
-
     def __deepcopy__(self, memo) -> Job:
         return self
 
-    def as_dict(self) -> Dict[str, Any]:
-        trips_str = ', '.join(str(trip) for trip in self.trips)
-        dict_values = {
-            'trips': f'{{{trips_str}}}',
-            'objective': self.objective,
-        }
-        return dict_values
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('trip_identifiers', tuple(trip.identifier for trip in self.trips)),
+            ('objective', self.objective),
+        )

jinete/models/objectives.py

@@ -65,7 +65,7 @@ def _result_optimization_function(self, result: Result) -> float:
 
     def _planning_optimization_function(self, planning: Planning) -> float:
         scoring = 0.0
-        for route in planning:
+        for route in planning.routes:
             scoring += self._route_optimization_function(route)
         return scoring
 

jinete/models/planned_trips.py

@@ -14,9 +14,10 @@
 
 if TYPE_CHECKING:
     from typing import (
-        Dict,
         Any,
         Optional,
+        Generator,
+        Tuple,
     )
     from uuid import (
         UUID,
@@ -113,15 +114,15 @@ def feasible(self) -> bool:
     def empty(self) -> bool:
         return self.trip.empty
 
-    def as_dict(self) -> Dict[str, Any]:
-        return {
-            'route_uuid': self.route_uuid,
-            'trip_identifier': self.trip_identifier,
-            'pickup': self.pickup,
-            'delivery': self.delivery,
-            'down_time': self.down_time,
-            'feasible': self.feasible,
-        }
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('route_uuid', self.route_uuid),
+            ('trip_identifier', self.trip_identifier),
+            ('pickup', self.pickup),
+            ('delivery', self.delivery),
+            ('down_time', self.down_time),
+            ('feasible', self.feasible),
+        )
 
     def flush(self) -> None:
         self._feasible = None

jinete/models/plannings.py

@@ -16,6 +16,8 @@
         Dict,
         Any,
         Iterator,
+        Generator,
+        Tuple,
     )
     from .routes import (
         Route,
@@ -46,9 +48,6 @@ def __init__(self, routes: Set[Route] = None, uuid: UUID = None):
         self.routes = routes
         self.uuid = uuid
 
-    def __iter__(self):
-        yield from self.routes
-
     @property
     def loaded_routes(self):
         return set(route for route in self.routes if route.loaded)
@@ -62,10 +61,11 @@ def planned_trips(self) -> Iterator[PlannedTrip]:
     def trips(self) -> Iterator[Trip]:
         yield from (planned_trip.trip for planned_trip in self.planned_trips)
 
-    def as_dict(self) -> Dict[str, Any]:
-        return {
-            'uuid': self.uuid,
-        }
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('uuid', self.uuid),
+            ('route_uuids', tuple(route.uuid for route in self.routes))
+        )
 
     def __deepcopy__(self, memo: Dict[int, Any]) -> Planning:
         planning = Planning()

jinete/models/positions.py

@@ -3,15 +3,21 @@
 import logging
 from abc import (
     ABC,
+    abstractmethod,
 )
 from typing import (
     TYPE_CHECKING,
 )
 
+from .abc import (
+    Model,
+)
+
 if TYPE_CHECKING:
     from typing import (
         Tuple,
         Sequence,
+        Generator,
         Dict,
         Any,
     )
@@ -22,16 +28,18 @@
 logger = logging.getLogger(__name__)
 
 
-class Position(ABC):
+class Position(Model, ABC):
     def __init__(self, surface: Surface):
         self.surface = surface
 
-    def __eq__(self, other):
-        return hash(self) == hash(other)
-
     def distance_to(self, other: Position) -> float:
         return self.surface.distance(self, other)
 
+    @property
+    @abstractmethod
+    def coordinates(self) -> Tuple[Any]:
+        pass
+
     def time_to(self, other: Position, now: float = None) -> float:
         return self.surface.time(self, other, now=now)
 
@@ -59,8 +67,13 @@ def __eq__(self, other) -> bool:
     def __ne__(self, other) -> bool:
         return self.coordinates != other.coordinates
 
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('coordinates', self.coordinates),
+        )
+
     def __str__(self):
-        c = ",".join(f"{x:07.3f}" for x in self)
+        c = ",".join(f"{x:07.3f}" for x in self.coordinates)
         return f'({c})'
 
     def __getitem__(self, item):

jinete/models/routes.py

@@ -27,6 +27,8 @@
         Dict,
         Optional,
         Iterable,
+        Generator,
+        Tuple,
     )
     from uuid import (
         UUID,
@@ -64,9 +66,6 @@ def __init__(self, vehicle: Vehicle, stops: List[Stop] = None, uuid: UUID = None
         else:
             self.stops = list(stops)
 
-    def __iter__(self):
-        yield from self.planned_trips
-
     def __deepcopy__(self, memo: Dict[int, Any]) -> Route:
         vehicle = deepcopy(self.vehicle, memo)
 
@@ -174,16 +173,17 @@ def last_stop(self) -> Stop:
         return stop
 
     @property
-    def vehicle_uuid(self) -> Optional[UUID]:
+    def vehicle_identifier(self) -> Optional[str]:
         if self.vehicle is None:
             return None
-        return self.vehicle.uuid
-
-    def as_dict(self) -> Dict[str, Any]:
-        return {
-            'uuid': self.uuid,
-            'vehicle_uuid': self.vehicle_uuid,
-        }
+        return self.vehicle.identifier
+
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('uuid', self.uuid),
+            ('vehicle_identifier', self.vehicle_identifier),
+            ('trip_identifiers', tuple(trip.identifier for trip in self.trips))
+        )
 
     def conjecture_trip(self, trip: Trip) -> PlannedTrip:
         pickup = Stop(self, trip.origin_position, self.last_stop)

jinete/models/services.py

@@ -15,6 +15,8 @@
     from typing import (
         Dict,
         Any,
+        Generator,
+        Tuple,
     )
     from .positions import (
         Position,
@@ -50,17 +52,14 @@ def __eq__(self, other: Service) -> bool:
     def __hash__(self):
         return hash(tuple(self))
 
-    def __iter__(self):
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
         yield from (
             ('position', self.position),
             ('earliest', self.earliest),
             ('latest', self.latest),
             ('duration', self.duration),
         )
 
-    def as_dict(self) -> Dict[str, Any]:
-        return dict(self)
-
     def distance_to(self, other: Service) -> float:
         return self.position.distance_to(other.position)
 

jinete/models/stops.py

@@ -9,15 +9,12 @@
 )
 
 if TYPE_CHECKING:
-    from uuid import (
-        UUID,
-    )
     from typing import (
-        Dict,
+        Generator,
+        Tuple,
         Any,
         Optional,
         Iterable,
-        Tuple,
         List,
     )
     from .positions import (
@@ -131,10 +128,6 @@ def load_time(self) -> float:
     def vehicle(self) -> Vehicle:
         return self.route.vehicle
 
-    @property
-    def vehicle_uuid(self) -> UUID:
-        return self.vehicle.uuid
-
     @property
     def stops(self) -> List[Stop]:
         return self.route.stops
@@ -180,11 +173,11 @@ def arrival_time(self):
     def departure_time(self) -> float:
         return self.arrival_time + self.load_time
 
-    def as_dict(self) -> Dict[str, Any]:
-        return {
-            'vehicle_uuid': self.vehicle_uuid,
-            'position': self.position,
-        }
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('route_uuid', self.route.uuid),
+            ('position', self.position),
+        )
 
     def flush(self) -> None:
         self._down_time = None

jinete/models/surfaces.py

@@ -28,6 +28,8 @@
         Set,
         Any,
         Dict,
+        Generator,
+        Tuple,
     )
     from uuid import (
         UUID,
@@ -69,12 +71,10 @@ def distance(self, position_a: Position, position_b: Position) -> float:
     def time(self, position_a: Position, position_b: Position, **kwargs) -> float:
         pass
 
-    def as_dict(self) -> Dict[str, Any]:
-        positions_str = ', '.join(str(position) for position in self.positions)
-        dict_values = {
-            'positions': f'{{{positions_str}}}'
-        }
-        return dict_values
+    def __iter__(self) -> Generator[Tuple[str, Any], None, None]:
+        yield from (
+            ('position_coordinates', tuple(position.coordinates for position in self.positions)),
+        )
 
 
 class GeometricSurface(Surface):
@@ -93,7 +93,7 @@ def distance(self, position_a: Position, position_b: Position) -> float:
         try:
             distance = self.cached_distance[position_a][position_b]
         except KeyError:
-            distance = self.metric(position_a, position_b)
+            distance = self.metric(position_a.coordinates, position_b.coordinates)
             self.cached_distance[position_a][position_b] = distance
 
         return distance