laketower 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

laketower/templates/tables/history.html

@@ -2,6 +2,11 @@
 {% import 'tables/_macros.html' as table_macros %}
 
 {% block body %}
+{% if error %}
+<div class="alert alert-danger" role="alert">
+  {{ error.message }}
+</div>
+{% else %}
 {{ table_macros.table_nav(table_id, 'history') }}
 
 <div class="row">
@@ -39,4 +44,5 @@
       {% endfor %}
   </div>
 </div>
+{% endif %}
 {% endblock %}

laketower/templates/tables/import.html

@@ -0,0 +1,71 @@
+{% extends "_base.html" %}
+{% import 'tables/_macros.html' as table_macros %}
+
+{% block body %}
+{{ table_macros.table_nav(table_id, 'import') }}
+
+{% if message %}
+{% if message.type == 'success' %}{% set alert_type = 'success' %}
+{% elif message.type == 'error' %}{% set alert_type = 'danger' %}
+{% else %}{% set alert_type = 'primary' %}
+{% endif %}
+
+<div class="alert alert-{{ alert_type }}" role="alert">
+  {{ message.body }}
+</div>
+{% endif %}
+
+<div class="row justify-content-center">
+  <div class="col-12 col-md-8 col-lg-4">
+    <form action="{{ request.url.path }}" method="post" enctype="multipart/form-data">
+      <div class="mb-3">
+        <label for="import-file-input" class="form-label">Input file</label>
+        <input id="import-file-input" class="form-control" name="input_file" type="file" accept=".csv" required>
+      </div>
+
+      <div class="mb-3">
+        <label class="form-label">Mode</label>
+
+        <div class="form-check">
+          <input id="import-mode-append" class="form-check-input" name="mode" type="radio" value="append" checked>
+          <label for="import-mode-append" class="form-check-label">Append</label>
+        </div>
+        <div class="form-check">
+          <input id="import-mode-overwrite" class="form-check-input" name="mode" type="radio" value="overwrite">
+          <label for="import-mode-overwrite" class="form-check-label">Overwrite</label>
+        </div>
+      </div>
+
+      <div class="mb-3">
+        <label for="import-file-format" class="form-label">File format</label>
+        <select id="import-file-format" class="form-select" name="file_format">
+          <option value="csv" selected>CSV</option>
+        </select>
+      </div>
+
+      <div class="mb-3">
+        <label for="import-delimiter" class="form-label">Delimiter</label>
+        <input id="import-delimiter" class="form-control" name="delimiter" value="," required>
+      </div>
+
+      <div class="mb-3">
+        <label for="import-encoding" class="form-label">Encoding</label>
+        <select id="import-encoding" class="form-select" name="encoding">
+          <option value="utf-8" selected>UTF-8</option>
+          <option value="utf-16">UTF-16</option>
+          <option value="utf-32">UTF-32</option>
+          <option value="latin-1">Latin-1</option>
+        </select>
+      </div>
+
+      <div class="mb-3">
+        <div class="d-flex justify-content-end">
+          <button type="submit" class="btn btn-primary">
+            <i class="bi-upload" aria-hidden="true"></i> Import Data
+          </button>
+        </div>
+      </div>
+    </form>
+  </div>
+</div>
+{% endblock %}

laketower/templates/tables/index.html

@@ -2,6 +2,11 @@
 {% import 'tables/_macros.html' as table_macros %}
 
 {% block body %}
+{% if error %}
+<div class="alert alert-danger" role="alert">
+  {{ error.message }}
+</div>
+{% else %}
 {{ table_macros.table_nav(table_id, 'overview') }}
 
 <div class="row row-cols-1 row-cols-md-2 g-4">
@@ -81,4 +86,5 @@
     </div>
   </div>
 </div>
+{% endif %}
 {% endblock %}

laketower/templates/tables/query.html

@@ -8,9 +8,21 @@
 
     <form action="{{ request.url.path }}" method="get">
       <div class="mb-3">
-        <textarea name="sql" rows="5" class="form-control">{{ sql_query }}</textarea>
+        <textarea id="sql-editor" name="sql" rows="5" class="form-control">{{ sql_query }}</textarea>
       </div>
 
+      {% if sql_params|length %}
+      <h3 class="mb-3">Parameters</h3>
+      {% for param_name, param_value in sql_params.items() %}
+      <div class="row mb-3">
+        <label for="param-{{ param_name }}" class="col-form-label col-sm-2">{{ param_name }}</label>
+        <div class="col-sm-4">
+          <input id="param-{{ param_name }}" class="form-control" name="{{ param_name }}" value="{{ param_value }}">
+        </div>
+      </div>
+      {% endfor %}
+      {% endif %}
+
       <div class="mb-3">
         <div class="d-flex justify-content-end">
           <button type="submit" class="btn btn-primary">
