dataops-testgen 2.2.0__py3-none-any.whl

testgen/ui/services/test_suite_service.py

@@ -0,0 +1,76 @@
+import streamlit as st
+
+import testgen.ui.queries.test_suite_queries as test_suite_queries
+import testgen.ui.services.test_definition_service as test_definition_service
+
+
+def get_by_table_group(project_code, table_group_id):
+    schema = st.session_state["dbschema"]
+    return test_suite_queries.get_by_table_group(schema, project_code, table_group_id)
+
+
+def edit(test_suite):
+    schema = st.session_state["dbschema"]
+    test_suite_queries.edit(schema, test_suite)
+
+
+def add(test_suite):
+    schema = st.session_state["dbschema"]
+    test_suite_queries.add(schema, test_suite)
+
+
+def cascade_delete(test_suite_names, dry_run=False):
+    if not test_suite_names:
+        return True
+    schema = st.session_state["dbschema"]
+    can_be_deleted = not has_test_suite_dependencies(schema, test_suite_names)
+    if not dry_run:
+        test_definition_service.cascade_delete(test_suite_names)
+        test_suite_queries.cascade_delete(schema, test_suite_names)
+    return can_be_deleted
+
+
+def has_test_suite_dependencies(schema, test_suite_names):
+    if not test_suite_names:
+        return False
+    return not test_suite_queries.get_test_suite_dependencies(schema, test_suite_names).empty
+
+
+def are_test_suites_in_use(test_suite_names):
+    if not test_suite_names:
+        return False
+    schema = st.session_state["dbschema"]
+    usage_result = test_suite_queries.get_test_suite_usage(schema, test_suite_names)
+    return not usage_result.empty
+
+
+def get_test_suite_refresh_warning(table_groups_id, test_suite_name):
+    if not test_suite_name:
+        return False
+    schema = st.session_state["dbschema"]
+    row_result = test_suite_queries.get_test_suite_refresh_check(schema, table_groups_id, test_suite_name)
+
+    test_ct = None
+    unlocked_test_ct = None
+    unlocked_edits_ct = None
+    if row_result:
+        test_ct = row_result["test_ct"]
+        unlocked_test_ct = row_result["unlocked_test_ct"]
+        unlocked_edits_ct = row_result["unlocked_edits_ct"]
+
+    return test_ct, unlocked_test_ct, unlocked_edits_ct
+
+
+def get_generation_set_choices():
+    schema = st.session_state["dbschema"]
+    dfSets = test_suite_queries.get_generation_sets(schema)
+    if dfSets.empty:
+        return None
+    else:
+        return dfSets["generation_set"].to_list()
+
+
+def lock_edited_tests(test_suite_name):
+    schema = st.session_state["dbschema"]
+    tests_locked = test_suite_queries.lock_edited_tests(schema, test_suite_name)
+    return tests_locked

testgen/ui/services/toolbar_service.py

