lakefront 0.1.0__tar.gz

lakefront-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piotr Nowakowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lakefront-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: lakefront
+Version: 0.1.0
+Summary: Lakehouse Observability Platform
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lakefront
+
+Lakehouse Observability Platform
+
+## About
+
+Terminal-first tool for exploring and monitoring Parquet datasets.
+Keyboard-driven TUI.
+Powered by DuckDB.
+
+## Install
+
+```bash
+pip install lakefront
+```
+
+## Setup
+
+```bash
+lakefront db init       # initialize local database
+lakefront db reset      # wipe and reinitialize
+```
+
+State is stored in `~/.config/lakefront/` — two files:
+
+```
+~/.config/lakefront/
+├── .db           # projects + sources (DuckDB)
+└── .project      # active project name
+```
+
+## Usage
+
+```bash
+lakefront ui       # launch TUI
+```
+
+### TUI keybindings
+
+| key         | action         |
+| ----------- | -------------- |
+| `n`         | new project    |
+| `d`         | delete project |
+| `enter`     | open project   |
+| `backspace` | go back        |
+| `q`         | quit           |
+
+## Structure
+
+```
+pkg/
+├── core/     # ProjectManager, Explorer, models
+├── tui/      # Textual screens and widgets
+└── cli/      # Typer entrypoint
+```

lakefront-0.1.0/README.md

@@ -0,0 +1,55 @@
+# Lakefront
+
+Lakehouse Observability Platform
+
+## About
+
+Terminal-first tool for exploring and monitoring Parquet datasets.
+Keyboard-driven TUI.
+Powered by DuckDB.
+
+## Install
+
+```bash
+pip install lakefront
+```
+
+## Setup
+
+```bash
+lakefront db init       # initialize local database
+lakefront db reset      # wipe and reinitialize
+```
+
+State is stored in `~/.config/lakefront/` — two files:
+
+```
+~/.config/lakefront/
+├── .db           # projects + sources (DuckDB)
+└── .project      # active project name
+```
+
+## Usage
+
+```bash
+lakefront ui       # launch TUI
+```
+
+### TUI keybindings
+
+| key         | action         |
+| ----------- | -------------- |
+| `n`         | new project    |
+| `d`         | delete project |
+| `enter`     | open project   |
+| `backspace` | go back        |
+| `q`         | quit           |
+
+## Structure
+
+```
+pkg/
+├── core/     # ProjectManager, Explorer, models
+├── tui/      # Textual screens and widgets
+└── cli/      # Typer entrypoint
+```

lakefront-0.1.0/lakefront.egg-info/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: lakefront
+Version: 0.1.0
+Summary: Lakehouse Observability Platform
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Lakefront
+
+Lakehouse Observability Platform
+
+## About
+
+Terminal-first tool for exploring and monitoring Parquet datasets.
+Keyboard-driven TUI.
+Powered by DuckDB.
+
+## Install
+
+```bash
+pip install lakefront
+```
+
+## Setup
+
+```bash
+lakefront db init       # initialize local database
+lakefront db reset      # wipe and reinitialize
+```
+
+State is stored in `~/.config/lakefront/` — two files:
+
+```
+~/.config/lakefront/
+├── .db           # projects + sources (DuckDB)
+└── .project      # active project name
+```
+
+## Usage
+
+```bash
+lakefront ui       # launch TUI
+```
+
+### TUI keybindings
+
+| key         | action         |
+| ----------- | -------------- |
+| `n`         | new project    |
+| `d`         | delete project |
+| `enter`     | open project   |
+| `backspace` | go back        |
+| `q`         | quit           |
+
+## Structure
+
+```
+pkg/
+├── core/     # ProjectManager, Explorer, models
+├── tui/      # Textual screens and widgets
+└── cli/      # Typer entrypoint
+```