@@ -25,6 +37,12 @@
       {{ error.message }}
     </div>
     {% else %}
+    <div class="d-flex justify-content-between align-items-center mb-2">
+      <h3>Results</h3>
+      <a href="/tables/query/csv?sql={{ sql_query | urlencode }}" class="btn btn-outline-secondary btn-sm">
+        <i class="bi-download" aria-hidden="true"></i> Export CSV
+      </a>
+    </div>
     <div class="table-responsive">
       <table class="table table-sm table-bordered table-striped table-hover">
         <thead>
@@ -48,4 +66,16 @@
     {% endif %}
   </div>
 </div>
+{% endblock %}
+
+{% block extra_scripts %}
+<script src="{{ url_for('static', path='/editor.bundle.js') }}"></script>
+<script>
+  window.addEventListener("DOMContentLoaded", () => {
+    const textArea = document.querySelector("textarea#sql-editor")
+    textArea.style.display = "none";
+    const sqlSchema = {{ sql_schema | tojson }}
+    const sqlEditor = editor.createEditor(textArea, { readOnly: false, dialect: 'duckdb', schema: sqlSchema})
+  })
+</script>
 {% endblock %}

laketower/templates/tables/statistics.html

@@ -2,6 +2,11 @@
 {% import 'tables/_macros.html' as table_macros %}
 
 {% block body %}
+{% if error %}
+<div class="alert alert-danger" role="alert">
+  {{ error.message }}
+</div>
+{% else %}
 {{ table_macros.table_nav(table_id, 'statistics') }}
 
 <div class="row">
@@ -53,4 +58,5 @@
     </div>
   </div>
 </div>
+{% endif %}
 {% endblock %}

laketower/templates/tables/view.html

@@ -2,6 +2,11 @@
 {% import 'tables/_macros.html' as table_macros %}
 
 {% block body %}
+{% if error %}
+<div class="alert alert-danger" role="alert">
+  {{ error.message }}
+</div>
+{% else %}
 {{ table_macros.table_nav(table_id, 'view') }}
 
 <div class="row">
@@ -93,4 +98,5 @@
     </div>
   </div>
 </div>
+{% endif %}
 {% endblock %}

laketower/web.py

@@ -1,19 +1,28 @@
 import urllib.parse
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Annotated
 
+import bleach
+import markdown
 import pydantic_settings
-from fastapi import APIRouter, FastAPI, Query, Request
-from fastapi.responses import HTMLResponse
+from fastapi import APIRouter, FastAPI, File, Form, Query, Request, UploadFile
+from fastapi.responses import HTMLResponse, RedirectResponse, Response
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 
+from laketower import __about__
 from laketower.config import Config, load_yaml_config
 from laketower.tables import (
     DEFAULT_LIMIT,
+    ImportFileFormatEnum,
+    ImportModeEnum,
     execute_query,
+    extract_query_parameter_names,
     generate_table_statistics_query,
     generate_table_query,
+    import_file_to_table,
+    load_datasets,
     load_table,
 )
 
@@ -22,6 +31,12 @@ class Settings(pydantic_settings.BaseSettings):
     laketower_config_path: Path
 
 
+@dataclass(frozen=True)
+class AppMetadata:
+    app_name: str
+    app_version: str
+
+
 def current_path_with_args(request: Request, args: list[tuple[str, str]]) -> str:
     keys_to_update = set(arg[0] for arg in args)
     query_params = request.query_params.multi_items()
@@ -33,19 +48,28 @@ def current_path_with_args(request: Request, args: list[tuple[str, str]]) -> str
     return f"{request.url.path}?{query_string}"
 
 
+def render_markdown(md_text: str) -> str:
+    return bleach.clean(
+        markdown.markdown(md_text), tags=bleach.sanitizer.ALLOWED_TAGS | {"p"}
+    )
+
+
 templates = Jinja2Templates(directory=Path(__file__).parent / "templates")
 templates.env.filters["current_path_with_args"] = current_path_with_args
+templates.env.filters["render_markdown"] = render_markdown
 
 router = APIRouter()
 
 
 @router.get("/", response_class=HTMLResponse)
 def index(request: Request) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     return templates.TemplateResponse(
         request=request,
         name="index.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
         },
@@ -54,14 +78,20 @@ def index(request: Request) -> HTMLResponse:
 
 @router.get("/tables/query", response_class=HTMLResponse)
 def get_tables_query(request: Request, sql: str) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
