wiederverwendbar 0.8.6__py3-none-any.whl → 0.9.0__py3-none-any.whl

wiederverwendbar/examples/before_after_wrap.py

@@ -1,74 +0,0 @@
-from wiederverwendbar.before_after_wrap import WrappedClass, wrap
-
-
-class BaseClass(metaclass=WrappedClass):
-    def before_cls_test1(self, __ba_before_result__):
-        print("before_cls_test1")
-
-    @wrap(before=before_cls_test1, after="after_cls_test1")
-    def cls_test1(self, __ba_before_result__):
-        print("cls_test1")
-
-    def after_cls_test1(self, __ba_result__):
-        print("after_cls_test1")
-
-    def before_cls_test2(self):
-        print("before_cls_test2")
-
-    @wrap(before=before_cls_test2, after="after_cls_test2")
-    def cls_test2(self):
-        print("cls_test2")
-
-    def after_cls_test2(self):
-        print("after_cls_test2")
-
-
-class ChildClass(BaseClass):
-    def before_cls_test1A(self):
-        print("before_cls_test1A")
-
-    @wrap(before=before_cls_test1A, after="after_cls_test1A", include_base=False)
-    def cls_test1(self, __ba_before_result__):
-        super().cls_test1(__ba_use__=False)
-        print("cls_test1A")
-
-    def after_cls_test1A(self):
-        print("after_cls_test1A")
-
-    def before_cls_test3(self):
-        print("before_cls_test3")
-
-    @wrap(before=before_cls_test3, after="after_cls_test3")
-    def cls_test3(self):
-        print("cls_test3")
-
-    def after_cls_test3(self):
-        print("after_cls_test3")
-
-
-def before_test1(*_, **__):
-    print("before_test1")
-
-
-@wrap(before=before_test1, after="after_test1")
-def test1(arg1: str):
-    print(f"test1 -> {arg1}")
-
-
-def after_test1(*_, **__):
-    print("after_test1")
-
-
-if __name__ == "__main__":
-    base_class = BaseClass()
-    base_class.cls_test1()
-    base_class.cls_test2()
-
-    child_class = ChildClass()
-    child_class.cls_test1()
-    child_class.cls_test2()
-    child_class.cls_test3()
-
-    test1("qwe")
-
-

wiederverwendbar/examples/colors.py

@@ -1,16 +0,0 @@
-from wiederverwendbar.functions.colors import Color
-
-if __name__ == '__main__':
-    color = Color(red=255, green=0, blue=0, alpha=0.5)
-    color_str_rgb = color.as_rgb()
-    color_str_rgba = color.as_rgba()
-    color_str_hex = color.as_hex()
-    color_str_hex_short = color.from_str("a0a")
-
-    print("Color Class: ", color)
-    print("Color RGB: ", color_str_rgb)
-    print("Color RGBA: ", color_str_rgba)
-    print("Color HEX: ", color_str_hex)
-    print("Color HEX Short: ", color_str_hex_short)
-
-    print()

wiederverwendbar/examples/extended_thread.py

@@ -1,28 +0,0 @@
-import time
-from typing import Union
-
-from wiederverwendbar.threading import ExtendedThread
-
-
-
-def test_watchdog(self: ExtendedThread):
-    return True
-
-
-def thread_target(*args, **kwargs):
-    print("loop", args, kwargs)
-
-
-if __name__ == '__main__':
-    thread = ExtendedThread(name="test", target=thread_target, args=(1, 2), kwargs={"a": 1}, loop_sleep_time=1, watchdog_target=test_watchdog)
-
-    while True:
-        try:
-            time.sleep(3)
-            with thread.loop_wait():
-                print("main thread")
-                time.sleep(5)
-        except KeyboardInterrupt:
-            break
-    # thread.stop()
-    # thread.raise_exception(Exception("hallo welt"))

wiederverwendbar/examples/file_config.py

@@ -1,11 +0,0 @@
-from wiederverwendbar.pydantic.file_config import FileConfig
-
-
-class Config(FileConfig):
-    asd: int = 123
-    qwe: str = "qwe"
-    yxc: bool = False
-
-
-if __name__ == '__main__':
-    config = Config(file_path="test")

wiederverwendbar/examples/indexable_model.py

@@ -1,19 +0,0 @@
-from wiederverwendbar.pydantic.indexable_model import IndexableModel
-
-
-class Config(IndexableModel):
-    asd: int = 123
-    qwe: str = "qwe"
-    yxc: bool = False
-
-
-if __name__ == '__main__':
-    config = Config()
-
-    asd = config["asd"]
-    qwe = config["qwe"]
-    yxc = config["yxc"]
-
-    asd_1 = config[0]
-    qwe_1 = config[1]
-    yxc_1 = config[2]