lakefront-0.1.0/lakefront.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+lakefront.egg-info/PKG-INFO
+lakefront.egg-info/SOURCES.txt
+lakefront.egg-info/dependency_links.txt
+lakefront.egg-info/top_level.txt
+pkg/cli/src/lakefront/cli/__init__.py
+pkg/core/src/lakefront/core/__init__.py
+pkg/core/src/lakefront/core/bootstrap.py
+pkg/core/src/lakefront/core/config.py
+pkg/core/src/lakefront/core/explorer.py
+pkg/core/src/lakefront/core/manager.py
+pkg/core/src/lakefront/core/models.py
+pkg/tui/src/lakefront/tui/__init__.py

lakefront-0.1.0/lakefront.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lakefront-0.1.0/lakefront.egg-info/top_level.txt

@@ -0,0 +1 @@
+pkg

lakefront-0.1.0/pkg/cli/src/lakefront/cli/__init__.py

@@ -0,0 +1,78 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer()
+projects = typer.Typer()
+app.add_typer(projects, name="projects")
+db_app = typer.Typer()
+app.add_typer(db_app, name="db")
+
+
+console = Console()
+
+
+@db_app.command(
+    help="Initialize the lakefront database. Run this command before using any other commands."
+)
+def init():
+    from lakefront.core import bootstrap
+
+    console.print("[bold green]Initializing database...[/]")
+    bootstrap()
+
+
+@db_app.command(help="Open a duckdb shell connected to the lakefront database.")
+def shell():
+    """Open a duckdb shell connected to the lakefront database.
+
+    Usage:
+    $ lakefront db shell
+    $ db: SELECT * FROM projects;
+    $ db: show tables;
+    $ db: describe projects;
+    $ db:.exit
+    """
+    import subprocess
+
+    from lakefront.core.config import DB_PATH
+
+    subprocess.run(["duckdb", str(DB_PATH)], check=True)
+
+
+@db_app.command()
+def reset():
+    from lakefront.core import bootstrap, teardown
+
+    console.print("[bold green]Re-initializing database...[/]")
+    teardown()
+    bootstrap()
+
+
+@projects.command("list")
+def list_projects():
+    from lakefront.core import ProjectManager
+
+    pm = ProjectManager()
+    projects = pm.list()
+    table = Table(title="Projects", show_header=True, header_style="bold white")
+    table.add_column("ID", justify="right", style="white", width=6)
+    table.add_column("Name", style="dim", width=30)
+    table.add_column("Created At", justify="right", style="dim")
+    for p in projects:
+        table.add_row(str(p.id), p.name, p.created_at.strftime("%Y-%m-%d %H:%M:%S"))
+    console.print(table)
+
+
+@app.command()
+def version():
+    from lakefront.core import get_version
+
+    console.print(f"[white]lakefront v{get_version()} [/]")
+
+
+@app.command()
+def ui():
+    from lakefront.tui import LakeFrontApp
+
+    LakeFrontApp().run()

lakefront-0.1.0/pkg/core/src/lakefront/core/__init__.py

@@ -0,0 +1,12 @@
+from .bootstrap import bootstrap, teardown
+from .explorer import Explorer
+from .manager import ProjectManager
+
+
+def get_version() -> str:
+    import importlib.metadata as pkg
+
+    return pkg.version("lakefront-core")
+
+
+__all__ = ["ProjectManager", "Explorer", "bootstrap", "teardown", "get_version"]

lakefront-0.1.0/pkg/core/src/lakefront/core/bootstrap.py