@@ -0,0 +1,77 @@
+from time import sleep
+
+import streamlit as st
+
+
+class ToolBar:
+    slot_count = 5
+    toolbar_prompt = None
+    action_prompt = None
+    help_link = "https://docs.datakitchen.io/article/dataops-testgen-help/dataops-testgen-help"
+
+    long_slots = None
+    short_slots = None
+    button_slots = None
+    status_bar = None
+    action_container = None
+
+    def __init__(self, long_slot_count=5, short_slot_count=0, button_slot_count=0, prompt=None, multiline=False):
+        self.toolbar_prompt = prompt
+
+        lst_slots_line2 = []
+        slots_line2 = None
+
+        # Initialize Toolbar Slots for widgets at right size ratio
+        lst_slots_line1 = [10] * long_slot_count
+        if multiline:
+            lst_slots_line2 = [7] * short_slot_count
+            lst_slots_line2 += [2] * button_slot_count
+        else:
+            lst_slots_line1 += [7] * short_slot_count
+            lst_slots_line1 += [2] * button_slot_count
+
+        slots_line1 = st.columns(lst_slots_line1)
+        if multiline:
+            slots_line2 = st.columns(lst_slots_line2)
+
+        if long_slot_count > 0:
+            self.long_slots = slots_line1[:long_slot_count]
+        if multiline:
+            if short_slot_count > 0:
+                self.short_slots = slots_line2[0:short_slot_count]
+            if button_slot_count > 0:
+                self.button_slots = slots_line2[-1 * button_slot_count :]
+        else:
+            if short_slot_count > 0:
+                self.short_slots = slots_line1[long_slot_count : long_slot_count + short_slot_count]
+            if button_slot_count > 0:
+                self.button_slots = slots_line1[-1 * button_slot_count :]
+
+        # Add vertical space to short slots
+        for i in range(short_slot_count):
+            self.short_slots[i].markdown("</p>&nbsp;</br>", unsafe_allow_html=True)
+
+        # Add vertical space to button slots
+        for i in range(button_slot_count):
+            self.button_slots[i].markdown("</p>&nbsp;</br>", unsafe_allow_html=True)
+
+        self.status_bar = st.empty()
+        self.set_prompt()
+
+    def set_prompt(self, str_new_prompt=None):
+        str_prompt = self.toolbar_prompt if str_new_prompt is None else str_new_prompt
+        if str_prompt:
+            self.toolbar_prompt = str_prompt
+            self.status_bar.markdown(f":green[**{str_prompt}**]")
+        else:
+            self.status_bar.empty()
+
+    def show_status(self, str_message, str_type):
+        if str_type == "success":
+            self.status_bar.success(str_message, icon="✅")
+        elif str_type == "error":
+            self.status_bar.error(str_message, icon="❌")
+        elif str_type == "info":
+            self.status_bar.info(str_message, icon="💡")
+        sleep(2)
+        self.set_prompt()

testgen/ui/session.py

@@ -0,0 +1,46 @@
+import typing
+
+from streamlit import session_state
+from streamlit.runtime.state import SessionStateProxy
+
+from testgen.utils.singleton import Singleton
+
+
+class TestgenSession(Singleton):
+    renders: int
+    current_page: str
+    current_page_args: dict
+
+    dbschema: str
+
+    name: str
+    username: str
+    authentication_status: bool
+    auth_role: typing.Literal["admin", "edit", "read"]
+    logging_out: bool
+
+    project: str
+    add_project: bool
+
+    sb_latest_rel: str
+    sb_schema_rev: str
+
+    def __init__(self, state: SessionStateProxy) -> None:
+        super().__setattr__("_state", state)
+
+    def __getattr__(self, key: str) -> typing.Any:
+        state = object.__getattribute__(self, "_state")
+        if key not in state:
+            return None
+        return state[key]
+
+    def __setattr__(self, key: str, value: typing.Any) -> None:
+        object.__getattribute__(self, "_state")[key] = value
+
+    def __delattr__(self, key: str) -> None:
+        state = object.__getattribute__(self, "_state")
+        if key in state:
+            del state[key]
+
+
+session = TestgenSession(session_state)

testgen/ui/views/app_log_modal.py

