carconnectivity-plugin-database 0.1__py3-none-any.whl → 0.1a16__py3-none-any.whl

carconnectivity_plugins/database/agents/trip_agent.py

@@ -22,7 +22,6 @@ if TYPE_CHECKING:
 
     from carconnectivity.attributes import EnumAttribute, FloatAttribute
 
-    from carconnectivity_plugins.database.plugin import Plugin
     from carconnectivity_plugins.database.model.vehicle import Vehicle
 
 LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.agents.trip_agent")
@@ -41,7 +40,7 @@ class TripAgent(BaseAgent):
             of the vehicle to detect state transitions.
         trip (Optional[Trip]): The currently active trip, if any.
     Raises:
-        ValueError: If vehicle or self.carconnectivity_vehicle is None during initialization.
+        ValueError: If vehicle or vehicle.carconnectivity_vehicle is None during initialization.
     Notes:
         - A new trip is started when the vehicle transitions to IGNITION_ON or DRIVING state.
         - A trip is ended when the vehicle transitions from IGNITION_ON/DRIVING to another state.
@@ -50,14 +49,11 @@ class TripAgent(BaseAgent):
         - Trip records include start/end dates and odometer readings when available.
     """
 
-    def __init__(self, database_plugin: Plugin, session_factory: scoped_session[Session], vehicle: Vehicle, carconnectivity_vehicle: GenericVehicle) -> None:
-        if vehicle is None or carconnectivity_vehicle is None:
+    def __init__(self, session_factory: scoped_session[Session], vehicle: Vehicle) -> None:
+        if vehicle is None or vehicle.carconnectivity_vehicle is None:
             raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
-        self.database_plugin: Plugin = database_plugin
         self.session_factory: scoped_session[Session] = session_factory
         self.vehicle: Vehicle = vehicle
-        self.carconnectivity_vehicle: GenericVehicle = carconnectivity_vehicle
-
         self.last_carconnectivity_state: Optional[GenericVehicle.State] = None
         self.last_parked_position_latitude: Optional[float] = None
         self.last_parked_position_longitude: Optional[float] = None
@@ -71,19 +67,19 @@ class TripAgent(BaseAgent):
                     LOG.info("Last trip for vehicle %s is still open during startup, closing it now", vehicle.vin)
         self.session_factory.remove()
 
-        self.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
-        self.__on_state_change(self.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
+        vehicle.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
+        self.__on_state_change(vehicle.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
 
-        self.carconnectivity_vehicle.position.latitude.add_observer(self._on_position_latitude_change, Observable.ObserverEvent.UPDATED)
-        self._on_position_latitude_change(self.carconnectivity_vehicle.position.latitude, Observable.ObserverEvent.UPDATED)
+        vehicle.carconnectivity_vehicle.position.latitude.add_observer(self._on_position_latitude_change, Observable.ObserverEvent.UPDATED)
+        self._on_position_latitude_change(vehicle.carconnectivity_vehicle.position.latitude, Observable.ObserverEvent.UPDATED)
 
-        self.carconnectivity_vehicle.position.longitude.add_observer(self._on_position_longitude_change, Observable.ObserverEvent.UPDATED)
-        self._on_position_longitude_change(self.carconnectivity_vehicle.position.longitude, Observable.ObserverEvent.UPDATED)
+        vehicle.carconnectivity_vehicle.position.longitude.add_observer(self._on_position_longitude_change, Observable.ObserverEvent.UPDATED)
+        self._on_position_longitude_change(vehicle.carconnectivity_vehicle.position.longitude, Observable.ObserverEvent.UPDATED)
 
     def __on_state_change(self, element: EnumAttribute[GenericVehicle.State], flags: Observable.ObserverEvent) -> None:
         del flags
         if element.enabled:
-            if self.carconnectivity_vehicle is None:
+            if self.vehicle.carconnectivity_vehicle is None:
                 raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
             if element.enabled and element.value is not None:
                 if self.last_carconnectivity_state is not None:
@@ -101,9 +97,9 @@ class TripAgent(BaseAgent):
                                 LOG.info("Starting new trip for vehicle %s", self.vehicle.vin)
                                 start_date: datetime = element.last_updated if element.last_updated is not None else datetime.now(tz=timezone.utc)
                                 new_trip: Trip = Trip(vin=self.vehicle.vin, start_date=start_date)
-                                if self.carconnectivity_vehicle.odometer.enabled and \
-                                        self.carconnectivity_vehicle.odometer.value is not None:
-                                    new_trip.start_odometer = self.carconnectivity_vehicle.odometer.value
+                                if self.vehicle.carconnectivity_vehicle.odometer.enabled and \
+                                        self.vehicle.carconnectivity_vehicle.odometer.value is not None:
+                                    new_trip.start_odometer = self.vehicle.carconnectivity_vehicle.odometer.value
                                 if not self._update_trip_position(session=session, trip=new_trip, start=True):
                                     # if now no position is available try the last known position that is not older than 5min
                                     if self.last_parked_position_latitude is not None and self.last_parked_position_longitude is not None \
@@ -120,16 +116,15 @@ class TripAgent(BaseAgent):
                                 except DatabaseError as err:
                                     session.rollback()
                                     LOG.error('DatabaseError while adding trip for vehicle %s to database: %s', self.vehicle.vin, err)
-                                    self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                             elif self.last_carconnectivity_state in (GenericVehicle.State.IGNITION_ON, GenericVehicle.State.DRIVING) \
                                     and element.value not in (GenericVehicle.State.IGNITION_ON, GenericVehicle.State.DRIVING):
                                 if self.trip is not None and not self.trip.is_completed():
                                     LOG.info("Ending trip for vehicle %s", self.vehicle.vin)
                                     try:
                                         self.trip.destination_date = element.last_updated if element.last_updated is not None else datetime.now(tz=timezone.utc)
-                                        if self.carconnectivity_vehicle.odometer.enabled and \
-                                                self.carconnectivity_vehicle.odometer.value is not None:
-                                            self.trip.destination_odometer = self.carconnectivity_vehicle.odometer.value
+                                        if self.vehicle.carconnectivity_vehicle.odometer.enabled and \
+                                                self.vehicle.carconnectivity_vehicle.odometer.value is not None:
+                                            self.trip.destination_odometer = self.vehicle.carconnectivity_vehicle.odometer.value
                                             LOG.debug('Set destination odometer %.2f for trip of vehicle %s', self.trip.destination_odometer, self.vehicle.vin)
                                         if self._update_trip_position(session=session, trip=self.trip, start=False):
                                             self.trip = None
@@ -137,7 +132,6 @@ class TripAgent(BaseAgent):
                                     except DatabaseError as err:
                                         session.rollback()
                                         LOG.error('DatabaseError while ending trip for vehicle %s in database: %s', self.vehicle.vin, err)
-                                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     self.session_factory.remove()
                 self.last_carconnectivity_state = element.value
 
@@ -157,43 +151,41 @@ class TripAgent(BaseAgent):
 
     def _on_position_change(self) -> None:
         # Check if there is a finished trip that lacks destination position. We allow 5min after destination_date to set the position.
-        if self.trip is not None:
+        if self.trip is not None and self.trip.destination_date is not None and self.trip.destination_position_latitude is None \
+                and self.last_parked_position_time is not None \
+                and self.last_parked_position_time < (self.trip.destination_date + timedelta(minutes=5)):
             with self.session_factory() as session:
                 with self.trip_lock:
                     self.trip = session.merge(self.trip)
                     session.refresh(self.trip)
-                    if self.trip.destination_date is not None and self.trip.destination_position_latitude is None \
-                            and self.last_parked_position_time is not None \
-                            and self.last_parked_position_time < (self.trip.destination_date + timedelta(minutes=5)):
-                        self._update_trip_position(session, self.trip, start=False,
-                                                   latitude=self.last_parked_position_latitude,
-                                                   longitude=self.last_parked_position_longitude)
+                    self._update_trip_position(session, self.trip, start=False,
+                                               latitude=self.last_parked_position_latitude,
+                                               longitude=self.last_parked_position_longitude)
             self.session_factory.remove()
 
     def _update_trip_position(self, session: Session, trip: Trip, start: bool,
                               latitude: Optional[float] = None, longitude: Optional[float] = None) -> bool:
-        if self.carconnectivity_vehicle is None:
+        if self.vehicle.carconnectivity_vehicle is None:
             raise ValueError("Vehicle's carconnectivity_vehicle attribute is None")
         if latitude or longitude is None:
-            if self.carconnectivity_vehicle.position.enabled and self.carconnectivity_vehicle.position.latitude.enabled \
-                    and self.carconnectivity_vehicle.position.longitude.enabled \
-                    and self.carconnectivity_vehicle.position.latitude.value is not None \
-                    and self.carconnectivity_vehicle.position.longitude.value is not None:
-                latitude = self.carconnectivity_vehicle.position.latitude.value
-                longitude = self.carconnectivity_vehicle.position.longitude.value
+            if self.vehicle.carconnectivity_vehicle.position.enabled and self.vehicle.carconnectivity_vehicle.position.latitude.enabled \
+                    and self.vehicle.carconnectivity_vehicle.position.longitude.enabled \
+                    and self.vehicle.carconnectivity_vehicle.position.latitude.value is not None \
+                    and self.vehicle.carconnectivity_vehicle.position.longitude.value is not None:
+                latitude = self.vehicle.carconnectivity_vehicle.position.latitude.value
+                longitude = self.vehicle.carconnectivity_vehicle.position.longitude.value
         if latitude is not None and longitude is not None:
             if start:
                 if trip.start_position_latitude is None and trip.start_position_longitude is None:
                     try:
-                        trip.start_position_latitude = self.carconnectivity_vehicle.position.latitude.value
-                        trip.start_position_longitude = self.carconnectivity_vehicle.position.longitude.value
+                        trip.start_position_latitude = self.vehicle.carconnectivity_vehicle.position.latitude.value
+                        trip.start_position_longitude = self.vehicle.carconnectivity_vehicle.position.longitude.value
                         session.commit()
                     except DatabaseError as err:
                         session.rollback()
                         LOG.error('DatabaseError while updating position for trip of vehicle %s in database: %s', self.vehicle.vin, err)
-                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
-                if trip.start_location is None and self.carconnectivity_vehicle.position.location.enabled:
-                    location: Location = Location.from_carconnectivity_location(location=self.carconnectivity_vehicle.position.location)
+                if trip.start_location is None and self.vehicle.carconnectivity_vehicle.position.location.enabled:
+                    location: Location = Location.from_carconnectivity_location(location=self.vehicle.carconnectivity_vehicle.position.location)
                     try:
                         location = session.merge(location)
                         trip.start_location = location
@@ -201,20 +193,18 @@ class TripAgent(BaseAgent):
                     except DatabaseError as err:
                         session.rollback()
                         LOG.error('DatabaseError while merging location for trip of vehicle %s in database: %s', self.vehicle.vin, err)
-                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 return True
             else:
                 if trip.destination_position_latitude is None and trip.destination_position_longitude is None:
                     try:
-                        trip.destination_position_latitude = self.carconnectivity_vehicle.position.latitude.value
-                        trip.destination_position_longitude = self.carconnectivity_vehicle.position.longitude.value
+                        trip.destination_position_latitude = self.vehicle.carconnectivity_vehicle.position.latitude.value
+                        trip.destination_position_longitude = self.vehicle.carconnectivity_vehicle.position.longitude.value
                         session.commit()
                     except DatabaseError as err:
                         session.rollback()
                         LOG.error('DatabaseError while updating position for trip of vehicle %s in database: %s', self.vehicle.vin, err)
-                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
-                if trip.destination_location is None and self.carconnectivity_vehicle.position.location.enabled:
-                    location: Location = Location.from_carconnectivity_location(location=self.carconnectivity_vehicle.position.location)
+                if trip.destination_location is None and self.vehicle.carconnectivity_vehicle.position.location.enabled:
+                    location: Location = Location.from_carconnectivity_location(location=self.vehicle.carconnectivity_vehicle.position.location)
                     try:
                         location = session.merge(location)
                         trip.destination_location = location
@@ -222,6 +212,5 @@ class TripAgent(BaseAgent):
                     except DatabaseError as err:
                         session.rollback()
                         LOG.error('DatabaseError while merging location for trip of vehicle %s in database: %s', self.vehicle.vin, err)
-                        self.database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 return True
         return False

carconnectivity_plugins/database/model/charging_session.py

@@ -77,13 +77,13 @@ class ChargingSession(Base):  # pylint: disable=too-few-public-methods
     location: Mapped[Optional["Location"]] = relationship("Location")
     charging_station_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("charging_stations.uid"))
     charging_station: Mapped[Optional["ChargingStation"]] = relationship("ChargingStation")
-    meter_start_kwh: Mapped[Optional[float]]
-    meter_end_kwh: Mapped[Optional[float]]
-    price_per_kwh: Mapped[Optional[float]]
-    price_per_min: Mapped[Optional[float]]
-    price_per_session: Mapped[Optional[float]]
-    real_charged: Mapped[Optional[float]]
-    real_cost: Mapped[Optional[float]]
+    meter_start_kwh = Mapped[Optional[float]]
+    meter_end_kwh = Mapped[Optional[float]]
+    price_per_kwh = Mapped[Optional[float]]
+    price_per_min = Mapped[Optional[float]]
+    price_per_session = Mapped[Optional[float]]
+    real_charged = Mapped[Optional[float]]
+    real_cost = Mapped[Optional[float]]
     tags: Mapped[list["Tag"]] = relationship("Tag", secondary=charging_tag_association_table, backref=backref("charging_sessions"))
 
     # pylint: disable-next=too-many-arguments, too-many-positional-arguments

carconnectivity_plugins/database/model/drive.py

@@ -18,8 +18,6 @@ if TYPE_CHECKING:
     from sqlalchemy.orm.session import Session
     from sqlalchemy import Constraint
 
-    from carconnectivity_plugins.database.plugin import Plugin
-
 LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.model.drive")
 
 
@@ -58,13 +56,14 @@ class Drive(Base):
     capacity_total: Mapped[Optional[float]]
     wltp_range: Mapped[Optional[float]]
 
+    carconnectivity_drive: Optional[GenericDrive] = None
     agents: list[BaseAgent] = []
 
     def __init__(self, vin, drive_id: Optional[str] = None) -> None:
         self.vin = vin
         self.drive_id = drive_id
 
-    def connect(self, database_plugin: Plugin, session_factory: scoped_session[Session], carconnectivity_drive: GenericDrive) -> None:
+    def connect(self, session_factory: scoped_session[Session], carconnectivity_drive: GenericDrive) -> None:
         """
         Connect a CarConnectivity drive object to this database model instance.
         This method establishes a connection between the database drive model and a CarConnectivity drive object,