@@ -0,0 +1,35 @@
+# polon/core/manager.py
+
+from .config import CONFIG_DIR, DB_PATH, PROJECTS_DIR, metadb
+
+
+def bootstrap():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    PROJECTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    with metadb() as db:
+        db.execute("""
+            CREATE SEQUENCE IF NOT EXISTS projects_id_seq;
+            CREATE TABLE IF NOT EXISTS projects (
+                id          INTEGER PRIMARY KEY DEFAULT nextval('projects_id_seq'),
+                name        TEXT NOT NULL UNIQUE,
+                path        TEXT NOT NULL,
+                created_at  TIMESTAMP DEFAULT now()
+            );
+            CREATE SEQUENCE IF NOT EXISTS conf_id_seq;
+            CREATE TABLE IF NOT EXISTS conf (
+                id          INTEGER PRIMARY KEY DEFAULT nextval('conf_id_seq'),
+                key         TEXT NOT NULL UNIQUE,
+                value       TEXT NOT NULL,
+                created_at  TIMESTAMP DEFAULT now()
+            );
+        """)
+
+
+def teardown():
+    if not DB_PATH.exists():
+        return
+    with metadb() as db:
+        db.execute("DROP TABLE IF EXISTS projects")
+        db.execute("DROP SEQUENCE IF EXISTS projects_id_seq")
+    DB_PATH.unlink(missing_ok=True)

lakefront-0.1.0/pkg/core/src/lakefront/core/config.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+
+import duckdb
+
+CONFIG_DIR = Path("~/.config/lakefront").expanduser()
+DB_PATH = CONFIG_DIR / ".db"
+ACTIVE_PATH = CONFIG_DIR / ".project"
+PROJECTS_DIR = Path("~/.local/share/lakefront/projects").expanduser()
+
+
+def metadb():
+    return duckdb.connect(str(DB_PATH))
+
+
+def make_project_path(name: str) -> Path:
+    path = PROJECTS_DIR / name
+    path.mkdir(parents=True, exist_ok=True)
+    return path

lakefront-0.1.0/pkg/core/src/lakefront/core/explorer.py

@@ -0,0 +1,5 @@
+class Explorer:
+    def profile(self, path: str) -> dict: ...
+    def drift(self, path: str) -> list[dict]: ...
+    def preview(self, path: str) -> dict: ...
+    def sql(self, path: str, query: str) -> dict: ...

lakefront-0.1.0/pkg/core/src/lakefront/core/manager.py

@@ -0,0 +1,30 @@
+from .config import ACTIVE_PATH, DB_PATH
+from .models import ProjectDTO, ProjectRepository
+
+
+class ProjectManager:
+    def __init__(self):
+        if not DB_PATH.exists():
+            raise RuntimeError("database not initialized. run: lakefront db init")
+        self.repo = ProjectRepository()
+
+    def create(self, name: str) -> ProjectDTO:
+        return self.repo.save(name)
+
+    def list(self) -> list[ProjectDTO]:
+        return self.repo.find_all()
+
+    def delete(self, name: str):
+        self.repo.delete(name)
+        if self.active() == name:
+            ACTIVE_PATH.unlink(missing_ok=True)
+
+    def switch(self, name: str):
+        if not self.repo.find_by_name(name):
+            raise ValueError(f"project '{name}' does not exist")
+        ACTIVE_PATH.write_text(name)
+
+    def active(self) -> str | None:
+        if ACTIVE_PATH.exists():
+            return ACTIVE_PATH.read_text().strip()
+        return None

lakefront-0.1.0/pkg/core/src/lakefront/core/models.py

