Renamed project

src/cpl_core/database/__init__.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+"""
+sh_cpl-core sh-edraft Common Python library
+~~~~~~~~~~~~~~~~~~~
+
+sh-edraft Common Python library
+
+:copyright: (c) 2020 - 2021 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'cpl_core.database'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2020 - 2021 sh-edraft.de'
+__version__ = '2021.10.6'
+
+from collections import namedtuple
+
+# imports:
+from .database_model import DatabaseModel
+from .database_settings import DatabaseSettings
+from .database_settings_name_enum import DatabaseSettingsNameEnum
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='2021', minor='10', micro='6')

src/cpl_core/database/connection/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+"""
+sh_cpl-core sh-edraft Common Python library
+~~~~~~~~~~~~~~~~~~~
+
+sh-edraft Common Python library
+
+:copyright: (c) 2020 - 2021 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'cpl_core.database.connection'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2020 - 2021 sh-edraft.de'
+__version__ = '2021.10.6'
+
+from collections import namedtuple
+
+# imports:
+from .database_connection import DatabaseConnection
+from .database_connection_abc import DatabaseConnectionABC
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='2021', minor='10', micro='6')

src/cpl_core/database/connection/database_connection.py

@@ -0,0 +1,64 @@
+from typing import Optional
+
+from sqlalchemy import engine, create_engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from cpl.console.console import Console
+from cpl.console.foreground_color_enum import ForegroundColorEnum
+from cpl.database.connection.database_connection_abc import DatabaseConnectionABC
+from cpl.database.database_settings import DatabaseSettings
+
+
+class DatabaseConnection(DatabaseConnectionABC):
+    r"""Representation of the database connection
+
+    Parameter
+    ---------
+        database_settings: :class:`cpl.database.database_settings.DatabaseSettings`
+    """
+
+    def __init__(self, database_settings: DatabaseSettings):
+        DatabaseConnectionABC.__init__(self)
+
+        self._db_settings = database_settings
+
+        self._engine: Optional[engine] = None
+        self._session: Optional[Session] = None
+        self._credentials: Optional[str] = None
+
+    @property
+    def engine(self) -> engine:
+        return self._engine
+
+    @property
+    def session(self) -> Session:
+        return self._session
+
+    def connect(self, connection_string: str):
+        try:
+            self._engine = create_engine(connection_string)
+
+            if self._db_settings.auth_plugin is not None:
+                self._engine = create_engine(connection_string, connect_args={'auth_plugin': self._db_settings.auth_plugin})
+
+            if self._db_settings.encoding is not None:
+                self._engine.encoding = self._db_settings.encoding
+
+            if self._db_settings.case_sensitive is not None:
+                self._engine.case_sensitive = self._db_settings.case_sensitive
+
+            if self._db_settings.echo is not None:
+                self._engine.echo = self._db_settings.echo
+
+            self._engine.connect()
+
+            db_session = sessionmaker(bind=self._engine)
+            self._session = db_session()
+            Console.set_foreground_color(ForegroundColorEnum.green)
+            Console.write_line(f'[{__name__}] Connected to database')
+            Console.set_foreground_color(ForegroundColorEnum.default)
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(f'[{__name__}] Database connection failed -> {e}')
+            Console.set_foreground_color(ForegroundColorEnum.default)
+            exit()

src/cpl_core/database/connection/database_connection_abc.py

@@ -0,0 +1,30 @@
+from abc import abstractmethod, ABC
+
+from sqlalchemy import engine
+from sqlalchemy.orm import Session
+
+
+class DatabaseConnectionABC(ABC):
+    r"""ABC for the :class:`cpl.database.connection.database_connection.DatabaseConnection`"""
+
+    @abstractmethod
+    def __init__(self): pass
+
+    @property
+    @abstractmethod
+    def engine(self) -> engine: pass
+
+    @property
+    @abstractmethod
+    def session(self) -> Session: pass
+
+    @abstractmethod
+    def connect(self, connection_string: str):
+        r"""Connects to a database by connection string
+
+        Parameter
+        ---------
+            connection_string: :class:`str`
+                Database connection string, see: https://docs.sqlalchemy.org/en/14/core/engines.html
+        """
+        pass