wiederverwendbar/examples/logger.py

@@ -1,31 +0,0 @@
-import logging
-
-from wiederverwendbar.logger import LoggerSingleton
-from wiederverwendbar.logger import LoggerSettings
-
-import uvicorn
-from fastapi import FastAPI
-
-
-if __name__ == '__main__':
-    logger = LoggerSingleton(init=True, name="test", settings=LoggerSettings(log_level="DEBUG"), ignored_loggers_like=["uvicorn"])
-
-    sub_logger = logging.getLogger("sub")
-
-    logger.debug("debug")
-    logger.info("info")
-    logger.warning("warning")
-    logger.error("error")
-    logger.critical("critical")
-
-    sub_logger.debug("debug")
-    sub_logger.info("info")
-    sub_logger.warning("warning")
-    sub_logger.error("error")
-    sub_logger.critical("critical")
-
-    app = FastAPI()
-
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-    print()

wiederverwendbar/examples/logger_context/example.py

@@ -1,58 +0,0 @@
-import logging
-import sys
-import threading
-
-from wiederverwendbar.logger import LoggingContext
-from wiederverwendbar.logger import LoggerSingleton, LoggerSettings
-
-from wiederverwendbar.examples.logger_context.example_module import example_function
-
-LoggerSingleton(init=True, name="test", settings=LoggerSettings(log_level="DEBUG"), ignored_loggers_like=["logger1", "logger2"])
-
-logger1 = logging.getLogger("logger1")
-ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
-ch.setFormatter(logging.Formatter('logger1 - %(name)s - %(levelname)s - %(message)s'))
-logger1.addHandler(ch)
-logger1.setLevel(logging.DEBUG)
-
-logger2 = logging.getLogger("logger2")
-ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
-ch.setFormatter(logging.Formatter('logger2 - %(name)s - %(levelname)s - %(message)s'))
-logger2.addHandler(ch)
-logger2.setLevel(logging.DEBUG)
-
-
-def test_thread():
-    while True:
-        # generate log messages on different loggers
-        example_function()
-
-
-# start test thread
-thread = threading.Thread(target=test_thread, daemon=True)
-thread.start()
-
-if __name__ == '__main__':
-    # no context
-    logger1.debug("no context")
-    logger2.debug("no context")
-
-    with LoggingContext(logger1, handle_origin_logger=False) as context1_a:
-        with LoggingContext(logger2, handle_origin_logger=False) as context2_a:
-            example_function()
-        example_function()
-    example_function()
-
-    with LoggingContext(logger1):
-        with LoggingContext(logger2):
-            example_function()
-        example_function()
-    example_function()
-
-    # again no context
-    logger1.debug("again no context")
-    logger2.debug("again no context")
-
-    sys.exit(0)

wiederverwendbar/examples/logger_context/example_module.py

@@ -1,13 +0,0 @@
-import logging
-import time
-
-logger = logging.getLogger(__name__)
-
-
-def example_function():
-    logger.debug("example_function")
-    func_logger = logging.getLogger(__name__ + ".example_function")
-    time.sleep(1)
-    func_logger.debug("debug")
-    time.sleep(1)
-    return

wiederverwendbar/examples/mongoengine/automatic_reference.py

@@ -1,25 +0,0 @@
-from mongoengine import ListField, ReferenceField, StringField
-
-from wiederverwendbar.mongoengine import AutomaticReferenceDocument
-
-
-# --- example classes ---
-
-class Test1(AutomaticReferenceDocument):
-    meta = {"collection": "test1"}
-
-    name = StringField(required=True)
-    test2_one_to_one = ReferenceField("Test2", automatic_reference="test1_one_to_one")
-    test2_one_to_many = ReferenceField("Test2", automatic_reference="test1_many_to_one")
-    test2_many_to_one = ListField(ReferenceField("Test2"), automatic_reference="test1_one_to_many")
-    test2_many_to_many = ListField(ReferenceField("Test2"), automatic_reference="test1_many_to_many")
-
-
-class Test2(AutomaticReferenceDocument):
-    meta = {"collection": "test2"}
-
-    name = StringField(required=True)
-    test1_one_to_one = ReferenceField("Test1", automatic_reference="test2_one_to_one")
-    test1_one_to_many = ReferenceField("Test1", automatic_reference="test2_many_to_one")
-    test1_many_to_one = ListField(ReferenceField("Test1"), automatic_reference="test2_one_to_many")
-    test1_many_to_many = ListField(ReferenceField("Test1"), automatic_reference="test2_many_to_many")

wiederverwendbar/examples/mongoengine/db.py

