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

carconnectivity_plugins/database/model/connection_state.py

@@ -0,0 +1,53 @@
+""" This module contains the Vehicle connectionstate database model"""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+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
+
+
+class ConnectionState(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a vehicle connection state record in the database.
+    This class models the states table which tracks the historical connection
+    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 = 'connection_states'
+
+    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)
+    connection_state: Mapped[Optional[GenericVehicle.ConnectionState]]
+
+    # pylint: disable-next=too-many-arguments, too-many-positional-arguments
+    def __init__(self, vin: str, first_date: datetime, last_date: datetime, connection_state: Optional[GenericVehicle.ConnectionState]) -> None:
+        self.vin = vin
+        self.first_date = first_date
+        self.last_date = last_date
+        self.connection_state = connection_state

carconnectivity_plugins/database/model/datetime_decorator.py

@@ -0,0 +1,44 @@
+"""Decorator for handling datetime objects in SQLAlchemy models.
+This decorator ensures that datetime values are stored in UTC and retrieved in UTC,
+while also converting naive datetime objects to the local timezone before storing.
+It is designed to work with SQLAlchemy's DateTime type."""
+from datetime import datetime, timezone
+import sqlalchemy
+
+
+# pylint: disable=too-many-ancestors
+class DatetimeDecorator(sqlalchemy.types.TypeDecorator):
+    """Decorator for handling datetime objects in SQLAlchemy models."""
+    impl = sqlalchemy.types.DateTime
+    cache_ok = True
+
+    def process_literal_param(self, value, dialect):
+        """Process literal parameter for SQLAlchemy."""
+        if value is None:
+            return None
+        return f"'{value.isoformat()}'"
+
+    @property
+    def python_type(self):
+        """Return the Python type handled by this decorator."""
+        return datetime
+
+    LOCAL_TIMEZONE = datetime.utcnow().astimezone().tzinfo
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+
+        if value.tzinfo is None:
+            value = value.astimezone(self.LOCAL_TIMEZONE)
+
+        return value.astimezone(timezone.utc)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+
+        return value.astimezone(timezone.utc)

carconnectivity_plugins/database/model/drive.py

