Gramplets.nl

🌐 English · Deutsch · Español · Français · 简体中文

Gramplets en de add-onwinkel

Gramplets zijn het add-onsysteem van Gramps Connect: kleine Python-programma's die de stamboom bevragen en een resultaat weergeven — een tabel, een grafiek, platte tekst of HTML. Er zijn twee soorten: Gramplets, die u vanuit het menu Gramplets in een eigen venster uitvoert, en Weergave-Gramplets, die in een paneel onder een lijst staan (Persoon, Gezin of elk ander objecttype) en volgen wat u daar selecteert. Wat ze ongewoon maakt, is waar ze draaien: elk ervan is echt Python, dat rechtstreeks in uw browsertabblad wordt uitgevoerd onder Pyodide (naar WebAssembly gecompileerde CPython), met lokaal gebouwde wheels van het eigen datamodel gramps.gen.lib van Gramps. Er wordt niets op uw computer geïnstalleerd en niets draait op een server — zie Architectuur.

Dat betekent ook dat elke Gramplet bewerkbaar is. Open er een in de Gramplet-editor van de app, en u kijkt naar (en kunt wijzigen) de echte broncode — geen zwarte doos achter een instellingenpaneel. Verander hoe een grafiek eruitziet, pas aan waarnaar een opzoeking zoekt, of schrijf een nieuwe vanaf nul, allemaal zonder de app te verlaten.

Wie Gramplets kan gebruiken

Iedereen die in de stamboom is ingelogd, kan de Gramplets ervan uitvoeren, vanuit het menu Gramplets of in het paneel Weergave-Gramplets van een lijst. Alleen de Eigenaar van de stamboom of een Beheerder van de site kan ze schrijven: er een aanmaken, de code ervan bewerken, of er een installeren, bijwerken of verwijderen via de Gramplet-winkel. Voor alle anderen verschijnen de winkel, Nieuwe Gramplet… en de bewerkpotloden helemaal niet.

Rol	Gramplets uitvoeren	Gramplets schrijven / installeren
Gast	✓ (behalve privé-Gramplets)	—
Lid	✓	—
Bijdrager	✓	—
Redacteur	✓	—
Eigenaar	✓	✓
Beheerder	✓	✓

Een Gramplet schrijven vereist meer dan de gebruikelijke rechten van een Redacteur, omdat de code ervan in de browser draait van iedereen die hem gebruikt — een wijziging raakt de stamboom dus voor iedereen, niet alleen uw eigen bewerkingen. Een Gramplet wordt opgeslagen als een gewoon Media-object met het label Gramplet, dus de gebruikelijke privacyregels gelden: als hij als privé is gemarkeerd, zien Gasten hem niet.

Hetzelfde geldt voor Gegevenswijzigingen toestaan (zie Gegevens wijzigen): alleen een Eigenaar of Beheerder kan dat voor een Gramplet inschakelen. Iedereen kan een proefrun van zo'n Gramplet doen, die niets opslaat; het opslaan van de wijzigingen vereist rechten van Redacteur of hoger (de eigen rechten van de server om toe te voegen, te bewerken en te verwijderen), dus voor Gasten, Leden en Bijdragers is de knop Uitvoeren van het venster uitgeschakeld.

Bladeren en installeren

De Gramplet-winkel is een doorbladerbare catalogus in de app — open hem via Gramplets → Gramplet-winkel…. Hij heeft twee tabbladen, Gramplets en Weergave-Gramplets; installeer, werk bij of verwijder elk item met één klik. Een geïnstalleerde Gramplet verschijnt meteen in het menu Gramplets (gegroepeerd per categorie); een geïnstalleerde Weergave-Gramplet wordt aan een lijst toegevoegd met de + in het paneel Weergave-Gramplets van die lijst. De winkel wordt onafhankelijk van de eigen releases van Gramps Connect gepubliceerd — de catalogus is statische inhoud (gramplet-store/ in de repository) die de draaiende app tijdens het draaien ophaalt, niet in de build van de app gebundeld, zodat er nieuwe Gramplets in de winkel kunnen verschijnen zonder dat iemand Gramps Connect zelf bijwerkt.

Voorbeelden die al in de catalogus staan, zijn onder meer deze Gramplets, die vanuit het menu Gramplets draaien:

Gramplet	Wat hij doet
Age at Death by Decade	Grafiek van de mediane leeftijd bij overlijden per decennium van geboorte of overlijden
Mark Unsourced People Private	Markeert iedereen zonder enige bron als privé — wijzigt gegevens, dus openen is een proefrun die laat zien wie zou veranderen, en Uitvoeren slaat het op (zie Gegevens wijzigen)
People Without Sources	Iedereen zonder citaat op zichzelf of op een van zijn gebeurtenissen (een scan van de hele stamboom met voortgangsbalk)
Possible Duplicate People	Personen met dezelfde naam die binnen een paar jaar van elkaar zijn geboren, om te controleren en samen te voegen
Tag People	Voegt een label dat u uit een lijst kiest toe aan iedereen in het huidige Personen-filter — wijzigt gegevens, dus het is een proefrun tot u op Uitvoeren klikt

en deze Weergave-Gramplets:

Weergave-Gramplet	Wat hij doet
Age-at-Death Histogram	Interactief plotly-histogram van de leeftijd bij overlijden in de hele stamboom (of de huidige gefilterde lijst)
All Relationships	Relatieberekeningen in de hele stamboom
Attributes / Backlinks / Children / Citations / Coordinates / Events / Gallery / Notes	Detailpanelen in de stijl van de desktop-Gramplets voor het geselecteerde record
Born In	Opzoeken op geboorteplaats
Crossing Relationships	Vindt relaties die op ongewone manieren generaties kruisen
GOQL Query	Typ een ruwe GOQL-where-clausule en kies veldexpressies als kolommen
Hello Table	Het minimale startvoorbeeld
People Search	Live zoeken naar Personen terwijl u typt, op naam, geslacht en overlijdensdatum
Phonebook Surname Sort	Sorteren op achternaam zonder onderscheid in accenten (bijv. "Müller" komt naast "Muller")
Relationship / Relationships	Hoe twee geselecteerde personen verwant zijn
Selected Record	Reageert op het record dat op dat moment open is
To-Do / Todo Tracker	Houdt onderzoekstaken in de hele stamboom bij
Tree Statistics	Een dashboard met aantallen records en afgeleide percentages

In elke lijstweergave (Personen, Gezinnen, Gebeurtenissen, …) verschijnen de Weergave-Gramplets die u aan die weergave hebt toegevoegd als tabbladen in een inklapbaar paneel Weergave-Gramplets onder de tabel. Het paneel is in het begin ingeklapt, en een Weergave-Gramplet draait alleen zolang het paneel open is: uitklappen voert het geselecteerde tabblad uit. De eerste run in een sessie laadt ook de Python-omgeving in de browser, dus die kan een paar seconden duren; latere runs zijn snel. Het paneel ingeklapt houden kost niets, omdat er geen Python wordt geladen tot u het opent.

Gramplets in een eigen venster

Een Gramplet (in tegenstelling tot een Weergave-Gramplet) is aan geen enkele lijst gebonden. Kies er een in het menu Gramplets — per categorie in submenu's gegroepeerd zodra er meer dan één categorie is — en hij opent in een zwevend venster:

• Hij draait bij het openen. Een Gramplet die eerst invoer nodig heeft — een achternaam, een aantal generaties — tekent zijn eigen velden en een knop Uitvoeren, met dezelfde widgets die Weergave-Gramplets gebruiken.
• Gramplets die gegevens wijzigen (in het menu gemarkeerd met ✎) doen bij het openen een proefrun en hebben de knoppen Proefrun / Uitvoeren en Ongedaan maken — zie Gegevens wijzigen.
• Hij kijkt naar de lijst erachter. Als er in de hoofdweergave een lijst open is, ziet de Gramplet het geselecteerde record en het huidige filter daarvan, zoals ze waren toen de run begon; daarna ergens anders heen navigeren verandert een lopende run niet.
• Voortgang en Annuleren. Een langere Gramplet toont een voortgangsbalk terwijl hij werkt; Annuleren stopt hem meteen en behoudt wat hij tot dan toe had geproduceerd.
• Ondertussen doorwerken. Minimaliseer een venster (▾) en het wordt een klein label onder in het scherm dat laat zien hoe ver het is; de run gaat door. Als een geminimaliseerde Gramplet klaar is, krijgt u een melding met een knop Tonen. Meerdere Gramplets kunnen tegelijk draaien (tot vijf vensters), elk onafhankelijk, en ze blijven open terwijl u tussen weergaven wisselt.
• Verplaatsen, formaat wijzigen, maximaliseren. Sleep een venster aan de titelbalk, wijzig het formaat vanuit de hoek, of maximaliseer het (⤢, of dubbelklik op de titel). Elke Gramplet onthoudt de grootte en positie van zijn venster in uw browser.
• Bewerken. Voor de Eigenaar van de stamboom of een Beheerder van de site (zie Wie Gramplets kan gebruiken) heeft de titelbalk van het venster een potlood (✎) dat de Gramplet-editor opent; opslaan start het venster opnieuw met uw wijzigingen.
• Sluiten. Om een Gramplet opnieuw vanaf het begin uit te voeren, sluit u het venster en kiest u hem opnieuw in het menu. Een venster sluiten dat nog draait, vraagt eerst om bevestiging, net als de pagina verlaten of herladen — het browsertabblad sluiten stopt elke run.

