swl 5.0.0__py3-none-any.whl

swl/.gitignore

@@ -0,0 +1 @@
+_version.py

swl/__init__.py

@@ -0,0 +1,26 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024-2025 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+# ._version.py is generated by setuptools_scm
+
+from pathlib import Path
+
+from .actions import Actions
+from .config import configure_logging
+from .responses import *
+from .swl import SWL
+from .uvicorn_app import uvicorn_main
+
+VERSION = SWL.SWL_VERSION
+static_dir = Path(__file__).parent / "static"
+templates_dir = Path(__file__).parent / "templates"

swl/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '5.0.0'
+__version_tuple__ = version_tuple = (5, 0, 0)
+
+__commit_id__ = commit_id = 'g4ab6b414a'

swl/actions.py

@@ -0,0 +1,150 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024-2026 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+import logging
+from hashlib import md5
+
+from starlette._exception_handler import wrap_app_handling_exceptions
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, RedirectResponse
+
+logger = logging.getLogger(__name__)
+
+
+def hash_name(name):
+    return md5(name.encode(encoding="utf-8")).hexdigest()
+
+
+class Actions:
+    def __init__(self, path="/action", default_auth=True, key=None):
+        self._actions = {}
+        self._path = path
+        self._extra_kwargs = {}
+        self._default_auth = default_auth
+        self._key = key or hash_name
+        if not self._path.startswith("/"):
+            raise ValueError("path must start with /")
+
+    @property
+    def actions_path(self):
+        return self._path + "/{action:str}"
+
+    def register_module(self, *modules):
+        for module in modules:
+            if hasattr(module, "__actions__"):
+                logger.info(
+                    f"loading module {module.__name__}, "
+                    + f"methods: {len(module.__actions__)}"
+                )
+                for item in module.__actions__:
+                    if not isinstance(item, dict):
+                        item = dict(method=item, authenticated=self._default_auth)
+                    self.register_method(**item)
+
+    def register_method(self, method, authenticated=None, is_authorized=None):
+        if authenticated is None:
+            authenticated = self._default_auth
+        is_allowed = is_authorized_fn(authenticated, is_authorized)
+        logger.debug(f"   - {method.__name__} - {is_allowed.__doc__}")
+
+        key = self._key(method.__name__)
+        self._actions[key] = dict(func=method, is_allowed=is_allowed)
+
+    def register_kwarg(self, key, value):
+        self._extra_kwargs[key] = value
+
+    def register(self, method_name, path=None):
+        key = self._key(method_name)
+        if path is not None:
+            return path + f"/{key}"
+        if key not in self._actions:
+            raise RuntimeError(f"Method not found: {method_name}")
+        return self._path + f"/{key}"
+
+    def get(self, key):
+        return self._actions.get(key)
+
+    def wrap(self, method, authenticated=True, **kwargs):
+        return ActionMethodWrap(self, method, authenticated=authenticated, **kwargs)
+
+    async def handle(self, request):
+        if "action" in request.path_params:
+            key = request.path_params["action"]
+            if (action := self.get(key)) is None:
+                raise HTTPException(404)
+            logger.debug(f"handle {self._path}/{key[:8]}.. {action['func'].__name__}")
+
+            user = request.user if "user" in request.scope else None
+            if not await action["is_allowed"](user, request, **self._extra_kwargs):
+                # action["authenticated"] is True and not request.user.is_authenticated:
+                raise HTTPException(403)
+
+            result = await action["func"](request, **self._extra_kwargs)
+            return result
+        raise HTTPException(404)
+
+
+def is_authorized_fn(authenticated, is_authorized):
+    doc = "authenticated=False"
+    if authenticated:
+        doc = "authenticated=True"
+        if is_authorized is not None:
+            doc += f", is_authorized={is_authorized.__name__}(...)"
+
+    async def is_allowed(user, request, **kwargs):
+        if not authenticated:
+            return True
+        if user is None or not user.is_authenticated:
+            return False
+        if is_authorized is not None:
+            return await is_authorized(request, **kwargs)
+        return True
+
+    is_allowed.__doc__ = doc
+
+    return is_allowed
+
+
+class ActionMethodWrap:
+    def __init__(
+        self, actions, method, authenticated=True, is_authorized=None, redirect=None
+    ):
+        self._actions = actions
+        self._method = method
+        self._authenticated = authenticated
+        self._is_authorized = is_authorized
+        if is_authorized is not None and not authenticated:
+            raise ValueError("is_authorized can only be set when authenticated is True")
+        self.is_allowed = is_authorized_fn(authenticated, is_authorized)
+        self._redirect = redirect
+
+    async def __call__(self, scope, receive, send):
+        request = Request(scope, receive, send)
+
+        if not await self.is_allowed(
+            scope.get("user"), request, **self._actions._extra_kwargs
+        ):
+            if self._redirect is None:
+                response = PlainTextResponse("Forbidden", status_code=403)
+            else:
+                request.session["next"] = request.url.path
+                response = RedirectResponse(self._redirect, status_code=303)
+            await response(scope, receive, send)
+        else:
+
+            async def app(scope, receive, send):
+                response = await self._method(request, **self._actions._extra_kwargs)
+                await response(scope, receive, send)
+
+            await wrap_app_handling_exceptions(app, request)(scope, receive, send)