@@ -79,8 +78,9 @@ class Drive(Base):
             - Automatically syncs the drive type if enabled and has a value
             - Creates and registers a DriveStateAgent for managing drive state
         """
-        if self.agents:
+        if self.carconnectivity_drive is not None:
             raise ValueError("Can only connect once! Drive already connected with database model")
-        LOG.debug("Adding DriveStateAgent to drive %s of vehicle %s", self.drive_id, self.vin)
-        drive_state_agent: DriveStateAgent = DriveStateAgent(database_plugin, session_factory, self, carconnectivity_drive)  # type: ignore[assignment]
+        self.carconnectivity_drive = carconnectivity_drive
+        drive_state_agent: DriveStateAgent = DriveStateAgent(session_factory, self)  # type: ignore[assignment]
         self.agents.append(drive_state_agent)
+        LOG.debug("Adding DriveStateAgent to drive %s of vehicle %s", self.drive_id, self.vin)

carconnectivity_plugins/database/model/vehicle.py

@@ -23,8 +23,6 @@ if TYPE_CHECKING:
     from sqlalchemy.orm import scoped_session
     from sqlalchemy.orm.session import Session
 
-    from carconnectivity_plugins.database.plugin import Plugin
-
 LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database.model.vehicle")
 
 
@@ -68,12 +66,13 @@ class Vehicle(Base):
     type: Mapped[Optional[GenericVehicle.Type]]
     license_plate: Mapped[Optional[str]]
 
+    carconnectivity_vehicle: Optional[GenericVehicle] = None
     agents: list[BaseAgent] = []
 
     def __init__(self, vin) -> None:
         self.vin = vin
 
-    def connect(self, database_plugin: Plugin, session_factory: scoped_session[Session], carconnectivity_vehicle: GenericVehicle) -> None:
+    def connect(self, session_factory: scoped_session[Session], carconnectivity_vehicle: GenericVehicle) -> None:
         """
         Connect a CarConnectivity vehicle instance to this database vehicle model and set up observers.
         This method establishes a connection between a CarConnectivity vehicle object and this database vehicle model.
