dataops-testgen 2.2.0__py3-none-any.whl

testgen/ui/queries/test_definition_queries.py

@@ -0,0 +1,270 @@
+import streamlit as st
+
+import testgen.ui.services.database_service as db
+
+
+def update_attribute(schema, test_definition_ids, attribute, value):
+    sql = f"""UPDATE {schema}.test_definitions
+                SET
+                    {attribute}='{value}'
+                where
+                    id in ({"'" + "','".join(test_definition_ids) + "'"})
+                ;
+                """
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+@st.cache_data(show_spinner=False)
+def get_test_definitions(schema, project_code, test_suite, table_name, column_name, test_definition_ids):
+    if table_name:
+        table_condition = f" AND d.table_name = '{table_name}'"
+    else:
+        table_condition = ""
+    if column_name:
+        column_condition = f" AND d.column_name = '{column_name}'"
+    else:
+        column_condition = ""
+    sql = f"""
+            SELECT
+                   d.schema_name, d.table_name, d.column_name, t.test_name_short, t.test_name_long,
+                   d.id::VARCHAR(50),
+                   d.project_code, d.table_groups_id::VARCHAR(50), d.test_suite, d.test_suite_id::VARCHAR,
+                   d.test_type, d.cat_test_id::VARCHAR(50),
+                   d.test_active,
+                   CASE WHEN d.test_active = 'Y' THEN 'Yes' ELSE 'No' END as test_active_display,
+                   d.lock_refresh,
+                   CASE WHEN d.lock_refresh = 'Y' THEN 'Yes' ELSE 'No' END as lock_refresh_display,
+                   t.test_scope, 
+                   d.test_description,
+                   d.profiling_as_of_date,
+                   d.last_manual_update,
+                   d.severity, COALESCE(d.severity, s.severity, t.default_severity) as urgency,
+                   d.export_to_observability as export_to_observability_raw,
+                   CASE
+                        WHEN d.export_to_observability = 'Y' THEN 'Yes'
+                        WHEN d.export_to_observability = 'N' THEN 'No'
+                        WHEN d.export_to_observability IS NULL AND s.export_to_observability = 'Y' THEN 'Inherited (Yes)'
+                        ELSE 'Inherited (No)'
+                    END as export_to_observability,
+                   -- test_action,
+                   d.threshold_value, COALESCE(t.measure_uom_description, t.measure_uom) as export_uom,
+                   d.baseline_ct, d.baseline_unique_ct, d.baseline_value,
+                   d.baseline_value_ct, d.baseline_sum, d.baseline_avg, d.baseline_sd,
+                   d.subset_condition,
+                   d.groupby_names, d.having_condition, d.window_date_column, d.window_days,
+                   d.match_schema_name, d.match_table_name, d.match_column_names,
+                   d.match_subset_condition, d.match_groupby_names, d.match_having_condition,
+                   d.skip_errors, d.custom_query,
+                   COALESCE(d.test_description, t.test_description) as final_test_description,
+                   t.default_parm_columns, t.selection_criteria,
+                   d.profile_run_id::VARCHAR(50), d.test_action, d.test_definition_status,
+                   d.watch_level, d.check_result, d.last_auto_gen_date,
+                   d.test_mode
+              FROM {schema}.test_definitions d
+            INNER JOIN {schema}.test_types t ON (d.test_type = t.test_type)
+            INNER JOIN {schema}.test_suites s ON (d.test_suite_id = s.id)
+            WHERE True
+    """
+
+    if project_code:
+        sql += f"""             AND d.project_code = '{project_code}'
+        """
+
+    if test_suite:
+        sql += f""" AND d.test_suite = '{test_suite}' {table_condition} {column_condition}
+        """
+    if test_definition_ids:
+        sql += f""" AND d.id in ({"'" + "','".join(test_definition_ids) + "'"})
+        """
+
+    sql += """ORDER BY d.schema_name, d.table_name, d.column_name, d.test_type;
+    """
+
+    return db.retrieve_data(sql)
+
+
+def update(schema, test_definition):
+    sql = f"""UPDATE {schema}.test_definitions
+                SET
+                    cat_test_id = {test_definition["cat_test_id"]},
+                    --last_auto_gen_date = NULLIF('test_definition["last_auto_gen_date"]', ''),
+                    --profiling_as_of_date = NULLIF('test_definition["profiling_as_of_date"]', ''),
+                    last_manual_update = CURRENT_TIMESTAMP AT TIME ZONE 'UTC',
+                    skip_errors = {test_definition["skip_errors"]},
+                    custom_query = NULLIF($${test_definition["custom_query"]}$$, ''),
+                    test_definition_status = NULLIF('{test_definition["test_definition_status"]}', ''),
+                    export_to_observability = NULLIF('{test_definition["export_to_observability"]}', ''),
+                    column_name = NULLIF($${test_definition["column_name"]}$$, ''),
+                    watch_level = NULLIF('{test_definition["watch_level"]}', ''),
+                    project_code = NULLIF('{test_definition["project_code"]}', ''),
+                    table_groups_id = '{test_definition["table_groups_id"]}'::UUID,
+                    """
+
+    if test_definition["profile_run_id"]:
+        sql += f"""  profile_run_id = '{test_definition["profile_run_id"]}'::UUID,
+                """
+
+    sql += f"""     test_type = NULLIF('{test_definition["test_type"]}', ''),
+                    test_suite = NULLIF('{test_definition["test_suite"]}', ''),
+                    test_description = NULLIF($${test_definition["test_description"]}$$, ''),
+                    test_action = NULLIF('{test_definition["test_action"]}', ''),
+                    test_mode = NULLIF('{test_definition["test_mode"]}', ''),
+                    lock_refresh = NULLIF('{test_definition["lock_refresh"]}', ''),
+                    schema_name = NULLIF('{test_definition["schema_name"]}', ''),
+                    table_name = NULLIF('{test_definition["table_name"]}', ''),
+                    test_active = NULLIF('{test_definition["test_active"]}', ''),
+                    severity = NULLIF('{test_definition["severity"]}', ''),
+                    check_result = NULLIF('{test_definition["check_result"]}', ''),
+                    baseline_ct = NULLIF('{test_definition["baseline_ct"]}', ''),
+                    baseline_unique_ct = NULLIF('{test_definition["baseline_unique_ct"]}', ''),
+                    baseline_value = NULLIF($${test_definition["baseline_value"]}$$, ''),
+                    baseline_value_ct = NULLIF('{test_definition["baseline_value_ct"]}', ''),
+                    threshold_value = NULLIF($${test_definition["threshold_value"]}$$, ''),
+                    baseline_sum = NULLIF('{test_definition["baseline_sum"]}', ''),
+                    baseline_avg = NULLIF('{test_definition["baseline_avg"]}', ''),
+                    baseline_sd = NULLIF('{test_definition["baseline_sd"]}', ''),
+                    subset_condition = NULLIF($${test_definition["subset_condition"]}$$, ''),
+                    groupby_names = NULLIF($${test_definition["groupby_names"]}$$, ''),
+                    having_condition = NULLIF($${test_definition["having_condition"]}$$, ''),
+                    window_date_column = NULLIF('{test_definition["window_date_column"]}', ''),
+                    match_schema_name = NULLIF('{test_definition["match_schema_name"]}', ''),
+                    match_table_name = NULLIF('{test_definition["match_table_name"]}', ''),
+                    match_column_names = NULLIF($${test_definition["match_column_names"]}$$, ''),
+                    match_subset_condition = NULLIF($${test_definition["match_subset_condition"]}$$, ''),
+                    match_groupby_names = NULLIF($${test_definition["match_groupby_names"]}$$, ''),
+                    match_having_condition = NULLIF($${test_definition["match_having_condition"]}$$, ''),
+                    window_days = COALESCE({test_definition["window_days"]}, 0)
+                where
+                    id = '{test_definition["id"]}'
+                ;
+                """
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def add(schema, test_definition):
+    sql = f"""INSERT INTO {schema}.test_definitions
+                (
+                    --cat_test_id,
+                    --last_auto_gen_date,
+                    --profiling_as_of_date,
+                    last_manual_update,
+                    skip_errors,
+                    custom_query,
+                    test_definition_status,
+                    export_to_observability,
+                    column_name,
+                    watch_level,
+                    project_code,
+                    table_groups_id,
+                    profile_run_id,
+                    test_type,
+                    test_suite,
+                    test_suite_id,
+                    test_description,
+                    test_action,
+                    test_mode,
+                    lock_refresh,
+                    schema_name,
+                    table_name,
+                    test_active,
+                    severity,
+                    check_result,
+                    baseline_ct,
+                    baseline_unique_ct,
+                    baseline_value,
+                    baseline_value_ct,
+                    threshold_value,
+                    baseline_sum,
+                    baseline_avg,
+                    baseline_sd,
+                    subset_condition,
+                    groupby_names,
+                    having_condition,
+                    window_date_column,
+                    match_schema_name,
+                    match_table_name,
+                    match_column_names,
+                    match_subset_condition,
+                    match_groupby_names,
+                    match_having_condition,
+                    window_days
+                )
+                SELECT
+                    --{test_definition["cat_test_id"]} as cat_test_id,
+                    --NULLIF('test_definition["last_auto_gen_date"]', '') as last_auto_gen_date,
+                    --NULLIF('test_definition["profiling_as_of_date"]', '') as profiling_as_of_date,
+                    CURRENT_TIMESTAMP AT TIME ZONE 'UTC' as last_manual_update,
+                    {test_definition["skip_errors"]} as skip_errors,
+                    NULLIF($${test_definition["custom_query"]}$$, '') as custom_query,
+                    NULLIF('{test_definition["test_definition_status"]}', '') as test_definition_status,
+                    NULLIF('{test_definition["export_to_observability"]}', '') as export_to_observability,
+                    NULLIF('{test_definition["column_name"]}', '') as column_name,
+                    NULLIF('{test_definition["watch_level"]}', '') as watch_level,
+                    NULLIF('{test_definition["project_code"]}', '') as project_code,
+                    '{test_definition["table_groups_id"]}'::UUID as table_groups_id,
+                    NULL AS profile_run_id,
+                    NULLIF('{test_definition["test_type"]}', '') as test_type,
+                    NULLIF('{test_definition["test_suite"]}', '') as test_suite,
+                    '{test_definition["test_suite_id"]}'::UUID as test_suite_id,
+                    NULLIF('{test_definition["test_description"]}', '') as test_description,
+                    NULLIF('{test_definition["test_action"]}', '') as test_action,
+                    NULLIF('{test_definition["test_mode"]}', '') as test_mode,
+                    NULLIF('{test_definition["lock_refresh"]}', '') as lock_refresh,
+                    NULLIF('{test_definition["schema_name"]}', '') as schema_name,
+                    NULLIF('{test_definition["table_name"]}', '') as table_name,
+                    NULLIF('{test_definition["test_active"]}', '') as test_active,
+                    NULLIF('{test_definition["severity"]}', '') as severity,
+                    NULLIF('{test_definition["check_result"]}', '') as check_result,
+                    NULLIF('{test_definition["baseline_ct"]}', '') as baseline_ct,
+                    NULLIF('{test_definition["baseline_unique_ct"]}', '') as baseline_unique_ct,
+                    NULLIF($${test_definition["baseline_value"]}$$, '') as baseline_value,
+                    NULLIF($${test_definition["baseline_value_ct"]}$$, '') as baseline_value_ct,
+                    NULLIF($${test_definition["threshold_value"]}$$, '') as threshold_value,
+                    NULLIF($${test_definition["baseline_sum"]}$$, '') as baseline_sum,
+                    NULLIF('{test_definition["baseline_avg"]}', '') as baseline_avg,
+                    NULLIF('{test_definition["baseline_sd"]}', '') as baseline_sd,
+                    NULLIF($${test_definition["subset_condition"]}$$, '') as subset_condition,
+                    NULLIF($${test_definition["groupby_names"]}$$, '') as groupby_names,
+                    NULLIF($${test_definition["having_condition"]}$$, '') as having_condition,
+                    NULLIF('{test_definition["window_date_column"]}', '') as window_date_column,
+                    NULLIF('{test_definition["match_schema_name"]}', '') as match_schema_name,
+                    NULLIF('{test_definition["match_table_name"]}', '') as match_table_name,
+                    NULLIF($${test_definition["match_column_names"]}$$, '') as match_column_names,
+                    NULLIF($${test_definition["match_subset_condition"]}$$, '') as match_subset_condition,
+                    NULLIF($${test_definition["match_groupby_names"]}$$, '') as match_groupby_names,
+                    NULLIF($${test_definition["match_having_condition"]}$$, '') as match_having_condition,
+                    COALESCE({test_definition["window_days"]}, 0) as window_days
+                ;
+                """
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def get_test_definition_usage(schema, test_definition_ids):
+    test_definition_names_join = [f"'{item}'" for item in test_definition_ids]
+    sql = f"""
+            select distinct test_definition_id from {schema}.test_results where test_definition_id in ({",".join(test_definition_names_join)});
+    """
+    return db.retrieve_data(sql)
+
+
+def delete(schema, test_definition_ids):
+    if test_definition_ids is None or len(test_definition_ids) == 0:
+        raise ValueError("No Test Definition is specified.")
+
+    items = [f"'{item}'" for item in test_definition_ids]
+    sql = f"""DELETE FROM {schema}.test_definitions WHERE id in ({",".join(items)})"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def cascade_delete(schema, test_suite_names):
+    if test_suite_names is None or len(test_suite_names) == 0:
+        raise ValueError("No Test Suite is specified.")
+
+    items = [f"'{item}'" for item in test_suite_names]
+    sql = f"""delete from {schema}.test_definitions where test_suite in ({",".join(items)})"""
+    db.execute_sql(sql)
+    st.cache_data.clear()

testgen/ui/queries/test_run_queries.py

@@ -0,0 +1,32 @@
+import streamlit as st
+
+import testgen.common.date_service as date_service
+import testgen.ui.services.database_service as db
+
+
+def cascade_delete(schema: str, test_suite_names: list[str]) -> None:
+    if test_suite_names is None or len(test_suite_names) == 0:
+        raise ValueError("No Test Suite is specified.")
+
+    items = [f"'{item}'" for item in test_suite_names]
+    sql = f"""delete from {schema}.working_agg_cat_results where test_suite in ({",".join(items)});
+delete from {schema}.working_agg_cat_tests where test_suite in ({",".join(items)});
+delete from {schema}.test_runs where test_suite in ({",".join(items)});
+delete from {schema}.test_results where test_suite in ({",".join(items)});
+delete from {schema}.execution_queue where test_suite in ({",".join(items)});"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def update_status(schema: str, test_run_id: str, status: str) -> None:
+    if not all([test_run_id, status]):
+        raise ValueError("Missing query parameters.")
+
+    now = date_service.get_now_as_string()
+
+    sql = f"""UPDATE {schema}.test_runs
+SET status = '{status}',
+    test_endtime = '{now}'
+where id = '{test_run_id}' :: UUID;"""
+    db.execute_sql(sql)
+    st.cache_data.clear()