@@ -1,7 +0,0 @@
-from wiederverwendbar.logger import LoggerSingleton, LoggerSettings
-from wiederverwendbar.mongoengine import MongoengineDbSingleton
-
-LoggerSingleton(name="test", settings=LoggerSettings(log_level=LoggerSettings.LogLevels.DEBUG), init=True)
-
-if __name__ == '__main__':
-    MongoengineDbSingleton(init=True)

wiederverwendbar/examples/mongoengine/log_streamer.py

@@ -1,9 +0,0 @@
-import time
-
-from wiederverwendbar.examples.mongoengine.logger import MyMongoengineLogDocument
-from wiederverwendbar.mongoengine import MongoengineLogStreamer
-
-if __name__ == '__main__':
-    with MongoengineLogStreamer(MyMongoengineLogDocument) as streamer:
-        while True:
-            time.sleep(1)

wiederverwendbar/examples/mongoengine/logger.py

@@ -1,25 +0,0 @@
-import logging
-
-from mongoengine import StringField
-
-from wiederverwendbar.mongoengine import MongoengineDbSingleton, MongoengineLogDocument, MongoengineLogHandler
-
-MongoengineDbSingleton(init=True)
-
-
-class MyMongoengineLogDocument(MongoengineLogDocument):
-    meta = {"collection": "log.test"}
-
-    test = StringField(required=True)
-
-
-logger = logging.getLogger("test123")
-
-logger.addHandler(logging.StreamHandler())
-logger.addHandler(MongoengineLogHandler(document=MyMongoengineLogDocument, document_kwargs={"test": "test"}))
-
-logger.setLevel(logging.DEBUG)
-
-if __name__ == '__main__':
-    logger.debug("Hello")
-    logger.debug("Hello")

wiederverwendbar/examples/post_init.py

@@ -1,29 +0,0 @@
-from wiederverwendbar.post_init import PostInit
-
-class MyParentClass(PostInit):
-    def __init__(self, parent_attr: str):
-        super().__init__()
-
-        self.parent_attr = parent_attr
-
-        print(f"Parent attribute: {parent_attr}")
-
-    def __post_init__(self):
-        print(f"Parent post init attribute: {self.parent_attr}")
-
-
-class MyClass(MyParentClass):
-    def __init__(self, my_attr: str, parent_attr: str):
-        super().__init__(parent_attr=parent_attr)
-
-        self.my_attr = my_attr
-
-        print(f"My attribute: {my_attr}")
-
-    def __post_init__(self):
-        super().__post_init__()
-        print(f"My post init attribute: {self.my_attr}")
-
-
-if __name__ == '__main__':
-    my_class = MyClass(my_attr="My attribute", parent_attr="Parent attribute")

wiederverwendbar/examples/route.py

@@ -1,12 +0,0 @@
-from ipaddress import IPv4Network, IPv4Address
-
-from wiederverwendbar.route import RouteManager, Route
-
-if __name__ == '__main__':
-    route_manager = RouteManager()
-    test_route = Route(target=IPv4Network("192.168.200.0/24"), gateway=IPv4Address("192.168.65.1"))
-    result_add = route_manager.create(test_route)
-    all_routes = route_manager.get_all()
-    result_delete = route_manager.delete(test_route)
-
-    print()

wiederverwendbar/examples/singletons.py

@@ -1,59 +0,0 @@
-from pydantic import BaseModel
-
-from wiederverwendbar.logger import LoggerSingleton, LoggerSettings
-from wiederverwendbar.pydantic import ModelSingleton
-from wiederverwendbar.singleton import Singleton
-
-logger = LoggerSingleton(init=True, name="test", settings=LoggerSettings(log_level="DEBUG"), ignored_loggers_like=["uvicorn"])
-
-
-class A(metaclass=Singleton, order=3):
-    def __init__(self):
-        print("A created")
-
-    def __del__(self):
-        print("A deleted")
-
-
-class B(metaclass=Singleton, order=2):
-    def __init__(self):
-        print("B created")
-
-    def __del__(self):
-        print("B deleted")
-
-
-class C(metaclass=Singleton, order=1):
-    def __init__(self):
-        print("C created")
-
-    def __del__(self):
-        print("C deleted")
-
-
-class Model(BaseModel, metaclass=ModelSingleton):
-    qwe: str
-
-
-Model(qwe="qwe", init=True)
-
-
-def init():
-    A(init=True)
-    B(init=True)
-    C(init=True)
-    print("init")
-
-
-def main():
-    a = A()
-    b = B()
-    c = C()
-
-    print("main")
-
-
-if __name__ == '__main__':
-    Singleton.delete_ordered_on_exit = True
-    init()
-    main()

wiederverwendbar/examples/sqlalchemy/db.py

@@ -1,89 +0,0 @@
-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/examples/starlette_admin/action_log.py

