dataops-testgen 2.2.0__py3-none-any.whl

testgen/ui/components/frontend/js/main.js

@@ -0,0 +1,99 @@
+/**
+ * @typedef Properties
+ * @type {object}
+ * @property {string} id - id of the specific component to be rendered
+ * @property {string} key - user key of the specific component to be rendered
+ * @property {object} props - object with the props to pass to the rendered component 
+ */
+import van from './van.min.js';
+import { Streamlit } from './streamlit.js';
+import { Button } from './components/button.js'
+import { Select } from './components/select.js'
+import { Location } from './components/location.js'
+import { Breadcrumbs } from './components/breadcrumbs.js'
+
+let currentWindowVan = van;
+let topWindowVan = window.top.van;
+
+const TestGenComponent = (/** @type {string} */ id, /** @type {object} */ props) => {
+    const componentById = {
+        select: Button,
+        button: Select,
+        location: Location,
+        breadcrumbs: Breadcrumbs,
+        sidebar: window.top.testgen.components.Sidebar,
+    };
+
+    if (Object.keys(componentById).includes(id)) {
+        return componentById[id](props);
+    }
+
+    return '';
+};
+
+window.addEventListener('message', (event) => {
+    if (event.data.type === 'streamlit:render') {
+        const componentId = event.data.args.id;
+        const componentKey = event.data.args.key;
+
+        let van = currentWindowVan;
+        let mountPoint = document.body;
+        let componentState = window.testgen.states[componentKey];
+        if (shouldRenderOutsideFrame(componentId)) {
+            window.frameElement.style.display = 'none';
+            componentState = window.top.testgen.states[componentKey];
+            mountPoint = window.frameElement.parentElement;
+            van = topWindowVan;
+        }
+
+        if (componentId === 'sidebar') {
+            window.top.testgen.components.Sidebar.onLogout = logout;
+            window.top.testgen.components.Sidebar.onProjectChanged = changeProject;
+            window.top.testgen.components.Sidebar.StreamlitInstance = Streamlit;
+        }
+
+        if (componentState === undefined) {
+            document.body.dataset.component = event.data.args.id;
+
+            componentState = {};
+            for (const [ key, value ] of Object.entries(event.data.args.props)) {
+                componentState[key] = van.state(value);
+            }
+
+            if (shouldRenderOutsideFrame(componentId)) {
+                window.top.testgen.states[componentKey] = componentState;
+            } else {
+                window.testgen.states[componentKey] = componentState;
+            }
+
+            return van.add(mountPoint, TestGenComponent(componentId, componentState));
+        }
+
+        for (const [ key, value ] of Object.entries(event.data.args.props)) {
+            if (componentState[key].val !== value) {
+                componentState[key].val = value;
+            }
+        }
+    }
+});
+
+Streamlit.init();
+
+function shouldRenderOutsideFrame(componentId) {
+    return 'sidebar' === componentId;
+}
+
+function logout(authCookieName) {
+    window.parent.postMessage({ type: 'TestgenLogout', cookie: authCookieName }, '*');
+    Streamlit.sendData({ logout: true });
+    return false;
+}
+
+function changeProject(/** @type string */ projectCode) {
+    Streamlit.sendData({ change_to_project: projectCode });
+}
+
+window.testgen = {
+    states: {},
+    loadedStylesheets: {},
+};

testgen/ui/components/frontend/js/streamlit.js

@@ -0,0 +1,19 @@
+const Streamlit = {
+    init: () => {
+        sendMessageToStreamlit('streamlit:componentReady', { apiVersion: 1 });
+    },
+    setFrameHeight: (height) => {
+        sendMessageToStreamlit('streamlit:setFrameHeight', { height: height });
+    },
+    sendData: (data) => {
+        sendMessageToStreamlit('streamlit:setComponentValue', { value: data, dataType: 'json' });
+    },
+};
+
+function sendMessageToStreamlit(type, data) {
+    if (window.top) {
+        window.top.postMessage(Object.assign({ type: type, isStreamlitMessage: true }, data), '*');
+    }
+}
+
+export { Streamlit };

