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

carconnectivity_plugins/database/model/charging_session.py

@@ -0,0 +1,144 @@
+""" This module contains the Vehicle charging sessions 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.charging import Charging
+
+from carconnectivity_plugins.database.model.base import Base
+
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+charging_tag_association_table = Table('charging_sessions_tags', Base.metadata,
+                                       Column('charging_sessions_id', ForeignKey('charging_sessions.id')),
+                                       Column('tags_name', ForeignKey('tags.name'))
+                                       )
+
+
+class ChargingSession(Base):  # pylint: disable=too-few-public-methods
+    """
+    Represents a charging session for an electric vehicle.
+    This class models a complete charging session lifecycle, tracking various timestamps
+    and metrics from when the vehicle is plugged in until it is disconnected. It captures
+    connection events (plug, lock, charge start/end, unlock, unplug) along with session
+    metadata such as battery levels, charge type, location, and odometer readings.
+    Attributes:
+        id (int): Primary key identifier for the charging session.
+        vin (str): Vehicle Identification Number, foreign key to the vehicles table.
+        vehicle (Vehicle): Relationship to the associated Vehicle object.
+        plug_connected_date (datetime, optional): Timestamp when the plug was connected.
+        plug_locked_date (datetime, optional): Timestamp when the plug was locked.
+        plug_unlocked_date (datetime, optional): Timestamp when the plug was unlocked.
+        session_start_date (datetime, optional): Timestamp when charging started.
+        session_end_date (datetime, optional): Timestamp when charging ended.
+        plug_disconnected_date (datetime, optional): Timestamp when the plug was disconnected.
+        start_level (float, optional): Battery level percentage at session start.
+        end_level (float, optional): Battery level percentage at session end.
+        session_charge_type (Charging.ChargingType, optional): Type of charging (e.g., AC, DC).
+        session_position_latitude (float, optional): Latitude coordinate of charging location.
+        session_position_longitude (float, optional): Longitude coordinate of charging location.
+        session_odometer (float, optional): Odometer reading at session start.
+        charging_type (Charging.ChargingType, optional): General charging type used during session.
+        tags (list[Tag]): Associated tags for categorizing or labeling the session.
+    The class provides various helper methods to query the current and historical state
+    of the charging session, such as whether the vehicle is currently connected, locked,
+    or actively charging.
+    """
+
+    __tablename__: str = 'charging_sessions'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "session_start_date", name="vin_session_start_date"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    vin: Mapped[str] = mapped_column(ForeignKey("vehicles.vin"))
+    vehicle: Mapped["Vehicle"] = relationship("Vehicle")
+    plug_connected_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    plug_locked_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    plug_unlocked_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    session_start_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    session_end_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    plug_disconnected_date: Mapped[Optional[datetime]] = mapped_column(UtcDateTime)
+    start_level: Mapped[Optional[float]]
+    end_level: Mapped[Optional[float]]
+    session_charge_type: Mapped[Optional[Charging.ChargingType]]
+    session_position_latitude: Mapped[Optional[float]]
+    session_position_longitude: Mapped[Optional[float]]
+    session_odometer: Mapped[Optional[float]]
+    charging_type: Mapped[Optional[Charging.ChargingType]]
+    location_uid: Mapped[Optional[str]] = mapped_column(ForeignKey("locations.uid"))
+    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]]
+    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
+    def __init__(self, vin: str, plug_connected_date: Optional[datetime] = None, plug_locked_date: Optional[datetime] = None,
+                 session_start_date: Optional[datetime] = None, start_level: Optional[float] = None,
+                 session_charge_type: Optional[Charging.ChargingType] = None, session_position_latitude: Optional[float] = None,
+                 session_position_longitude: Optional[float] = None, session_odometer: Optional[float] = None,
+                 charging_type: Optional[Charging.ChargingType] = None) -> None:
+        self.vin = vin
+        self.plug_connected_date = plug_connected_date
+        self.plug_locked_date = plug_locked_date
+        self.session_start_date = session_start_date
+        self.start_level = start_level
+        self.session_charge_type = session_charge_type
+        self.session_position_latitude = session_position_latitude
+        self.session_position_longitude = session_position_longitude
+        self.session_odometer = session_odometer
+        self.charging_type = charging_type
+
+    def is_connected(self) -> bool:
+        """Returns True if the vehicle is currently connected to a charger."""
+        return self.plug_connected_date is not None and self.plug_disconnected_date is None
+
+    def is_locked(self) -> bool:
+        """Returns True if the vehicle is currently locked to a charger."""
+        return self.plug_locked_date is not None and self.plug_unlocked_date is None
+
+    def is_charging(self) -> bool:
+        """Returns True if the vehicle is currently in a charging session."""
+        return self.session_start_date is not None and self.session_end_date is None
+
+    def is_closed(self) -> bool:
+        """Returns True if the charging session has ended."""
+        return self.session_end_date is not None or self.plug_unlocked_date is not None or self.plug_disconnected_date is not None
+
+    def was_started(self) -> bool:
+        """Returns True if the charging session was started but may also have been already ended."""
+        return self.session_start_date is not None
+
+    def was_connected(self) -> bool:
+        """Returns True if the vehicle was connected to a charger during this session."""
+        return self.plug_connected_date is not None
+
+    def was_locked(self) -> bool:
+        """Returns True if the vehicle was locked to a charger during this session."""
+        return self.plug_locked_date is not None
+
+    def was_ended(self) -> bool:
+        """Returns True if the charging session was ended."""
+        return self.session_end_date is not None
+
+    def was_disconnected(self) -> bool:
+        """Returns True if the vehicle was disconnected from a charger during this session."""
+        return self.plug_disconnected_date is not None
+
+    def was_unlocked(self) -> bool:
+        """Returns True if the vehicle was unlocked from a charger during this session."""
+        return self.plug_unlocked_date is not None

carconnectivity_plugins/database/model/charging_state.py

@@ -0,0 +1,57 @@
+""" This module contains the Vehicle charging 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.charging import Charging
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+class ChargingState(Base):  # pylint: disable=too-few-public-methods
+    """
+    SQLAlchemy model representing a vehicle's charging state over a time period.
+
+    This model stores charging state information for vehicles, tracking the state
+    between a first and last date. It maintains a foreign key relationship with
+    the Vehicle model through the VIN (Vehicle Identification Number).
+
+    Attributes:
+        id (int): Primary key for the charging state record.
+        vin (str): Foreign key reference to the vehicle's VIN in the vehicles table.
+        vehicle (Vehicle): Relationship to the associated Vehicle model.
+        first_date (datetime): The start datetime of this charging state period (UTC).
+        last_date (datetime): The end datetime of this charging state period (UTC).
+        state (Optional[Charging.ChargingState]): The charging state during this period,
+            or None if no state is available.
+
+    Args:
+        vin (str): The vehicle identification number.
+        first_date (datetime): The starting datetime for this charging state.
+        last_date (datetime): The ending datetime for this charging state.
+        state (Optional[Charging.ChargingState]): The charging state value.
+    """
+    __tablename__: str = 'charging_states'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="charging_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[Charging.ChargingState]]
+
+    def __init__(self, vin: str, first_date: datetime, last_date: datetime, state: Optional[Charging.ChargingState]) -> None:
+        self.vin = vin
+        self.first_date = first_date
+        self.last_date = last_date
+        self.state = state