Resultaten worden alleen in het venster getoond; ze worden nog nergens opgeslagen.

Een Gramplet schrijven

De code van een Gramplet draait in een sandbox waarin al een set functies en objecten beschikbaar is — geen imports nodig om bij de stamboom te komen. De map gramplet_examples/ in de repository is een genummerde rondleiding door de API, van eenvoudigst tot meest geavanceerd; dezelfde referentie is ook in de app zelf beschikbaar via de helpknop (i) "Een Gramplet schrijven" in de Gramplet-editor.

De kleinste nuttige Gramplet

matches = people(
    "gender == Person.MALE and birth.date.sortval >= Date('Jan 1, 1900')",
    limit=25,
)

columns("Person")
for person in matches:
    row(person)

• people(where=None, what=None, order=None, limit=50) haalt in één aanroep de Personen op die aan een query voldoen, als volledige records — of, met what=["gramps_id", "primary_name"], alleen die velden — en er is een families()/events()/places()/repositories()/sources()/ citations()/media()/notes()/tags() voor elk ander objecttype, met dezelfde signatuur, alleen een andere tabel.
• where= wordt geschreven in GOQL — precies dezelfde syntaxis als het zoekvak van elke lijstweergave, inclusief het reiken over relaties (birth.date.sortval), ook als het veld waarop u filtert niet een veld is dat u toont.
• Geen await nodig, ook al is dit onder de motorkap een echte netwerkaanroep — die wordt automatisch voor u ingevoegd.
• row(*values) voegt één rij aan de tabel toe. Een heel Persoon-/Gebeurtenis-/Plaats-/...-object doorgeven (in plaats van een met de hand gekozen veld ervan) geeft het weer als een klikbare link die al de volledige naam/titel en de Gramps-ID toont — erop klikken opent een pop-up om dat record te bekijken in Lijst, Kaart, Grafiek of Tijdlijn.
• name_of(person) is de naam van een persoon als tekst — voornaam, dan achternamen ("Root Ancestor"), zoals row() ze labelt — voor een kop of een zin. Accepteert ook een van hun namen, bijv. name_of(person.alternate_names[0]).

Elk record dat people()/families()/enz. teruggeeft, is een Gramps- "DataDict" — een gewone dict met de velden van het object, maar met toegang via punten erbovenop: person.primary_name.first_name is dezelfde waarde als person["primary_name"]["first_name"]. Gebruik dit wanneer u iets uit een veld wilt berekenen of een veld wilt tonen dat de eigen weergave van row() niet laat zien. row(), html() en print() kunnen elk zo vaak worden aangeroepen als u wilt, in elke volgorde — alles verschijnt in de volgorde waarin u het hebt toegevoegd.

Een record afdrukken mislukt nooit: print(person) of f"{person}" toont een heel record zoals row() het labelt ("Root Ancestor [I0001]"), een datum als datum, en al het andere — een filter()-resultaat, person.primary_name — als de kale velden.

Goedkoop tellen zonder de stamboom te downloaden

total_people = db.get_number_of_people()
women = db.get_number_of("person", where="gender == Person.FEMALE")
no_birth_date = db.get_number_of("person", where="birth.date.sortval is None")

db.get_number_of_<type>() is een goedkope telling over de hele stamboom — het totaal komt terug in een header van het antwoord, er worden geen records echt gedownload. db.get_number_of(object_type, where=...) is de voorwaardelijke tegenhanger, voor wanneer de telling zelf een filter nodig heeft.

Over relaties heen reiken in een query, en terug voor weergave

