Restructuring

src/cpl-database/cpl/database/__init__.py

@@ -0,0 +1,3 @@
+from .database_settings_name_enum import DatabaseSettingsNameEnum
+from .database_settings import DatabaseSettings
+from .table_abc import TableABC

src/cpl-database/cpl/database/connection/__init__.py

@@ -0,0 +1,2 @@
+from .database_connection import DatabaseConnection
+from .database_connection_abc import DatabaseConnectionABC

src/cpl-database/cpl/database/connection/database_connection.py

@@ -0,0 +1,54 @@
+from typing import Optional
+
+import mysql.connector as sql
+from mysql.connector.abstracts import MySQLConnectionAbstract
+from mysql.connector.cursor import MySQLCursorBuffered
+
+from cpl.database.connection.database_connection_abc import DatabaseConnectionABC
+from cpl.database.database_settings import DatabaseSettings
+from cpl.core.utils.credential_manager import CredentialManager
+
+
+class DatabaseConnection(DatabaseConnectionABC):
+    r"""Representation of the database connection"""
+
+    def __init__(self):
+        DatabaseConnectionABC.__init__(self)
+
+        self._database: Optional[MySQLConnectionAbstract] = None
+        self._cursor: Optional[MySQLCursorBuffered] = None
+
+    @property
+    def server(self) -> MySQLConnectionAbstract:
+        return self._database
+
+    @property
+    def cursor(self) -> MySQLCursorBuffered:
+        return self._cursor
+
+    def connect(self, settings: DatabaseSettings):
+        connection = sql.connect(
+            host=settings.host,
+            port=settings.port,
+            user=settings.user,
+            passwd=CredentialManager.decrypt(settings.password),
+            charset=settings.charset,
+            use_unicode=settings.use_unicode,
+            buffered=settings.buffered,
+            auth_plugin=settings.auth_plugin,
+            ssl_disabled=settings.ssl_disabled,
+        )
+        connection.cursor().execute(f"CREATE DATABASE IF NOT EXISTS `{settings.database}`;")
+        self._database = sql.connect(
+            host=settings.host,
+            port=settings.port,
+            user=settings.user,
+            passwd=CredentialManager.decrypt(settings.password),
+            db=settings.database,
+            charset=settings.charset,
+            use_unicode=settings.use_unicode,
+            buffered=settings.buffered,
+            auth_plugin=settings.auth_plugin,
+            ssl_disabled=settings.ssl_disabled,
+        )
+        self._cursor = self._database.cursor()

