Marimo-dashboard
Marimo-dashboard er en tjeneste på Dapla Lab som er skreddersydd for utvikling av dashboards og applikasjoner. Tjenesten bygger på Marimo, som er et reaktivt Python-miljø med svært god støtte for brukerinteraksjon og dynamiske visualiseringer.
I tillegg kan man bruke Marimo-studio, en utvidelse som gjør det lett å legge til form og stil ved hjelp av vanlig html og css.
Bruksområde
Marimo-dashboard-tjenesten er egnet for å utvikle frittstående notebook-filer og åpne dem som selvstendige, interaktive applikasjoner.
Tjenesten benytter seg ikke av Python-prosjektet i repoet, men lager automatisk et isolert Python-miljø for hver notebook-fil.
Marimo er skreddersydd for utvikling av Python og SQL-kode, og støtter ikke R.
Forberedelser
Før man starter Marimo bør man ha lest kapitlet om Dapla Lab og satt opp Git- og GitHub-konfigurasjonen under Min konto. Deretter gjør du følgende:
- Logg deg inn på Dapla Lab
- Under Tjenestekatalog trykker du på Start-knappen for Marimo-studio
- Gi tjenesten et navn
- Åpne Marimo-dashboard konfigurasjoner
Konfigurasjon
Mye av konfigurasjonen for Marimo-dasboards er lik det som gjelder for Jupyter. Det gjelder blant annet valg av team og tilgangsgruppe, Git/GitHub, ressurser, diskplass og avanserte valg som Parquedit-støtte.
Det viktigste er den delen som er spesifikt for Marimo-dashboard:
Oppstartsmåte
- Edit-modus brukes når man skal utvikle en notebook-fil, det vil si skrive kode i Marimo-grensesnittet.
- Run-modus brukes når man vil kjøre en notebook-fil som en selvstendig applikasjon, uten å vise verken koden eller Marimo-grensesnittet.
Dashboard-repo
Man kan oppgi et GitHub-repo som skal klones ved oppstart av tjenesten.
Som konvensjon skal Github-repoet en mappe dashboards/ på rotnivå. Hva som forventes av repoet avhenger av oppstartsmåten:
- I edit-modus forventes ingenting av repoet. Man kan selv opprette
dashboards/-mappen og nye notebook-filer første gang man starter tjenesten. - I run-modus forventes en eksisterende
dashboards/-mappe med én eller flere Marimo-notebooks. Notebook-filene kan organiseres fritt i undermapper.
Dersom feltet er tomt vil tjenesten åpne i work/-mappen og man kan selv klone eller opprette et nytt repo ved hjelp av terminalen.
Funksjonalitet
Edit-modus
I denne modusen åpnes hele Marimo-grensesnittet, slik at man kan utvikle og redigere notebook-filer direkte i nettleseren.
Marimo er rik på funksjoner og har et brukervennlig grensesnitt som man kan lese mer om her.
For å bruke git (Github) og opencode (KI) må man bruke den integrerte terminalen i Marimo, som kan åpnes på følgende måte:
Run-modus
Dette passer når man allerede har laget en ferdig notebook-fil som skal vises som et brukergrensesnitt, for eksempel for utforsking av data eller deling av resultater internt i et team.
Hvis målet er å utvikle selve filen, er det normalt best å starte i edit-modus. Før man bruker run-modus er det lurt å sjekke at notebooken lar seg kjøre i edit-modus.
KI-støtte
KI kan være et effektivt hjelpemiddel for å utvikle interaktive applikasjoner i Marimo.
Anbefalte forberedelser:
- Sørg for at du har en notebook åpen i Marimo-grensesnittet som er lagret i
dashboards/-mappen. - Sørg for å ha commitet eventuelle egne endringer først så ikke disse blir overskrevet av agenten.
- Sørg for å ha relevante pakker lastet ned i notebooken (se Installere pakker).
- Kjør kommandoen
ssb-marimo docsfor å laste ned nyeste versjon av Dapla-manualen som agenten kan lese.
Åpne terminalen, kjør opencode og begynn å snakke med agenten om hva du ønsker.
Det anbefales å være så spesifikk som mulig om ønsket applikasjonsflyt, og gjerne referere til installerte pakker eller deler av Dapla-manualen som skal brukes.
Merk at agenten vil spørre om å utføre kommandoer av typen:
bash ~/.agents/skills/marimo-pair/scripts/execute-code.sh \
--url http://localhost:8080 \
-c "import marimo._code_mode as cm; help(cm)"Dette er kommandoer som lar agenten gjøre strukturerte endringer og inspisere tilstanden til notebooken. Kort sagt får agenten muligheten til å se det samme som deg; input, output, feilmeldinger og mer. Ofte vil disse kommandoene være vanskelige å lese. Det viktigste er å være sikker på at man kun har testdata i tjenesten, og at man alltid går gjennom den ferdige koden og pusher den til Github manuelt.
Marimo-studio
Marimo-studio er en utvidelse til Marimo som kan brukes til å opprette en html-side for notebooken. Man kan sette cellene inn i html-siden og dermed få full kontroll på layout og stil på den interaktive applikasjonen.
For å komme i gang, åpne en eksisterende notebook-fil i dashboards/-mappen. Det anbefales at man allerede har utviklet det meste av notebook-filen før man oppretter en html-side.
Alternativ 1: åpne en terminal og kjør kommandoen ssb-marimo html. Dette vil opprette en html-fil som importerer SSB Designsystem sitt tema.
Klikk på “Add view” øverst til høyre, gi ønsket navn, velg “HTML document” og trykk “Create view”.
Du vil nå ha fått opprettet flere filer og får valget om å se en forhåndsvisning av viewet.
Legg merke til de nye filene og spesielt index.html der viewet ligger. Det anbefales å sjekke inn disse filene til Github.
Data og Git/GitHub
Marimo følger samme mønster som de andre utviklingstjenestene i Dapla Lab:
- Datatilgang styres av hvilket team og hvilken tilgangsgruppe du velger.
- Teamets bøtter blir tilgjengelige i filsystemet under
/buckets/. - Git-bruker, e-post og GitHub-token kan arves fra Min konto i Dapla Lab.
For detaljer om datatilgang, delt-bøtter, Git/GitHub, ressurser, diskplass og oppstartsskript, se Jupyter-kapitlet.
Datatilgang
Dersom man ønsker å utforske filene i /buckets kan man kjøre en kodecelle med følgende innhold:
import fsspec
from fsspec.implementations.dirfs import DirFileSystem
fs = DirFileSystem("/buckets", fsspec.filesystem("file"))Deretter åpner man Marimos filutforsker i sidemenyen. Fanen “Remote storage” vil vise innholdet i /buckets:
Merk at Marimo-grensesnittet ikke har innebygd støtte for å åpne datafiler. Man kan imidlertid enkelt utvikle applikasjoner med både filutforsker og datavisning:
Filutforsker-komponenten kan opprettes med følgende kodecelle og konfigureres etter behov:
import marimo as mo
file_browser = mo.ui.file_browser(
initial_path="/buckets/",
filetypes=["parquet"],
selection_mode="file",
multiple=False,
)
file_browserVariabelen file_browser vil til enhver tid inneholde hvilken fil som er valgt av brukeren. Denne kan brukes i en ny kodecelle, for eksempel til å vise dataene i en tabell-komponent:
import polars as pl
selected_files = file_browser.value
if len(selected_files) > 0:
df = pl.read_parquet(selected_files[0].path)
output = mo.ui.table(df)
else:
output = mo.md("Ingen fil er valgt.")
outputApplikasjonen vil følge vanlig tilgangsstyring, det vil si at den viser dataene til teamet man åpner tjenesten med.
Installere pakker
Pakker installeres i selve notebooken ved hjelp av Marimo-grensesnittet:
- Pass på at du er i riktig notebook.
- Klikk på boks-ikonet i sidemenyen for å se installerte pakker.
- For å legge til flere pakker, skriv pakkenavnet i inputfeltet og trykk “Add”.
- For å legge til pakker med en spesifikk versjon, skriv for eksempel
dapla-toolbelt-metadata==0.19og trykk “Add”.
Hver notebook-fil vil ha sin egen liste av installerte pakker. Når man ser på notebook-filen i en vanlig teksteditor eller på Github, vil pakkene være deklarert øverst i filen:
test.py
# /// script
# dependencies = [
# "dapla-toolbelt-metadata==0.19.0",
# "marimo",
# "polars==2.0.0",
# ]
# requires-python = ">=3.14"
# ///
import marimo
__generated_with = "0.25.1"
app = marimo.App(width="medium")
@app.cell
def _():
import dapla_metadata
import polars as pl
if __name__ == "__main__":
app.run()Dette gjør at filen kan kjøres helt isolert fra resten av prosjektet. Videre kan den kjøres som en helt vanlig Python-fil:
uv run test.pyNår man kjører denne kommandoen, vil først vil alle avhengighetene installeres, og deretter vil kodecellene kjøres i riktig rekkefølge. Interaktive komponenter vil bruke en default-verdi, som man kan konfigurere i de fleste tilfeller.
Lagring av arbeid
Kode bør lagres i GitHub og data bør lagres i bøtter. Filer som bare ligger lokalt i tjenesten kan gå tapt hvis tjenesten slettes, og filer utenfor $HOME/work slettes når tjenesten pauses.
Slette tjenesten
For å slette tjenesten kan man trykke på Slett-knappen i Dapla Lab under Mine tjenester. Når man sletter en tjeneste, slettes også filsystemet i tjenesten og ressursene frigjøres. Hvis du har installert pakker lokalt i tjenesten, må disse installeres på nytt neste gang.
Pause tjenesten
Man kan pause tjenesten ved å trykke på Pause-knappen i Dapla Lab under Mine tjenester. Når man pauser tjenesten, slettes alt på den lokale disken som ikke er lagret under $HOME/work.
Monitorering
Man kan monitorere en instans av Marimo-dashboard ved å trykke på tjenesten under Mine tjenester i Dapla Lab. Derfra kommer man til overvåkningssiden for tjenesten, med lenker til teknisk informasjon og eksternt dashboard på samme måte som for andre tjenester i Dapla Lab. Se monitorering i Dapla Lab.