Een where=-voorwaarde kan over een relatie heen reiken om erop te filteren — de geboortegebeurtenis van een persoon, de vader van een gezin, de plaats van een gebeurtenis — ook al geven people()/families()/enz. altijd een heel, los object terug, zonder manier om direct om een gerelateerd veld te vragen:

born_and_died_same_place = people(
    "birth.place.title == death.place.title and birth.place.title is not None",
    order=[{"column": "surname", "direction": "asc"}],
    limit=50,
)

Een gerelateerd veld terugkrijgen om te tonen (in plaats van er alleen op te filteren) is een aparte opzoeking met de hand via de eigen methoden van db — db.get_event_from_handle(...) enzovoort — via dezelfde omweg met handles die het eigen datamodel van Gramps intern gebruikt.

Verzamelingen werken ook: any(c.given_name == 'Steve' for c in children) komt overeen met een gezin als een kind aan een voorwaarde voldoet, en len([c for c in children if c.gender == Person.MALE]) > 1 telt alleen de zonen. Zie GOQL voor het volledige verhaal over verzamelingen, inclusief de huidige grens (één sprong in een verzameling, geen verder ketenen voorbij wat erin zit).

Reageren op het geselecteerde record

record = get_selected()
if record is not None:
    if isinstance(record, Person):
        ...

get_selected() geeft het record terug dat op dat moment open is in het eigen detailpaneel van de weergave — None als er niets is geselecteerd, of bij het draaien vanuit het voorbeeld van de losse editor (dat helemaal geen weergavecontext heeft). Eén netwerkaanroep bij de eerste aanroep in een run, daarna onthouden voor de rest ervan. isinstance(record, Person) (enz.) vertelt u wat voor record u hebt gekregen, wat ertoe doet voor een Gramplet die aan "Alle" weergaven is gekoppeld. Om dit live te laten bijwerken terwijl u door de lijst klikt, zet u in de eigen editor van de Gramplet "Automatisch opnieuw uitvoeren als het geselecteerde record verandert" aan — staat dat uit (de standaard), dan werkt get_selected() nog steeds, maar weerspiegelt het alleen wat er geselecteerd was toen de Gramplet om een andere reden voor het laatst draaide.

Reageren op het actieve filter

Een Gramplet kan zijn eigen query leggen bovenop het filter dat op dat moment op de weergave is toegepast — getypt in het eigen zoekvak van de weergave of toegepast via de keuzelijst "Filters" (een opgeslagen filter of aangepaste regel) — zodat het filteren van de lijst tot één tak van de stamboom de eigen uitvoer van de Gramplet op dezelfde manier beperkt:

rows = filter(
    "person",
    where=and_filters(get_filter(), "birth.date.sortval is not None and death.date.sortval is not None"),
)

Dit vereist dat views: [...] in het manifest is ingesteld (get_filter() geeft alleen een where_expr terug die bij het eigen objecttype van de weergave past) en listensToFilter: true, zodat de Gramplet echt opnieuw wordt weergegeven als het filter verandert.

Grafieken

pygal, matplotlib en plotly zijn allemaal meegebundeld — een gewone import (of, voor plotly, from plotly.subplots import make_subplots) werkt offline, zonder %pip install. print(fig) op een plotly-Figure, een SVG-tekenreeks van pygal of een matplotlib-figuur wordt automatisch herkend en als grafiek weergegeven — geen handmatige to_html()/inbedding nodig.

Geef voor grafiekgegevens what=[...] mee als u maar een of twee velden nodig hebt — people() alleen downloadt elk veld van elk record, wat verspilling is voor een grafiek die bijvoorbeeld alleen de leeftijd bij overlijden uitzet.

Naast elkaar plaatsen

col1, col2 = st.columns([2, 1])
with col1:
    row("Wider column")
with col2:
    row("Narrower column")

st.columns(spec) plaatst spec gebieden naast elkaar — een int voor zoveel kolommen van gelijke breedte, of een lijst met gewichten (st.columns([2, 1])) voor evenredige breedtes — en geeft één gebied per kolom terug. Alles wat binnen with col: wordt geschreven (row()/html()/print(), of een andere st.*-aanroep, inclusief een geneste st.columns()) komt in die kolom terecht in plaats van op het hoogste niveau; col.write(x) werkt op dezelfde manier zonder with-blok.

Een Gramplet in een eigen venster

Gramplets → Nieuwe Gramplet… opent de Gramplet-editor, klaar voor deze soort (zet bij een bestaande Soort op Gramplet — opent in een venster vanuit het menu Gramplets). In plaats van de instellingen voor Weergave-Gramplets is er een veld Categorie, dat hem met andere groepeert in het menu Gramplets (bijv. chart); leeg plaatst hem onder Overig.

