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

carconnectivity_plugins/database/model/drive_range_full.py

@@ -0,0 +1,53 @@
+""" This module contains the Drive range estimated full database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+class DriveRangeEstimatedFull(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a drive range estimated full record in the database.
+    This class models the range information for a specific drive, tracking the first and last
+    date of the range measurement along with the range value itself.
+    Attributes:
+        id (int): Primary key identifier for the drive range record.
+        drive_id (int): Foreign key reference to the associated drive record.
+        drive (Drive): Relationship to the Drive model.
+        first_date (datetime): The timestamp when the range measurement started.
+        last_date (datetime): The timestamp when the range measurement ended.
+        range (Optional[float]): The measured range value in appropriate units (e.g., kilometers or miles).
+            Can be None if the range data is not available.
+    Args:
+        drive_id (int): The identifier of the associated drive.
+        first_date (datetime): The start timestamp of the range measurement.
+        last_date (datetime): The end timestamp of the range measurement.
+        range (Optional[float]): The range value, or None if unavailable.
+    """
+
+    __tablename__: str = 'drive_ranges_estimated_full'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("drive_id", "first_date", name="drive_ranges_estimated_full_drive_id_first_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    drive_id: Mapped[int] = mapped_column(ForeignKey("drives.id"))
+    drive: Mapped["Drive"] = relationship("Drive")
+    first_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    last_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    range_estimated_full: Mapped[Optional[float]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, drive_id: Mapped[int], first_date: datetime, last_date: datetime, range_estimated_full: Optional[float]) -> None:
+        self.drive_id = drive_id
+        self.first_date = first_date
+        self.last_date = last_date
+        self.range_estimated_full = range_estimated_full

carconnectivity_plugins/database/model/location.py

@@ -0,0 +1,85 @@
+""" This module contains the location database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy.orm import Mapped, mapped_column
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from carconnectivity.location import Location as CarConnectivityLocation
+
+
+class Location(Base):  # pylint: disable=too-few-public-methods,too-many-instance-attributes
+    """
+    SQLAlchemy model representing a geographical location.
+    This class maps to the 'locations' table in the database and stores
+    geographical and address information for a specific location.
+    Attributes:
+        uid (str): Unique identifier for the location (primary key).
+        source (Optional[str]): The data source providing the location information.
+        latitude (Optional[float]): Latitude coordinate of the location.
+        longitude (Optional[float]): Longitude coordinate of the location.
+        display_name (Optional[str]): Human-readable display name of the location.
+        name (Optional[str]): Name of the location.
+        amenity (Optional[str]): Type of amenity at the location.
+        house_number (Optional[str]): House or building number.
+        road (Optional[str]): Street or road name.
+        neighbourhood (Optional[str]): Neighbourhood or area name.
+        city (Optional[str]): City name.
+        postcode (Optional[str]): Postal code.
+        county (Optional[str]): County name.
+        country (Optional[str]): Country name.
+        state (Optional[str]): State or province name.
+        state_district (Optional[str]): State district name.
+        raw (Optional[str]): Raw location data as received from the source.
+    Methods:
+        from_carconnectivity_location: Class method to create a Location instance
+            from a CarConnectivity Location object.
+    """
+
+    __tablename__: str = 'locations'
+
+    uid: Mapped[str] = mapped_column(primary_key=True)
+    source: Mapped[Optional[str]]
+    latitude: Mapped[Optional[float]]
+    longitude: Mapped[Optional[float]]
+    display_name: Mapped[Optional[str]]
+    name: Mapped[Optional[str]]
+    amenity: Mapped[Optional[str]]
+    house_number: Mapped[Optional[str]]
+    road: Mapped[Optional[str]]
+    neighbourhood: Mapped[Optional[str]]
+    city: Mapped[Optional[str]]
+    postcode: Mapped[Optional[str]]
+    county: Mapped[Optional[str]]
+    country: Mapped[Optional[str]]
+    state: Mapped[Optional[str]]
+    state_district: Mapped[Optional[str]]
+    raw: Mapped[Optional[str]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, uid: str) -> None:
+        self.uid = uid
+
+    @classmethod
+    def from_carconnectivity_location(cls, location: CarConnectivityLocation) -> Location:
+        """Create a Location instance from a carconnectivity Location object."""
+        loc = cls(uid=location.uid.value)
+        loc.source = location.source.value
+        loc.latitude = location.latitude.value
+        loc.longitude = location.longitude.value
+        loc.display_name = location.display_name.value
+        loc.name = location.name.value
+        loc.amenity = location.amenity.value
+        loc.house_number = location.house_number.value
+        loc.road = location.road.value
+        loc.neighbourhood = location.neighbourhood.value
+        loc.city = location.city.value
+        loc.postcode = location.postcode.value
+        loc.county = location.county.value
+        loc.country = location.country.value
+        loc.state = location.state.value
+        loc.state_district = location.state_district.value
+        loc.raw = location.raw.value
+        return loc

carconnectivity_plugins/database/model/migrations.py

@@ -0,0 +1,24 @@
+""" Module for running database migrations using Alembic."""
+import os
+
+from alembic.command import upgrade, stamp
+from alembic.config import Config
+
+
+def run_database_migrations(dsn: str, stamp_only: bool = False):
+    """Run database migrations using Alembic."""
+    # retrieves the directory that *this* file is in
+    migrations_dir = os.path.dirname(os.path.realpath(__file__))
+    # this assumes the alembic.ini is also contained in this same directory
+    config_file = os.path.join(migrations_dir, "alembic.ini")
+
+    config = Config(file_=config_file)
+    config.attributes['configure_logger'] = False
+    config.set_main_option("script_location", migrations_dir + '/carconnectivity_schema')
+    config.set_main_option('sqlalchemy.url', dsn)
+
+    if stamp_only:
+        stamp(config, "head")
+    else:
+        # upgrade the database to the latest revision
+        upgrade(config, "head")

carconnectivity_plugins/database/model/outside_temperature.py

@@ -0,0 +1,52 @@
+""" This module contains the Vehicle outside temperature database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+class OutsideTemperature(Base):  # pylint: disable=too-few-public-methods
+    """
+    SQLAlchemy model representing outside temperature measurements for vehicles.
+    This class stores outside temperature data associated with a vehicle, including
+    the time period when the measurement was recorded.
+    Attributes:
+        id (int): Primary key identifier for the temperature record.
+        vin (str): Vehicle Identification Number, foreign key referencing vehicles table.
+        vehicle (Vehicle): Relationship to the Vehicle model.
+        first_date (datetime): The timestamp when this temperature measurement was first recorded.
+        last_date (datetime): The timestamp when this temperature measurement was last updated.
+        outside_temperature (float, optional): The outside temperature value in degrees (unit depends on system configuration).
+            Can be None if the temperature is not available.
+    Args:
+        vin (str): Vehicle Identification Number for the associated vehicle.
+        first_date (datetime): Initial timestamp for the temperature measurement.
+        last_date (datetime): Last update timestamp for the temperature measurement.
+        outside_temperature (float, optional): The measured outside temperature value.
+    """
+    __tablename__: str = 'outside_temperatures'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="outside_temperatures_vin_first_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
+    vehicle: Mapped["Vehicle"] = relationship("Vehicle")
+    first_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    last_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    outside_temperature: Mapped[Optional[float]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, vin: str, first_date: datetime, last_date: datetime, outside_temperature: Optional[float]) -> None:
+        self.vin = vin
+        self.first_date = first_date
+        self.last_date = last_date
+        self.outside_temperature = outside_temperature

carconnectivity_plugins/database/model/state.py

@@ -0,0 +1,56 @@
+""" This module contains the Vehicle state database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity.vehicle import GenericVehicle
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+class State(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a vehicle state record in the database.
+    This class models the states table which tracks the historical state of vehicles over time periods.
+    Attributes:
+        id (int): Primary key for the state record.
+        vin (str): Foreign key reference to the vehicle identification number in the parent table.
+        vehicle (Vehicle): Relationship to the Vehicle model.
+        first_date (datetime): The timestamp when this state period began (UTC).
+        last_date (datetime, optional): The timestamp when this state period ended (UTC).
+            None indicates the state is still active.
+        state (GenericVehicle.State, optional): The vehicle's operational state during this period.
+        connection_state (GenericVehicle.ConnectionState, optional): The vehicle's connection state
+            during this period.
+    Args:
+        vin (str): The vehicle identification number.
+        first_date (datetime): The start timestamp of the state period.
+        last_date (datetime): The end timestamp of the state period.
+        state (GenericVehicle.State, optional): The vehicle's operational state.
+        connection_state (GenericVehicle.ConnectionState, optional): The vehicle's connection state.
+    """
+    __tablename__: str = 'states'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="states_vin_first_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
+    vehicle: Mapped["Vehicle"] = relationship("Vehicle")
+    first_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    last_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    state: Mapped[Optional[GenericVehicle.State]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, vin: str, first_date: datetime, last_date: datetime, state: Optional[GenericVehicle.State]) -> None:
+        self.vin = vin
+        self.first_date = first_date
+        self.last_date = last_date
+        self.state = state

carconnectivity_plugins/database/model/tag.py

@@ -0,0 +1,31 @@
+""" This module contains the Tag database model"""
+from __future__ import annotations
+from typing import Optional
+
+from sqlalchemy.orm import Mapped, mapped_column
+
+from carconnectivity_plugins.database.model.base import Base
+
+
+class Tag(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a tag in the database.
+    A tag is a label that can be associated with various entities in the system.
+    Each tag has a unique name and an optional description.
+    Attributes:
+        name (str): The unique name of the tag. Acts as the primary key.
+        description (str, optional): An optional description providing more context about the tag.
+    Args:
+        name (str): The unique name for the tag.
+        description (str, optional): An optional description for the tag. Defaults to None.
+    """
+
+    __tablename__: str = 'tags'
+
+    name: Mapped[str] = mapped_column(primary_key=True)
+    description: Mapped[Optional[str]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, name: str, description: Optional[str] = None) -> None:
+        self.name = name
+        self.description = description

carconnectivity_plugins/database/model/timedelta_decorator.py

@@ -0,0 +1,33 @@
+"""Decorator for handling timedelta objects in SQLAlchemy models.
+This decorator ensures that duration values are stored in microsecond format"""
+from datetime import timedelta
+import sqlalchemy
+
+
+# pylint: disable=too-many-ancestors
+class TimedeltaDecorator(sqlalchemy.types.TypeDecorator):
+    """Decorator for handling datetime objects in SQLAlchemy models."""
+    impl = sqlalchemy.types.Float
+    cache_ok = True
+
+    @property
+    def python_type(self):
+        """Return the Python type handled by this decorator."""
+        return timedelta
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+
+        return value.total_seconds()
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+
+        return timedelta(seconds=value)
+
+    def process_literal_param(self, value, dialect):
+        if value is None:
+            return value
+        return value.total_seconds()

carconnectivity_plugins/database/model/trip.py

@@ -0,0 +1,85 @@
+""" This module contains the Vehicle trip database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey, Table, Column, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship, backref
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+trip_tag_association_table = Table('trips_tags', Base.metadata,
+                                   Column('trips_id', ForeignKey('trips.id')),
+                                   Column('tags_name', ForeignKey('tags.name'))
+                                   )
+
+
+class Trip(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a vehicle trip in the database.
+
+    A Trip records information about a journey made by a vehicle, including start and
+    destination details such as timestamps, positions, and mileage readings. Trips can
+    be associated with tags for categorization and filtering.
+
+    Attributes:
+        id (int): Primary key identifier for the trip.
+        vin (str): Vehicle Identification Number, foreign key to vehicles table.
+        vehicle (Vehicle): Relationship to the associated Vehicle object.
+        start_date (datetime): UTC timestamp when the trip started.
+        destination_date (datetime, optional): UTC timestamp when the trip ended.
+        start_position_latitude (float, optional): Latitude coordinate of trip start location.
+        start_position_longitude (float, optional): Longitude coordinate of trip start location.
+        destination_position_latitude (float, optional): Latitude coordinate of trip destination.
+        destination_position_longitude (float, optional): Longitude coordinate of trip destination.
+        start_odometer (float, optional): Vehicle mileage in kilometers at trip start.
+        destination_odometer (float, optional): Vehicle mileage in kilometers at trip end.
+        tags (list[Tag]): List of tags associated with this trip for categorization.
+
+    Args:
+        vin (str): Vehicle Identification Number for the trip.
+        start_date (datetime): The starting timestamp of the trip.
+        start_position_latitude (float, optional): Latitude coordinate of trip start location.
+        start_position_longitude (float, optional): Longitude coordinate of trip start location.
+        start_odometer (float, optional): Vehicle mileage in kilometers at trip start.
+    """
+    __tablename__: str = 'trips'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "start_date", name="vin_start_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
+    vehicle: Mapped["Vehicle"] = relationship("Vehicle")
+    start_date: Mapped[datetime] = mapped_column(UtcDateTime)
+    destination_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    start_position_latitude: Mapped[Optional[float]]
+    start_position_longitude: Mapped[Optional[float]]
+    start_location_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("locations.uid"))
+    start_location: Mapped[Optional["Location"]] = relationship("Location", foreign_keys=[start_location_uid])
+    destination_position_latitude: Mapped[Optional[float]]
+    destination_position_longitude: Mapped[Optional[float]]
+    destination_location_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("locations.uid"))
+    destination_location: Mapped[Optional["Location"]] = relationship("Location", foreign_keys=[destination_location_uid])
+    start_odometer: Mapped[Optional[float]]
+    destination_odometer: Mapped[Optional[float]]
+
+    tags: Mapped[list["Tag"]] = relationship("Tag", secondary=trip_tag_association_table, backref=backref("trips"))
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, vin: str, start_date: datetime, start_position_latitude: Optional[float] = None,
+                 start_position_longitude: Optional[float] = None, start_odometer: Optional[float] = None) -> None:
+        self.vin = vin
+        self.start_date = start_date
+        self.start_position_latitude = start_position_latitude
+        self.start_position_longitude = start_position_longitude
+        self.start_odometer = start_odometer
+
+    def is_completed(self) -> bool:
+        """Returns True if the trip has been completed (i.e., has a destination date)."""
+        return self.destination_date is not None

carconnectivity_plugins/database/model/vehicle.py

@@ -0,0 +1,184 @@
+""" This module contains the Vehicle database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+import logging
+
+from sqlalchemy.exc import DatabaseError, IntegrityError
+from sqlalchemy.orm import Mapped, mapped_column
+
+from carconnectivity.vehicle import GenericVehicle, ElectricVehicle
+from carconnectivity.observable import Observable
+from carconnectivity.attributes import StringAttribute, IntegerAttribute, EnumAttribute
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.agents.state_agent import StateAgent
+from carconnectivity_plugins.database.agents.charging_agent import ChargingAgent
+from carconnectivity_plugins.database.agents.climatization_agent import ClimatizationAgent
+from carconnectivity_plugins.database.agents.trip_agent import TripAgent
+from carconnectivity_plugins.database.model.base import Base
+from carconnectivity_plugins.database.model.drive import Drive
+
+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")
+
+
+class Vehicle(Base):
+    """
+    SQLAlchemy model representing a vehicle in the database.
+
+    This class maps vehicle data from the CarConnectivity framework to database records,
+    maintaining synchronization between the CarConnectivity vehicle objects and their
+    corresponding database entries.
+
+    Attributes:
+        vin (str): Vehicle Identification Number, used as the primary key.
+        name (Optional[str]): The name or nickname of the vehicle.
+        manufacturer (Optional[str]): The manufacturer of the vehicle.
+        model (Optional[str]): The model name of the vehicle.
+        model_year (Optional[int]): The model year of the vehicle.
+        type (Optional[GenericVehicle.Type]): The type of vehicle (e.g., electric, hybrid).
+        license_plate (Optional[str]): The license plate number of the vehicle.
+        carconnectivity_vehicle (Optional[GenericVehicle]): Reference to the associated
+            CarConnectivity GenericVehicle object (not persisted in database).
+
+    Methods:
+        __init__(vin): Initialize a new Vehicle instance with the given VIN.
+        connect(carconnectivity_vehicle): Connect this database model to a CarConnectivity
+            vehicle object and set up observers to sync changes.
+
+    Notes:
+        The class uses SQLAlchemy's mapped_column and Mapped types for database mapping.
+        Observer callbacks are registered to automatically update database fields when
+        corresponding values change in the CarConnectivity vehicle object.
+    """
+    __tablename__ = 'vehicles'
+    __allow_unmapped__ = True
+
+    vin: Mapped[str] = mapped_column(primary_key=True)
+    name: Mapped[Optional[str]]
+    manufacturer: Mapped[Optional[str]]
+    model: Mapped[Optional[str]]
+    model_year: Mapped[Optional[int]]
+    type: Mapped[Optional[GenericVehicle.Type]]
+    license_plate: Mapped[Optional[str]]
+
+    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:
+        """
+        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.
+        It registers observers for various vehicle attributes (name, manufacturer, model, model_year, type, and license_plate)
+        to monitor changes and synchronize them with the database. If the attributes are enabled and have values that differ
+        from the current database values, they are immediately synchronized.
+        Args:
+            carconnectivity_vehicle (GenericVehicle): The CarConnectivity vehicle instance to connect and observe.
+        Returns:
+            None
+        Note:
+            - Observers are triggered on transaction end to batch updates
+            - Only enabled attributes are synchronized
+            - The type attribute is only synchronized if it's not None
+        """
+        if self.agents:
+            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
+
+        with session_factory() as session:
+            for drive_id, drive in 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)
+                    try:
+                        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)
+                    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)
+                    LOG.debug('Connecting drive %s for vehicle %s', drive_id, self.vin)
+
+            state_agent: StateAgent = StateAgent(database_plugin, session_factory, self, carconnectivity_vehicle)
+            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)
+            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)
+            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)
+                self.agents.append(charging_agent)
+                LOG.debug("Adding ChargingAgent to vehicle %s", self.vin)
+        session_factory.remove()
+
+    def __on_name_change(self, element: StringAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.name != element.value:
+            self.name = element.value
+
+    def __on_manufacturer_change(self, element: StringAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.manufacturer != element.value:
+            self.manufacturer = element.value
+
+    def __on_model_change(self, element: StringAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.model != element.value:
+            self.model = element.value
+
+    def __on_model_year_change(self, element: IntegerAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.model_year != element.value:
+            self.model_year = element.value
+
+    def __on_type_change(self, element: EnumAttribute[GenericVehicle.Type], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.value is not None and self.type != element.value:
+            self.type = element.value
+
+    def __on_license_plate_change(self, element: StringAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.license_plate != element.value:
+            self.license_plate = element.value