testgen/ui/components/frontend/js/van.min.js

@@ -0,0 +1 @@
+let e,t,l,r,o,f=Object,n=f.getPrototypeOf,s=document,a={isConnected:1},i={},d=n(a),u=n(n),_=(e,t,l,r)=>(e??(setTimeout(l,r),new Set)).add(t),h=(e,t,r)=>{let o=l;l=t;try{return e(r)}catch(e){return console.error(e),r}finally{l=o}},c=e=>e.filter(e=>e.t?.isConnected),g=t=>o=_(o,t,()=>{for(let e of o)e.l=c(e.l),e.o=c(e.o);o=e},1e3),w={get val(){return l?.add(this),this.i},get oldVal(){return l?.add(this),this.u},set val(l){let r=this;if(l!==r.i){r.i=l;let o=[...r.o=c(r.o)];for(let t of o)x(t.f,t.s,t.t),t.t=e;r.l.length?t=_(t,r,p):r.u=l}}},v=e=>({__proto__:w,i:e,u:e,l:[],o:[]}),S=e=>n(e??0)===w,y=(e,t)=>{let l=new Set,o={f:e},f=r;r=[];let n=h(e,l,t);n=(n??s).nodeType?n:new Text(n);for(let e of l)g(e),e.l.push(o);for(let e of r)e.t=n;return r=f,o.t=n},x=(e,t=v(),l)=>{let o=new Set,f={f:e,s:t};f.t=l??r?.push(f)??a,t.val=h(e,o);for(let e of o)g(e),e.o.push(f);return t},V=(t,...l)=>{for(let r of l.flat(1/0)){let l=n(r??0),o=l===w?y(()=>r.val):l===u?y(r):r;o!=e&&t.append(o)}return t},b=t=>new Proxy((l,...r)=>{let[o,...a]=n(r[0]??0)===d?r:[{},...r],_=t?s.createElementNS(t,l):s.createElement(l);for(let[t,r]of f.entries(o)){let o=l=>l?f.getOwnPropertyDescriptor(l,t)??o(n(l)):e,s=l+","+t,a=i[s]??(i[s]=o(n(_))?.set??0),d=a?a.bind(_):_.setAttribute.bind(_,t),h=n(r??0);h===w?y(()=>(d(r.val),_)):h!==u||t.startsWith("on")&&!r.h?d(r):y(()=>(d(r()),_))}return V(_,...a)},{get:(t,l)=>t.bind(e,l)}),m=(e,t)=>t?t!==e&&e.replaceWith(t):e.remove(),p=()=>{let l=[...t].filter(e=>e.i!==e.u);t=e;for(let t of new Set(l.flatMap(e=>e.l=c(e.l))))m(t.t,y(t.f,t.t)),t.t=e;for(let e of l)e.u=e.i};export default{add:V,_:e=>(e.h=1,e),tags:b(),tagsNS:b,state:v,val:e=>S(e)?e.val:e,oldVal:e=>S(e)?e.oldVal:e,derive:x,hydrate:(e,t)=>m(e,y(t,e))};

testgen/ui/components/utils/callbacks.py