De code draait zodra het venster opent. Om eerst om invoer te vragen, tekent u die met de st.*-widgets en doet u het echte werk achter een st.button. Ze volgen de namen en argumenten van Streamlit: st.button, st.text_input, st.number_input, st.checkbox, st.selectbox, st.radio, st.columns, st.progress, de berichtvakken st.info / st.success / st.warning / st.error, en st.session_state. Ze werken in Weergave-Gramplets op dezelfde manier. Toon voor een Gramplet die lang draait een balk met st.progress(value, text), zoals in Streamlit: value is 0–100 (of 0.0–1.0), en .progress(...) van de teruggegeven balk verplaatst hem ter plekke en .empty() verwijdert hem — goedkoop genoeg om eenmaal per rij aan te roepen. Het werkt ook in Weergave-Gramplets. people(..., limit=None) (en de andere lijstfuncties) geven elke overeenkomst terug in plaats van de eerste 50:

surname = st.text_input("Surname", "Smith")
if st.button("Run"):
    everyone = people(f"primary_name.surname_list[0].surname == '{surname}'", limit=None)
    bar = st.progress(0, text="Checking people...")
    for i, person in enumerate(everyone):
        bar.progress((i + 1) / len(everyone))
        ...
    bar.empty()

Een pakket van derden installeren

%pip install unidecode
from unidecode import unidecode

%pip install is magische syntaxis uit Jupyter, die vóór het uitvoeren van uw code wordt herschreven tot een echte aanroep await micropip.install([...]) — het moet een eigen regel zijn, bovenaan, precies zoals in een notebook (het binnen een if schrijven werkt bijvoorbeeld niet). Dit werkt alleen voor pure-Python-pakketten zonder gecompileerde code/C-extensies; pygal/matplotlib/plotly hebben het niet nodig omdat ze meegebundeld zijn, maar de meeste kleine pure-Python-hulpmiddelen op PyPI zijn zo prima te installeren.

Gegevens wijzigen

Een Gramplet (geen Weergave-Gramplet — die wijzigen nooit gegevens) kan records wijzigen en verwijderen zodra Gegevenswijzigingen toestaan in de Gramplet-editor is ingeschakeld. De API is dezelfde die Gram.py Script in Gramps Desktop gebruikt: u wijzigt een record zoals u elk Python-object zou wijzigen.

for person in people("len(citation_list) == 0", limit=None):
    person.private = True

Mark Unsourced People Private uit de winkel is een volledig voorbeeld: hij vindt personen eerst goedkoop met filter(), en haalt dan alleen de personen op die het nodig hebben en wijzigt die, binnen één benoemde begin_changes()-groep. Tag People laat zien hoe u aan een lijst toevoegt (person.tag_list.append(tag.handle) — records slaan labels op als handles, niet als namen) en een st.selectbox() waarin u een keuze moet maken voordat er iets verandert.

• record.field = value wijzigt een veld, ook geneste velden (person.primary_name.first_name = "Chris"). Dat doen ook bewerkingen van lijsten (.append(), .pop(), ...) en elke set_*()-methode, bijv. person.set_privacy(True).
• delete(record) verwijdert een record. Verwijzingen ernaar vanuit andere records worden niet verwijderd.
• begin_changes("message") / end_changes() groeperen de wijzigingen daartussen onder dat bericht. Optioneel: zonder deze is de hele run één groep, genoemd naar de Gramplet.

Records uit people() en de andere functies in het meervoud, get_raw_object(), get_object(), get_selected() en db.* kunnen worden gewijzigd. Resultaten van filter() niet, omdat die slechts een deel van de velden van een record bevatten. Twee keer om hetzelfde record vragen in één run geeft hetzelfde object terug, met uw wijzigingen erin.

Eerst een proefrun. In de Gramplet-editor is elke run een proefrun, en het venster van de Gramplet openen vanuit het menu Gramplets doet ook een proefrun. Er wordt niets opgeslagen; onder de uitvoer toont een geel vak Proefrun elk record dat zou veranderen, met de oude en nieuwe waarde van elk gewijzigd veld, en elk record dat zou worden verwijderd, met hoeveel andere records er nog naar verwijzen. Elk gewijzigd record wordt eerst gecontroleerd aan de hand van zijn Gramps-schema, dezelfde controle die de server doet; een ongeldige waarde stopt de run en noemt het veld. Eén manier waarop een proefrun kan verschillen van de echte run: zoekopdrachten (filter(), count(), where=) draaien op de server, dus die zien de stamboom nog zoals hij was vóór de wijzigingen van de run.