@@ -89,33 +88,34 @@ class Vehicle(Base):
             - Only enabled attributes are synchronized
             - The type attribute is only synchronized if it's not None
         """
-        if self.agents:
+        if self.carconnectivity_vehicle is not None:
             raise ValueError("Can only connect once! Vehicle already connected with database model")
-        carconnectivity_vehicle.name.add_observer(self.__on_name_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
-        if carconnectivity_vehicle.name.enabled and self.name != carconnectivity_vehicle.name.value:
-            self.name = carconnectivity_vehicle.name.value
-        carconnectivity_vehicle.manufacturer.add_observer(self.__on_manufacturer_change, Observable.ObserverEvent.VALUE_CHANGED,
-                                                          on_transaction_end=True)
-        if carconnectivity_vehicle.manufacturer.enabled and self.manufacturer != carconnectivity_vehicle.manufacturer.value:
-            self.manufacturer = carconnectivity_vehicle.manufacturer.value
-        carconnectivity_vehicle.model.add_observer(self.__on_model_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
-        if carconnectivity_vehicle.model.enabled and self.model != carconnectivity_vehicle.model.value:
-            self.model = carconnectivity_vehicle.model.value
-        carconnectivity_vehicle.model_year.add_observer(self.__on_model_year_change, Observable.ObserverEvent.VALUE_CHANGED,
-                                                        on_transaction_end=True)
-        if carconnectivity_vehicle.model_year.enabled and self.model_year != carconnectivity_vehicle.model_year.value:
-            self.model_year = carconnectivity_vehicle.model_year.value
-        carconnectivity_vehicle.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
-        if carconnectivity_vehicle.type.enabled and carconnectivity_vehicle.type.value is not None \
-                and self.type != carconnectivity_vehicle.type.value:
-            self.type = carconnectivity_vehicle.type.value
-        carconnectivity_vehicle.license_plate.add_observer(self.__on_license_plate_change, Observable.ObserverEvent.VALUE_CHANGED,
-                                                           on_transaction_end=True)
-        if carconnectivity_vehicle.license_plate.enabled and self.license_plate != carconnectivity_vehicle.license_plate.value:
-            self.license_plate = carconnectivity_vehicle.license_plate.value
+        self.carconnectivity_vehicle = carconnectivity_vehicle
+        self.carconnectivity_vehicle.name.add_observer(self.__on_name_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        if self.carconnectivity_vehicle.name.enabled and self.name != self.carconnectivity_vehicle.name.value:
+            self.name = self.carconnectivity_vehicle.name.value
+        self.carconnectivity_vehicle.manufacturer.add_observer(self.__on_manufacturer_change, Observable.ObserverEvent.VALUE_CHANGED,
+                                                               on_transaction_end=True)
+        if self.carconnectivity_vehicle.manufacturer.enabled and self.manufacturer != self.carconnectivity_vehicle.manufacturer.value:
+            self.manufacturer = self.carconnectivity_vehicle.manufacturer.value
+        self.carconnectivity_vehicle.model.add_observer(self.__on_model_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        if self.carconnectivity_vehicle.model.enabled and self.model != self.carconnectivity_vehicle.model.value:
+            self.model = self.carconnectivity_vehicle.model.value
+        self.carconnectivity_vehicle.model_year.add_observer(self.__on_model_year_change, Observable.ObserverEvent.VALUE_CHANGED,
+                                                             on_transaction_end=True)
+        if self.carconnectivity_vehicle.model_year.enabled and self.model_year != self.carconnectivity_vehicle.model_year.value:
+            self.model_year = self.carconnectivity_vehicle.model_year.value
+        self.carconnectivity_vehicle.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        if self.carconnectivity_vehicle.type.enabled and self.carconnectivity_vehicle.type.value is not None \
+                and self.type != self.carconnectivity_vehicle.type.value:
+            self.type = self.carconnectivity_vehicle.type.value
+        self.carconnectivity_vehicle.license_plate.add_observer(self.__on_license_plate_change, Observable.ObserverEvent.VALUE_CHANGED,
+                                                                on_transaction_end=True)
+        if self.carconnectivity_vehicle.license_plate.enabled and self.license_plate != self.carconnectivity_vehicle.license_plate.value:
+            self.license_plate = self.carconnectivity_vehicle.license_plate.value
 
         with session_factory() as session:
-            for drive_id, drive in carconnectivity_vehicle.drives.drives.items():
+            for drive_id, drive in self.carconnectivity_vehicle.drives.drives.items():
                 drive_db: Optional[Drive] = session.query(Drive).filter(Drive.vin == self.vin, Drive.drive_id == drive_id).first()
                 if drive_db is None:
                     drive_db = Drive(vin=self.vin, drive_id=drive_id)
@@ -123,32 +123,30 @@ class Vehicle(Base):
                         session.add(drive_db)
                         session.commit()
                         LOG.debug('Added new drive %s for vehicle %s to database', drive_id, self.vin)
-                        drive_db.connect(database_plugin, session_factory, drive)
+                        drive_db.connect(session_factory, drive)
                     except IntegrityError as err:
                         session.rollback()
                         LOG.error('IntegrityError while adding drive %s for vehicle %s to database, likely due to concurrent addition: %s', drive_id, self.vin,
                                   err)
-                        database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                     except DatabaseError as err:
                         session.rollback()
                         LOG.error('DatabaseError while adding drive %s for vehicle %s to database: %s', drive_id, self.vin, err)
-                        database_plugin.healthy._set_value(value=False)  # pylint: disable=protected-access
                 else:
-                    drive_db.connect(database_plugin, session_factory, drive)
+                    drive_db.connect(session_factory, drive)
                     LOG.debug('Connecting drive %s for vehicle %s', drive_id, self.vin)
 
-            state_agent: StateAgent = StateAgent(database_plugin, session_factory, self, carconnectivity_vehicle)
+            state_agent: StateAgent = StateAgent(session_factory, self)
             self.agents.append(state_agent)
             LOG.debug("Adding StateAgent to vehicle %s", self.vin)
-            climazination_agent: ClimatizationAgent = ClimatizationAgent(database_plugin, session_factory, self, carconnectivity_vehicle)
+            climazination_agent: ClimatizationAgent = ClimatizationAgent(session_factory, self)
             self.agents.append(climazination_agent)
             LOG.debug("Adding ClimatizationAgent to vehicle %s", self.vin)
-            trip_agent: TripAgent = TripAgent(database_plugin, session_factory, self, carconnectivity_vehicle)
+            trip_agent: TripAgent = TripAgent(session_factory, self)
             self.agents.append(trip_agent)
             LOG.debug("Adding TripAgent to vehicle %s", self.vin)
 
-            if isinstance(carconnectivity_vehicle, ElectricVehicle):
-                charging_agent: ChargingAgent = ChargingAgent(database_plugin, session_factory, self, carconnectivity_vehicle)
+            if isinstance(self.carconnectivity_vehicle, ElectricVehicle):
+                charging_agent: ChargingAgent = ChargingAgent(session_factory, self)
                 self.agents.append(charging_agent)
                 LOG.debug("Adding ChargingAgent to vehicle %s", self.vin)
         session_factory.remove()

carconnectivity_plugins/database/plugin.py

@@ -38,8 +38,8 @@ class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
         car_connectivity (CarConnectivity): An instance of CarConnectivity.
         config (Dict): Configuration dictionary containing connection details.
     """
