wiederverwendbar 0.8.3__tar.gz → 0.8.5__tar.gz

{wiederverwendbar-0.8.3 → wiederverwendbar-0.8.5}/PKG-INFO

@@ -1,49 +1,49 @@
 Metadata-Version: 2.1
 Name: wiederverwendbar
-Version: 0.8.3
+Version: 0.8.5
 Summary: A collection of scripts, classes and tools they are \"wiederverwendbar\".
 Author-Email: Julius Koenig <info@bastelquartier.de>
 License: GPL-3.0
 Requires-Python: >=3.9
-Requires-Dist: pydantic>=2.11.4
+Requires-Dist: pydantic>=2.11.5
 Requires-Dist: pydantic-settings>=2.9.1
 Requires-Dist: devtools>=0.12.2
 Provides-Extra: full
 Requires-Dist: rich>=14.0.0; extra == "full"
-Requires-Dist: typer>=0.15.3; extra == "full"
+Requires-Dist: typer>=0.16.0; extra == "full"
 Requires-Dist: pythonping>=1.1.4; extra == "full"
 Requires-Dist: mongoengine>=0.29.1; extra == "full"
-Requires-Dist: nicegui>=2.17.0; extra == "full"
-Requires-Dist: uvicorn>=0.34.2; extra == "full"
+Requires-Dist: nicegui>=2.19.0; extra == "full"
+Requires-Dist: uvicorn>=0.34.3; extra == "full"
 Requires-Dist: fastapi>=0.115.12; extra == "full"
-Requires-Dist: starlette-admin[i18n]>=0.14.1; extra == "full"
+Requires-Dist: starlette-admin[i18n]>=0.15.1; extra == "full"
 Requires-Dist: pillow>=11.2.1; extra == "full"
 Requires-Dist: blinker>=1.9.0; extra == "full"
-Requires-Dist: kombu>=5.5.3; extra == "full"
+Requires-Dist: kombu>=5.5.4; extra == "full"
 Requires-Dist: nest-asyncio>=1.6.0; extra == "full"
-Requires-Dist: sqlalchemy>=2.0.40; extra == "full"
+Requires-Dist: sqlalchemy>=2.0.41; extra == "full"
 Provides-Extra: rich
 Requires-Dist: rich>=14.0.0; extra == "rich"
 Provides-Extra: typer
-Requires-Dist: typer>=0.15.3; extra == "typer"
+Requires-Dist: typer>=0.16.0; extra == "typer"
 Provides-Extra: mongoengine
 Requires-Dist: mongoengine>=0.29.1; extra == "mongoengine"
 Requires-Dist: blinker>=1.9.0; extra == "mongoengine"
 Provides-Extra: uvicorn
-Requires-Dist: uvicorn>=0.34.2; extra == "uvicorn"
+Requires-Dist: uvicorn>=0.34.3; extra == "uvicorn"
 Provides-Extra: fastapi
 Requires-Dist: fastapi>=0.115.12; extra == "fastapi"
 Provides-Extra: nicegui
-Requires-Dist: nicegui>=2.17.0; extra == "nicegui"
+Requires-Dist: nicegui>=2.19.0; extra == "nicegui"
 Provides-Extra: starlette-admin
-Requires-Dist: starlette-admin[i18n]>=0.14.1; extra == "starlette-admin"
+Requires-Dist: starlette-admin[i18n]>=0.15.1; extra == "starlette-admin"
 Requires-Dist: pillow>=11.2.1; extra == "starlette-admin"
-Requires-Dist: kombu>=5.5.3; extra == "starlette-admin"
+Requires-Dist: kombu>=5.5.4; extra == "starlette-admin"
 Requires-Dist: nest-asyncio>=1.6.0; extra == "starlette-admin"
 Provides-Extra: fuctions
 Requires-Dist: pythonping>=1.1.4; extra == "fuctions"
 Provides-Extra: sqlalchemy