src/cpl_core/database/context/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+"""
+sh_cpl-core sh-edraft Common Python library
+~~~~~~~~~~~~~~~~~~~
+
+sh-edraft Common Python library
+
+:copyright: (c) 2020 - 2021 sh-edraft.de
+:license: MIT, see LICENSE for more details.
+
+"""
+
+__title__ = 'cpl_core.database.context'
+__author__ = 'Sven Heidemann'
+__license__ = 'MIT'
+__copyright__ = 'Copyright (c) 2020 - 2021 sh-edraft.de'
+__version__ = '2021.10.6'
+
+from collections import namedtuple
+
+# imports:
+from .database_context import DatabaseContext
+from .database_context_abc import DatabaseContextABC
+
+VersionInfo = namedtuple('VersionInfo', 'major minor micro')
+version_info = VersionInfo(major='2021', minor='10', micro='6')

src/cpl_core/database/context/database_context.py

@@ -0,0 +1,56 @@
+from sqlalchemy import engine, Table
+from sqlalchemy.orm import Session
+
+from cpl.console.console import Console
+from cpl.console.foreground_color_enum import ForegroundColorEnum
+from cpl.database.connection.database_connection import DatabaseConnection
+from cpl.database.connection.database_connection_abc import DatabaseConnectionABC
+from cpl.database.context.database_context_abc import DatabaseContextABC
+from cpl.database.database_settings import DatabaseSettings
+from cpl.database.database_model import DatabaseModel
+
+
+class DatabaseContext(DatabaseContextABC):
+    r"""Representation of the database context
+
+    Parameter
+    ---------
+        database_settings: :class:`cpl.database.database_settings.DatabaseSettings`
+    """
+
+    def __init__(self, database_settings: DatabaseSettings):
+        DatabaseContextABC.__init__(self)
+
+        self._db: DatabaseConnectionABC = DatabaseConnection(database_settings)
+        self._tables: list[Table] = []
+
+    @property
+    def engine(self) -> engine:
+        return self._db.engine
+
+    @property
+    def session(self) -> Session:
+        return self._db.session
+
+    def connect(self, connection_string: str):
+        self._db.connect(connection_string)
+        self._create_tables()
+
+    def save_changes(self):
+        self._db.session.commit()
+
+    def _create_tables(self):
+        try:
+            for subclass in DatabaseModel.__subclasses__():
+                self._tables.append(subclass.__table__)
+
+            DatabaseModel.metadata.drop_all(self._db.engine, self._tables)
+            DatabaseModel.metadata.create_all(self._db.engine, self._tables, checkfirst=True)
+            Console.set_foreground_color(ForegroundColorEnum.green)
+            Console.write_line(f'[{__name__}] Created tables')
+            Console.set_foreground_color(ForegroundColorEnum.default)
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(f'[{__name__}] Creating tables failed -> {e}')
+            Console.set_foreground_color(ForegroundColorEnum.default)
+            exit()

src/cpl_core/database/context/database_context_abc.py

@@ -0,0 +1,40 @@
+from abc import abstractmethod, ABC
+
+from sqlalchemy import engine
+from sqlalchemy.orm import Session
+
+
+class DatabaseContextABC(ABC):
+    r"""ABC for the :class:`cpl.database.context.database_context.DatabaseContext`"""
+
+    @abstractmethod
+    def __init__(self, *args):
+        pass
+
+    @property
+    @abstractmethod
+    def engine(self) -> engine: pass
+
+    @property
+    @abstractmethod
+    def session(self) -> Session: pass
+
+    @abstractmethod
+    def connect(self, connection_string: str):
+        r"""Connects to a database by connection string
+
+        Parameter
+        ---------
+            connection_string: :class:`str`
+                Database connection string, see: https://docs.sqlalchemy.org/en/14/core/engines.html
+        """
+        pass
+
+    def save_changes(self):
+        r"""Saves changes of the database"""
+        pass
+
+    @abstractmethod
+    def _create_tables(self):
+        r"""Create all tables for application from database model"""
+        pass