-    tables_dataset = {
-        table_config.name: load_table(table_config).dataset()
-        for table_config in config.tables
+    tables_dataset = load_datasets(config.tables)
+    sql_schema = {
+        table_name: dataset.schema.names
+        for table_name, dataset in tables_dataset.items()
+    }
+    sql_param_names = extract_query_parameter_names(sql)
+    sql_params = {
+        name: request.query_params.get(name) or "" for name in sql_param_names
     }
 
     try:
-        results = execute_query(tables_dataset, sql)
+        results = execute_query(tables_dataset, sql, sql_params=sql_params)
         error = None
     except ValueError as e:
         error = {"message": str(e)}
@@ -71,52 +101,90 @@ def get_tables_query(request: Request, sql: str) -> HTMLResponse:
         request=request,
         name="tables/query.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "table_results": results,
             "sql_query": sql,
+            "sql_schema": sql_schema,
+            "sql_params": sql_params,
             "error": error,
         },
     )
 
 
+@router.get("/tables/query/csv")
+def export_tables_query_csv(request: Request, sql: str) -> Response:
+    config: Config = request.app.state.config
+    tables_dataset = load_datasets(config.tables)
+
+    results = execute_query(tables_dataset, sql)
+    csv_content = results.to_csv(header=True, index=False, sep=",")
+
+    return Response(
+        content=csv_content,
+        media_type="text/csv",
+        headers={"Content-Disposition": "attachment; filename=query_results.csv"},
+    )
+
+
 @router.get("/tables/{table_id}", response_class=HTMLResponse)
 def get_table_index(request: Request, table_id: str) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     table_config = next(
         filter(lambda table_config: table_config.name == table_id, config.tables)
     )
-    table = load_table(table_config)
+    try:
+        table = load_table(table_config)
+        table_metadata = table.metadata()
+        table_schema = table.schema()
+        error = None
+    except ValueError as e:
+        error = {"message": str(e)}
+        table_metadata = None
+        table_schema = None
 
     return templates.TemplateResponse(
         request=request,
         name="tables/index.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "table_id": table_id,
-            "table_metadata": table.metadata(),
-            "table_schema": table.schema(),
+            "table_metadata": table_metadata,
+            "table_schema": table_schema,
+            "error": error,
         },
     )
 
 
 @router.get("/tables/{table_id}/history", response_class=HTMLResponse)
 def get_table_history(request: Request, table_id: str) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     table_config = next(
         filter(lambda table_config: table_config.name == table_id, config.tables)
     )
-    table = load_table(table_config)
+    try:
+        table = load_table(table_config)
+        table_history = table.history()
+        error = None
+    except ValueError as e:
+        error = {"message": str(e)}
+        table_history = None
 
     return templates.TemplateResponse(
         request=request,
         name="tables/history.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "table_id": table_id,
-            "table_history": table.history(),
+            "table_history": table_history,
+            "error": error,
         },
     )
 
@@ -127,26 +195,35 @@ def get_table_statistics(
     table_id: str,
     version: int | None = None,
 ) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     table_config = next(
         filter(lambda table_config: table_config.name == table_id, config.tables)
     )
-    table = load_table(table_config)
-    table_name = table_config.name
-    table_metadata = table.metadata()
-    table_dataset = table.dataset(version=version)
-    sql_query = generate_table_statistics_query(table_name)
-    query_results = execute_query({table_name: table_dataset}, sql_query)
+    try:
+        table = load_table(table_config)
+        table_name = table_config.name
+        table_metadata = table.metadata()
+        table_dataset = table.dataset(version=version)
+        sql_query = generate_table_statistics_query(table_name)
+        query_results = execute_query({table_name: table_dataset}, sql_query)
+        error = None
+    except ValueError as e:
+        error = {"message": str(e)}
+        table_metadata = None
+        query_results = None
 
     return templates.TemplateResponse(
         request=request,
         name="tables/statistics.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "table_id": table_id,
             "table_metadata": table_metadata,
             "table_results": query_results,
+            "error": error,
         },
     )
 
@@ -161,23 +238,32 @@ def get_table_view(
     sort_desc: str | None = None,
     version: int | None = None,
 ) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     table_config = next(
         filter(lambda table_config: table_config.name == table_id, config.tables)
     )