swl/actions_test.py

@@ -0,0 +1,245 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024-2026 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+import pytest
+from starlette.applications import Starlette
+from starlette.responses import PlainTextResponse
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+from swl.test_utils import environment, create_app, login_user, logout_user
+
+from .actions import Actions
+
+
+@pytest.fixture
+def write_module(tmp_path):
+    import sys
+
+    sys.path.insert(0, tmp_path.as_posix())
+
+    def write_mod(name, text):
+        (tmp_path / name).write_text(text)
+
+    yield write_mod
+    sys.path.pop(0)
+
+
+def test_register_module_with_actions(tmp_path, write_module):
+    actions = Actions()
+
+    write_module("mod1.py", "def method1(x):\n  return 42")
+    write_module("mod2.py", "def method2(x):\n  return 42\n__actions__ = [method2]")
+    write_module(
+        "mod3.py",
+        "def method3(x):\n  return 42"
+        + "\n__actions__ = [dict(method=method3, authenticated=False)]",
+    )
+    write_module(
+        "mod4.py",
+        "def method4(x):\n  return 42"
+        + "\n__actions__ = [dict(method=method4, authenticated=True)]",
+    )
+
+    import mod1
+    import mod2
+    import mod3
+    import mod4
+
+    actions.register_module(mod1)
+    assert len(actions._actions) == 0
+    actions.register_module(mod2)
+    assert len(actions._actions) == 1
+    actions.register_module(mod3)
+    assert len(actions._actions) == 2
+    actions.register_module(mod4)
+    assert len(actions._actions) == 3
+
+    auth = [
+        action
+        for action in actions._actions.values()
+        if action["is_allowed"].__doc__.startswith("authenticated=True")
+    ]
+    assert len(auth) == 2
+
+
+async def test_default_auth(write_module):
+    write_module("mod2.py", "def method2(x):\n return 42\n__actions__ = [method2]")
+    import mod2
+
+    auth_actions = Actions()
+    auth_actions.register_module(mod2)
+    assert list(auth_actions._actions.values())[0]["is_allowed"].__doc__.startswith(
+        "authenticated=True"
+    )
+
+    noauth_actions = Actions(default_auth=False)
+    noauth_actions.register_module(mod2)
+    assert list(noauth_actions._actions.values())[0]["is_allowed"].__doc__.startswith(
+        "authenticated=False"
+    )
+
+
+async def test_default_auth_with_dict(write_module):
+    write_module(
+        "mod2.py", "def method2(x):\n return 42\n__actions__ = [dict(method=method2)]"
+    )
+    import mod2
+
+    auth_actions = Actions()
+    auth_actions.register_module(mod2)
+    assert list(auth_actions._actions.values())[0]["is_allowed"].__doc__.startswith(
+        "authenticated=True"
+    )
+
+    noauth_actions = Actions(default_auth=False)
+    noauth_actions.register_module(mod2)
+    assert list(noauth_actions._actions.values())[0]["is_allowed"].__doc__.startswith(
+        "authenticated=False"
+    )
+
+
+def test_register_with_different_path(write_module):
+    write_module(
+        "mod2.py", "def method2(x):\n return 42\n__actions__ = [dict(method=method2)]"
+    )
+    import mod2
+
+    actions = Actions(path="/my/action", key=str.upper)
+    actions.register_module(mod2)
+
+    assert actions.register("method2") == "/my/action/METHOD2"
+    with pytest.raises(RuntimeError):
+        actions.register("unknown")
+    assert actions.register("unknown", path="/other/action") == "/other/action/UNKNOWN"
+
+
+async def test_is_authorized(environment):
+    client, swl, userbase = environment
+
+    async def some_action(request, **kwargs):
+        return PlainTextResponse("Some Action")
+
+    async def userbase_has_user2(request, userbase, **kwargs):
+        return (userbase.get("user2")) is not None
+
+    swl.actions.register_method(some_action, is_authorized=userbase_has_user2)
+
+    response = client.post(swl.actions.register("some_action"))
+    assert response.status_code == 403
+
+    userbase.create("user2", "user2_password", admin=False)
+    response = client.post(swl.actions.register("some_action"))
+    assert response.status_code == 200
+    assert response.text == "Some Action"
+
+
+async def test_method_wrap(environment):
+    _, swl, userbase = environment
+
+    async def kwargs_page(request, **kwargs):
+        kwarg_keys = sorted(kwargs.keys())
+        return PlainTextResponse(f"Kwargs: {kwarg_keys}")
+
+    app = await create_app(
+        swl,
+        userbase,
+        routes=[
+            Route("/wrapped", endpoint=swl.endpoint(kwargs_page)),
+            Route("/unwrapped", endpoint=kwargs_page),
+        ],
+    )
+    client = TestClient(app)
+    login_user(client, "user", "user_password")
+
+    response = client.get("/unwrapped")
+    assert response.text == "Kwargs: []"
+
+    response = client.get("/wrapped")
+    assert response.text == "Kwargs: ['swl', 'userbase']"
+
+
+async def test_wrap_authenticated(environment):
+    _, swl, userbase = environment
+
+    async def auth_page(request, **kwargs):
+        return PlainTextResponse("Authenticated")
+
+    async def is_admin(request, **kwargs):
+        return request.user.admin
+
+    async def login_page(request, **kwargs):
+        return PlainTextResponse(request.session.get("next", "No next"))
+
+    app = await create_app(
+        swl,
+        userbase,
+        routes=[
+            Route(
+                "/auth",
+                endpoint=swl.endpoint(
+                    auth_page, authenticated=True, redirect="/login/here"
+                ),
+            ),
+            Route(
+                "/noauth",
+                endpoint=swl.endpoint(auth_page, authenticated=False),
+            ),
+            Route(
+                "/login/here",
+                endpoint=swl.endpoint(login_page, authenticated=False),
+            ),
+            Route(
+                "/admin_only",
+                endpoint=swl.endpoint(
+                    auth_page,
+                    authenticated=True,
+                    is_authorized=is_admin,
+                    redirect="/login/here",
+                ),
+            ),
+        ],
+    )
+    client = TestClient(app)
+
+    response = client.get("/auth", follow_redirects=False)
+    assert response.status_code == 303
+    assert response.headers["location"] == "/login/here"
+    response = client.get("/login/here", follow_redirects=False)
+    assert response.status_code == 200
+    assert response.text == "/auth"
+
+    login_user(client, "user", "user_password")
+    response = client.get("/auth")
+    assert response.status_code == 200
+    assert response.text == "Authenticated"
+
+    response = client.get("/admin_only", follow_redirects=False)
+    assert response.status_code == 303
+    response = client.get(response.headers["location"], follow_redirects=False)
+    assert response.status_code == 200
+    assert response.text == "/admin_only"
+
+    login_user(client, "admin", "admin_password")
+    response = client.get("/admin_only")
+    assert response.status_code == 200
+    assert response.text == "Authenticated"
+
+    response = client.get("/noauth")
+    assert response.status_code == 200
+    assert response.text == "Authenticated"
+
+    logout_user(client)
+    response = client.get("/noauth")
+    assert response.status_code == 200
+    assert response.text == "Authenticated"