@@ -0,0 +1,51 @@
+"""
+Streamlit component's callbacks are broken for CustomComponents, this is
+a temporary patch picked up from the internet.
+
+https://gist.github.com/okld/1a2b2fd2cb9f85fc8c4e92e26c6597d5
+"""
+
+import logging
+
+from streamlit import session_state
+from streamlit.components.v1 import components
+
+LOG = logging.getLogger("testgen")
+
+
+def _patch_register_widget(register_widget):
+    def wrapper_register_widget(*args, **kwargs):
+        user_key = kwargs.get("user_key", None)
+        callbacks = session_state.get("_components_callbacks", None)
+
+        # Check if a callback was registered for that user_key.
+        if user_key and callbacks and user_key in callbacks:
+            callback = callbacks[user_key]
+
+            # Add callback-specific args for the real register_widget function.
+            kwargs["on_change_handler"] = callback[0]
+            kwargs["args"] = callback[1]
+            kwargs["kwargs"] = callback[2]
+
+        # Call the original function with updated kwargs.
+        return register_widget(*args, **kwargs)
+
+    return wrapper_register_widget
+
+
+# Patch function only once.
+if not hasattr(components.register_widget, "__callbacks_patched__"):
+    components.register_widget.__callbacks_patched__ = True
+    components.register_widget = _patch_register_widget(components.register_widget)
+
+
+def register_callback(element_key, callback, *callback_args, **callback_kwargs):
+    # Initialize callbacks store.
+    if "_components_callbacks" not in session_state:
+        session_state._components_callbacks = {}
+
+    # Register a callback for a given element_key.
+    try:
+        session_state._components_callbacks[element_key] = (callback, callback_args, callback_kwargs)
+    except:
+        LOG.debug("unexpected error registering component callback", exc_info=False, stack_info=False)

testgen/ui/components/utils/component.py

@@ -0,0 +1,13 @@
+import pathlib
+
+from streamlit.components import v1 as components
+
+components_dir = pathlib.Path(__file__).parent.parent.joinpath("frontend")
+component_function = components.declare_component("testgen", path=components_dir)
+
+
+def component(*, id_, props, key=None, default=None):
+    component_props = props
+    if not component_props:
+        component_props = {}
+    return component_function(id=id_, props=component_props, key=key, default=default)

testgen/ui/components/widgets/__init__.py

@@ -0,0 +1,6 @@
+# ruff: noqa: F401
+
+from testgen.ui.components.widgets.breadcrumbs import breadcrumbs
+from testgen.ui.components.widgets.location import LocationChanged, location
+from testgen.ui.components.widgets.modal import Modal
+from testgen.ui.components.widgets.sidebar import sidebar

testgen/ui/components/widgets/breadcrumbs.py

@@ -0,0 +1,32 @@
+import logging
+import typing
+
+from testgen.ui.components.utils.component import component
+
+LOG = logging.getLogger("testgen")
+
+
+def breadcrumbs(
+    key: str = "testgen:breadcrumbs",
+    breadcrumbs: list["Breadcrumb"] | None = None,
+) -> None:
+    """
+    Testgen component to display the breadcrumbs with a hash link on
+    each page.
+
+    # Parameters
+    :param key: unique key to give the component a persisting state
+    :param breadcrumbs: list of dicts with label and path
+    """
+
+    component(
+        id_="breadcrumbs",
+        key=key,
+        default={},
+        props={"breadcrumbs": breadcrumbs},
+    )
+
+
+class Breadcrumb(typing.TypedDict):
+    path: str | None
+    label: str

testgen/ui/components/widgets/location.py