@@ -0,0 +1,92 @@
+import logging
+import os
+import re
+from datetime import date, datetime
+
+import streamlit as st
+
+import testgen.common.logs as logs
+import testgen.ui.services.form_service as fm
+from testgen.common import display_service
+from testgen.ui.components import widgets as testgen
+
+LOG = logging.getLogger("testgen")
+
+
+# Read the log file
+@st.cache_data
+def _read_log(file_path):
+    try:
+        with open(file_path) as file:
+            log_data = file.readlines()
+        return log_data  # NOQA TRY300
+
+    except Exception:
+        st.warning(f"Log file  is unavailable: {file_path}")
+        LOG.debug(f"Log viewer can't read log file {file_path}")
+
+
+# Function to filter log data by date
+def _filter_by_date(log_data, start_date, end_date):
+    filtered_data = []
+    for line in log_data:
+        # Assuming the log line starts with a date in the format 'YYYY-MM-DD'
+        match = re.match(r"^(\d{4}-\d{2}-\d{2})", line)
+        if match:
+            log_date = datetime.strptime(match.group(1), "%Y-%m-%d")
+            if start_date <= log_date <= end_date:
+                filtered_data.append(line)
+    return filtered_data
+
+
+# Function to search text in log data
+def _search_text(log_data, search_query):
+    return [line for line in log_data if search_query in line]
+
+
+def view_log_file(button_container):
+    log_file_modal = testgen.Modal(title=None, key="dk-view-log-modal", max_width=1100)
+
+    with button_container:
+        if st.button(
+            "Troubleshooting　→", help="Open and review TestGen Log files", use_container_width=True
+        ):
+            log_file_modal.open()
+
+    if log_file_modal.is_open():
+        with log_file_modal.container():
+            fm.render_modal_header("TestGen App Log", None, "Review/Troubleshoot daily log files")
+
+            _, file_out_path = display_service.get_in_out_paths()
+
+            col1, col2, col3 = st.columns([33, 33, 33])
+            log_date = col1.date_input("Log Date", value=datetime.today())
+
+            log_file_location = logs.get_log_full_path()
+
+            if log_date != date.today():
+                log_file_location += log_date.strftime(".%Y-%m-%d")
+
+            log_file_name = os.path.basename(log_file_location)
+
+            log_data = _read_log(log_file_location)
+
+            search_query = col2.text_input("Filter by Text")
+            if search_query:
+                show_data = _search_text(log_data, search_query)
+            else:
+                show_data = log_data
+
+            # Refresh button
+            col3.write(" \n ")
+            if col3.button("Refresh"):
+                # Clear cache to refresh the log data
+                st.cache_data.clear()
+
+            if log_data:
+                st.markdown(f"**Log File:** {log_file_name}")
+                # TOO SLOW: st.code(body=''.join(show_data), language="log", line_numbers=True)
+                st.text_area("Log Data", value="".join(show_data), height=400)
+
+                # Download button
+                st.download_button("Download", data="".join(show_data), file_name=log_file_name)

testgen/ui/views/connections.py

@@ -0,0 +1,72 @@
+import logging
+import typing
+
+import streamlit as st
+
+import testgen.ui.services.form_service as fm
+import testgen.ui.services.toolbar_service as tb
+from testgen.ui.components import widgets as testgen
+from testgen.ui.navigation.menu import MenuItem
+from testgen.ui.navigation.page import Page
+from testgen.ui.services import connection_service
+from testgen.ui.session import session
+from testgen.ui.views.connections_base import show_connection, show_create_qc_schema_modal
+
+LOG = logging.getLogger("testgen")
+
+
+class ConnectionsPage(Page):
+    path = "connections"
+    can_activate: typing.ClassVar = [
+        lambda: session.authentication_status or "login",
+    ]
+    menu_item = MenuItem(icon="database", label="Data Configuration", order=3)
+
+    def render(self) -> None:
+        fm.render_page_header(
+            "Connection",
+            "https://docs.datakitchen.io/article/dataops-testgen-help/connect-your-database",
+            lst_breadcrumbs=[
+                {"label": "Overview", "path": "overview"},
+                {"label": "Connection", "path": None},
+            ],
+        )
+
+        project_code = session.project
+        dataframe = connection_service.get_connections(project_code)
+        connection = dataframe.iloc[0]
+
+        tool_bar = tb.ToolBar(long_slot_count=6, short_slot_count=0, button_slot_count=0, prompt=None)
+
+        enable_table_groups = connection["project_host"] and connection["project_db"] and connection["project_qc_schema"]
+
+        form_container = st.expander("", expanded=True)
+        with form_container:
+            connection_modal = None
+            mode = "edit"
+            show_connection(connection_modal, connection, mode, project_code, show_header=False)
+
+        if tool_bar.long_slots[-1].button(
+            f":{'gray' if not enable_table_groups else 'green'}[Table Groups　→]",
+            help="Create or edit Table Groups for the Connection",
+            use_container_width=True,
+        ):
+            st.session_state["connection"] = connection.to_dict()
+
+            session.current_page = "connections/table-groups"
+            session.current_page_args = {"connection_id": connection["connection_id"]}
+            st.experimental_rerun()
+
+        create_qc_schema_modal = testgen.Modal(title=None, key="dk-create-qc-schema-modal", max_width=1100)
+
+        _, col2 = st.columns([70, 30])
+
+        if col2.button(
+            "Configure QC Utility Schema",
+            help="Creates the required Utility schema and related functions in the target database",
+            use_container_width=True,
+        ):
+            create_qc_schema_modal.open()
+
+        if create_qc_schema_modal.is_open():
+            show_create_qc_schema_modal(create_qc_schema_modal, connection)