swl/auth_test.py

@@ -0,0 +1,121 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+import uuid
+
+from starlette.applications import Starlette
+from starlette.authentication import AuthCredentials, AuthenticationBackend, BaseUser
+from starlette.middleware import Middleware
+from starlette.middleware.authentication import AuthenticationMiddleware
+from starlette.middleware.sessions import SessionMiddleware
+from starlette.responses import PlainTextResponse
+from starlette.routing import Route
+from starlette.testclient import TestClient
+
+from swl.swl import SWL
+
+
+class TestUser(BaseUser):
+    @property
+    def display_name(self):
+        return "TestUser"
+
+    @property
+    def is_authenticated(self):
+        return True
+
+
+class TestAuthBackend(AuthenticationBackend):
+    async def authenticate(self, conn):
+        if "user" in conn.session:
+            return AuthCredentials(["authenticated"]), TestUser()
+
+
+async def authenticated_method(request, swl):
+    return swl.success()
+
+
+async def unauthenticated_method(request, swl):
+    return swl.success()
+
+
+async def page(request, swl, **kwargs):
+    return PlainTextResponse(f"Authenticated: {request.user.is_authenticated}")
+
+
+async def login(request, swl, **kwargs):
+    request.session["user"] = True
+    return PlainTextResponse("OK")
+
+
+async def logout(request, swl, **kwargs):
+    request.session.clear()
+    return PlainTextResponse("OK")
+
+
+async def test_auth(tmp_path):
+
+    swl = SWL(config={})
+    swl.actions.register_method(authenticated_method)
+    swl.actions.register_method(unauthenticated_method, authenticated=False)
+
+    app = Starlette(
+        routes=[
+            swl.action_route,
+            Route("/secure", endpoint=swl.endpoint(page)),
+            Route(
+                "/unsecure",
+                endpoint=swl.endpoint(page, authenticated=False, redirect="/login"),
+            ),
+            Route("/login", endpoint=swl.endpoint(login, authenticated=False)),
+            Route("/logout", endpoint=swl.endpoint(logout, authenticated=False)),
+        ],
+        middleware=[
+            Middleware(SessionMiddleware, secret_key=str(uuid.uuid1())),
+            Middleware(
+                AuthenticationMiddleware,
+                backend=TestAuthBackend(),
+            ),
+        ],
+    )
+
+    client = TestClient(app)
+    response = client.post("/secure")
+    assert response.status_code == 403
+
+    response = client.post("/unsecure")
+    assert response.status_code == 200
+    assert response.text == "Authenticated: False"
+
+    response = client.post(swl.actions.register("authenticated_method"))
+    assert response.status_code == 403
+
+    response = client.post(swl.actions.register("unauthenticated_method"))
+    assert response.status_code == 204  # empty SuccessResponse
+
+    response = client.get("/login")
+    assert response.status_code == 200
+
+    response = client.post("/secure")
+    assert response.status_code == 200
+    assert response.text == "Authenticated: True"
+
+    response = client.post("/unsecure")
+    assert response.status_code == 200
+    assert response.text == "Authenticated: True"
+
+    response = client.post(swl.actions.register("authenticated_method"))
+    assert response.status_code == 204  # empty SuccessResponse
+
+    response = client.post(swl.actions.register("unauthenticated_method"))
+    assert response.status_code == 204  # empty SuccessResponse