@@ -0,0 +1,65 @@
+import base64
+import dataclasses
+import logging
+import typing
+
+import streamlit as st
+
+from testgen.ui.components.utils.callbacks import register_callback
+from testgen.ui.components.utils.component import component
+from testgen.ui.session import session
+
+LOG = logging.getLogger("testgen")
+
+
+def location(
+    key: str = "testgen:location",
+    on_change: typing.Callable[["LocationChanged"], None] | None = None,
+) -> None:
+    """
+    Testgen component to listen for location changes in the url hash.
+
+    # Parameters
+    :param key: unique key to give the component a persisting state
+    :param on_change: callback for when the browser location changes
+    """
+    register_callback(key, _handle_location_change, key, on_change)
+
+    initialized = bool(session.renders and session.renders > 1)
+    current_page_code = _encode_page(session.current_page, session.current_page_args or {})
+
+    change = component(
+        id_="location",
+        key=key,
+        default={},
+        props={"initialized": initialized, "current_page_code": current_page_code},
+    )
+
+    if not initialized and change:
+        change = LocationChanged(**change)
+        if _encode_page(change.page, change.args) != current_page_code:
+            _handle_location_change(key, on_change)
+
+
+def _handle_location_change(key: str, callback: typing.Callable[["LocationChanged"], None] | None):
+    if callback:
+        change = st.session_state[key]
+        if "page" not in change:
+            change["page"] = "overview"
+        return callback(LocationChanged(**change))
+
+
+def _encode_page(page: str, args: dict) -> str | None:
+    page_code = None
+    if page:
+        query_params = "&".join([f"{name}={value}" for name, value in args.items()])
+        if query_params:
+            page = f"{page}?{query_params}"
+        page_code = base64.b64encode(page.encode()).decode()
+    return page_code
+
+
+@dataclasses.dataclass
+class LocationChanged:
+    page: str
+    args: dict = dataclasses.field(default_factory=dict)

testgen/ui/components/widgets/modal.py

@@ -0,0 +1,97 @@
+from contextlib import contextmanager
+
+import streamlit
+import streamlit.components.v1 as components
+from streamlit_modal import Modal as BaseModal
+
+
+class Modal(BaseModal):
+    @contextmanager
+    def container(self):
+        streamlit.markdown(self._modal_styles(), unsafe_allow_html=True)
+        with streamlit.container():
+            _container = streamlit.container()
+            if self.title:
+                _container.markdown(f"<h2>{self.title}</h2>", unsafe_allow_html=True)
+
+            close_ = streamlit.button("X", key=f"{self.key}-close")
+            if close_:
+                self.close()
+
+            if not close_:
+                components.html(self._modal_script(), height=0, width=0)
+
+        with _container:
+            yield _container
+
+    def _modal_styles(self) -> str:
+        max_width = f"{self.max_width}px" if self.max_width else "unset"
+
+        return f"""
+        <style>
+            div[data-modal-container='true'][key='{self.key}'] {{
+                position: fixed;
+                width: 100vw !important;
+                left: 0;
+                z-index: 1001;
+            }}
+
+            div[data-modal-container='true'][key='{self.key}'] > div:first-child {{
+                margin: auto;
+            }}
+
+            div[data-modal-container='true'][key='{self.key}'] h1 a {{
+                display: none
+            }}
+
+            div[data-modal-container='true'][key='{self.key}']::before {{
+                    position: fixed;
+                    content: ' ';
+                    left: 0;
+                    right: 0;
+                    top: 0;
+                    bottom: 0;
+                    z-index: 1000;
+                    background-color: rgba(0, 0, 0, 0.5);
+            }}
+            div[data-modal-container='true'][key='{self.key}'] > div:first-child {{
+                max-width: {max_width};
+            }}
+
+            div[data-modal-container='true'][key='{self.key}'] > div:first-child > div:first-child {{
+                width: unset !important;
+                background-color: #fff;
+                padding: {self.padding}px;
+                margin-top: {2*self.padding}px;
+                margin-left: -{self.padding}px;
+                margin-right: -{self.padding}px;
+                margin-bottom: -{2*self.padding}px;
+                z-index: 1001;
+                border-radius: 5px;
+            }}
+            div[data-modal-container='true'][key='{self.key}'] > div > div:nth-child(1 of .element-container)  {{
+                z-index: 1003;
+                position: absolute;
+            }}
+            div[data-modal-container='true'][key='{self.key}'] > div > div:nth-child(1 of .element-container) > div {{
+                text-align: right;
+                padding-right: {self.padding}px;
+                max-width: {max_width};
+            }}
+
+            div[data-modal-container='true'][key='{self.key}'] > div > div:nth-child(1 of .element-container) > div > button {{
+                right: 0;
+                margin-top: {2*self.padding + 14}px;
+            }}
+        </style>
+        """
+
+    def _modal_script(self) -> str:
+        return f"""
+        <script type="text/javascript">
+            const modalContainer = window.frameElement.parentElement.parentElement.parentElement;
+
+            modalContainer.setAttribute('data-modal-container', 'true');
+            modalContainer.setAttribute('key', '{self.key}');
+        </script>
+        """