-    def __init__(self, plugin_id: str, car_connectivity: CarConnectivity, config: Dict, initialization: Optional[Dict] = None) -> None:
-        BasePlugin.__init__(self, plugin_id=plugin_id, car_connectivity=car_connectivity, config=config, log=LOG, initialization=initialization)
+    def __init__(self, plugin_id: str, car_connectivity: CarConnectivity, config: Dict) -> None:
+        BasePlugin.__init__(self, plugin_id=plugin_id, car_connectivity=car_connectivity, config=config, log=LOG)
 
         self._background_thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
@@ -93,6 +93,11 @@ class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
                         session.commit()
                         self.car_connectivity.garage.add_observer(self.__on_add_vehicle, flag=Observable.ObserverEvent.ENABLED, on_transaction_end=True)
                         with self.vehicles_lock:
+                            self.vehicles = {vehicle.vin: vehicle for vehicle in session.query(Vehicle).all()}
+                            for vehicle in self.vehicles.values():
+                                car_connectivity_vehicle: Optional[GenericVehicle] = self.car_connectivity.garage.get_vehicle(vehicle.vin)
+                                if car_connectivity_vehicle is not None:
+                                    vehicle.connect(self.scoped_session_factory, car_connectivity_vehicle)
                             for garage_vehicle in self.car_connectivity.garage.list_vehicles():
                                 if garage_vehicle.vin.value is not None and garage_vehicle.vin.value not in self.vehicles:
                                     LOG.debug('New vehicle found in garage during startup: %s', garage_vehicle.vin.value)