swl/breadcrumbs.py

@@ -0,0 +1,52 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+
+class Crumb:
+    @classmethod
+    def from_dict(cls, dct):
+        return cls(**dct)
+
+    def __init__(self, label, action, arguments):
+        self.label = label
+        self.action = action
+        self.arguments = arguments
+
+    def __eq__(self, other):
+        return (
+            self.label == other.label
+            and self.action == other.action
+            and self.arguments == other.arguments
+        )
+
+    def as_dict(self):
+        return dict(label=self.label, action=self.action, arguments=self.arguments)
+
+
+class Breadcrumbs:
+    def __init__(self, breadcrumbs):
+        self._crumbs = [Crumb.from_dict(crumb) for crumb in (breadcrumbs or [])]
+
+    def add(self, label, action, arguments=None):
+        new_crumb = Crumb(label=label, action=action, arguments=arguments or {})
+
+        if new_crumb in self._crumbs:
+            self._crumbs = self._crumbs[: self._crumbs.index(new_crumb) + 1]
+        else:
+            self._crumbs.append(new_crumb)
+
+    def __iter__(self):
+        return iter(self._crumbs)
+
+    def as_dict(self):
+        return [crumb.as_dict() for crumb in self._crumbs]

swl/config.py

@@ -0,0 +1,66 @@
+## begin license ##
+#
+# "SWL"(Seecr Web Lib) makes developing webbased apps easier
+#
+# Copyright (C) 2024-2025 Seecr (Seek You Too B.V.) https://seecr.nl
+#
+# This file is part of "Seecr Web Lib"
+#
+# "Seecr Web Lib" is licensed under the MIT License; see the LICENSE file.
+# SPDX-License-Identifier: MIT
+#
+## end license ##
+
+import logging
+from copy import copy
+
+color_end = "\033[0m"
+color_red = "\033[1;31m"
+color_yellow = "\033[1;33m"
+
+colors = {
+    "WARNING": color_yellow,
+    "ERROR": color_red,
+    "CRITICAL": color_red,
+}
+
+
+def colorize(levelname):
+    if levelname in colors:
+        return colors[levelname] + levelname + color_end
+    return levelname
+
+
+class DefaultFormatter(logging.Formatter):
+    """
+    A custom log formatter class.
+
+    It does the following:
+    * Outputs the LOG_LEVEL in uppercase, right-aligned to 8 characters
+
+    Idea based on uvicorn.logging.DefaultFormatter
+    """
+
+    def formatMessage(self, record: logging.LogRecord) -> str:
+        recordcopy = copy(record)
+        levelname = recordcopy.levelname
+        seperator = " " * (8 - len(recordcopy.levelname))
+        recordcopy.__dict__["levelprefix"] = colorize(levelname) + ":" + seperator
+        return super().formatMessage(recordcopy)
+
+
+def configure_logging(loglevel):
+
+    root = logging.getLogger()
+    sh = logging.StreamHandler()
+    df = DefaultFormatter("%(levelprefix)s %(message)s")
+    sh.setFormatter(df)
+    root.addHandler(sh)
+    root.setLevel(loglevel)
+
+    # set levels logging
+    logging.getLogger("uvicorn").setLevel("INFO")
+    logging.getLogger("python_multipart").setLevel("INFO")
+    logging.getLogger("sqlalchemy.engine").setLevel("WARNING")
+    logging.getLogger("aiosqlite").setLevel("WARNING")
+    logging.getLogger("databases").setLevel("WARNING")