testgen/ui/queries/test_suite_queries.py

@@ -0,0 +1,145 @@
+import pandas as pd
+import streamlit as st
+
+import testgen.ui.services.database_service as db
+
+
+@st.cache_data(show_spinner=False)
+def get_by_table_group(schema, project_code, table_group_id):
+    sql = f"""
+            SELECT
+                id::VARCHAR(50),
+                project_code, test_suite,
+                connection_id::VARCHAR(50),
+                table_groups_id::VARCHAR(50),
+                test_suite_description, test_action,
+                case when severity is null then 'Inherit' else severity end,
+                export_to_observability, test_suite_schema, component_key, component_type, component_name
+            FROM {schema}.test_suites
+            WHERE project_code = '{project_code}'
+            AND table_groups_id = '{table_group_id}'
+            ORDER BY test_suite;
+    """
+    return db.retrieve_data(sql)
+
+
+def edit(schema, test_suite):
+    sql = f"""UPDATE {schema}.test_suites
+                SET
+                    test_suite='{test_suite["test_suite"]}',
+                    test_suite_description='{test_suite["test_suite_description"]}',
+                    test_action=NULLIF('{test_suite["test_action"]}', ''),
+                    severity=NULLIF('{test_suite["severity"]}', 'Inherit'),
+                    export_to_observability='{'Y' if test_suite["export_to_observability"] else 'N'}',
+                    test_suite_schema=NULLIF('{test_suite["test_suite_schema"]}', ''),
+                    component_key=NULLIF('{test_suite["component_key"]}', ''),
+                    component_type=NULLIF('{test_suite["component_type"]}', ''),
+                    component_name=NULLIF('{test_suite["component_name"]}', '')
+                where
+                    id = '{test_suite["id"]}';
+                    """
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def add(schema, test_suite):
+    sql = f"""INSERT INTO {schema}.test_suites
+                (id,
+                project_code, test_suite, connection_id, table_groups_id, test_suite_description, test_action,
+                severity, export_to_observability, test_suite_schema, component_key, component_type,
+                component_name)
+            SELECT
+                gen_random_uuid(),
+                '{test_suite["project_code"]}',
+                '{test_suite["test_suite"]}',
+                '{test_suite["connection_id"]}',
+                '{test_suite["table_groups_id"]}',
+                NULLIF('{test_suite["test_suite_description"]}', ''),
+                NULLIF('{test_suite["test_action"]}', ''),
+                NULLIF('{test_suite["severity"]}', 'Inherit'),
+                '{'Y' if test_suite["export_to_observability"] else 'N' }'::character varying,
+                NULLIF('{test_suite["test_suite_schema"]}', ''),
+                NULLIF('{test_suite["component_key"]}', ''),
+                NULLIF('{test_suite["component_type"]}', ''),
+                NULLIF('{test_suite["component_name"]}', '')
+                ;"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def delete(schema, test_suite_ids):
+    if test_suite_ids is None or len(test_suite_ids) == 0:
+        raise ValueError("No table group is specified.")
+
+    items = [f"'{item}'" for item in test_suite_ids]
+    sql = f"""DELETE FROM {schema}.test_suites WHERE id in ({",".join(items)})"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def cascade_delete(schema: str, test_suite_names: list[str]) -> None:
+    if test_suite_names is None or len(test_suite_names) == 0:
+        raise ValueError("No Test Suite is specified.")
+
+    items = [f"'{item}'" for item in test_suite_names]
+    sql = f"""delete from {schema}.test_suites where test_suite in ({",".join(items)})"""
+    db.execute_sql(sql)
+    st.cache_data.clear()
+
+
+def get_test_suite_dependencies(schema: str, test_suite_names: list[str]) -> pd.DataFrame:
+    test_suite_names_join = [f"'{item}'" for item in test_suite_names]
+    sql = f"""
+            select distinct test_suite from {schema}.test_definitions where test_suite in ({",".join(test_suite_names_join)})
+            union
+            select distinct test_suite from {schema}.execution_queue where test_suite in ({",".join(test_suite_names_join)})
+            union
+            select distinct test_suite from {schema}.test_results where test_suite in ({",".join(test_suite_names_join)});
+    """
+    return db.retrieve_data(sql)
+
+
+
+def get_test_suite_usage(schema: str, test_suite_names: list[str]) -> pd.DataFrame:
+    test_suite_names_join = [f"'{item}'" for item in test_suite_names]
+    sql = f"""
+            select distinct test_suite from {schema}.test_runs where test_suite in ({",".join(test_suite_names_join)}) and status = 'Running'
+    """
+    return db.retrieve_data(sql)
+
+
+def get_test_suite_refresh_check(schema, table_groups_id, test_suite_name):
+    sql = f"""
+           SELECT COUNT(*) as test_ct,
+                  SUM(CASE WHEN COALESCE(d.lock_refresh, 'N') = 'N' THEN 1 ELSE 0 END) as unlocked_test_ct,
+                  SUM(CASE WHEN COALESCE(d.lock_refresh, 'N') = 'N' AND d.last_manual_update IS NOT NULL THEN 1 ELSE 0 END) as unlocked_edits_ct
+             FROM {schema}.test_definitions d
+           INNER JOIN {schema}.test_types t
+              ON (d.test_type = t.test_type)
+            WHERE d.table_groups_id = '{table_groups_id}'::UUID
+              AND d.test_suite = '{test_suite_name}'
+              AND t.run_type = 'CAT'
+              AND t.selection_criteria IS NOT NULL;
+"""
+    return db.retrieve_data_list(sql)[0]
+
+
+def get_generation_sets(schema):
+    sql = f"""
+           SELECT DISTINCT generation_set
+             FROM {schema}.generation_sets
+           ORDER BY generation_set;
+"""
+    return db.retrieve_data(sql)
+
+
+def lock_edited_tests(schema, test_suite_name):
+    sql = f"""
+           UPDATE {schema}.test_definitions
+              SET lock_refresh = 'Y'
+            WHERE test_suite = '{test_suite_name}'
+              AND last_manual_update IS NOT NULL
+              AND lock_refresh = 'N';
+"""
+    db.execute_sql(sql)
+    return True