carconnectivity_plugins/database/model/charging_station.py

@@ -0,0 +1,66 @@
+""" This module contains the charging stations 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.charging_station import ChargingStation as CarConnectivityChargingStation
+
+
+class ChargingStation(Base):  # pylint: disable=too-few-public-methods,too-many-instance-attributes
+    """
+    SQLAlchemy model representing a charging station in the database.
+    This class maps charging station data to the 'charging_stations' database table,
+    storing information about electric vehicle charging locations and their properties.
+    Attributes:
+        uid (str): Unique identifier for the charging station (primary key).
+        source (Optional[str]): Source or provider of the charging station data.
+        name (Optional[str]): Name or title of the charging station.
+        latitude (Optional[float]): Geographic latitude coordinate of the station.
+        longitude (Optional[float]): Geographic longitude coordinate of the station.
+        address (Optional[str]): Physical address of the charging station.
+        max_power (Optional[float]): Maximum power output in kilowatts (kW).
+        num_spots (Optional[int]): Number of available charging spots.
+        operator_id (Optional[str]): Identifier of the charging station operator.
+        operator_name (Optional[str]): Name of the charging station operator.
+        raw (Optional[str]): Raw data from the original source in string format.
+    Methods:
+        from_carconnectivity_charging_station: Class method to create an instance from a
+            CarConnectivity ChargingStation object.
+    """
+    __tablename__: str = 'charging_stations'
+
+    uid: Mapped[str] = mapped_column(primary_key=True)
+    source: Mapped[Optional[str]]
+    name: Mapped[Optional[str]]
+    latitude: Mapped[Optional[float]]
+    longitude: Mapped[Optional[float]]
+    address: Mapped[Optional[str]]
+    max_power: Mapped[Optional[float]]
+    num_spots: Mapped[Optional[int]]
+    operator_id: Mapped[Optional[str]]
+    operator_name: 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_charging_station(cls, charging_station: CarConnectivityChargingStation) -> ChargingStation:
+        """Create a ChargingStation instance from a carconnectivity ChargingStation object."""
+        cs = cls(uid=charging_station.uid.value)
+        cs.source = charging_station.source.value
+        cs.name = charging_station.name.value
+        cs.latitude = charging_station.latitude.value
+        cs.longitude = charging_station.longitude.value
+        cs.address = charging_station.address.value
+        cs.max_power = charging_station.max_power.value
+        cs.num_spots = charging_station.num_spots.value
+        cs.operator_id = charging_station.operator_id.value
+        cs.operator_name = charging_station.operator_name.value
+        cs.raw = charging_station.raw.value
+        return cs

carconnectivity_plugins/database/model/climatization_state.py

@@ -0,0 +1,57 @@
+""" This module contains the Vehicle climatization 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.climatization import Climatization
+
+from carconnectivity_plugins.database.model.base import Base
+
+if TYPE_CHECKING:
+    from sqlalchemy import Constraint
+
+
+class ClimatizationState(Base):  # pylint: disable=too-few-public-methods
+    """
+    SQLAlchemy model representing a vehicle's climatization state over a time period.
+
+    This model stores climatization state information for vehicles, tracking the state
+    between a first and last date. It maintains a foreign key relationship with
+    the Vehicle model through the VIN (Vehicle Identification Number).
+
+    Attributes:
+        id (int): Primary key for the climatization state record.
+        vin (str): Foreign key reference to the vehicle's VIN in the vehicles table.
+        vehicle (Vehicle): Relationship to the associated Vehicle model.
+        first_date (datetime): The start datetime of this climatization state period (UTC).
+        last_date (datetime): The end datetime of this climatization state period (UTC).
+        state (Optional[Climatization.ClimatizationState]): The climatization state during this period,
+            or None if no state is available.
+
+    Args:
+        vin (str): The vehicle identification number.
+        first_date (datetime): The starting datetime for this climatization state.
+        last_date (datetime): The ending datetime for this climatization state.
+        state (Optional[Climatization.ClimatizationState]): The climatization state value.
+    """
+    __tablename__: str = 'climatization_states'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="climatization_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[Climatization.ClimatizationState]]
+
+    def __init__(self, vin: str, first_date: datetime, last_date: datetime, state: Optional[Climatization.ClimatizationState]) -> None:
+        self.vin = vin
+        self.first_date = first_date
+        self.last_date = last_date
+        self.state = state