@@ -0,0 +1,50 @@
+from dataclasses import dataclass
+from datetime import datetime
+
+from .config import make_project_path, metadb
+
+
+@dataclass
+class ProjectDTO:
+    id: int
+    name: str
+    path: str
+    created_at: datetime
+
+    @classmethod
+    def from_record(cls, record: tuple) -> "ProjectDTO":
+        return cls(id=record[0], name=record[1], path=record[2], created_at=record[3])
+
+
+class ProjectConfig:
+    def __init__(self, project_id: int):
+        self.project_id = project_id
+
+
+class ProjectRepository:
+    def find_by_name(self, name: str) -> ProjectDTO | None:
+        with metadb() as db:
+            row = db.execute(
+                "SELECT id, name, path, created_at FROM projects WHERE name = ?", [name]
+            ).fetchone()
+        return ProjectDTO.from_record(row) if row else None
+
+    def find_all(self) -> list[ProjectDTO]:
+        with metadb() as db:
+            rows = db.execute(
+                "SELECT id, name, path, created_at FROM projects ORDER BY created_at DESC"
+            ).fetchall()
+        return [ProjectDTO.from_record(row) for row in rows]
+
+    def save(self, name: str) -> ProjectDTO:
+        path = make_project_path(name)
+        with metadb() as db:
+            row = db.execute(
+                "INSERT INTO projects (name, path) VALUES (?, ?) RETURNING id, name, path, created_at",
+                [name, str(path)],
+            ).fetchone()
+        return ProjectDTO.from_record(row)
+
+    def delete(self, name: str):
+        with metadb() as db:
+            db.execute("DELETE FROM projects WHERE name = ?", [name])

lakefront-0.1.0/pkg/tui/src/lakefront/tui/__init__.py