testgen/ui/scripts/patch_streamlit.py

@@ -0,0 +1,111 @@
+# ruff: noqa: TRY002
+
+import functools
+import pathlib
+import shutil
+
+import streamlit
+from bs4 import BeautifulSoup, Tag
+
+INJECTED_CLASS = "testgen-mods"
+STREAMLIT_ROOT = pathlib.Path(streamlit.__file__).parent
+STREAMLIT_INDEX = STREAMLIT_ROOT / "static" / "index.html"
+STREAMLIT_JS_FOLDER = STREAMLIT_ROOT / "static" / "static" / "js"
+STREAMLIT_CSS_FOLDER = STREAMLIT_ROOT / "static" / "static" / "css"
+TESTGEN_ROOT = pathlib.Path(__file__).parent.parent.parent
+
+
+def patch(force: bool = False) -> list[str]:
+    operations = [
+        "ui/assets/style.css:insert",
+        "ui/assets/scripts.js:insert",
+        "ui/components/frontend/css/KFOmCnqEu92Fr1Mu7GxKOzY.woff2:copy",
+        "ui/components/frontend/css/KFOmCnqEu92Fr1Mu4mxK.woff2:copy",
+        "ui/components/frontend/css/KFOlCnqEu92Fr1MmEU9fChc4EsA.woff2:copy",
+        "ui/components/frontend/css/KFOlCnqEu92Fr1MmEU9fBBc4.woff2:copy",
+        "ui/components/frontend/css/material-symbols-rounded.woff2:copy",
+        "ui/components/frontend/css/roboto-font-faces.css:inject",
+        "ui/components/frontend/css/material-symbols-rounded.css:inject",
+        "ui/components/frontend/js/van.min.js:copy",
+        "ui/components/frontend/js/components/sidebar.js:inject",
+    ]
+
+    _patch_streamlit_index(*operations, force=force)
+
+    return [op.split(":")[0] for op in operations]
+
+
+def _patch_streamlit_index(*operations: list[str], force: bool = False) -> None:
+    """
+    Patches the index.html inside streamlit package to inject Testgen's
+    own styles and scripts before rendering time.
+
+    The new tags are injected with a distinctive class so that on the
+    next streamlit re-run it skips injecting (making it a tag faster
+    than st.markdown method).
+
+    NOTE: keeps a .bak of the original index.html file
+
+    :param filename: list of path to valid .css and .js files
+    :param force: to use in development while actively changing the
+    injected files to force re-injection
+    """
+
+    html = BeautifulSoup(STREAMLIT_INDEX.read_text(), features="html.parser")
+    if force or not html.find_all(attrs={"class": INJECTED_CLASS}):
+        streamlit_index_backup = STREAMLIT_INDEX.with_suffix(".bak")
+
+        if not streamlit_index_backup.exists():
+            shutil.copy(STREAMLIT_INDEX, streamlit_index_backup)
+        else:
+            shutil.copy(streamlit_index_backup, STREAMLIT_INDEX)
+            html = BeautifulSoup(STREAMLIT_INDEX.read_text(), features="html.parser")
+
+        head = html.find(name="head")
+        if head:
+            actions = {
+                "insert": _inline_tag,
+                "copy": _sourced_tag,
+                "inject": functools.partial(_sourced_tag, inject=True),
+            }
+            for operation in operations:
+                filename, action = operation.split(":")
+                if (filepath := (TESTGEN_ROOT / filename)).exists():
+                    if tag := actions[action](filepath, html):
+                        head.append(tag)
+
+            STREAMLIT_INDEX.write_text(str(html))
+
+
+def _inline_tag(filepath: pathlib.Path, html: BeautifulSoup, **_) -> Tag:
+    tag_for_ext = {
+        ".css": lambda: html.new_tag("style", **{"class": INJECTED_CLASS}),
+        ".js": lambda: html.new_tag("script", **{"type": "module", "class": INJECTED_CLASS}),
+    }
+
+    try:
+        tag = tag_for_ext[filepath.suffix]()
+    except:
+        raise Exception(f"Unsupported insert operation for file with extension {filepath.suffix}") from None
+
+    tag.string = filepath.read_text()
+    return tag
+
+
+def _sourced_tag(filepath: pathlib.Path, html: BeautifulSoup, inject: bool = False) -> Tag | None:
+    tag_for_ext = {
+        ".css": lambda: html.new_tag(
+            "link", **{"href": f"./static/css/{filepath.name}", "rel": "stylesheet", "class": INJECTED_CLASS}
+        ),
+        ".js": lambda: html.new_tag(
+            "script", **{"type": "module", "src": f"./static/js/{filepath.name}", "class": INJECTED_CLASS}
+        ),
+    }
+    copy_to = ({".js": STREAMLIT_JS_FOLDER}).get(filepath.suffix, STREAMLIT_CSS_FOLDER)
+
+    shutil.copy(filepath, copy_to)
+
+    if not inject or filepath.suffix not in tag_for_ext:
+        return None
+
+    return tag_for_ext[filepath.suffix]()