src/cpl_core/database/database_model.py

@@ -0,0 +1,3 @@
+from sqlalchemy.ext.declarative import declarative_base
+
+DatabaseModel: declarative_base = declarative_base()

src/cpl_core/database/database_settings.py

@@ -0,0 +1,97 @@
+import traceback
+from typing import Optional
+
+from cpl.configuration.configuration_model_abc import ConfigurationModelABC
+from cpl.console.console import Console
+from cpl.console.foreground_color_enum import ForegroundColorEnum
+from cpl.database.database_settings_name_enum import DatabaseSettingsNameEnum
+
+
+class DatabaseSettings(ConfigurationModelABC):
+    r"""Represents settings for the database connection"""
+
+    def __init__(self):
+        ConfigurationModelABC.__init__(self)
+
+        self._auth_plugin: Optional[str] = None
+        self._connection_string: Optional[str] = None
+        self._credentials: Optional[str] = None
+        self._encoding: Optional[str] = None
+        self._case_sensitive: Optional[bool] = None
+        self._echo: Optional[bool] = None
+
+    @property
+    def auth_plugin(self) -> str:
+        return self._auth_plugin
+
+    @auth_plugin.setter
+    def auth_plugin(self, auth_plugin: str):
+        self._auth_plugin = auth_plugin
+
+    @property
+    def connection_string(self) -> str:
+        return self._connection_string
+
+    @connection_string.setter
+    def connection_string(self, connection_string: str):
+        self._connection_string = connection_string
+
+    @property
+    def credentials(self) -> str:
+        return self._credentials
+
+    @credentials.setter
+    def credentials(self, credentials: str):
+        self._credentials = credentials
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, encoding: str) -> None:
+        self._encoding = encoding
+
+    @property
+    def case_sensitive(self) -> bool:
+        return self._case_sensitive
+
+    @case_sensitive.setter
+    def case_sensitive(self, case_sensitive: bool) -> None:
+        self._case_sensitive = case_sensitive
+
+    @property
+    def echo(self) -> bool:
+        return self._echo
+
+    @echo.setter
+    def echo(self, echo: bool) -> None:
+        self._echo = echo
+
+    def from_dict(self, settings: dict):
+        r"""Sets attributes from given dict
+
+        Parameter
+        ---------
+        settings: :class:`dict`
+        """
+        try:
+            self._connection_string = settings[DatabaseSettingsNameEnum.connection_string.value]
+            self._credentials = settings[DatabaseSettingsNameEnum.credentials.value]
+
+            if DatabaseSettingsNameEnum.auth_plugin.value in settings:
+                self._auth_plugin = settings[DatabaseSettingsNameEnum.auth_plugin.value]
+
+            if DatabaseSettingsNameEnum.encoding.value in settings:
+                self._encoding = settings[DatabaseSettingsNameEnum.encoding.value]
+
+            if DatabaseSettingsNameEnum.case_sensitive.value in settings:
+                self._case_sensitive = bool(settings[DatabaseSettingsNameEnum.case_sensitive.value])
+
+            if DatabaseSettingsNameEnum.echo.value in settings:
+                self._echo = bool(settings[DatabaseSettingsNameEnum.echo.value])
+        except Exception as e:
+            Console.set_foreground_color(ForegroundColorEnum.red)
+            Console.write_line(f'[ ERROR ] [ {__name__} ]: Reading error in {self.__name__} settings')
+            Console.write_line(f'[ EXCEPTION ] [ {__name__} ]: {e} -> {traceback.format_exc()}')
+            Console.set_foreground_color(ForegroundColorEnum.default)

src/cpl_core/database/database_settings_name_enum.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class DatabaseSettingsNameEnum(Enum):
+
+    connection_string = 'ConnectionString'
+    credentials = 'Credentials'
+    encoding = 'Encoding'
+    case_sensitive = 'CaseSensitive'
+    echo = 'Echo'
+    auth_plugin = 'AuthPlugin'