Daarna Uitvoeren. Het venster van de Gramplet heeft de knoppen Proefrun en Uitvoeren (het menu markeert zulke Gramplets met ✎). Uitvoeren slaat elke groep wijzigingen op zodra de code die afsluit — bij end_changes(), of als de run eindigt — als één transactie, zodat die als één item in de geschiedenis van de stamboom verschijnt. Zolang het resultaat van een echte run wordt getoond, staat in de titelbalk Wijzigingen opslaan, en wordt het vak onder de uitvoer groen en markeert het elke groep als opgeslagen. Als de server een groep weigert — waarschijnlijk omdat iemand anders een van de records ervan heeft gewijzigd nadat de Gramplet het las — wordt niets van die groep opgeslagen, stopt de run met een foutmelding, en blijven groepen die daarvoor waren opgeslagen opgeslagen. Widgets in de uitvoer (st.button("Apply") enzovoort) voeren de code opnieuw uit in de modus waaruit het huidige resultaat kwam, zodat een Gramplet in een proefrun kan laten zien wat hij zou wijzigen en het na Uitvoeren kan toepassen.

Ongedaan maken. Na een echte run toont het venster hoeveel groepen het heeft opgeslagen en een knop Ongedaan maken, die ze terugdraait, de laatste eerst. Ongedaan maken weigert een groep waarvan iemand de records sindsdien heeft gewijzigd, in plaats van die bewerkingen te overschrijven. Het wordt alleen aangeboden voor het huidige resultaat van het venster: de Gramplet opnieuw uitvoeren, of het venster sluiten, beëindigt het.

Publiceren in de winkel

Eén map per Gramplet in gramplet-store/, genoemd naar de id (de mapnaam en het eigen veld id van het manifest moeten overeenkomen):

gramplet-store/
  <slug>/
    manifest.json   # verplicht
    code.py         # verplicht -- de Python-broncode van de Gramplet
    icon.png        # optioneel (png/jpg/jpeg/svg/webp)

Velden van manifest.json:

Veld	Verplicht	Betekenis
id	ja	Moet overeenkomen met de mapnaam.
name	ja	Getoond als titel van het item in de winkel.
description	ja	Getoond onder de naam in de winkel.
version	ja	Gewone semver, bijv. "1.0.0" — verhoog die telkens wanneer code.py of het manifest verandert, zodat geïnstalleerde kopieën kunnen zien dat er een update beschikbaar is.
author	ja	Getoond in de winkel.
category	ja	Een kort label ("example", "detail", "utility", "chart", ...) om items te groeperen/filteren.
views	nee	Aan welke weergaven per objecttype ("person", "family", ...) deze Gramplet kan worden toegevoegd. Weglaten voor "elk type".
listensToSelection	nee	Of deze Gramplet opnieuw moet draaien als het geselecteerde record verandert.
listensToFilter	nee	Of deze Gramplet opnieuw moet draaien als het actieve filter verandert (zoekvak of keuzelijst Filters).
kind	nee	"view" (de standaard) voor een Weergave-Gramplet; "window" voor een Gramplet die vanuit het menu Gramplets draait. views/listensTo* gelden alleen voor Weergave-Gramplets.
allowChanges	nee	true om hem te installeren met Gegevenswijzigingen toestaan ingeschakeld (de winkel toont een badge Wijzigt uw gegevens). Alleen toegestaan met "kind": "window".

Genereer na het toevoegen of bewerken van een item catalog.json opnieuw — het enige bestand dat de app echt ophaalt:

npm --prefix app run build:gramplet-catalog

Dit valideert elk item (verplichte velden aanwezig, id komt overeen met de map, version ziet eruit als semver, code.py niet leeg, kind geldig) en faalt luid bij het eerste probleem in plaats van een kapotte catalogus te publiceren.

Wat Gramplets nog niet kunnen

Gramplets kunnen records wijzigen en verwijderen (zie Gegevens wijzigen), maar nog geen nieuwe aanmaken. Er is ook nog geen equivalent voor andere typen Gramps-add-ons (hulpmiddelen, rapporten). Zie Roadmap en bekende beperkingen voor de huidige stand daarvan.