|
| 1 | +"""Marimo UI for managed Hotdata databases (create + parquet table loads).""" |
| 2 | + |
| 3 | +from __future__ import annotations |
| 4 | + |
| 5 | +import os |
| 6 | +import tempfile |
| 7 | + |
| 8 | +import marimo as mo |
| 9 | + |
| 10 | +from hotdata_runtime import ( |
| 11 | + DEFAULT_SCHEMA, |
| 12 | + HotdataClient, |
| 13 | + LoadManagedTableResult, |
| 14 | + ManagedDatabase, |
| 15 | +) |
| 16 | + |
| 17 | +from hotdata_marimo._options import empty_dropdown |
| 18 | + |
| 19 | + |
| 20 | +def _parse_table_names(text: str) -> list[str]: |
| 21 | + return [line.strip() for line in text.splitlines() if line.strip()] |
| 22 | + |
| 23 | + |
| 24 | +def _upload_parquet_bytes(client: HotdataClient, contents: bytes) -> str: |
| 25 | + with tempfile.NamedTemporaryFile(suffix=".parquet", delete=False) as tmp: |
| 26 | + tmp.write(contents) |
| 27 | + path = tmp.name |
| 28 | + try: |
| 29 | + return client.upload_parquet(path) |
| 30 | + finally: |
| 31 | + os.unlink(path) |
| 32 | + |
| 33 | + |
| 34 | +def databases_panel(client: HotdataClient): |
| 35 | + """Table of managed databases in the workspace.""" |
| 36 | + dbs = client.list_managed_databases() |
| 37 | + if not dbs: |
| 38 | + return mo.vstack( |
| 39 | + [ |
| 40 | + mo.md("### Managed databases"), |
| 41 | + mo.md("_No managed databases yet._"), |
| 42 | + mo.md( |
| 43 | + "Create one below, or with the CLI: " |
| 44 | + "`hotdata databases create --name <name> --table <table>`." |
| 45 | + ), |
| 46 | + ], |
| 47 | + gap=1, |
| 48 | + ) |
| 49 | + rows: list[dict[str, object]] = [ |
| 50 | + {"name": db.name, "id": db.id, "sql_prefix": f"{db.name}.{{schema}}.{{table}}"} |
| 51 | + for db in dbs |
| 52 | + ] |
| 53 | + return mo.vstack( |
| 54 | + [ |
| 55 | + mo.md("### Managed databases"), |
| 56 | + mo.ui.table( |
| 57 | + rows, |
| 58 | + label="Managed databases", |
| 59 | + pagination=True, |
| 60 | + page_size=min(10, len(rows)), |
| 61 | + selection=None, |
| 62 | + max_height=240, |
| 63 | + ), |
| 64 | + mo.md("_Query as `database.schema.table` in SQL._"), |
| 65 | + ], |
| 66 | + gap=1, |
| 67 | + ) |
| 68 | + |
| 69 | + |
| 70 | +class ManagedDatabaseWriter: |
| 71 | + """Create managed databases and load parquet files into declared tables. |
| 72 | +
|
| 73 | + Instantiate in one cell and use ``.tab_ui`` in another (see package README). |
| 74 | + """ |
| 75 | + |
| 76 | + def __init__( |
| 77 | + self, |
| 78 | + client: HotdataClient, |
| 79 | + *, |
| 80 | + default_schema: str = DEFAULT_SCHEMA, |
| 81 | + ) -> None: |
| 82 | + self._client = client |
| 83 | + self._default_schema = default_schema |
| 84 | + self._last_create_n: int | None = None |
| 85 | + self._last_load_n: int | None = None |
| 86 | + self._create_result: ManagedDatabase | None = None |
| 87 | + self._load_result: LoadManagedTableResult | None = None |
| 88 | + self._create_error: str | None = None |
| 89 | + self._load_error: str | None = None |
| 90 | + self._show_create_success = False |
| 91 | + self._show_load_success = False |
| 92 | + |
| 93 | + self.name = mo.ui.text("", label="Database name", full_width=True) |
| 94 | + self.schema = mo.ui.text(default_schema, label="Schema", full_width=True) |
| 95 | + self.tables = mo.ui.text_area( |
| 96 | + "", |
| 97 | + label="Tables to declare (one per line)", |
| 98 | + full_width=True, |
| 99 | + ) |
| 100 | + self.create = mo.ui.button( |
| 101 | + value=0, |
| 102 | + on_click=lambda n: n + 1, |
| 103 | + label="Create database", |
| 104 | + kind="success", |
| 105 | + ) |
| 106 | + |
| 107 | + self._rebuild_database_pick() |
| 108 | + self.table = mo.ui.text("", label="Table name", full_width=True) |
| 109 | + self.file = mo.ui.file( |
| 110 | + filetypes=[".parquet"], |
| 111 | + label="Parquet file", |
| 112 | + kind="area", |
| 113 | + ) |
| 114 | + self.load = mo.ui.button( |
| 115 | + value=0, |
| 116 | + on_click=lambda n: n + 1, |
| 117 | + label="Load table", |
| 118 | + kind="success", |
| 119 | + ) |
| 120 | + |
| 121 | + def _rebuild_database_pick(self) -> None: |
| 122 | + dbs = self._client.list_managed_databases() |
| 123 | + if not dbs: |
| 124 | + self.database = empty_dropdown( |
| 125 | + label="Database", |
| 126 | + message="(create one first)", |
| 127 | + ) |
| 128 | + return |
| 129 | + self.database = mo.ui.dropdown( |
| 130 | + options={db.name: db.name for db in dbs}, |
| 131 | + label="Database", |
| 132 | + full_width=True, |
| 133 | + ) |
| 134 | + |
| 135 | + def _maybe_create(self) -> None: |
| 136 | + create_n = self.create.value |
| 137 | + if create_n == 0 or create_n == self._last_create_n: |
| 138 | + return |
| 139 | + self._last_create_n = create_n |
| 140 | + self._create_error = None |
| 141 | + self._create_result = None |
| 142 | + self._show_create_success = False |
| 143 | + self._show_load_success = False |
| 144 | + db_name = self.name.value.strip() |
| 145 | + if not db_name: |
| 146 | + self._create_error = "Enter a database name." |
| 147 | + return |
| 148 | + schema = self.schema.value.strip() or self._default_schema |
| 149 | + tables = _parse_table_names(self.tables.value) |
| 150 | + try: |
| 151 | + self._create_result = self._client.create_managed_database( |
| 152 | + db_name, |
| 153 | + schema=schema, |
| 154 | + tables=tables or None, |
| 155 | + ) |
| 156 | + self._rebuild_database_pick() |
| 157 | + self._show_create_success = True |
| 158 | + except (RuntimeError, ValueError, KeyError) as e: |
| 159 | + self._create_error = str(e) |
| 160 | + |
| 161 | + def _maybe_load(self) -> None: |
| 162 | + load_n = self.load.value |
| 163 | + if load_n == 0 or load_n == self._last_load_n: |
| 164 | + return |
| 165 | + self._last_load_n = load_n |
| 166 | + self._load_error = None |
| 167 | + self._load_result = None |
| 168 | + self._show_load_success = False |
| 169 | + database = self.database.value |
| 170 | + table = self.table.value.strip() |
| 171 | + if not database: |
| 172 | + self._load_error = "Choose or create a database first." |
| 173 | + return |
| 174 | + if not table: |
| 175 | + self._load_error = "Enter a table name." |
| 176 | + return |
| 177 | + uploads = self.file.value |
| 178 | + if not uploads: |
| 179 | + self._load_error = "Choose a parquet file to upload." |
| 180 | + return |
| 181 | + schema = self.schema.value.strip() or self._default_schema |
| 182 | + try: |
| 183 | + upload_id = _upload_parquet_bytes(self._client, uploads[0].contents) |
| 184 | + self._load_result = self._client.load_managed_table( |
| 185 | + database, |
| 186 | + table, |
| 187 | + schema=schema, |
| 188 | + upload_id=upload_id, |
| 189 | + ) |
| 190 | + self._show_load_success = True |
| 191 | + self._show_create_success = False |
| 192 | + except (RuntimeError, ValueError, KeyError, OSError) as e: |
| 193 | + self._load_error = str(e) |
| 194 | + |
| 195 | + @property |
| 196 | + def result_panel(self): |
| 197 | + _ = self.create.value |
| 198 | + _ = self.load.value |
| 199 | + self._maybe_create() |
| 200 | + self._maybe_load() |
| 201 | + |
| 202 | + if self._create_error: |
| 203 | + return mo.callout(mo.md(self._create_error), kind="danger") |
| 204 | + if self._show_create_success and self._create_result is not None: |
| 205 | + db = self._create_result |
| 206 | + return mo.callout( |
| 207 | + mo.md( |
| 208 | + f"Created **{db.name}** (`{db.id}`). " |
| 209 | + "Load parquet into a declared table below." |
| 210 | + ), |
| 211 | + kind="success", |
| 212 | + ) |
| 213 | + |
| 214 | + if self._load_error: |
| 215 | + return mo.callout(mo.md(self._load_error), kind="danger") |
| 216 | + if self._show_load_success and self._load_result is not None: |
| 217 | + loaded = self._load_result |
| 218 | + return mo.callout( |
| 219 | + mo.md( |
| 220 | + f"Loaded **{loaded.full_name}** · **{loaded.row_count}** rows." |
| 221 | + ), |
| 222 | + kind="success", |
| 223 | + ) |
| 224 | + |
| 225 | + return mo.md("_Create a database or load a parquet table to see results here._") |
| 226 | + |
| 227 | + @property |
| 228 | + def ui(self): |
| 229 | + _ = self.create.value |
| 230 | + _ = self.load.value |
| 231 | + _ = self.database.value |
| 232 | + return mo.vstack( |
| 233 | + [ |
| 234 | + mo.md("### Create database"), |
| 235 | + self.name, |
| 236 | + self.schema, |
| 237 | + self.tables, |
| 238 | + self.create, |
| 239 | + mo.md("### Load parquet table"), |
| 240 | + self.database, |
| 241 | + self.table, |
| 242 | + self.file, |
| 243 | + self.load, |
| 244 | + ], |
| 245 | + gap=1, |
| 246 | + ) |
| 247 | + |
| 248 | + @property |
| 249 | + def tab_ui(self): |
| 250 | + _ = self.create.value |
| 251 | + _ = self.load.value |
| 252 | + if hasattr(self.database, "value"): |
| 253 | + _ = self.database.value |
| 254 | + return mo.vstack( |
| 255 | + [ |
| 256 | + databases_panel(self._client), |
| 257 | + self.ui, |
| 258 | + self.result_panel, |
| 259 | + ], |
| 260 | + gap=2, |
| 261 | + ) |
| 262 | + |
| 263 | + |
| 264 | +def managed_database_writer( |
| 265 | + client: HotdataClient, |
| 266 | + *, |
| 267 | + default_schema: str = DEFAULT_SCHEMA, |
| 268 | +) -> ManagedDatabaseWriter: |
| 269 | + return ManagedDatabaseWriter(client, default_schema=default_schema) |
0 commit comments