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

carconnectivity_database/carconnectivity_database_base.py

@@ -0,0 +1,26 @@
+"""Module containing the commandline interface for the carconnectivity package."""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import logging
+
+from carconnectivity.carconnectivity_base import CLI
+
+from carconnectivity_plugins.database._version import __version__
+
+if TYPE_CHECKING:
+    pass
+
+LOG = logging.getLogger("carconnectivity-database")
+
+
+def main() -> None:
+    """
+    Entry point for the car connectivity database application.
+
+    This function initializes and starts the command-line interface (CLI) for the
+    car connectivity application using the specified logger and application name.
+    """
+    cli: CLI = CLI(logger=LOG, name='carconnectivity-database', description='Commandline Interface to interact with Car Services of various brands',
+                   subversion=__version__)
+    cli.main()

carconnectivity_plugin_database-0.1a1.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: carconnectivity-plugin-database
+Version: 0.1a1
+Summary: CarConnectivity plugin for storing data to Databases
+Author: Till Steinbach
+License: MIT License
+        
+        Copyright (c) 2021 Till Steinbach
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Home Automation
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: carconnectivity>=0.8
+Requires-Dist: sqlalchemy~=2.0.34
+Requires-Dist: psycopg2-binary~=2.9.9
+Requires-Dist: alembic~=1.13.2
+Dynamic: license-file
+
+
+
+# CarConnectivity Plugin for Database storage
+[![GitHub sourcecode](https://img.shields.io/badge/Source-GitHub-green)](https://github.com/tillsteinbach/CarConnectivity-plugin-database/)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/tillsteinbach/CarConnectivity-plugin-database)](https://github.com/tillsteinbach/CarConnectivity-plugin-database/releases/latest)
+[![GitHub](https://img.shields.io/github/license/tillsteinbach/CarConnectivity-plugin-database)](https://github.com/tillsteinbach/CarConnectivity-plugin-database/blob/master/LICENSE)
+[![GitHub issues](https://img.shields.io/github/issues/tillsteinbach/CarConnectivity-plugin-database)](https://github.com/tillsteinbach/CarConnectivity-plugin-database/issues)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/carconnectivity-plugin-database?label=PyPI%20Downloads)](https://pypi.org/project/carconnectivity-plugin-database/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/carconnectivity-plugin-database)](https://pypi.org/project/carconnectivity-plugin-database/)
+[![Donate at PayPal](https://img.shields.io/badge/Donate-PayPal-2997d8)](https://www.paypal.com/donate?hosted_button_id=2BVFF5GJ9SXAJ)
+[![Sponsor at Github](https://img.shields.io/badge/Sponsor-GitHub-28a745)](https://github.com/sponsors/tillsteinbach)
+
+[CarConnectivity](https://github.com/tillsteinbach/CarConnectivity) is a python API to connect to various car services. If you want to store the data collected from your vehicle to a relational database (e.g. MySQL, PostgreSQL, or SQLite) this plugin will help you.
+
+### Install using PIP
+If you want to use the CarConnectivity Plugin for Databases, the easiest way is to obtain it from [PyPI](https://pypi.org/project/carconnectivity-plugin-database/). Just install it using:
+```bash
+pip3 install carconnectivity-plugin-database
+```
+after you installed CarConnectivity
+
+## Configuration
+In your carconnectivity.json configuration add a section for the database plugin like this. A documentation of all possible config options can be found [here](https://github.com/tillsteinbach/CarConnectivity-plugin-database/tree/main/doc/Config.md).
+```
+{
+    "carConnectivity": {
+        "connectors": [
+            ...
+        ]
+        "plugins": [
+            {
+                "type": "database",
+                "config": {
+                    "db_url": "sqlite:///carconnectivity.db"
+                }
+            }
+        ]
+    }
+}
+```
+
+## Updates
+If you want to update, the easiest way is:
+```bash
+pip3 install carconnectivity-plugin-database --upgrade
+```

carconnectivity_plugin_database-0.1a1.dist-info/RECORD

@@ -0,0 +1,26 @@
+carconnectivity_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_database/carconnectivity_database_base.py,sha256=tsCWJJlBody2IDSw55WPkl-q4sAGNWHgid1iK7nQ5Jk,842
+carconnectivity_plugin_database-0.1a1.dist-info/licenses/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_plugins/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_plugins/database/_version.py,sha256=7RVZDNVLiBlSQw2ZRHUKaSt9y7gnMixptmDyf1GD1mk,514
+carconnectivity_plugins/database/plugin.py,sha256=g_OWJNR-v7QA8G_atvCX22S3Ff4DB14M_lPNAmpix-Y,15281
+carconnectivity_plugins/database/model/__init__.py,sha256=6TKjVHWZWXZWA_uqK38zioF8CN8Bh_LqPvEzX3Kh_FE,306
+carconnectivity_plugins/database/model/alembic.ini,sha256=_cT30ZkhLipi-fFq1NOPzBfpd_FTqj55co53TMuLGSM,2702
+carconnectivity_plugins/database/model/attribute.py,sha256=sIeAz1bJ12REvv5cck2Hii938u6PhLygNPBKFiSNetY,1076
+carconnectivity_plugins/database/model/attribute_value.py,sha256=yh7KrLVnh0Jr1xcU19-vlKA4i6HF4_wzZCnRzVyCGfI,5067
+carconnectivity_plugins/database/model/base.py,sha256=bYej-MB6Xp4On2hQA3k5BRvwxz5frKjFLKX7Arq61HQ,147
+carconnectivity_plugins/database/model/datetime_decorator.py,sha256=284bx5oQ5ACErm26qnif171QtKtF8efI2IBDXlyffzw,1444
+carconnectivity_plugins/database/model/migrations.py,sha256=x6XMnzTFfhIDRvEZ4B1jR73dFdrNUcpMCWeyAi324QI,897
+carconnectivity_plugins/database/model/timedelta_decorator.py,sha256=mdB9ZibJV-4v5H4EY25yxg407O2r6b5D960wMmCqLuE,976
+carconnectivity_plugins/database/model/carconnectivity_schema/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
+carconnectivity_plugins/database/model/carconnectivity_schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_plugins/database/model/carconnectivity_schema/env.py,sha256=trMAoTgw_EWjjTPnw1fWbKyDGEpAtbvd1exqznTozaE,2093
+carconnectivity_plugins/database/model/carconnectivity_schema/script.py.mako,sha256=8_xgA-gm_OhehnO7CiIijWgnm00ZlszEHtIHrAYFJl0,494
+carconnectivity_plugins/database/model/carconnectivity_schema/versions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_plugins/database/ui/plugin_ui.py,sha256=LQOuXIeBOLH4Gg0Qqjmzu9BOHI0Rir9KLq3gZF5Rlr4,1815
+carconnectivity_plugins/database/ui/templates/database/status.html,sha256=OypmDrRib6tBM1fC7ijyTmF9HI53XlpF4tq_diXiLKc,162
+carconnectivity_plugin_database-0.1a1.dist-info/METADATA,sha256=OHWDxC8rQYtVRl7O0moCAfKlKkioVh11FneAcEpdLSU,4809
+carconnectivity_plugin_database-0.1a1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+carconnectivity_plugin_database-0.1a1.dist-info/entry_points.txt,sha256=YB5RERxEA_pxYQesyAyzV8hmPM2o3_F9FZbnSQaSuLQ,105
+carconnectivity_plugin_database-0.1a1.dist-info/top_level.txt,sha256=836FhYp_OWsQq5Vyjb95dilEMQPHUYCTZa2GBgNFEVE,49
+carconnectivity_plugin_database-0.1a1.dist-info/RECORD,,

carconnectivity_plugin_database-0.1a1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

carconnectivity_plugin_database-0.1a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+carconnectivity-database = carconnectivity_database.carconnectivity_database_base:main

carconnectivity_plugin_database-0.1a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Till Steinbach
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

carconnectivity_plugin_database-0.1a1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+carconnectivity_database
+carconnectivity_plugins

carconnectivity_plugins/database/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1a1'
+__version_tuple__ = version_tuple = (0, 1, 'a1')

carconnectivity_plugins/database/model/__init__.py

@@ -0,0 +1,5 @@
+""" This module contains the database model for car connectivity plugins."""
+
+from .attribute import Attribute  # noqa: F401
+from .attribute_value import AttributeIntegerValue, AttributeBooleanValue, AttributeFloatValue, AttributeStringValue, AttributeDatetimeValue, \
+    AttributeEnumValue  # noqa: F401

carconnectivity_plugins/database/model/alembic.ini

@@ -0,0 +1,100 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = carconnectivity_schema
+
+# template used to generate migration files
+# file_template = %%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to vwsfriend-schema/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator"
+# version_locations = %(here)s/bar:%(here)s/bat:vwsfriend-schema/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. Valid values are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # default: use os.pathsep
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = sqlite:///carconnectivity-schema/reference.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

carconnectivity_plugins/database/model/attribute.py

@@ -0,0 +1,30 @@
+"""Module implements the database model for attributes"""
+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.attributes import GenericAttribute
+
+
+# pylint: disable-next=too-few-public-methods
+class Attribute(Base):
+    """Model for storing attributes in the database."""
+    __tablename__: str = 'attribute'
+    id: Mapped[int] = mapped_column(primary_key=True)
+    path: Mapped[Optional[str]] = mapped_column(unique=True, nullable=True)
+
+    def __init__(self, path: str) -> None:
+        self.path = path
+
+    @classmethod
+    def from_generic_attribute(cls, attribute: GenericAttribute) -> Attribute:
+        """Create an Attribute instance from a GenericAttribute.
+        Args:
+            attribute (GenericAttribute): The generic attribute to convert.
+        Returns:
+            Attribute: An instance of the Attribute class."""
+        return cls(path=attribute.get_absolute_path())

carconnectivity_plugins/database/model/attribute_value.py

@@ -0,0 +1,121 @@
+"""Module implements the database model for attribute values."""
+from __future__ import annotations
+from typing import Optional
+
+from datetime import datetime, timedelta
+
+
+from sqlalchemy import Integer, Boolean, Float, String, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship, declared_attr
+
+from carconnectivity_plugins.database.model.base import Base
+from carconnectivity_plugins.database.model.datetime_decorator import DatetimeDecorator
+from carconnectivity_plugins.database.model.timedelta_decorator import TimedeltaDecorator
+
+from carconnectivity_plugins.database.model.attribute import Attribute
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeValue(Base):
+    """Base class for storing attribute values in the database."""
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    attribute_id: Mapped[int] = mapped_column(Integer, ForeignKey("attribute.id"), nullable=False)
+    start_date: Mapped[datetime] = mapped_column(DatetimeDecorator(timezone=True), nullable=False)
+    end_date: Mapped[Optional[datetime]] = mapped_column(DatetimeDecorator(timezone=True), nullable=True)
+
+    @declared_attr
+    # pylint: disable-next=no-self-argument
+    def attribute(cls):
+        """Relationship to the Attribute model."""
+        return relationship("Attribute")
+
+    def __init__(self, attribute: Attribute, start_date: datetime) -> None:
+        self.attribute = attribute
+        self.start_date = start_date
+        self.end = None
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeIntegerValue(AttributeValue):
+    """Model for storing integer values of attributes in the database."""
+    __tablename__: str = 'attribute_integer_value'
+
+    value: Mapped[Optional[int]] = mapped_column(Integer, nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[int]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeBooleanValue(AttributeValue):
+    """Model for storing booleans values of attributes in the database."""
+    __tablename__: str = 'attribute_boolean_value'
+
+    value: Mapped[Optional[bool]] = mapped_column(Boolean, nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[bool]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeFloatValue(AttributeValue):
+    """Model for storing float values of attributes in the database."""
+    __tablename__: str = 'attribute_float_value'
+
+    value: Mapped[Optional[float]] = mapped_column(Float, nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[float]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeStringValue(AttributeValue):
+    """Model for storing string values of attributes in the database."""
+    __tablename__: str = 'attribute_string_value'
+
+    value: Mapped[Optional[str]] = mapped_column(String, nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[str]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeDatetimeValue(AttributeValue):
+    """Model for storing datetime values of attributes in the database."""
+    __tablename__: str = 'attribute_datetime_value'
+
+    value: Mapped[Optional[datetime]] = mapped_column(DatetimeDecorator(timezone=True), nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[datetime]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeDurationValue(AttributeValue):
+    """Model for storing timedelta values of attributes in the database."""
+    __tablename__: str = 'attribute_duration_value'
+
+    value: Mapped[Optional[timedelta]] = mapped_column(TimedeltaDecorator(), nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[timedelta]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value
+
+
+# pylint: disable-next=too-few-public-methods
+class AttributeEnumValue(AttributeValue):
+    """Model for storing enum values of attributes in the database."""
+    __tablename__: str = 'attribute_enum_value'
+
+    value: Mapped[Optional[str]] = mapped_column(String, nullable=True, sort_order=1)
+
+    def __init__(self, attribute: Attribute, start_date: datetime, value: Optional[str]) -> None:
+        super().__init__(attribute=attribute, start_date=start_date)
+        self.value = value

carconnectivity_plugins/database/model/base.py

@@ -0,0 +1,4 @@
+"""Module just storing the Base class for SQLAlchemy models."""
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()

carconnectivity_plugins/database/model/carconnectivity_schema/README

@@ -0,0 +1 @@
+Generic single-database configuration.

carconnectivity_plugins/database/model/carconnectivity_schema/env.py

@@ -0,0 +1,78 @@
+# pylint: skip-file
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from carconnectivity_plugins.database.model.base import Base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.attributes.get('configure_logger', True):
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        compare_type=True,
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata, compare_type=True
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

carconnectivity_plugins/database/model/carconnectivity_schema/script.py.mako

@@ -0,0 +1,24 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

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/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/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/plugin.py

@@ -0,0 +1,263 @@
+"""Module implements the plugin to connect with Database"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import threading
+import logging
+
+from sqlalchemy import Engine, create_engine, text, inspect
+from sqlalchemy.orm import sessionmaker, scoped_session
+from sqlalchemy.exc import OperationalError
+from sqlalchemy.orm.session import Session
+
+from carconnectivity.errors import ConfigurationError
+from carconnectivity.util import config_remove_credentials
+
+from carconnectivity.observable import Observable
+
+from carconnectivity.attributes import GenericAttribute, IntegerAttribute, BooleanAttribute, FloatAttribute, StringAttribute, DateAttribute, EnumAttribute, \
+    DurationAttribute
+
+from carconnectivity_plugins.base.plugin import BasePlugin
+
+from carconnectivity_plugins.database._version import __version__
+from carconnectivity_plugins.database.model.migrations import run_database_migrations
+
+from carconnectivity_plugins.database.model.base import Base
+from carconnectivity_plugins.database.model.attribute import Attribute
+from carconnectivity_plugins.database.model.attribute_value import AttributeIntegerValue, AttributeBooleanValue, AttributeFloatValue, AttributeStringValue, \
+    AttributeDatetimeValue, AttributeDurationValue, AttributeEnumValue
+
+if TYPE_CHECKING:
+    from typing import Dict, Optional, Any
+    from carconnectivity.carconnectivity import CarConnectivity
+
+LOG: logging.Logger = logging.getLogger("carconnectivity.plugins.database")
+
+
+class Plugin(BasePlugin):  # pylint: disable=too-many-instance-attributes
+    """
+    Plugin class for Database connectivity.
+    Args:
+        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) -> 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()
+
+        LOG.info("Loading database plugin with config %s", config_remove_credentials(config))
+
+        if 'db_url' in config:
+            self.active_config['db_url'] = config['db_url']
+        else:
+            raise ConfigurationError('db_url must be configured in the plugin config')
+
+        connect_args = {}
+        if 'postgresql' in self.active_config['db_url']:
+            connect_args['options'] = '-c timezone=utc'
+        self.engine: Engine = create_engine(self.active_config['db_url'], pool_pre_ping=True, connect_args=connect_args)
+        session_factory: sessionmaker[Session] = sessionmaker(bind=self.engine)
+        scoped_session_factory: scoped_session[Session] = scoped_session(session_factory)
+        self.session: Session = scoped_session_factory()
+
+        self.attribute_map: Dict[GenericAttribute, Attribute] = {}
+
+    def startup(self) -> None:
+        LOG.info("Starting database plugin")
+        self._background_thread = threading.Thread(target=self._background_loop, daemon=False)
+        self._background_thread.name = 'carconnectivity.plugins.database-background'
+        self._background_thread.start()
+        self.healthy._set_value(value=True)  # pylint: disable=protected-access
+        LOG.debug("Starting Database plugin done")
+        return super().startup()
+
+    def _background_loop(self) -> None:
+        self._stop_event.clear()
+        first_run: bool = True
+        while not self._stop_event.is_set():
+            try:
+                self.session.execute(text('SELECT 1')).all()
+                self.healthy._set_value(value=True)  # pylint: disable=protected-access
+                if first_run:
+                    LOG.info('Database connection established successfully')
+                    first_run = False
+                    if not inspect(self.engine).has_table("alembic_version"):
+                        LOG.info('It looks like you have an empty database will create all tables')
+                        Base.metadata.create_all(self.engine)
+                        run_database_migrations(dsn=self.active_config['db_url'], stamp_only=True)
+                    else:
+                        LOG.info('It looks like you have an existing database will check if an upgrade is necessary')
+                        run_database_migrations(dsn=self.active_config['db_url'])
+                        LOG.info('Database upgrade done')
+
+                    self.car_connectivity.add_observer(observer=self.__on_attribute_update, flag=Observable.ObserverEvent.ALL, on_transaction_end=True)
+
+                    for attribute in self.car_connectivity.get_attributes(recursive=True):
+                        self.register_attribute(attribute, commit=False)
+                    self.session.commit()
+
+            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
+            self._stop_event.wait(10)
+
+    def shutdown(self) -> None:
+        self._stop_event.set()
+        if self._background_thread is not None:
+            self._background_thread.join()
+        return super().shutdown()
+
+    def get_version(self) -> str:
+        return __version__
+
+    def get_type(self) -> str:
+        return "carconnectivity-plugin-database"
+
+    def get_name(self) -> str:
+        return "Database Plugin"
+
+    def __on_attribute_update(self, element: Any, flags: Observable.ObserverEvent):
+        """
+        Callback for attribute updates.
+        Args:
+            element (Any): The updated element.
+            flags (Observable.ObserverEvent): Flags indicating the type of update.
+        """
+        if isinstance(element, GenericAttribute):
+            if flags & Observable.ObserverEvent.ENABLED:
+                LOG.debug('Attribute %s enabled', element.name)
+                self.register_attribute(element, commit=True)
+            elif flags & Observable.ObserverEvent.DISABLED:
+                LOG.debug('Attribute %s disabled', element.name)
+                if element in self.attribute_map:
+                    del self.attribute_map[element]
+            elif flags & Observable.ObserverEvent.VALUE_CHANGED:
+                LOG.debug('Attribute %s value changed', element.name)
+                self.update_value(element, commit=True)
+
+    def register_attribute(self, attribute: GenericAttribute, commit: bool = True) -> Attribute:
+        """ Register an attribute in the database.
+        Args:
+            attribute (GenericAttribute): The attribute to register.
+            commit (bool): Whether to commit the session after registering.
+        Returns:
+            Attribute: The database attribute instance."""
+        database_attribute: Optional[Attribute] = self.session.query(Attribute).filter(Attribute.path == attribute.get_absolute_path()).first()
+        if database_attribute is None:
+            database_attribute = Attribute.from_generic_attribute(attribute)
+            self.session.add(database_attribute)
+        self.attribute_map[attribute] = database_attribute
+        LOG.debug('Registering attribute %s', attribute.name)
+        self.update_value(attribute=attribute, commit=commit)
+        LOG.debug('Updated value for attribute %s to %s', attribute.name, attribute.value)
+        if commit:
+            self.session.commit()
+        return database_attribute
+
+    # pylint: disable-next=too-many-branches, too-many-statements
+    def update_value(self, attribute: GenericAttribute, commit: bool = True) -> None:
+        """ Update the value of an attribute in the database.
+        Args:
+            attribute (GenericAttribute): The attribute to update.
+            commit (bool): Whether to commit the session after updating."""
+        if attribute not in self.attribute_map:
+            database_attribute: Attribute = self.register_attribute(attribute, commit=commit)
+        else:
+            database_attribute = self.attribute_map[attribute]
+        if attribute.last_updated is not None:
+            if isinstance(attribute, IntegerAttribute):
+                last_integer_value: Optional[AttributeIntegerValue] = self.session.query(AttributeIntegerValue) \
+                    .filter(AttributeIntegerValue.attribute == database_attribute) \
+                    .order_by(AttributeIntegerValue.start_date.desc()).first()
+                if last_integer_value is None or last_integer_value.value != attribute.value:
+                    last_integer_value = AttributeIntegerValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_integer_value.end_date = attribute.last_updated
+                    self.session.add(last_integer_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_integer_value.value = attribute.value
+                    last_integer_value.end_date = attribute.last_updated
+            elif isinstance(attribute, BooleanAttribute):
+                last_boolean_value: Optional[AttributeBooleanValue] = self.session.query(AttributeBooleanValue) \
+                    .filter(AttributeBooleanValue.attribute == database_attribute) \
+                    .order_by(AttributeBooleanValue.start_date.desc()).first()
+                if last_boolean_value is None or last_boolean_value.value != attribute.value:
+                    last_boolean_value = AttributeBooleanValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_boolean_value.end_date = attribute.last_updated
+                    self.session.add(last_boolean_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_boolean_value.value = attribute.value
+                    last_boolean_value.end_date = attribute.last_updated
+            elif isinstance(attribute, FloatAttribute):
+                last_float_value: Optional[AttributeFloatValue] = self.session.query(AttributeFloatValue) \
+                    .filter(AttributeFloatValue.attribute == database_attribute) \
+                    .order_by(AttributeFloatValue.start_date.desc()).first()
+                if last_float_value is None or last_float_value.value != attribute.value:
+                    last_float_value = AttributeFloatValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_float_value.end_date = attribute.last_updated
+                    self.session.add(last_float_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_float_value.value = attribute.value
+                    last_float_value.end_date = attribute.last_updated
+            elif isinstance(attribute, StringAttribute):
+                last_string_value: Optional[AttributeStringValue] = self.session.query(AttributeStringValue) \
+                    .filter(AttributeStringValue.attribute == database_attribute) \
+                    .order_by(AttributeStringValue.start_date.desc()).first()
+                if last_string_value is None or last_string_value.value != attribute.value:
+                    last_string_value = AttributeStringValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_string_value.end_date = attribute.last_updated
+                    self.session.add(last_string_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_string_value.value = attribute.value
+                    last_string_value.end_date = attribute.last_updated
+            elif isinstance(attribute, DateAttribute):
+                last_datetime_value: Optional[AttributeDatetimeValue] = self.session.query(AttributeDatetimeValue) \
+                    .filter(AttributeDatetimeValue.attribute == database_attribute) \
+                    .order_by(AttributeDatetimeValue.start_date.desc()).first()
+                if last_datetime_value is None or last_datetime_value.value != attribute.value:
+                    last_datetime_value = AttributeDatetimeValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_datetime_value.end_date = attribute.last_updated
+                    self.session.add(last_datetime_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_datetime_value.value = attribute.value
+                    last_datetime_value.end_date = attribute.last_updated
+            elif isinstance(attribute, DurationAttribute):
+                last_duration_value: Optional[AttributeDurationValue] = self.session.query(AttributeDurationValue) \
+                    .filter(AttributeDurationValue.attribute == database_attribute) \
+                    .order_by(AttributeDurationValue.start_date.desc()).first()
+                if last_duration_value is None or last_duration_value.value != attribute.value:
+                    last_duration_value = AttributeDurationValue(attribute=database_attribute, start_date=attribute.last_updated, value=attribute.value)
+                    last_duration_value.end_date = attribute.last_updated
+                    self.session.add(last_duration_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_duration_value.value = attribute.value
+                    last_duration_value.end_date = attribute.last_updated
+            elif isinstance(attribute, EnumAttribute):
+                last_enum_value: Optional[AttributeEnumValue] = self.session.query(AttributeEnumValue) \
+                    .filter(AttributeEnumValue.attribute == database_attribute) \
+                    .order_by(AttributeEnumValue.start_date.desc()).first()
+                if attribute.value is None:
+                    value: Optional[str] = None
+                else:
+                    value = attribute.value.value
+                if last_enum_value is None or last_enum_value.value != value:
+                    last_enum_value = AttributeEnumValue(attribute=database_attribute, start_date=attribute.last_updated, value=value)
+                    last_enum_value.end_date = attribute.last_updated
+                    self.session.add(last_enum_value)
+                    LOG.debug('Updating value for attribute %s to %s', attribute.name, attribute.value)
+                else:
+                    last_enum_value.value = value
+                    last_enum_value.end_date = attribute.last_updated
+            else:
+                LOG.debug('Attribute type %s is not supported for database storage', type(attribute).__name__)
+                return
+            if commit:
+                self.session.commit()

carconnectivity_plugins/database/ui/plugin_ui.py

@@ -0,0 +1,48 @@
+""" User interface for the Database plugin in the Car Connectivity application. """
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+import os
+
+import flask
+import flask_login
+
+from carconnectivity_plugins.base.plugin import BasePlugin
+from carconnectivity_plugins.base.ui.plugin_ui import BasePluginUI
+
+if TYPE_CHECKING:
+    from typing import Optional, List, Dict, Union, Literal
+
+
+class PluginUI(BasePluginUI):
+    """
+    A user interface class for the Database plugin in the Car Connectivity application.
+    """
+    def __init__(self, plugin: BasePlugin):
+        blueprint: Optional[flask.Blueprint] = flask.Blueprint(name=plugin.id, import_name='carconnectivity-plugin-database', url_prefix=f'/{plugin.id}',
+                                                               template_folder=os.path.dirname(__file__) + '/templates')
+        super().__init__(plugin, blueprint=blueprint)
+
+        @self.blueprint.route('/', methods=['GET'])
+        def root():
+            return flask.redirect(flask.url_for('plugins.database.status'))
+
+        @self.blueprint.route('/status', methods=['GET'])
+        @flask_login.login_required
+        def status():
+            return flask.render_template('database/status.html', current_app=flask.current_app, plugin=self.plugin)
+
+    def get_nav_items(self) -> List[Dict[Literal['text', 'url', 'sublinks', 'divider'], Union[str, List]]]:
+        """
+        Generates a list of navigation items for the Database plugin UI.
+        """
+        return super().get_nav_items() + [{"text": "Status", "url": flask.url_for('plugins.database.status')}]
+
+    def get_title(self) -> str:
+        """
+        Returns the title of the plugin.
+
+        Returns:
+            str: The title of the plugin, which is "Database".
+        """
+        return "Database"

carconnectivity_plugins/database/ui/templates/database/status.html

@@ -0,0 +1,8 @@
+{% extends 'base.html' %}
+
+{% block header %}
+  <h1>{% block title %}Database Plugin Status {% endblock %}</h1>
+{% endblock %}
+
+{% block content %}
+{% endblock %}