carconnectivity-plugin-database 0.1a3__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.1a3.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: carconnectivity-plugin-database
+Version: 0.1a3
+Summary: CarConnectivity plugin for storing data to Databases
+Author: Till Steinbach
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+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: Programming Language :: Python :: 3.14
+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.9.2
+Requires-Dist: sqlalchemy~=2.0.45
+Requires-Dist: psycopg2-binary~=2.9.11
+Requires-Dist: alembic~=1.17.2
+Requires-Dist: SQLAlchemy-Utc~=0.14.0
+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.1a3.dist-info/RECORD

@@ -0,0 +1,34 @@
+carconnectivity_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_database/carconnectivity_database_base.py,sha256=tsCWJJlBody2IDSw55WPkl-q4sAGNWHgid1iK7nQ5Jk,842
+carconnectivity_plugin_database-0.1a3.dist-info/licenses/LICENSE,sha256=PIwI1alwDyOfvEQHdGCm2u9uf_mGE8030xZDfun0xTo,1071
+carconnectivity_plugins/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+carconnectivity_plugins/database/_version.py,sha256=_w2cIB58_wzKZ1MSbddFmQnkPRdfZ2IDpMt6GPDBSXg,707
+carconnectivity_plugins/database/plugin.py,sha256=GoZDei--vp0oT5GIij1E3Pa0XA8OvRXugSjKcUOgoiw,7524
+carconnectivity_plugins/database/agents/base_agent.py,sha256=WsEoB-dIZ6le3vuObwPDOBQ5WJUyfzqrE8SQIJD5X4I,28
+carconnectivity_plugins/database/agents/drive_state_agent.py,sha256=k494_Zq8jgULjICnjiX1v5oZvgG9wApc1n5G5AQstdE,3877
+carconnectivity_plugins/database/agents/state_agent.py,sha256=Cqu4SWrQdct6jYUSLz620uGwv_iEc-JYjIXLEaGABT4,6146
+carconnectivity_plugins/database/model/__init__.py,sha256=dT11R2M29wQLbMLWtrBpgYfQCoYIvOKWSjO9DqrwSjk,426
+carconnectivity_plugins/database/model/alembic.ini,sha256=_cT30ZkhLipi-fFq1NOPzBfpd_FTqj55co53TMuLGSM,2702
+carconnectivity_plugins/database/model/base.py,sha256=bYej-MB6Xp4On2hQA3k5BRvwxz5frKjFLKX7Arq61HQ,147
+carconnectivity_plugins/database/model/connection_state.py,sha256=QI6rPffEhsaYwU-Xsp6W1SDfJ1civWASbZzzxlebtiA,2547
+carconnectivity_plugins/database/model/datetime_decorator.py,sha256=284bx5oQ5ACErm26qnif171QtKtF8efI2IBDXlyffzw,1444
+carconnectivity_plugins/database/model/drive.py,sha256=f6Lu_SL9MdyczDRBHAgyae5FwQq4EAghcRlR0MGI0oA,4290
+carconnectivity_plugins/database/model/drive_level.py,sha256=GbU8Tf2eMN6Y9ixKFkJX-vOHBf3FP-MXqaQA36_bySA,2035
+carconnectivity_plugins/database/model/drive_range.py,sha256=6Rz-j6oFL0UAHHwNGJ0E3ST23sUa1fEgY9qSzoj40KY,2202
+carconnectivity_plugins/database/model/migrations.py,sha256=x6XMnzTFfhIDRvEZ4B1jR73dFdrNUcpMCWeyAi324QI,897
+carconnectivity_plugins/database/model/outside_temperature.py,sha256=kxqZk86rSa2eDkySmyUMRrHBdLMU5n1lQ2iePfUwS6k,2391
+carconnectivity_plugins/database/model/state.py,sha256=rJQV-C4cGxbDZwyVaPo3RjbmeilGv5mPszdCX9YZmiM,2426
+carconnectivity_plugins/database/model/timedelta_decorator.py,sha256=mdB9ZibJV-4v5H4EY25yxg407O2r6b5D960wMmCqLuE,976
+carconnectivity_plugins/database/model/vehicle.py,sha256=NTlQhxzlt0UK2EgeNUZqg71G2qNoKNnGFWjedHAJGv0,8174
+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.1a3.dist-info/METADATA,sha256=favJKw69RkxAnQQOwygUaTMJXIzX0wB-zimOHcruOxU,3625
+carconnectivity_plugin_database-0.1a3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+carconnectivity_plugin_database-0.1a3.dist-info/entry_points.txt,sha256=YB5RERxEA_pxYQesyAyzV8hmPM2o3_F9FZbnSQaSuLQ,105
+carconnectivity_plugin_database-0.1a3.dist-info/top_level.txt,sha256=836FhYp_OWsQq5Vyjb95dilEMQPHUYCTZa2GBgNFEVE,49
+carconnectivity_plugin_database-0.1a3.dist-info/RECORD,,

