phlo-observatory 0.1.1__tar.gz

phlo_observatory-0.1.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: phlo-observatory
+Version: 0.1.1
+Summary: Phlo Observatory - Data platform UI (bundled with phlo core)
+Author-email: Phlo Team <team@phlo.dev>
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/plain
+Requires-Dist: phlo>=0.1.0
+Requires-Dist: phlo-postgres>=0.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+Phlo Observatory - Data platform visibility and lineage UI.

phlo_observatory-0.1.1/README.md

@@ -0,0 +1,61 @@
+# phlo-observatory
+
+Phlo Observatory UI for data platform visibility.
+
+## Description
+
+Web-based UI for exploring the data lakehouse. View lineage, browse tables, run queries, and monitor pipeline health.
+
+## Installation
+
+```bash
+pip install phlo-observatory
+# or
+phlo plugin install observatory
+```
+
+## Configuration
+
+| Variable              | Default                       | Description              |
+| --------------------- | ----------------------------- | ------------------------ |
+| `OBSERVATORY_PORT`    | `3001`                        | Observatory web UI port  |
+| `DAGSTER_GRAPHQL_URL` | `http://dagster:3000/graphql` | Dagster GraphQL endpoint |
+| `NESSIE_URL`          | `http://nessie:19120/api/v2`  | Nessie API URL           |
+| `TRINO_URL`           | `http://trino:8080`           | Trino HTTP URL           |
+| `PHLO_API_URL`        | `http://phlo-api:4000`        | Phlo API URL             |
+
+## Auto-Configuration
+
+This package is **auto-configured** via environment:
+
+| Feature            | How It Works                               |
+| ------------------ | ------------------------------------------ |
+| **API Connection** | Connects to phlo-api for backend data      |
+| **Service URLs**   | Auto-configured from environment variables |
+| **Dev Mode**       | Hot-reloading in `--dev` mode              |
+
+## Usage
+
+```bash
+# Start Observatory
+phlo services start --service observatory
+
+# Start with dev mode (hot-reload)
+phlo services start --dev
+```
+
+## Features
+
+- **Data Explorer** - Browse tables, view schemas, query data
+- **Lineage Graph** - Visualize data flow and dependencies
+- **Asset Browser** - View Dagster assets and materialization status
+- **Quality Dashboard** - Monitor quality check results
+- **Branch Management** - Create and merge Nessie branches
+
+## Endpoints
+
+- **Web UI**: `http://localhost:3001`
+
+## Entry Points
+
+- `phlo.plugins.services` - Provides `ObservatoryServicePlugin`