-    table = load_table(table_config)
-    table_name = table_config.name
-    table_metadata = table.metadata()
-    table_dataset = table.dataset(version=version)
-    sql_query = generate_table_query(
-        table_name, limit=limit, cols=cols, sort_asc=sort_asc, sort_desc=sort_desc
-    )
-    results = execute_query({table_name: table_dataset}, sql_query)
+    try:
+        table = load_table(table_config)
+        table_name = table_config.name
+        table_metadata = table.metadata()
+        table_dataset = table.dataset(version=version)
+        sql_query = generate_table_query(
+            table_name, limit=limit, cols=cols, sort_asc=sort_asc, sort_desc=sort_desc
+        )
+        results = execute_query({table_name: table_dataset}, sql_query)
+        error = None
+    except ValueError as e:
+        error = {"message": str(e)}
+        table_metadata = None
+        sql_query = None
+        results = None
 
     return templates.TemplateResponse(
         request=request,
         name="tables/view.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "table_id": table_id,
@@ -185,23 +271,118 @@ def get_table_view(
             "table_results": results,
             "sql_query": sql_query,
             "default_limit": DEFAULT_LIMIT,
+            "error": error,
+        },
+    )
+
+
+@router.get("/tables/{table_id}/import", response_class=HTMLResponse)
+def get_table_import(
+    request: Request,
+    table_id: str,
+) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
+    config: Config = request.app.state.config
+    table_config = next(
+        filter(lambda table_config: table_config.name == table_id, config.tables)
+    )
+    try:
+        table = load_table(table_config)
+        table_metadata = table.metadata()
+        message = None
+    except ValueError as e:
+        message = {"type": "error", "body": str(e)}
+        table_metadata = None
+
+    return templates.TemplateResponse(
+        request=request,
+        name="tables/import.html",
+        context={
+            "app_metadata": app_metadata,
+            "tables": config.tables,
+            "queries": config.queries,
+            "table_id": table_id,
+            "table_metadata": table_metadata,
+            "message": message,
+        },
+    )
+
+
+@router.post("/tables/{table_id}/import", response_class=HTMLResponse)
+def post_table_import(
+    request: Request,
+    table_id: str,
+    input_file: Annotated[UploadFile, File()],
+    mode: Annotated[ImportModeEnum, Form()],
+    file_format: Annotated[ImportFileFormatEnum, Form()],
+    delimiter: Annotated[str, Form()],
+    encoding: Annotated[str, Form()],
+) -> HTMLResponse:
+    app_metadata: AppMetadata = request.app.state.app_metadata
+    config: Config = request.app.state.config
+    table_config = next(
+        filter(lambda table_config: table_config.name == table_id, config.tables)
+    )
+    try:
+        table = load_table(table_config)
+        table_metadata = table.metadata()
+        rows_imported = import_file_to_table(
+            table_config, input_file.file, mode, file_format, delimiter, encoding
+        )
+        message = {
+            "type": "success",
+            "body": f"Successfully imported {rows_imported} rows",
+        }
+    except Exception as e:
+        message = {"type": "error", "body": str(e)}
+        table_metadata = None
+
+    return templates.TemplateResponse(
+        request=request,
+        name="tables/import.html",
+        context={
+            "app_metadata": app_metadata,
+            "tables": config.tables,
+            "queries": config.queries,
+            "table_id": table_id,
+            "table_metadata": table_metadata,
+            "message": message,
         },
     )
 
 
 @router.get("/queries/{query_id}/view", response_class=HTMLResponse)
-def get_query_view(request: Request, query_id: str) -> HTMLResponse:
+def get_query_view(request: Request, query_id: str) -> Response:
+    app_metadata: AppMetadata = request.app.state.app_metadata
     config: Config = request.app.state.config
     query_config = next(
         filter(lambda query_config: query_config.name == query_id, config.queries)
     )
-    tables_dataset = {
-        table_config.name: load_table(table_config).dataset()
-        for table_config in config.tables
+
+    if (
+        len(request.query_params.keys()) == 0
+        and len(query_config.parameters.keys()) > 0
+    ):
+        default_parameters = {k: v.default for k, v in query_config.parameters.items()}
+        url = request.url_for("get_query_view", query_id=query_id)
+        query_params = urllib.parse.urlencode(default_parameters)
+        return RedirectResponse(f"{url}?{query_params}")
+
+    tables_dataset = load_datasets(config.tables)
+    sql_param_names = extract_query_parameter_names(query_config.sql)
+    sql_params = {
+        name: request.query_params.get(name)
+        or (
+            query_param.default
+            if (query_param := query_config.parameters.get(name))
+            else None
+        )
+        or ""
+        for name in sql_param_names
     }
 
     try:
-        results = execute_query(tables_dataset, query_config.sql)
+        results = execute_query(tables_dataset, query_config.sql, sql_params=sql_params)
         error = None
     except ValueError as e:
         error = {"message": str(e)}
@@ -211,10 +392,12 @@ def get_query_view(request: Request, query_id: str) -> HTMLResponse:
         request=request,
         name="queries/view.html",
         context={
+            "app_metadata": app_metadata,
             "tables": config.tables,
             "queries": config.queries,
             "query": query_config,
             "query_results": results,
+            "sql_params": sql_params,
             "error": error,
         },
     )
@@ -231,6 +414,9 @@ def create_app() -> FastAPI:
         name="static",
     )
     app.include_router(router)
+    app.state.app_metadata = AppMetadata(
+        app_name="Laketower", app_version=__about__.__version__
+    )
     app.state.config = config
 
     return app