src/cpl-database/cpl/database/connection/database_connection_abc.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+from cpl.database.database_settings import DatabaseSettings
+from mysql.connector.abstracts import MySQLConnectionAbstract
+from mysql.connector.cursor import MySQLCursorBuffered
+
+
+class DatabaseConnectionABC(ABC):
+    r"""ABC for the :class:`cpl.database.connection.database_connection.DatabaseConnection`"""
+
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @property
+    @abstractmethod
+    def server(self) -> MySQLConnectionAbstract:
+        pass
+
+    @property
+    @abstractmethod
+    def cursor(self) -> MySQLCursorBuffered:
+        pass
+
+    @abstractmethod
+    def connect(self, database_settings: DatabaseSettings):
+        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
+        """

src/cpl-database/cpl/database/context/__init__.py

@@ -0,0 +1,2 @@
+from .database_context import DatabaseContext
+from .database_context_abc import DatabaseContextABC

src/cpl-database/cpl/database/context/database_context.py

@@ -0,0 +1,52 @@
+from typing import Optional
+
+
+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 mysql.connector.cursor import MySQLCursorBuffered
+
+
+class DatabaseContext(DatabaseContextABC):
+    r"""Representation of the database context
+
+    Parameter:
+        database_settings: :class:`cpl.database.database_settings.DatabaseSettings`
+    """
+
+    def __init__(self):
+        DatabaseContextABC.__init__(self)
+
+        self._db: DatabaseConnectionABC = DatabaseConnection()
+        self._settings: Optional[DatabaseSettings] = None
+
+    @property
+    def cursor(self) -> MySQLCursorBuffered:
+        self._ping_and_reconnect()
+        return self._db.cursor
+
+    def _ping_and_reconnect(self):
+        try:
+            self._db.server.ping(reconnect=True, attempts=3, delay=5)
+        except Exception:
+            # reconnect your cursor as you did in __init__ or wherever
+            if self._settings is None:
+                raise Exception("Call DatabaseContext.connect first")
+            self.connect(self._settings)
+
+    def connect(self, database_settings: DatabaseSettings):
+        if self._settings is None:
+            self._settings = database_settings
+        self._db.connect(database_settings)
+
+        self.save_changes()
+
+    def save_changes(self):
+        self._ping_and_reconnect()
+        self._db.server.commit()
+
+    def select(self, statement: str) -> list[tuple]:
+        self._ping_and_reconnect()
+        self._db.cursor.execute(statement)
+        return self._db.cursor.fetchall()

src/cpl-database/cpl/database/context/database_context_abc.py

@@ -0,0 +1,40 @@
+from abc import ABC, abstractmethod
+
+from cpl.database.database_settings import DatabaseSettings
+from mysql.connector.cursor import MySQLCursorBuffered
+
+
+class DatabaseContextABC(ABC):
+    r"""ABC for the :class:`cpl.database.context.database_context.DatabaseContext`"""
+
+    @abstractmethod
+    def __init__(self, *args):
+        pass
+
+    @property
+    @abstractmethod
+    def cursor(self) -> MySQLCursorBuffered:
+        pass
+
+    @abstractmethod
+    def connect(self, database_settings: DatabaseSettings):
+        r"""Connects to a database by connection settings
+
+        Parameter:
+            database_settings :class:`cpl.database.database_settings.DatabaseSettings`
+        """
+
+    @abstractmethod
+    def save_changes(self):
+        r"""Saves changes of the database"""
+
+    @abstractmethod
+    def select(self, statement: str) -> list[tuple]:
+        r"""Runs SQL Statements
+
+        Parameter:
+            statement: :class:`str`
+
+        Returns:
+            list: Fetched list of selected elements
+        """

src/cpl-database/cpl/database/database_settings.py

@@ -0,0 +1,73 @@
+from typing import Optional
+
+from cpl.core.configuration.configuration_model_abc import ConfigurationModelABC
+
+
+class DatabaseSettings(ConfigurationModelABC):
+    r"""Represents settings for the database connection"""
+
+    def __init__(
+        self,
+        host: str = None,
+        port: int = 3306,
+        user: str = None,
+        password: str = None,
+        database: str = None,
+        charset: str = "utf8mb4",
+        use_unicode: bool = False,
+        buffered: bool = False,
+        auth_plugin: str = "caching_sha2_password",
+        ssl_disabled: bool = False,
+    ):
+        ConfigurationModelABC.__init__(self)
+
+        self._host: Optional[str] = host
+        self._port: Optional[int] = port
+        self._user: Optional[str] = user
+        self._password: Optional[str] = password
+        self._database: Optional[str] = database
+        self._charset: Optional[str] = charset
+        self._use_unicode: Optional[bool] = use_unicode
+        self._buffered: Optional[bool] = buffered
+        self._auth_plugin: Optional[str] = auth_plugin
+        self._ssl_disabled: Optional[bool] = ssl_disabled
+
+    @property
+    def host(self) -> Optional[str]:
+        return self._host
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._port
+
+    @property
+    def user(self) -> Optional[str]:
+        return self._user
+
+    @property
+    def password(self) -> Optional[str]:
+        return self._password
+
+    @property
+    def database(self) -> Optional[str]:
+        return self._database
+
+    @property
+    def charset(self) -> Optional[str]:
+        return self._charset
+
+    @property
+    def use_unicode(self) -> Optional[bool]:
+        return self._use_unicode
+
+    @property
+    def buffered(self) -> Optional[bool]:
+        return self._buffered
+
+    @property
+    def auth_plugin(self) -> Optional[str]:
+        return self._auth_plugin
+
+    @property
+    def ssl_disabled(self) -> Optional[bool]:
+        return self._ssl_disabled

src/cpl-database/cpl/database/database_settings_name_enum.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class DatabaseSettingsNameEnum(Enum):
+    host = "Host"
+    port = "Port"
+    user = "User"
+    password = "Password"
+    database = "Database"
+    charset = "Charset"
+    use_unicode = "UseUnicode"
+    buffered = "Buffered"
+    auth_plugin = "AuthPlugin"

src/cpl-database/cpl/database/db_logger.py

@@ -0,0 +1,8 @@
+from cpl.core.log import Logger
+from cpl.core.typing import Source
+
+
+class DBLogger(Logger):
+
+    def __init__(self, source: Source):
+        Logger.__init__(self, source, "db")

src/cpl-database/cpl/database/table_abc.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+from typing import Optional
+
+
+class TableABC(ABC):
+    @abstractmethod
+    def __init__(self):
+        self._created_at: Optional[datetime] = datetime.now().isoformat()
+        self._modified_at: Optional[datetime] = datetime.now().isoformat()
+
+    @property
+    def created_at(self) -> datetime:
+        return self._created_at
+
+    @property
+    def modified_at(self) -> datetime:
+        return self._modified_at
+
+    @modified_at.setter
+    def modified_at(self, value: datetime):
+        self._modified_at = value
+
+    @property
+    @abstractmethod
+    def insert_string(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def udpate_string(self) -> str:
+        pass
+
+    @property
+    @abstractmethod
+    def delete_string(self) -> str:
+        pass

src/cpl-database/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=70.1.0", "wheel>=0.43.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cpl-database"
+version = "2024.7.0"
+description = "CPL database"
+readme ="CPL database package"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Sven Heidemann", email = "sven.heidemann@sh-edraft.de" }
+]
+keywords = ["cpl", "database", "backend", "shared", "library"]
+
+dynamic = ["dependencies", "optional-dependencies"]
+
+[project.urls]
+Homepage = "https://www.sh-edraft.de"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["cpl*"]
+
+[tool.setuptools.dynamic]
+dependencies = { file = ["requirements.txt"] }
+optional-dependencies.dev = { file = ["requirements.dev.txt"] }
+
+

src/cpl-database/requirements.dev.txt

@@ -0,0 +1 @@
+black==25.1.0

src/cpl-database/requirements.txt

@@ -0,0 +1,2 @@
+cpl-core
+cpl-dependency