@@ -0,0 +1,87 @@
+""" This module contains the Drive database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from carconnectivity.drive import GenericDrive
+from carconnectivity.observable import Observable
+from carconnectivity.attributes import EnumAttribute
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.agents.drive_state_agent import DriveStateAgent
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm.session import Session
+    from sqlalchemy import Constraint
+
+
+class Drive(Base):
+    """
+    Database model representing a vehicle drive/trip.
+    This class maps to the 'drives' table and stores information about individual
+    vehicle drives, including their relationship to vehicles and various drive
+    attributes tracked through CarConnectivity.
+    Attributes:
+        id (int): Primary key for the drive record.
+        vin (str): Vehicle Identification Number, foreign key to vehicles table.
+        vehicle (Vehicle): SQLAlchemy relationship to the associated Vehicle.
+        drive_id (Optional[str]): Optional identifier for the drive.
+        type (Optional[GenericDrive.Type]): Type/category of the drive.
+        carconnectivity_drive (Optional[GenericDrive]): Reference to the CarConnectivity
+            drive object (not persisted to database).
+        agents (list[BaseAgent]): List of agents monitoring this drive (not persisted
+            to database).
+    Args:
+        vin (str): Vehicle Identification Number to associate this drive with.
+    Methods:
+        connect: Establishes connection between database model and CarConnectivity
+            drive object, sets up observers, and initializes agents.
+    """
+    __tablename__: str = 'drives'
+    __allow_unmapped__: bool = True
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "drive_id", name="vin_drive_id"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
+    vehicle: Mapped["Vehicle"] = relationship("Vehicle")
+    drive_id: Mapped[Optional[str]]
+    type: Mapped[Optional[GenericDrive.Type]]
+
+    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, 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,
+        sets up observers for type changes, synchronizes the drive type if available, and initializes the drive state agent.
+        Args:
+            session (Session): The database session to use for operations.
+            carconnectivity_drive (GenericDrive): The CarConnectivity drive object to connect to this database model.
+        Returns:
+            None
+        Note:
+            - Adds an observer to monitor type changes in the vehicle
+            - Automatically syncs the drive type if enabled and has a value
+            - Creates and registers a DriveStateAgent for managing drive state
+        """
+        self.carconnectivity_drive = carconnectivity_drive
+        self.carconnectivity_drive.type.add_observer(self.__on_type_change, Observable.ObserverEvent.VALUE_CHANGED, on_transaction_end=True)
+        if self.carconnectivity_drive.type.enabled and self.carconnectivity_drive.type.value is not None \
+                and self.type != self.carconnectivity_drive.type.value:
+            self.type = self.carconnectivity_drive.type.value
+
+        drive_state_agent: DriveStateAgent = DriveStateAgent(session, self)  # type: ignore[assignment]
+        self.agents.append(drive_state_agent)
+
+    def __on_type_change(self, element: EnumAttribute[GenericDrive.Type], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if element.value is not None and self.type != element.value:
+            self.type = element.value

carconnectivity_plugins/database/model/drive_level.py

@@ -0,0 +1,46 @@
+""" This module contains the Drive level database model"""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+
+class DriveLevel(Base):  # pylint: disable=too-few-public-methods
+    """
+    SQLAlchemy model representing energy levels for a drive.
+    This class maps to the 'drive_levels' database table and tracks the level.
+    Attributes:
+        id (int): Primary key identifier for the drive level record.
+        drive_id (str): Foreign key referencing the associated drive
+        drive (Drive): Relationship to the Drive model.
+        first_date (datetime): Timestamp when this level measurement started.
+        last_date (datetime): Timestamp when this level measurement ended.
+        level (Optional[float]): Battery level value (percentage or absolute value).
+    Args:
+        drive_id (str): The identifier of the associated drive.
+        first_date (datetime): Start timestamp for this level measurement.
+        last_date (datetime): End timestamp for this level measurement.
+        level (Optional[float]): The battery level value, can be None if unavailable.
+    """
+    __tablename__: str = 'drive_levels'
+
+    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)
+    level: 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, level: Optional[float]) -> None:
+        self.drive_id = drive_id
+        self.first_date = first_date
+        self.last_date = last_date
+        self.level = level

carconnectivity_plugins/database/model/drive_range.py

@@ -0,0 +1,49 @@
+""" This module contains the Drive range database model"""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+
+class DriveRange(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a drive range 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'
+
+    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: 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: Optional[float]) -> None:
+        self.drive_id = drive_id
+        self.first_date = first_date
+        self.last_date = last_date
+        self.range = range

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,48 @@
+""" This module contains the Vehicle outside temperature database model"""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from sqlalchemy_utc import UtcDateTime
+
+from carconnectivity_plugins.database.model.base import Base
+
+
+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'
+
+    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,52 @@
+""" This module contains the Vehicle state database model"""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime
+
+from sqlalchemy import ForeignKey
+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
+
+
+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'
+
+    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/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/vehicle.py

@@ -0,0 +1,148 @@
+""" This module contains the Vehicle database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+from sqlalchemy.orm import Mapped, mapped_column
+
+from carconnectivity.vehicle import GenericVehicle
+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.model.base import Base
+from carconnectivity_plugins.database.model.drive import Drive
+
+if TYPE_CHECKING:
+    from sqlalchemy.orm.session import Session
+
+
+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]]
+
+    carconnectivity_vehicle: Optional[GenericVehicle] = None
+    agents: list[BaseAgent] = []
+
+    def __init__(self, vin) -> None:
+        self.vin = vin
+
+    def connect(self, 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
+        """
+
+        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
+
+        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)
+                with session.begin_nested():
+                    session.add(drive_db)
+                session.commit()
+                LOG.debug('Added new drive %s for vehicle %s to database', drive_id, self.vin)
+            drive_db.connect(session, drive)
+
+        state_agent: StateAgent = StateAgent(session, self)  # type: ignore[assignment]
+        self.agents.append(state_agent)
+
+    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