phlo_observatory-0.1.1/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "phlo-observatory"
+version = "0.1.1"
+description = "Phlo Observatory - Data platform UI (bundled with phlo core)"
+readme = {text = "Phlo Observatory - Data platform visibility and lineage UI.", content-type = "text/plain"}
+requires-python = ">=3.11"
+authors = [
+    {name = "Phlo Team", email = "team@phlo.dev"},
+]
+license = {text = "MIT"}
+dependencies = [
+    "phlo>=0.1.0",
+    "phlo-postgres>=0.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "ruff>=0.1.0",
+]
+
+[project.entry-points."phlo.plugins.services"]
+observatory = "phlo_observatory.plugin:ObservatoryServicePlugin"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+phlo_observatory = [
+    "service.yaml",
+    "Dockerfile",
+    "README.md",
+    "components.json",
+    "eslint.config.js",
+    "package.json",
+    "package-lock.json",
+    "prettier.config.js",
+    "tsconfig.json",
+    "vite.config.ts",
+    "context/**",
+    "public/**",
+    "src/**",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"

phlo_observatory-0.1.1/setup.cfg

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

phlo_observatory-0.1.1/src/phlo_observatory/Dockerfile

@@ -0,0 +1,44 @@
+# Build stage
+FROM node:24-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy source files
+COPY . .
+
+# Build the application
+RUN npm run build
+
+# Production stage
+FROM node:24-alpine AS runner
+
+WORKDIR /app
+
+# Required for service discovery/status code paths that run `docker ps`.
+RUN apk add --no-cache docker-cli
+
+# Copy built application
+COPY --from=builder /app/.output /app/.output
+COPY --from=builder /app/package*.json ./
+COPY --from=builder /app/node_modules /app/node_modules
+
+# Set environment
+ENV NODE_ENV=production
+ENV HOST=0.0.0.0
+ENV PORT=3001
+
+# Expose port
+EXPOSE 3001
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD wget --no-verbose --tries=1 --spider http://localhost:3001/ || exit 1
+
+# Run the application
+CMD ["node", ".output/server/index.mjs"]

phlo_observatory-0.1.1/src/phlo_observatory/README.md

@@ -0,0 +1,305 @@
+Welcome to your new TanStack app!
+
+# Getting Started
+
+To run this application:
+
+```bash
+npm install
+npm run start
+```
+
+## Dev Host Configuration
+
+Vite dev server host settings can be overridden via environment variables:
+
+- `DEV_HOST`: server host (default: `localhost`)
+- `DEV_HMR_HOST`: HMR host (default: `DEV_HOST`)
+- `DEV_ALLOWED_HOSTS`: comma-separated allowed hosts (default: `DEV_HOST`)
+
+# Building For Production
+
+To build this application for production:
+
+```bash
+npm run build
+```
+
+## Testing
+
+This project uses [Vitest](https://vitest.dev/) for testing. You can run the tests with:
+
+```bash
+npm run test
+```
+
+## Styling
+
+This project uses [Tailwind CSS](https://tailwindcss.com/) for styling.
+
+## Linting & Formatting
+
+This project uses [eslint](https://eslint.org/) and [prettier](https://prettier.io/) for linting and formatting. Eslint is configured using [tanstack/eslint-config](https://tanstack.com/config/latest/docs/eslint). The following scripts are available:
+
+```bash
+npm run lint
+npm run format
+npm run check
+```
+
+## Routing
+
+This project uses [TanStack Router](https://tanstack.com/router). The initial setup is a file based router. Which means that the routes are managed as files in `src/routes`.
+
+### Adding A Route
+
+To add a new route to your application just add another a new file in the `./src/routes` directory.
+
+TanStack will automatically generate the content of the route file for you.
+
+Now that you have two routes you can use a `Link` component to navigate between them.
+
+### Adding Links
+
+To use SPA (Single Page Application) navigation you will need to import the `Link` component from `@tanstack/react-router`.
+
+```tsx
+import { Link } from '@tanstack/react-router'
+```
+
+Then anywhere in your JSX you can use it like so:
+
+```tsx
+<Link to="/about">About</Link>
+```
+
+This will create a link that will navigate to the `/about` route.
+
+More information on the `Link` component can be found in the [Link documentation](https://tanstack.com/router/v1/docs/framework/react/api/router/linkComponent).
+
+### Using A Layout
+
+In the File Based Routing setup the layout is located in `src/routes/__root.tsx`. Anything you add to the root route will appear in all the routes. The route content will appear in the JSX where you use the `<Outlet />` component.
+
+Here is an example layout that includes a header:
+
+```tsx
+import { Outlet, createRootRoute } from '@tanstack/react-router'
+import { TanStackRouterDevtools } from '@tanstack/react-router-devtools'
+
+import { Link } from '@tanstack/react-router'
+
+export const Route = createRootRoute({
+  component: () => (
+    <>
+      <header>
+        <nav>
+          <Link to="/">Home</Link>
+          <Link to="/about">About</Link>
+        </nav>
+      </header>
+      <Outlet />
+      <TanStackRouterDevtools />
+    </>
+  ),
+})
+```
+
+The `<TanStackRouterDevtools />` component is not required so you can remove it if you don't want it in your layout.
+
+More information on layouts can be found in the [Layouts documentation](https://tanstack.com/router/latest/docs/framework/react/guide/routing-concepts#layouts).
+
+## Data Fetching
+
+There are multiple ways to fetch data in your application. You can use TanStack Query to fetch data from a server. But you can also use the `loader` functionality built into TanStack Router to load the data for a route before it's rendered.
+
+For example:
+
+```tsx
+const peopleRoute = createRoute({
+  getParentRoute: () => rootRoute,
+  path: '/people',
+  loader: async () => {
+    const response = await fetch('https://swapi.dev/api/people')
+    return response.json() as Promise<{
+      results: {
+        name: string
+      }[]
+    }>
+  },
+  component: () => {
+    const data = peopleRoute.useLoaderData()
+    return (
+      <ul>
+        {data.results.map((person) => (
+          <li key={person.name}>{person.name}</li>
+        ))}
+      </ul>
+    )
+  },
+})
+```
+
+Loaders simplify your data fetching logic dramatically. Check out more information in the [Loader documentation](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#loader-parameters).
+
+### React-Query
+
+React-Query is an excellent addition or alternative to route loading and integrating it into you application is a breeze.
+
+First add your dependencies:
+
+```bash
+npm install @tanstack/react-query @tanstack/react-query-devtools
+```
+
+Next we'll need to create a query client and provider. We recommend putting those in `main.tsx`.
+
+```tsx
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+
+// ...
+
+const queryClient = new QueryClient()
+
+// ...
+
+if (!rootElement.innerHTML) {
+  const root = ReactDOM.createRoot(rootElement)
+
+  root.render(
+    <QueryClientProvider client={queryClient}>
+      <RouterProvider router={router} />
+    </QueryClientProvider>,
+  )
+}
+```
+
+You can also add TanStack Query Devtools to the root route (optional).
+
+```tsx
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+
+const rootRoute = createRootRoute({
+  component: () => (
+    <>
+      <Outlet />
+      <ReactQueryDevtools buttonPosition="top-right" />
+      <TanStackRouterDevtools />
+    </>
+  ),
+})
+```
+
+Now you can use `useQuery` to fetch your data.
+
+```tsx
+import { useQuery } from '@tanstack/react-query'
+
+import './App.css'
+
+function App() {
+  const { data } = useQuery({
+    queryKey: ['people'],
+    queryFn: () =>
+      fetch('https://swapi.dev/api/people')
+        .then((res) => res.json())
+        .then((data) => data.results as { name: string }[]),
+    initialData: [],
+  })
+
+  return (
+    <div>
+      <ul>
+        {data.map((person) => (
+          <li key={person.name}>{person.name}</li>
+        ))}
+      </ul>
+    </div>
+  )
+}
+
+export default App
+```
+
+You can find out everything you need to know on how to use React-Query in the [React-Query documentation](https://tanstack.com/query/latest/docs/framework/react/overview).
+
+## State Management
+
+Another common requirement for React applications is state management. There are many options for state management in React. TanStack Store provides a great starting point for your project.
+
+First you need to add TanStack Store as a dependency:
+
+```bash
+npm install @tanstack/store
+```
+
+Now let's create a simple counter in the `src/App.tsx` file as a demonstration.
+
+```tsx
+import { useStore } from '@tanstack/react-store'
+import { Store } from '@tanstack/store'
+import './App.css'
+
+const countStore = new Store(0)
+
+function App() {
+  const count = useStore(countStore)
+  return (
+    <div>
+      <button onClick={() => countStore.setState((n) => n + 1)}>
+        Increment - {count}
+      </button>
+    </div>
+  )
+}
+
+export default App
+```
+
+One of the many nice features of TanStack Store is the ability to derive state from other state. That derived state will update when the base state updates.
+
+Let's check this out by doubling the count using derived state.
+
+```tsx
+import { useStore } from '@tanstack/react-store'
+import { Store, Derived } from '@tanstack/store'
+import './App.css'
+
+const countStore = new Store(0)
+
+const doubledStore = new Derived({
+  fn: () => countStore.state * 2,
+  deps: [countStore],
+})
+doubledStore.mount()
+
+function App() {
+  const count = useStore(countStore)
+  const doubledCount = useStore(doubledStore)
+
+  return (
+    <div>
+      <button onClick={() => countStore.setState((n) => n + 1)}>
+        Increment - {count}
+      </button>
+      <div>Doubled - {doubledCount}</div>
+    </div>
+  )
+}
+
+export default App
+```
+
+We use the `Derived` class to create a new store that is derived from another store. The `Derived` class has a `mount` method that will start the derived store updating.
+
+Once we've created the derived store we can use it in the `App` component just like we would any other store using the `useStore` hook.
+
+You can find out everything you need to know on how to use TanStack Store in the [TanStack Store documentation](https://tanstack.com/store/latest).
+
+# Demo files
+
+Files prefixed with `demo` can be safely deleted. They are there to provide a starting point for you to play around with the features you've installed.
+
+# Learn More
+
+You can learn more about all of the offerings from TanStack in the [TanStack documentation](https://tanstack.com).

phlo_observatory-0.1.1/src/phlo_observatory/__init__.py

@@ -0,0 +1,25 @@
+"""Observatory UI plugin package."""
+
+from phlo_observatory.manifest import ObservatoryExtensionManifest
+from phlo_observatory.observatory_ext import ObservatoryExtensionPlugin
+from phlo_observatory.plugin import ObservatoryServicePlugin
+from phlo_observatory.settings import ObservatorySettings, get_settings
+from phlo_observatory.settings_service import (
+    SettingsRecord,
+    SettingsScope,
+    SettingsService,
+    get_settings_service,
+)
+
+__all__ = [
+    "ObservatoryExtensionManifest",
+    "ObservatoryExtensionPlugin",
+    "ObservatoryServicePlugin",
+    "ObservatorySettings",
+    "SettingsRecord",
+    "SettingsScope",
+    "SettingsService",
+    "get_settings",
+    "get_settings_service",
+]
+__version__ = "0.1.0"

phlo_observatory-0.1.1/src/phlo_observatory/components.json

@@ -0,0 +1,24 @@
+{
+  "$schema": "https://ui.shadcn.com/schema.json",
+  "style": "base-lyra",
+  "rsc": false,
+  "tsx": true,
+  "tailwind": {
+    "config": "",
+    "css": "src/styles.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "hooks": "@/hooks"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}

phlo_observatory-0.1.1/src/phlo_observatory/eslint.config.js

@@ -0,0 +1,21 @@
+//  @ts-check
+
+import { tanstackConfig } from '@tanstack/eslint-config'
+
+export default [
+  {
+    ignores: [
+      '**/.output/**',
+      '**/dist/**',
+      '**/node_modules/**',
+      '**/eslint.config.js',
+      '**/prettier.config.js',
+    ],
+  },
+  ...tanstackConfig,
+  {
+    rules: {
+      '@typescript-eslint/no-unnecessary-condition': 'off',
+    },
+  },
+]

phlo_observatory-0.1.1/src/phlo_observatory/extensions.py

@@ -0,0 +1,66 @@
+"""Observatory extension discovery utilities."""
+
+from __future__ import annotations
+
+import importlib.metadata
+
+from phlo.config import get_settings
+from phlo.logging import get_logger
+from phlo_observatory import ObservatoryExtensionPlugin
+
+logger = get_logger(__name__)
+
+_ENTRY_POINT_GROUP = "phlo.plugins.observatory"
+
+
+def _is_plugin_allowed(plugin_name: str) -> bool:
+    settings = get_settings()
+    if plugin_name in settings.plugins_blacklist:
+        logger.debug("Plugin '%s' is blacklisted, skipping", plugin_name)
+        return False
+    if settings.plugins_whitelist and plugin_name not in settings.plugins_whitelist:
+        logger.debug("Plugin '%s' is not in whitelist, skipping", plugin_name)
+        return False
+    return True
+
+
+def discover_observatory_extensions() -> list[ObservatoryExtensionPlugin]:
+    """Discover installed Observatory extension plugins."""
+    settings = get_settings()
+    if not settings.plugins_enabled:
+        logger.info("Plugin system is disabled")
+        return []
+
+    try:
+        entry_points = importlib.metadata.entry_points(group=_ENTRY_POINT_GROUP)
+    except TypeError:
+        entry_points = importlib.metadata.entry_points().get(_ENTRY_POINT_GROUP, [])
+
+    plugins: list[ObservatoryExtensionPlugin] = []
+    for entry_point in entry_points:
+        if not _is_plugin_allowed(entry_point.name):
+            continue
+        try:
+            plugin_class = entry_point.load()
+            plugin = plugin_class() if isinstance(plugin_class, type) else plugin_class
+        except Exception as exc:
+            logger.warning("Failed to load Observatory extension %s: %s", entry_point.name, exc)
+            continue
+        if not isinstance(plugin, ObservatoryExtensionPlugin):
+            logger.warning(
+                "Observatory extension %s has invalid type %s",
+                entry_point.name,
+                type(plugin).__name__,
+            )
+            continue
+        plugins.append(plugin)
+
+    return plugins
+
+
+def get_observatory_extension(name: str) -> ObservatoryExtensionPlugin | None:
+    """Return a single Observatory extension by name."""
+    for plugin in discover_observatory_extensions():
+        if plugin.metadata.name == name:
+            return plugin
+    return None

phlo_observatory-0.1.1/src/phlo_observatory/manifest.py

@@ -0,0 +1,72 @@
+"""Observatory extension manifest models."""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+
+class ObservatoryExtensionCompatibility(BaseModel):
+    """Compatibility requirements for an Observatory extension."""
+
+    observatory_min: str = Field(..., description="Minimum supported Observatory version")
+
+
+class ObservatoryExtensionSettings(BaseModel):
+    """Settings schema and defaults for an extension."""
+
+    settings_schema: dict[str, Any] = Field(
+        ..., description="Schema for extension settings and validation"
+    )
+    defaults: dict[str, Any] = Field(default_factory=dict)
+    scope: Literal["global", "extension"] = "extension"
+
+
+class ObservatoryExtensionRoute(BaseModel):
+    """Route registration entry for an extension."""
+
+    path: str
+    module: str
+    export: str = "registerRoutes"
+
+
+class ObservatoryExtensionNavItem(BaseModel):
+    """Navigation entry for an extension."""
+
+    title: str
+    to: str
+
+
+class ObservatoryExtensionSlot(BaseModel):
+    """Slot registration entry for an extension."""
+
+    slot_id: str
+    module: str
+    export: str = "registerSlot"
+
+
+class ObservatoryExtensionSettingsPanel(BaseModel):
+    """Settings panel registration entry for an extension."""
+
+    module: str
+    export: str = "registerSettings"
+
+
+class ObservatoryExtensionUI(BaseModel):
+    """UI contributions for an extension."""
+
+    routes: list[ObservatoryExtensionRoute] = Field(default_factory=list)
+    nav: list[ObservatoryExtensionNavItem] = Field(default_factory=list)
+    slots: list[ObservatoryExtensionSlot] = Field(default_factory=list)
+    settings: list[ObservatoryExtensionSettingsPanel] = Field(default_factory=list)
+
+
+class ObservatoryExtensionManifest(BaseModel):
+    """Manifest contract for Observatory extensions."""
+
+    name: str
+    version: str
+    compat: ObservatoryExtensionCompatibility
+    settings: ObservatoryExtensionSettings | None = None
+    ui: ObservatoryExtensionUI = Field(default_factory=ObservatoryExtensionUI)