@@ -1,126 +0,0 @@
-import logging
-import asyncio
-
-import uvicorn
-from starlette.applications import Starlette
-from starlette.responses import HTMLResponse
-from starlette.routing import Route
-from starlette.requests import Request
-from starlette_admin.contrib.mongoengine import Admin, ModelView
-from starlette_admin.actions import action
-from mongoengine import Document, StringField
-from kombu import Connection
-
-from wiederverwendbar.mongoengine import MongoengineDbSingleton
-from wiederverwendbar.starlette_admin import ActionLogAdmin, ActionLogger
-
-logger = logging.getLogger(__name__)
-ch = logging.StreamHandler()
-ch.setLevel(logging.DEBUG)
-logger.addHandler(ch)
-logger.setLevel(logging.DEBUG)
-
-# connect to database
-MongoengineDbSingleton(init=True)
-
-# create kombu connection
-kombu_connection = Connection(MongoengineDbSingleton().connection_string)
-
-
-# Create starlette app
-app = Starlette(
-    routes=[
-        Route(
-            "/",
-            lambda r: HTMLResponse("<a href=/admin/>Click me to get to Admin!</a>"),
-        ),
-    ],
-)
-
-
-class MyAdmin(Admin, ActionLogAdmin):
-    ...
-
-
-# Create admin
-admin = MyAdmin(title="Test Admin", kombu_connection=kombu_connection)
-
-
-class Test(Document):
-    meta = {"collection": "test"}
-
-    test_str = StringField()
-
-
-class TestView(ModelView):
-    def __init__(self):
-        super().__init__(document=Test, icon="fa fa-server", name="Test", label="Test")
-
-    actions = ["delete", "test_action_normal", "test_action_action_log"]
-
-    @action(name="test_action_normal",
-            text="Test Action - Normal")
-    # confirmation="Möchtest du die Test Aktion durchführen?",
-    # icon_class="fa-regular fa-network-wired",
-    # submit_btn_text="Ja, fortsetzen",
-    # submit_btn_class="btn-success")
-    async def test_action_normal(self, request: Request, pk: list[str]) -> str:
-        await asyncio.sleep(2)
-
-        return "Test Aktion erfolgreich."
-
-    @action(name="test_action_action_log",
-            text="Test Action - Action Log")
-    # confirmation="Möchtest du die Test Aktion durchführen?",
-    # icon_class="fa-regular fa-network-wired",
-    # submit_btn_text="Ja, fortsetzen",
-    # submit_btn_class="btn-success")
-    async def test_action_action_log(self, request: Request, pk: list[str]) -> str:
-        with ActionLogger(request, parent=logger) as action_logger:
-            # use context manager to ensure that the logger is finalized
-            with action_logger.sub_logger("sub_action_1", "Sub Action 1", steps=3, ignore_loggers_like=["pymongo"]) as sub_logger:
-                sub_logger.info("Test Aktion startet ...")
-                sub_logger.debug("Debug")
-                sub_logger.info("Test Aktion step 1")
-                await asyncio.sleep(2)
-                sub_logger.next_step()
-                sub_logger.info("Test Aktion step 2")
-                _ = 1 / 0  # raise exception
-                # raise ActionFailed("Test Aktion fehlgeschlagen.")
-                await asyncio.sleep(2)
-                sub_logger.next_step()
-                sub_logger.steps += 100
-                for i in range(1, 100):
-                    sub_logger.info(f"Test Aktion step 2 - {i}")
-                    sub_logger.next_step()
-                    await asyncio.sleep(0.1)
-                sub_logger.info("Test Aktion step 3")
-                await asyncio.sleep(2)
-
-            sub_action_2_logger = action_logger.new_sub_logger("sub_action_2", "Sub Action 2")
-            sub_action_2_logger.start(steps=3)
-            sub_action_3_logger = action_logger.new_sub_logger("sub_action_3", "Sub Action 3")
-            sub_action_3_logger.start()
-            sub_action_3_logger.steps = 3
-            sub_action_2_logger.info("Test Aktion startet ...")
-            sub_action_3_logger.info("Test Aktion startet ...")
-            await asyncio.sleep(2)
-            sub_action_2_logger.next_step()
-            sub_action_3_logger.next_step()
-            await asyncio.sleep(2)
-            sub_action_2_logger.next_step()
-            sub_action_3_logger.next_step()
-            sub_action_2_logger.finalize(success=False, on_error_msg="Test Aktion fehlgeschlagen.")
-            sub_action_3_logger.finalize(success=True, on_success_msg="Test Aktion erfolgreich.")
-
-        return "Test Aktion erfolgreich."
-
-
-# Add views to admin#
-admin.add_view(TestView())
-
-# Mount admin to app
-admin.mount_to(app)
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)