@@ -0,0 +1,224 @@
+from lakefront.core import ProjectManager
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Center, Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import (
+    Button,
+    DataTable,
+    Footer,
+    Header,
+    Input,
+    Label,
+    ListItem,
+    ListView,
+    Static,
+)
+
+pm = ProjectManager()
+
+
+class NewProjectScreen(Screen):
+    BINDINGS = [
+        Binding("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Input(placeholder="project name")
+        yield Footer()
+
+    def on_input_submitted(self, event: Input.Submitted):
+        pm.create(event.value)
+        self.app.pop_screen()
+
+
+class ProjectView(Screen):
+    BINDINGS = [
+        Binding("backspace", "app.pop_screen", "Back"),
+        Binding("ctrl+r", "run_sql", "Run SQL"),
+    ]
+
+    CSS = """
+    #left  { width: 25%; border-right: solid #39ff14 20%; }
+    #main  { width: 1fr; }
+    #right { width: 25%; border-left: solid #39ff14 20%; }
+
+    #sources-list { height: 1fr; }
+    #stats-panel  { height: 12; padding: 1; }
+
+    #sql-input  { height: 3; }
+    #data-table { height: 1fr; }
+
+    Label {
+        color: #39ff14;
+        padding: 0 1;
+    }
+    """
+
+    def __init__(self, project_name: str, **kwargs):
+        super().__init__(**kwargs)
+        self.project_name = project_name
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        with Horizontal():
+            with Vertical(id="left"):
+                yield Label("sources")
+                yield ProjectListView(id="sources-list")
+                yield Label("statistics")
+                yield Static(id="stats-panel")
+            with Vertical(id="main"):
+                yield Input(placeholder="SELECT * FROM data LIMIT 100", id="sql-input")
+                yield DataTable(id="data-table")
+            with Vertical(id="right"):
+                yield Label("schema")
+                yield DataTable(id="schema-table")
+        yield Footer()
+
+    def on_list_view_selected(self, event): ...
+
+    def action_run_sql(self): ...
+
+
+class ConfirmScreen(Screen):
+    BINDINGS = [
+        Binding("escape", "app.pop_screen", "Cancel"),
+    ]
+
+    def __init__(self, message: str, **kwargs):
+        super().__init__(**kwargs)
+        self.message = message
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Label(self.message)
+        yield Button("Yes", id="yes", variant="error")
+        yield Button("No", id="no")
+        yield Footer()
+
+    def on_button_pressed(self, event: Button.Pressed):
+        self.dismiss(event.button.id == "yes")
+
+
+LOGO = r"""
+__________               __    
+\______   \ ____ _____  |  | __
+ |     ___// __ \\__  \ |  |/ /
+ |    |   \  ___/ / __ \|    < 
+ |____|    \___  /____  /__|_ \
+               \/     \/     \/
+lakehouse observability platform
+"""
+
+
+class ProjectListView(ListView):
+    BINDINGS = [
+        Binding("j", "cursor_down", "Down", show=False),
+        Binding("k", "cursor_up", "Up", show=False),
+    ]
+
+
+class SplashScreen(Screen):
+    CSS = """
+        .hidden { display: none; }
+        SplashScreen ListView {
+            width: 40;
+            height: auto;
+            align: center middle;
+        }
+        SplashScreen #center {
+            width: 40;
+            height: auto;
+            align: center middle;
+        }
+        SplashScreen {
+            align: center middle;
+        }
+
+        SplashScreen Label {
+            width: 40;
+            content-align: center middle;
+        }
+        #logo {
+            color: #39ff14;
+            content-align: center middle;
+            width: 100%;
+        }
+
+    """
+    BINDINGS = [
+        Binding("n", "new_project", "New"),
+        Binding("d", "delete_project", "Delete"),
+        Binding("enter", "open_project", "Open"),
+    ]
+
+    def action_cursor_down(self):
+        self.query_one(ListView).action_scroll_down()
+
+    def action_cursor_up(self):
+        self.query_one(ListView).action_scroll_up()
+
+    def on_mount(self):
+        lv = self.query_one(ListView)
+        lv.clear()
+        for project in pm.list():
+            lv.append(ListItem(Label(project.name)))
+        lv.focus()
+
+    def on_screen_resume(self):
+        self.on_mount()
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Static(LOGO, id="logo")
+        yield Center(
+            Label("Projects"),
+            ProjectListView(),
+            Input(placeholder="delete? y/N", id="confirm", classes="hidden"),
+        )
+        yield Footer()
+
+    def on_list_view_selected(self, event: ListView.Selected):
+        name = str(event.item.query_one(Label).render())
+        self.app.push_screen(ProjectView(name))
+
+    def action_new_project(self):
+        self.app.push_screen(NewProjectScreen())
+
+    def on_input_submitted(self, event: Input.Submitted):
+        confirm = self.query_one("#confirm", Input)
+        confirm.add_class("hidden")
+        if event.value.lower() == "y" and self._pending_delete:
+            pm.delete(self._pending_delete)
+            self._pending_delete = None
+            self.on_mount()  # refresh list
+        confirm.clear()
+        self.query_one(ListView).focus()
+
+    def action_delete_project(self):
+        lv = self.query_one(ListView)
+        if lv.highlighted_child:
+            self._pending_delete = str(lv.highlighted_child.query_one(Label).render())
+            confirm = self.query_one("#confirm", Input)
+            confirm.remove_class("hidden")
+            confirm.focus()
+
+
+class LakeFrontApp(App):
+    TITLE = "Lakehouse Observability Platform"
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+    ]
+    CSS = """
+    ListItem > ListItem.--highlight {
+        background: #39ff14 20%;
+    }
+
+    ListItem > ListItem.--highlight > Label {
+        color: #39ff14;
+    }
+    """
+
+    def on_mount(self):
+        self.push_screen(SplashScreen())

lakefront-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "lakefront"
+version = "0.1.0"
+description = "Lakehouse Observability Platform"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.uv.workspace]
+members = [
+  "pkg/core",
+  "pkg/cli",
+  "pkg/tui"
+]
+
+[dependency-groups]
+dev = [
+    "deptry>=0.24.0",
+    "ipython>=8.38.0",
+    "pytest>=9.0.2",
+    "ruff>=0.15.1",
+]
+
+[tool.pytest.ini_options]
+pythonpath = "pkg/*/src"  
+addopts = "-vv --maxfail=1 --tb=short"
+markers = [
+    "integration: tests requiring external services like Docker",
+]
+
+[tool.deptry]
+ignore = [
+    "DEP003"
+]
+
+[tool.ruff.lint]
+select = ["I", "TID"]
+
+[tool.ruff.lint.isort]
+force-sort-within-sections = false
+known-first-party = ["lop"]
+combine-as-imports = true
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "parents"
+

lakefront-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+