testgen/ui/components/widgets/sidebar.py

@@ -0,0 +1,69 @@
+import dataclasses
+import logging
+import typing
+
+import streamlit as st
+
+from testgen.ui.components.utils.callbacks import register_callback
+from testgen.ui.components.utils.component import component
+from testgen.ui.navigation.menu import Menu
+from testgen.ui.services import authentication_service
+
+LOG = logging.getLogger("testgen")
+
+
+def sidebar(
+    key: str = "testgen:sidebar",
+    username: str | None = None,
+    menu: Menu = None,
+    current_page: str | None = None,
+    current_project: str | None = None,
+    on_logout: typing.Callable[[], None] | None = None,
+) -> None:
+    """
+    Testgen custom component to display a styled menu over streamlit's
+    sidebar.
+
+    # Parameters
+    :param key: unique key to give the component a persisting state
+    :param username: username to display at the bottom of the menu
+    :param menu: menu object with all root pages
+    :param current_page: page address to highlight the selected item
+    :param on_logout: callback for when user clicks logout
+    :param on_project_changed: callback for when user switches projects
+    """
+    register_callback(key, _handle_callbacks, key, on_logout)
+
+    component(
+        id_="sidebar",
+        props={
+            "username": username,
+            "menu": menu.filter_for_current_user().sort_items().asdict(),
+            "current_page": current_page,
+            "current_project": current_project,
+            "auth_cookie_name": authentication_service.AUTH_TOKEN_COOKIE_NAME,
+        },
+        key=key,
+        default={},
+    )
+
+
+def _handle_callbacks(
+    key: str,
+    on_logout: typing.Callable[[], None] | None = None,
+):
+    action = st.session_state[key]
+    action = MenuAction(**action)
+
+    if action.logout and on_logout:
+        return on_logout()
+
+
+class Project(typing.TypedDict):
+    code: str
+    name: str
+
+
+@dataclasses.dataclass
+class MenuAction:
+    logout: bool | None = None

testgen/ui/navigation/menu.py

@@ -0,0 +1,42 @@
+import dataclasses
+
+from testgen.ui.services import authentication_service
+
+
+@dataclasses.dataclass
+class MenuItem:
+    icon: str
+    label: str
+    page: str | None = dataclasses.field(default=None)
+    roles: list[authentication_service.RoleType] | None = dataclasses.field(default_factory=list)
+    order: int = dataclasses.field(default=0)
+
+
+@dataclasses.dataclass
+class Version:
+    current: str
+    latest: str
+    schema: str
+
+
+@dataclasses.dataclass
+class Menu:
+    items: list[MenuItem]
+    version: Version
+
+    def filter_for_current_user(self) -> "Menu":
+        filtered_items = []
+        for menu_item in self.items:
+            item_roles = menu_item.roles or []
+            if len(item_roles) <= 0 or any(map(authentication_service.current_user_has_role, item_roles)):
+                filtered_items.append(menu_item)
+        return dataclasses.replace(self, items=filtered_items)
+
+    def sort_items(self) -> "Menu":
+        return dataclasses.replace(self, items=sorted(self.items, key=lambda item: item.order))
+
+    def update_version(self, version: Version) -> "Menu":
+        return dataclasses.replace(self, version=version)
+
+    def asdict(self):
+        return dataclasses.asdict(self)

testgen/ui/navigation/page.py