carconnectivity_plugins/database/model/connection_state.py

@@ -0,0 +1,57 @@
+""" This module contains the Vehicle connectionstate 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 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'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("vin", "first_date", name="connection_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)
+    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,89 @@
+""" This module contains the Drive database model"""
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+
+import logging
+
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from carconnectivity.drive import GenericDrive
+
+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 import scoped_session
+    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")
+
+
+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]]
+    capacity: Mapped[Optional[float]]
+    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:
+        """
+        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
+        """
+        if self.carconnectivity_drive is not None:
+            raise ValueError("Can only connect once! Drive already connected with database model")
+        self.carconnectivity_drive = carconnectivity_drive
+        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)  # type: ignore[assignment]
+        self.agents.append(drive_state_agent)
+        

carconnectivity_plugins/database/model/drive_consumption.py

@@ -0,0 +1,48 @@
+""" This module contains the Drive consumption 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 DriveConsumption(Base):  # pylint: disable=too-few-public-methods
+    """
+    SQLAlchemy model representing consumption data for a specific drive .
+    This model stores consumption measurements for a drive
+    tracking energy or fuel usage between two timestamps.
+    Attributes:
+        id (int): Primary key identifier for the drive consumption record.
+        drive_id (int): Foreign key reference to the associated Drive.
+        drive (Drive): Relationship to the parent Drive object.
+        first_date (datetime): Start timestamp of the consumption measurement period.
+        last_date (datetime): End timestamp of the consumption measurement period.
+        consumption (Optional[float]): Measured consumption value for the period (e.g., kWh, liters).
+    Table Constraints:
+        - Unique constraint on (drive_id, first_date) to prevent duplicate entries.
+    """
+    __tablename__: str = 'drive_consumptions'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("drive_id", "first_date", name="drive_consumptions_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)
+    consumption: 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, consumption: Optional[float]) -> None:
+        self.drive_id = drive_id
+        self.first_date = first_date
+        self.last_date = last_date
+        self.consumption = consumption

carconnectivity_plugins/database/model/drive_level.py

@@ -0,0 +1,50 @@
+""" This module contains the Drive level 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 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'
+    __table_args__: tuple[Constraint] = (UniqueConstraint("drive_id", "first_date", name="drive_levels_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)
+    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