carconnectivity_plugin_database-0.1a3.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.1a3.dist-info/entry_points.txt

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

carconnectivity_plugin_database-0.1a3.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.1a3.dist-info/top_level.txt

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

carconnectivity_plugins/database/_version.py

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

carconnectivity_plugins/database/agents/base_agent.py

@@ -0,0 +1,2 @@
+class BaseAgent():
+    pass

carconnectivity_plugins/database/agents/drive_state_agent.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from carconnectivity.observable import Observable
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.model.drive_level import DriveLevel
+from carconnectivity_plugins.database.model.drive_range import DriveRange
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from sqlalchemy.orm.session import Session
+
+    from carconnectivity.attributes import LevelAttribute, RangeAttribute
+
+    from carconnectivity_plugins.database.model.drive import Drive
+
+
+class DriveStateAgent(BaseAgent):
+    def __init__(self, session: Session, drive: Drive) -> None:
+        if drive is None or drive.carconnectivity_drive is None:
+            raise ValueError("Drive or its carconnectivity_drive attribute is None")
+        self.session: Session = session
+        self.drive: Drive = drive
+
+        self.last_level: Optional[DriveLevel] = session.query(DriveLevel).filter(DriveLevel.drive_id == drive.id).order_by(DriveLevel.first_date.desc()).first()
+        self.last_range: Optional[DriveRange] = session.query(DriveRange).filter(DriveRange.drive_id == drive.id).order_by(DriveRange.first_date.desc()).first()
+
+        drive.carconnectivity_drive.level.add_observer(self.__on_level_change, Observable.ObserverEvent.UPDATED)
+        self.__on_level_change(drive.carconnectivity_drive.level, Observable.ObserverEvent.UPDATED)
+
+        drive.carconnectivity_drive.range.add_observer(self.__on_range_change, Observable.ObserverEvent.UPDATED)
+        self.__on_range_change(drive.carconnectivity_drive.range, Observable.ObserverEvent.UPDATED)
+
+    def __on_level_change(self, element: LevelAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.last_level is not None:
+            self.session.refresh(self.last_level)
+        if (self.last_level is None or self.last_level.level != element.value) \
+                and element.last_updated is not None:
+            new_level: DriveLevel = DriveLevel(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                               level=element.value)
+            with self.session.begin_nested():
+                self.session.add(new_level)
+            self.session.commit()
+            self.last_level = new_level
+        elif self.last_level is not None and self.last_level.level == element.value \
+                and element.last_updated is not None:
+            if self.last_level.last_date is None or element.last_updated > self.last_level.last_date:
+                with self.session.begin_nested():
+                    self.last_level.last_date = element.last_updated
+                self.session.commit()
+
+    def __on_range_change(self, element: RangeAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.last_range is not None:
+            self.session.refresh(self.last_range)
+        if (self.last_range is None or self.last_range.range != element.value) \
+                and element.last_updated is not None:
+            new_range: DriveRange = DriveRange(drive_id=self.drive.id, first_date=element.last_updated, last_date=element.last_updated,
+                                               range=element.value)
+            with self.session.begin_nested():
+                self.session.add(new_range)
+            self.session.commit()
+            self.last_range = new_range
+        elif self.last_range is not None and self.last_range.range == element.value \
+                and element.last_updated is not None:
+            if self.last_range.last_date is None or element.last_updated > self.last_range.last_date:
+                with self.session.begin_nested():
+                    self.last_range.last_date = element.last_updated
+                self.session.commit()

carconnectivity_plugins/database/agents/state_agent.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+from carconnectivity.observable import Observable
+
+from carconnectivity_plugins.database.agents.base_agent import BaseAgent
+from carconnectivity_plugins.database.model.state import State
+from carconnectivity_plugins.database.model.connection_state import ConnectionState
+from carconnectivity_plugins.database.model.outside_temperature import OutsideTemperature
+
+if TYPE_CHECKING:
+    from typing import Optional
+    from sqlalchemy.orm.session import Session
+
+    from carconnectivity.attributes import EnumAttribute, TemperatureAttribute
+
+    from carconnectivity.vehicle import GenericVehicle
+
+    from carconnectivity_plugins.database.model.vehicle import Vehicle
+
+
+class StateAgent(BaseAgent):
+    def __init__(self, session: Session, vehicle: Vehicle) -> None:
+        if vehicle is None or vehicle.carconnectivity_vehicle is None:
+            raise ValueError("Vehicle or its carconnectivity_vehicle attribute is None")
+        self.session: Session = session
+        self.vehicle: Vehicle = vehicle
+        self.last_state: Optional[State] = session.query(State).filter(State.vehicle == vehicle).order_by(State.first_date.desc()).first()
+        self.last_connection_state: Optional[ConnectionState] = session.query(ConnectionState).filter(ConnectionState.vehicle == vehicle) \
+            .order_by(ConnectionState.first_date.desc()).first()
+        self.last_outside_temperature: Optional[OutsideTemperature] = session.query(OutsideTemperature).filter(OutsideTemperature.vehicle == vehicle) \
+            .order_by(OutsideTemperature.first_date.desc()).first()
+
+        vehicle.carconnectivity_vehicle.state.add_observer(self.__on_state_change, Observable.ObserverEvent.UPDATED)
+        self.__on_state_change(vehicle.carconnectivity_vehicle.state, Observable.ObserverEvent.UPDATED)
+
+        vehicle.carconnectivity_vehicle.connection_state.add_observer(self.__on_connection_state_change, Observable.ObserverEvent.UPDATED)
+        self.__on_connection_state_change(vehicle.carconnectivity_vehicle.connection_state, Observable.ObserverEvent.UPDATED)
+
+        vehicle.carconnectivity_vehicle.outside_temperature.add_observer(self.__on_outside_temperature_change, Observable.ObserverEvent.UPDATED)
+        self.__on_outside_temperature_change(vehicle.carconnectivity_vehicle.outside_temperature, Observable.ObserverEvent.UPDATED)
+
+    def __on_state_change(self, element: EnumAttribute[GenericVehicle.State], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.last_state is not None:
+            self.session.refresh(self.last_state)
+        if (self.last_state is None or self.last_state.state != element.value) \
+                and element.last_updated is not None:
+            new_state: State = State(vin=self.vehicle.vin, first_date=element.last_updated, last_date=element.last_updated, state=element.value)
+            with self.session.begin_nested():
+                self.session.add(new_state)
+            self.session.commit()
+            self.last_state = new_state
+        elif self.last_state is not None and self.last_state.state == element.value and element.last_updated is not None:
+            if self.last_state.last_date is None or element.last_updated > self.last_state.last_date:
+                with self.session.begin_nested():
+                    self.last_state.last_date = element.last_updated
+                self.session.commit()
+
+    def __on_connection_state_change(self, element: EnumAttribute[GenericVehicle.ConnectionState], flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.last_connection_state is not None:
+            self.session.refresh(self.last_connection_state)
+        if (self.last_connection_state is None or self.last_connection_state.connection_state != element.value) \
+                and element.last_updated is not None:
+            new_connection_state: ConnectionState = ConnectionState(vin=self.vehicle.vin, first_date=element.last_updated,
+                                                                    last_date=element.last_updated, connection_state=element.value)
+            with self.session.begin_nested():
+                self.session.add(new_connection_state)
+            self.session.commit()
+            self.last_connection_state = new_connection_state
+        elif self.last_connection_state is not None and self.last_connection_state.connection_state == element.value and element.last_updated is not None:
+            if self.last_connection_state.last_date is None or element.last_updated > self.last_connection_state.last_date:
+                with self.session.begin_nested():
+                    self.last_connection_state.last_date = element.last_updated
+                self.session.commit()
+
+    def __on_outside_temperature_change(self, element: TemperatureAttribute, flags: Observable.ObserverEvent) -> None:
+        del flags
+        if self.last_outside_temperature is not None:
+            self.session.refresh(self.last_outside_temperature)
+        if (self.last_outside_temperature is None or self.last_outside_temperature.outside_temperature != element.value) \
+                and element.last_updated is not None:
+            new_outside_temperature: OutsideTemperature = OutsideTemperature(vin=self.vehicle.vin, first_date=element.last_updated,
+                                                                             last_date=element.last_updated, outside_temperature=element.value)
+            self.session.add(new_outside_temperature)
+            self.session.commit()
+            self.last_outside_temperature = new_outside_temperature
+        elif self.last_outside_temperature is not None and self.last_outside_temperature.outside_temperature == element.value \
+                and element.last_updated is not None:
+            if self.last_outside_temperature.last_date is None or element.last_updated > self.last_outside_temperature.last_date:
+                with self.session.begin_nested():
+                    self.last_outside_temperature.last_date = element.last_updated
+                self.session.commit()

carconnectivity_plugins/database/model/__init__.py

@@ -0,0 +1,10 @@
+""" This module contains the database model for car connectivity plugins."""
+
+from .drive import Drive  # noqa: F401
+from .drive_level import DriveLevel  # noqa: F401
+from .drive_range import DriveRange  # noqa: F401
+from .connection_state import ConnectionState  # noqa: F401
+from .outside_temperature import OutsideTemperature  # noqa: F401
+from .state import State  # noqa: F401
+from .vehicle import Vehicle  # 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/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"}