@@ -103,15 +108,15 @@ class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
                                             session.add(new_vehicle)
                                             session.commit()
                                             LOG.debug('Added new vehicle %s to database', garage_vehicle.vin.value)
-                                            new_vehicle.connect(self, self.scoped_session_factory, garage_vehicle)
+                                            new_vehicle.connect(self.scoped_session_factory, garage_vehicle)
                                             self.vehicles[garage_vehicle.vin.value] = new_vehicle
                                         except DatabaseError as err:
                                             session.rollback()
                                             LOG.error('DatabaseError while adding vehicle %s to database: %s', garage_vehicle.vin.value, err)
-                                            self.healthy._set_value(value=False)  # pylint: disable=protected-access
                                     else:
-                                        new_vehicle.connect(self, self.scoped_session_factory, garage_vehicle)
+                                        new_vehicle.connect(self.scoped_session_factory, garage_vehicle)
                                         self.vehicles[garage_vehicle.vin.value] = new_vehicle
+
                 except OperationalError as err:
                     LOG.error('Could not establish a connection to database, will try again after 10 seconds: %s', err)
                     self.healthy._set_value(value=False)  # pylint: disable=protected-access
@@ -136,13 +141,13 @@ class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
     def __on_add_vehicle(self, element, flags) -> None:
         del flags
         with self.vehicles_lock:
-            if isinstance(element, GenericVehicle) and element.vin.value not in self.vehicles:
+            if isinstance(element, GenericVehicle) and element.vin not in self.vehicles:
                 LOG.debug('New vehicle added to garage: %s', element.vin)
                 if element.vin.value is not None:
                     with self.scoped_session_factory() as session:
                         if element.vin.value in self.vehicles:
                             vehicle: Vehicle = self.vehicles[element.vin.value]
-                            vehicle.connect(self, self.scoped_session_factory, element)
+                            vehicle.connect(self.scoped_session_factory, element)
                         else:
                             vehicle: Vehicle = session.get(Vehicle, element.vin.value)
                             if vehicle is None:
@@ -150,12 +155,11 @@ class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
                                 try:
                                     session.add(vehicle)
                                     session.commit()
-                                    vehicle.connect(self, self.scoped_session_factory, element)
+                                    vehicle.connect(self.scoped_session_factory, element)
                                 except DatabaseError as err:
                                     session.rollback()
                                     LOG.error('DatabaseError while adding vehicle %s to database: %s', element.vin.value, err)
-                                    self.healthy._set_value(value=False)  # pylint: disable=protected-access
                             else:
-                                vehicle.connect(self, self.scoped_session_factory, element)
+                                vehicle.connect(self.scoped_session_factory, element)
                             self.vehicles[element.vin.value] = vehicle
                     self.scoped_session_factory.remove()