-Requires-Dist: sqlalchemy>=2.0.40; extra == "sqlalchemy"
+Requires-Dist: sqlalchemy>=2.0.41; extra == "sqlalchemy"
 Description-Content-Type: text/markdown
 
 # wiederverwendbar

{wiederverwendbar-0.8.3 → wiederverwendbar-0.8.5}/pyproject.toml

@@ -6,13 +6,13 @@ authors = [
     { name = "Julius Koenig", email = "info@bastelquartier.de" },
 ]
 dependencies = [
-    "pydantic>=2.11.4",
+    "pydantic>=2.11.5",
     "pydantic-settings>=2.9.1",
     "devtools>=0.12.2",
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.8.3"
+version = "0.8.5"
 
 [project.license]
 text = "GPL-3.0"
@@ -20,49 +20,49 @@ text = "GPL-3.0"
 [project.optional-dependencies]
 full = [
     "rich>=14.0.0",
-    "typer>=0.15.3",
+    "typer>=0.16.0",
     "pythonping>=1.1.4",
     "mongoengine>=0.29.1",
-    "nicegui>=2.17.0",
-    "uvicorn>=0.34.2",
+    "nicegui>=2.19.0",
+    "uvicorn>=0.34.3",
     "fastapi>=0.115.12",
-    "starlette-admin[i18n]>=0.14.1",
+    "starlette-admin[i18n]>=0.15.1",
     "pillow>=11.2.1",
     "blinker>=1.9.0",
-    "kombu>=5.5.3",
+    "kombu>=5.5.4",
     "nest-asyncio>=1.6.0",
-    "sqlalchemy>=2.0.40",
+    "sqlalchemy>=2.0.41",
 ]
 rich = [
     "rich>=14.0.0",
 ]
 typer = [
-    "typer>=0.15.3",
+    "typer>=0.16.0",
 ]
 mongoengine = [
     "mongoengine>=0.29.1",
     "blinker>=1.9.0",
 ]
 uvicorn = [
-    "uvicorn>=0.34.2",
+    "uvicorn>=0.34.3",
 ]
 fastapi = [
     "fastapi>=0.115.12",
 ]
 nicegui = [
-    "nicegui>=2.17.0",
+    "nicegui>=2.19.0",
 ]
 starlette-admin = [
-    "starlette-admin[i18n]>=0.14.1",
+    "starlette-admin[i18n]>=0.15.1",
     "pillow>=11.2.1",
-    "kombu>=5.5.3",
+    "kombu>=5.5.4",
     "nest-asyncio>=1.6.0",
 ]
 fuctions = [
     "pythonping>=1.1.4",
 ]
 sqlalchemy = [
-    "sqlalchemy>=2.0.40",
+    "sqlalchemy>=2.0.41",
 ]
 
 [build-system]

{wiederverwendbar-0.8.3 → wiederverwendbar-0.8.5}/src/wiederverwendbar/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.8.3"
+__version__ = "0.8.5"
 TITLE = "wiederverwendbar"
 VERSION = __version__
 AUTHOR = "Julius Koenig"

wiederverwendbar-0.8.5/src/wiederverwendbar/examples/sqlalchemy/db.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy import Column, ForeignKey, Integer, Text
+
+from sqlalchemy.orm import relationship
+
+from wiederverwendbar.logger import LoggerSingleton, LoggerSettings, LogLevels
+from wiederverwendbar.sqlalchemy import Base, SqlalchemySettings, SqlalchemyDbSingleton
+
+LoggerSingleton(name="test", settings=LoggerSettings(log_level=LogLevels.DEBUG), init=True)
+SqlalchemyDbSingleton(settings=SqlalchemySettings(db_file=Path("test.db")), init=True)
+
+
+class MyBase(Base, SqlalchemyDbSingleton().Base):
+    __abstract__ = True
+
+
+class Parent(MyBase):
+    __tablename__ = "parent"
+    __str_columns__: list[str] = ["id", "name"]
+
+    id: int = Column(Integer(), primary_key=True, autoincrement=True, name="parent_id")
+    name: str = Column(Text(50), nullable=False, unique=True)
+    children: list["Child"] = relationship("Child",
+                                           foreign_keys="Child.parent_id",
+                                           primaryjoin="Parent.id == Child.parent_id",
+                                           viewonly=True)
+
+
+class Child(MyBase):
+    __tablename__ = "child"
+    __str_columns__: list[str] = ["id", "name"]
+
+    id: int = Column(Integer(), primary_key=True, autoincrement=True, name="parent_id")
+    name: str = Column(Text(50), nullable=False, unique=True)
+    parent_id: int = Column(Integer(), ForeignKey("parent.parent_id"), nullable=False, name="child_parent_id")
+    parent: Optional[Parent] = relationship("Parent",
+                                            foreign_keys="Parent.id",
+                                            primaryjoin="Child.parent_id == Parent.id")
+
+
+if __name__ == '__main__':
+    SqlalchemyDbSingleton().create_all()
+
+    parent1 = Parent.get(name="parent1")
+    if parent1 is None:
+        parent1 = Parent(name="parent1")
+        parent1.save()
+
+    child1 = Child.get(name="child1")
+    if child1 is None:
+        child1 = Child(name="child1", parent_id=parent1.id)
+        child1.save()
+
+    child2 = Child.get(name="child2")
+    if child2 is None:
+        child2 = Child(name="child2", parent_id=parent1.id)
+        child2.save()
+
+    child3 = Child.get(name="child3")
+    if child3 is None:
+        child3 = Child(name="child3", parent_id=parent1.id)
+        child3.save()
+
+    parent2 = Parent.get(name="parent2")
+    if parent2 is None:
+        parent2 = Parent(name="parent2")
+        parent2.save()
+
+    child4 = Child.get(name="child4")
+    if child4 is None:
+        child4 = Child(name="child4", parent_id=parent2.id)
+        child4.save()
+
+    child5 = Child.get(name="child5")
+    if child5 is None:
+        child5 = Child(name="child5", parent_id=parent2.id)
+        child5.save()
+
+    child6 = Child.get(name="child6")
+    if child6 is None:
+        child6 = Child(name="child6", parent_id=parent2.id)
+        child6.save()
+
+    Parent.delete_all()  # Should raise an IntegrityError --> FOREIGN KEY constraint failed
+    parent2.delete() # Should raise an IntegrityError --> FOREIGN KEY constraint failed
+
+    print()

wiederverwendbar-0.8.5/src/wiederverwendbar/functions/get_pretty_str.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+def get_pretty_str(value):
+    if type(value) is str:
+        return f"'{value}'"
+    elif isinstance(value, Enum):
+        return get_pretty_str(value.value)
+    return f"{value}"

{wiederverwendbar-0.8.3 → wiederverwendbar-0.8.5}/src/wiederverwendbar/sqlalchemy/base.py

@@ -1,11 +1,13 @@
+import warnings
 from typing import Any, Optional, Callable, Union, TYPE_CHECKING
 
 from sqlalchemy import inspect
 from sqlalchemy.sql import ColumnExpressionArgument
-from sqlalchemy.orm import Session, QueryableAttribute, InstrumentedAttribute
+from sqlalchemy.orm import Session, QueryableAttribute
 from sqlalchemy.orm.exc import DetachedInstanceError
 
 from wiederverwendbar.default import Default
+from wiederverwendbar.functions.get_pretty_str import get_pretty_str
 from wiederverwendbar.sqlalchemy.raise_has_not_attr import raise_has_not_attr
 
 if TYPE_CHECKING:
@@ -141,7 +143,18 @@ class Base:
         super().__init__(*args, **kwargs)
 
     def __str__(self):
-        return f"{self.__class__.__name__}({', '.join([f'{column_name}={getattr(self, column_name)}' for column_name in self.__str_columns__])})"
+        out = f"{self.__class__.__name__}("
+        for attr_name in self.__str_columns__:
+            if type(attr_name) is tuple:
+                attr_view_name = attr_name[0]
+                attr_name = attr_name[1]
+            else:
+                attr_view_name = attr_name
+            if not hasattr(self, attr_name):
+                warnings.warn(f"Attribute '{attr_name}' is not set for {self}.")
+            out += f"{attr_view_name}={get_pretty_str(getattr(self, attr_name))}, "
+        out = out[:-2] + ")"
+        return out
 
     def __repr__(self):
         return self.__str__()
@@ -399,3 +412,19 @@ class Base:
         session.commit()
 
         self.session_close(session_created=session_created, session=session)
+
+    @classmethod
+    def delete_all(cls,
+                   *criterion: Union[ColumnExpressionArgument[bool], bool],
+                   session: Optional[Session] = None,
+                   **kwargs: Any) -> None:
+        session_created, session = cls.session(session=session)
+
+        # delete rows
+        if criterion:
+            session.query(cls).filter(*criterion, **kwargs).delete()
+        else:
+            session.query(cls).filter_by(**kwargs).delete()
+        session.commit()
+
+        cls.session_close(session_created=session_created, session=session)

wiederverwendbar-0.8.5/src/wiederverwendbar/sqlalchemy/db.py

@@ -0,0 +1,278 @@
+import inspect
+import logging
+import sqlite3
+from ipaddress import IPv4Address
+from pathlib import Path
+from typing import Any, Optional, Union, Sequence, Callable
+
+from sqlalchemy import create_engine, Table, event
+from sqlalchemy.orm import sessionmaker, declarative_base, DeclarativeMeta as _DeclarativeMeta, Session
+from sqlalchemy.ext.declarative import declarative_base
+
+from wiederverwendbar.sqlalchemy.settings import SqlalchemySettings
+
+logger = logging.getLogger(__name__)
+
+
+class DeclarativeMeta(_DeclarativeMeta):
+    def __init__(cls, classname: Any, bases: Any, dict_: Any, **kw: Any) -> None:
+        db = None
+        for base in bases:
+            if hasattr(base, "db"):
+                db = base.db
+        if db is None:
+            stack = inspect.stack()
+            for frame in stack:
+                if frame.function == "__init__":
+                    db = frame.frame.f_locals.get("self", None)
+                    if isinstance(db, SqlalchemyDb):
+                        break
+        super().__init__(classname=classname, bases=bases, dict_=dict_, **kw)
+
+        cls.db: SqlalchemyDb = db
+
+
+class SqlalchemyDb:
+    def __init__(self,
+                 file: Optional[Path] = None,
+                 host: Union[None, IPv4Address, str] = None,
+                 port: Optional[int] = None,
+                 protocol: Optional[str] = None,
+                 name: Optional[str] = None,
+                 username: Optional[str] = None,
+                 password: Optional[str] = None,
+                 echo: Optional[bool] = None,
+                 test_on_startup: Optional[bool] = None,
+                 sqlite_check_if_file_exist: Optional[bool] = None,
+                 sqlite_handle_foreign_keys: Optional[bool] = None,
+                 settings: Optional[SqlalchemySettings] = None):
+        """
+        Create a new Sqlalchemy Database
+
+        :param host: Host to connect to database
+        :param port: Port to connect to database
+        :param protocol: Protocol to connect to database
+        :param name: Name of the database
+        :param username: User to connect to database
+        :param password: Password to connect to database
+        :param echo: Echo SQL queries to console
+        :param test_on_startup: Test the database connection on startup.
+        :param sqlite_check_if_file_exist: Check if SQLite file exists before connecting to it.
+        :param sqlite_handle_foreign_keys: Enable SQLite Foreign Keys
+        :param settings: Sqlalchemy Settings
+        """
+
+        self._settings: SqlalchemySettings = settings or SqlalchemySettings()
+        self._file: Optional[Path] = file or self.settings.db_file
+        self._host: Union[IPv4Address, str, None] = host or self.settings.db_host
+        self._port: Optional[int] = port or self.settings.db_port
+        self._protocol: Optional[str] = protocol or self.settings.db_protocol
+        self._name: Optional[str] = name or self.settings.db_name
+        self._username: Optional[str] = username or self.settings.db_username
+        self._password: Optional[str] = password or self.settings.db_password
+        self._echo: bool = echo or self.settings.db_echo
+        self._test_on_startup: bool = test_on_startup or self.settings.db_test_on_startup
+        self._sqlite_check_if_file_exist: bool = sqlite_check_if_file_exist or self.settings.db_sqlite_check_if_file_exist
+        self._sqlite_handle_foreign_keys: bool = sqlite_handle_foreign_keys or self.settings.db_sqlite_handle_foreign_keys
+
+        logger.debug(f"Create {self}")
+
+        self.engine = create_engine(self.connection_string, echo=self.echo)
+        if self.protocol == "sqlite":
+            if self.sqlite_check_if_file_exist:
+                self.listen("connect", self._sqlite_check_if_file_exist_func)
+            if self.sqlite_handle_foreign_keys:
+                self.listen("connect", self._sqlite_handle_foreign_keys_func)
+        self._session_maker = sessionmaker(bind=self.engine)
+        self._Base: DeclarativeMeta = declarative_base(metaclass=DeclarativeMeta)
+        self.session_maker.configure(binds={self._Base: self.engine})
+
+        if self.test_on_startup:
+            self.test()
+
+    def __str__(self):
+        return f"{self.__class__.__name__}({self.connection_string_printable})"
+
+    @property
+    def settings(self) -> SqlalchemySettings:
+        return self._settings
+
+    @property
+    def file(self) -> Optional[Path]:
+        return self._file
+
+    @property
+    def host(self) -> Union[IPv4Address, str, None]:
+        return self._host
+
+    @property
+    def port(self) -> Optional[int]:
+        return self._port
+
+    @property
+    def protocol(self) -> Optional[str]:
+        return self._protocol
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @property
+    def username(self) -> Optional[str]:
+        return self._username
+
+    @property
+    def password(self) -> Optional[str]:
+        return self._password
+
+    @property
+    def echo(self) -> bool:
+        return self._echo
+
+    @property
+    def test_on_startup(self) -> bool:
+        return self._test_on_startup
+
+    @property
+    def sqlite_check_if_file_exist(self) -> bool:
+        return self._sqlite_check_if_file_exist
+
+    @property
+    def sqlite_handle_foreign_keys(self) -> bool:
+        return self._sqlite_handle_foreign_keys
+
+    @property
+    def session_maker(self) -> sessionmaker:
+        return self._session_maker
+
+    # noinspection PyPep8Naming
+    @property
+    def Base(self) -> Any:
+        return self._Base
+
+    def get_connection_string(self, printable: bool = False) -> str:
+        """
+        Get the Connection String
+
+        :param printable: If True, the password will be hidden
+        :return: str
+        """
+
+        connection_string = f"{self.protocol}://"
+        if self.protocol == "sqlite":
+            if self.file is not None:
+                connection_string += f"/{self.file}"
+        else:
+            if self.username is not None:
+                connection_string += f"{self.username}"
+            if self.password is not None:
+                connection_string += ":"
+                if printable:
+                    connection_string += "***"
+                else:
+                    connection_string += self.password
+            if self.host is None:
+                raise RuntimeError(f"No host specified for {self}")
+            connection_string += f"@{self.host}"
+            if self.port is None:
+                raise RuntimeError(f"No port specified for {self}")
+            connection_string += f":{self.port}"
+            if self.name is None:
+                raise RuntimeError(f"No name specified for {self}")
+            connection_string += f"/{self.name}"
+        return connection_string
+
+    @property
+    def connection_string(self) -> str:
+        """
+        Get the Connection String
+
+        :return: str
+        """
+
+        return self.get_connection_string()
+
+    @property
+    def connection_string_printable(self) -> str:
+        """
+        Get the Connection String with Password hidden
+
+        :return: str
+        """
+
+        return self.get_connection_string(printable=True)
+
+    def test(self):
+        self.engine.connect()
+        print()
+
+    def create_all(self,
+                   tables: Optional[Sequence[Table]] = None,
+                   check_first: bool = True) -> None:
+        """
+        Create all Tables
+
+        :param tables: List of Tables to create. If None, all Tables will be created.
+        :param check_first: Check if Tables exist before creating them.
+        :return: None
+        """
+
+        logger.debug(f"Create all for {self}")
+        self.Base.metadata.create_all(bind=self.engine, tables=tables, checkfirst=check_first)
+
+    def session(self) -> Session:
+        """
+        Create a new Session
+
+        :return: Session
+        """
+
+        logger.debug(f"Create Session for {self}")
+        return self.session_maker()
+
+    def listen(self,
+               identifier: str,
+               func: Callable[..., Any],
+               *args: Any,
+               **kwargs: Any) -> None:
+        """
+        Register a listener function for the engine.
+
+        :param identifier: String name of the event.
+        :param func: Callable function.
+        :return: None
+
+        .. Seealso::
+            sqlalchemy.event.api.listen for more.
+        """
+
+        event.listen(self.engine, identifier, func, *args, **kwargs)
+
+    def listens_for(self,
+                    identifier: str,
+                    *args: Any,
+                    **kw: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        """
+        Decorate a function as a listener for the engine.
+
+        :param identifier: String name of the event.
+        :return: Callable[[Callable[..., Any]], Callable[..., Any]]
+
+        .. Seealso::
+            sqlalchemy.event.api.listens_for for more.
+        """
+
+        return event.listens_for(self.engine, identifier, *args, **kw)
+
+    def _sqlite_check_if_file_exist_func(self, connection, _connection_record):
+        if self.file is not None:
+            if not self.file.is_file():
+                raise FileNotFoundError(f"Database file does not exist: {self.file}")
+
+    # noinspection PyMethodMayBeStatic
+    def _sqlite_handle_foreign_keys_func(self, connection, _connection_record):
+        if not isinstance(connection, sqlite3.Connection):
+            raise RuntimeError(f"Connection is not a sqlite3.Connection: {connection}")
+        cursor = connection.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()

{wiederverwendbar-0.8.3 → wiederverwendbar-0.8.5}/src/wiederverwendbar/sqlalchemy/settings.py

@@ -34,3 +34,12 @@ class SqlalchemySettings(PrintableSettings):
     db_echo: bool = Field(default=False,
                           title="Database echo.",
                           description="Echo SQL queries to console")
+    db_test_on_startup: bool = Field(default=True,
+                                 title="Test Database on Startup",
+                                 description="Test database connection on startup")
+    db_sqlite_check_if_file_exist: bool = Field(default=True,
+                                                title="Database SQLite Check If File Exist",
+                                                description="Check if file exists in SQLite")
+    db_sqlite_handle_foreign_keys: bool = Field(default=True,
+                                                title="Database SQLite Handle Foreign Keys",
+                                                description="Handle foreign keys in SQLite")

wiederverwendbar-0.8.3/src/wiederverwendbar/examples/sqlalchemy/db.py

@@ -1,31 +0,0 @@
-from pathlib import Path
-
-from sqlalchemy import Column, Text, Integer
-
-from wiederverwendbar.logger import LoggerSingleton, LoggerSettings
-from wiederverwendbar.sqlalchemy import Base, SqlalchemySettings, SqlalchemyDbSingleton
-
-LoggerSingleton(name="test", settings=LoggerSettings(log_level=LoggerSettings.LogLevels.DEBUG), init=True)
-
-
-class MyBase(Base, SqlalchemyDbSingleton(settings=SqlalchemySettings(db_file=Path("test.db")), init=True).Base):
-    __abstract__ = True
-
-
-class MyTable(MyBase):
-    __tablename__ = "my_table"
-    __str_columns__: list[str] = ["name"]
-
-    name = Column(Text(50), primary_key=True)
-    value = Column(Integer)
-
-
-if __name__ == '__main__':
-    SqlalchemyDbSingleton().create_all()
-
-    my_table = MyTable(name="test", value=1)
-
-    d = my_table.as_dict()
-    my_table.save()
-
-    print()