@@ -0,0 +1,20 @@
+import abc
+import typing
+
+import testgen.ui.navigation.router
+from testgen.ui.navigation.menu import MenuItem
+
+CanActivateGuard = typing.Callable[[], bool | str]
+
+
+class Page(abc.ABC):
+    path: str
+    menu_item: MenuItem | None = None
+    can_activate: typing.ClassVar[list[CanActivateGuard] | None] = None
+
+    def __init__(self, router: testgen.ui.navigation.router.Router) -> None:
+        self.router = router
+
+    @abc.abstractmethod
+    def render(self, **kwargs) -> None:
+        raise NotImplementedError

testgen/ui/navigation/router.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import logging
+import typing
+
+import streamlit as st
+
+import testgen.ui.navigation.page
+from testgen.utils.singleton import Singleton
+
+CanActivateGuard = typing.Callable[[], bool | str]
+
+LOG = logging.getLogger("testgen")
+
+
+class Router(Singleton):
+    active: testgen.ui.navigation.page.Page | None
+    _default: type[testgen.ui.navigation.page.Page] | None
+    _routes: dict[str, type[testgen.ui.navigation.page.Page]]
+
+    def __init__(
+        self,
+        /,
+        routes: list[type[testgen.ui.navigation.page.Page]],
+        default: type[testgen.ui.navigation.page.Page] | None = None,
+    ) -> None:
+        self._routes = {}
+
+        for route in routes:
+            self._routes[route.path] = route
+
+        self.active = None
+        self._default = default
+        if self._default:
+            self._routes[self._default.path] = self._default
+
+    def navigate(self, /, to: str, with_args: dict | None = None) -> None:
+        try:
+            route = self._routes[to]
+
+            bc_source = route(self).path
+
+            for guard in route.can_activate or []:
+                can_activate = guard()
+                if type(can_activate) == str:
+                    return self.navigate(to=can_activate, with_args={})
+
+                if not can_activate and self._default:
+                    return self.navigate(to=self._default.path, with_args=with_args)
+
+            if not isinstance(self.active, route):
+                self.active = route(self)
+
+            self.active.render(**(with_args or {}))
+        except KeyError as k:
+            error_message = f"{bc_source}: {k!s}"
+            st.error(error_message)
+            LOG.exception(error_message)
+            return self.navigate(to=self._default.path, with_args=with_args)
+        except Exception as e:
+            error_message = f"{bc_source}: {e!s}"
+            st.error(error_message)
+            LOG.exception(error_message)

testgen/ui/queries/authentication_queries.py

@@ -0,0 +1,47 @@
+import streamlit as st
+
+import testgen.ui.services.database_service as db
+
+
+@st.cache_data(show_spinner=False)
+def get_users(schema):
+    sql = f"""SELECT
+                    id::VARCHAR(50),
+                    username, email, "name", "password", preauthorized, role
+                FROM {schema}.auth_users"""
+    return db.retrieve_data(sql)
+
+
+def delete_users(schema, user_ids):
+    if user_ids is None or len(user_ids) == 0:
+        raise ValueError("No user is specified.")
+
+    items = [f"'{item}'" for item in user_ids]
+    sql = f"""DELETE FROM {schema}.auth_users WHERE id in ({",".join(items)})"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def add_user(schema, user, encrypted_password):
+    sql = f"""INSERT INTO {schema}.auth_users
+    (username, email, name, password, role)
+SELECT
+    '{user["username"]}' as username,
+    '{user["email"]}' as email,
+    '{user["name"]}' as name,
+    '{encrypted_password}' as password,
+    '{user["role"]}' as role;"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def edit_user(schema, user, encrypted_password):
+    sql = f"""UPDATE {schema}.auth_users SET
+        username = '{user["username"]}',
+        email = '{user["email"]}',
+        name = '{user["name"]}',
+        password = '{encrypted_password}',
+        role = '{user["role"]}'
+    WHERE id  = '{user["user_id"]}';"""
+    db.execute_sql(sql)
+    st.cache_data.clear()