Reference for all built-in template language functions¶

Here, we document all the built-in functions available in the calibre template language. Every function is implemented as a class in python and you can click the source links to see the source code, in case the documentation is insufficient. The functions are arranged in logical groups by type.

Booleaanse ¶

and ¶

class calibre.utils.formatter_functions.BuiltinAnd[broncode]¶

and(value [, value]*) – geeft de string '1' als alle waarden niet leeg zijn, anders geeft het de lege string. Je kunt zoveel waarden hebben als je wilt. In de meeste gevallen kun je de && operator gebruiken in plaats van deze functie. Een reden om and() niet te vervangen door && is wanneer kortsluiting de resultaten kan veranderen vanwege neveneffecten. Bijvoorbeeld, and(a='',b=5) zal altijd beide toewijzingen doen, waar de && operator de tweede niet zal doen.

not ¶

class calibre.utils.formatter_functions.BuiltinNot[broncode]¶

not(value) – retourneert de string '1' als de waarde leeg is, anders retourneert het de lege string. Deze functie kan meestal worden vervangen door de unary not (!) operator.

or ¶

class calibre.utils.formatter_functions.BuiltinOr[broncode]¶

or(value [, value]*) – retourneert de string '1' als een waarde niet leeg is, anders retourneert het de lege string. Je kunt zoveel waarden hebben als je wilt. Deze functie kan meestal worden vervangen door de || operator. Een reden waarom deze niet kan worden vervangen is als kortsluiting de resultaten zal veranderen vanwege neveneffecten.

Databasefuncties ¶

annotation_count ¶

class calibre.utils.formatter_functions.BuiltinAnnotationCount[broncode]¶

annotation_count() – retourneert het totale aantal annotaties van alle typen die aan het huidige boek zijn gekoppeld. Deze functie werkt alleen in de GUI en de contentserver.

approximate_formats ¶

class calibre.utils.formatter_functions.BuiltinApproximateFormats[broncode]¶

approximate_formats() – retourneert een door komma’s gescheiden lijst van formaten geassocieerd met het boek. Omdat de lijst afkomstig is van calibre’s database in plaats van het bestandssysteem, is er geen garantie dat de lijst correct is, hoewel het waarschijnlijk wel zo is. Merk op dat de resulterende formaatnamen altijd hoofdletters zijn, zoals in EPUB. De approximate_formats() functie is veel sneller dan de formats_... functies.

Deze functie werkt alleen in de GUI. Als je deze waarden wilt gebruiken in sjablonen voor opslaan naar schijf of verzenden naar apparaat, dan moet je een aangepaste “Kolom opgebouwd uit andere kolommen” maken, de functie gebruiken in het sjabloon van die kolom en de waarde van die kolom gebruiken in je sjablonen voor opslaan/verzenden.

book_count ¶

class calibre.utils.formatter_functions.BuiltinBookCount[broncode]¶

book_count(query, use_vl) – geeft het aantal boeken terug dat gevonden is door te zoeken naar query. Als use_vl 0` (nul) is dan worden virtuele bibliotheken genegeerd. Deze functie en zijn metgezel``book_values() zijn vooral nuttig in sjabloonzoekopdrachten, ter ondersteuning van zoekopdrachten die informatie uit veel boeken combineren, zoals het zoeken naar series met slechts één boek. De functie kan niet worden gebruikt in samengestelde kolommen tenzij de fijnafstelling``allow_template_database_functions_in_composites`` is ingesteld op True. Het kan alleen in de GUI worden gebruikt.Deze sjabloonzoekopdracht gebruikt bijvoorbeeld deze functie en zijn metgezel om alle series met slechts één boek te vinden:[LIST][*]Definieer een opgeslagen sjabloon (met Voorkeuren → Geavanceerd → Sjabloonfuncties`) met de naam series_alleen_één_boek (de naam is willekeurig). De sjabloon is:

programma:
    vals = globals(vals='');
    als !vals dan
        alle_series = book_values('series', 'series:true', ',', 0);
        voor series in all_series:
            if book_count('series:="' & series & '"', 0) == 1 then
                vals = list_join(',', vals, ',', series, ',')
            fi
        rof;
        set_globals(vals)
    fi;
    str_in_list(vals, ',', $series, 1, '')

De eerste keer dat het sjabloon draait (het eerste boek dat gecontroleerd wordt) slaat het de resultaten van het zoeken in de database op in een global sjabloonvariabele met de naam vals. Deze resultaten worden gebruikt om volgende boeken te controleren. Deze resultaten worden gebruikt om volgende boeken te controleren zonder de lookups opnieuw te doen.

book_values ¶

class calibre.utils.formatter_functions.BuiltinBookValues[broncode]¶

book_values(column, query, sep, use_vl) – returns a list of the unique values contained in the column column (a lookup name), separated by sep, in the books found by searching for query. If use_vl is 0 (zero) then virtual libraries are ignored. This function and its companion book_count() are particularly useful in template searches, supporting searches that combine information from many books such as looking for series with only one book. It cannot be used in composite columns unless the tweak allow_template_database_functions_in_composites is set to True. This function can be used only in the GUI and the content server.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “``” for CODE_TEXT on line 1 in “book_values”

extra_file_modtime ¶

class calibre.utils.formatter_functions.BuiltinExtraFileModtime[broncode]¶

extra_file_modtime(file_name, format_string) – returns the modification time of the extra file file_name in the book’s data/ folder if it exists, otherwise -1. The modtime is formatted according to format_string (see format_date() for details). If format_string is the empty string, returns the modtime as the floating point number of seconds since the epoch. See also the functions has_extra_files(), extra_file_names() and extra_file_size(). The epoch is OS dependent. This function can be used only in the GUI and the content server.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “`” for italics on line 1 in “extra_file_modtime”

extra_file_names ¶

class calibre.utils.formatter_functions.BuiltinExtraFileNames[broncode]¶

extra_file_names(sep [, pattern]) – geeft een sep-gescheiden lijst van extra bestanden in de data/ map van het boek. Als de optionele parameter pattern, een reguliere expressie, wordt meegegeven, dan wordt de lijst gefilterd op bestanden die overeenkomen met pattern. Het patroon is hoofdletterongevoelig. Zie ook de functies has_extra_files(), extra_file_modtime() en extra_file_size(). Deze functie kan alleen worden gebruikt in de GUI en de contentserver.

extra_file_size ¶

class calibre.utils.formatter_functions.BuiltinExtraFileSize[broncode]¶

extra_file_size(file_name) – geeft de grootte in bytes van het extra bestand file_name in de map data/ van het boek als het bestaat, anders -1. Zie ook de functies has_extra_files(), extra_file_names() en extra_file_modtime(). Deze functie kan alleen worden gebruikt in de GUI en de contentserver.

formats_modtimes ¶

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[broncode]¶

formats_modtimes(date_format_string) – retourneer een door komma’s gescheiden lijst van door dubbele punt gescheiden items FMT:DATE die modificatietijden voorstellen voor de formaten van een boek. De date_format_string parameter specificeert hoe de datum moet worden geformatteerd. Zie de functie format_date() voor meer informatie. U kunt de functie selecteren() gebruiken om de wijzigingstijd voor een bepaald formaat op te vragen. Merk op dat formaatnamen altijd hoofdletters zijn, zoals in EPUB.

formats_path_segments ¶

class calibre.utils.formatter_functions.BuiltinFormatsPathSegments[broncode]¶

formats_path_segments(with_author, with_title, with_format, with_ext, sep) – geef delen van het pad terug naar een boekformaat in de calibre bibliotheek, gescheiden door sep. De parameter sep moet meestal een schuine streep zijn ('/'). Dit wordt onder andere gebruikt om er zeker van te zijn dat paden die worden gegenereerd in de sjablonen Opslaan op schijf en Verzenden naar apparaat consistent worden ingekort. Een ander gebruik is om er zeker van te zijn dat de paden op het apparaat overeenkomen met de paden in de kalibreerbibliotheek.

Een boekpad bestaat uit 3 segmenten: de auteur, de titel inclusief de calibre database id tussen haakjes en het formaat (auteur - titel). Calibre kan elk van de drie inkorten vanwege de lengtebeperkingen van bestandsnamen. Je kiest welke segmenten je wilt opnemen door 1 voor dat segment door te geven. Als je geen segment wilt, geef dan 0 of de lege tekenreeks voor dat segment door. Het volgende geeft bijvoorbeeld alleen de formatnaam zonder de extensie:

formats_path_segments(0, 0, 1, 0, '/')

Omdat er slechts één segment is, wordt het scheidingsteken genegeerd.

Als er meerdere formaten (meerdere extensies) zijn, dan wordt een van de extensies willekeurig gekozen. Als je wilt weten welke extensie wordt gebruikt, haal dan het pad op zonder de extensie en voeg de gewenste extensie eraan toe.

Voorbeelden: Stel er is een boek in de calibre bibliotheek met een epub formaat van Joe Blogs met titel ‘Help’. Het zou het volgende pad hebben

Joe Blogs/Help - (calibre_id)/Help - Joe Blogs.epub

Het volgende laat zien wat er wordt geretourneerd voor verschillende parameters:

formats_path_segments(0, 0, 1, 0, '/') retourneert Help - Joe Blogs
formats_path_segments(0, 0, 1, 1, '/') geeft Help - Joe Blogs.epub terug
formats_path_segments(1, 0, 1, 1, '/') levert Joe Blogs/Help - Joe Blogs.epub op
formats_path_segments(1, 0, 1, 0, '/') geeft Joe Blogs/Help - Joe Blogs
formats_path_segments(0, 1, 0, 0, '/') geeft Help - (calibre_id)

formats_paths ¶

class calibre.utils.formatter_functions.BuiltinFormatsPaths[broncode]¶

formats_paths([scheidingsteken]) – geef een separator gescheiden lijst van door dubbele punt gescheiden items FMT:PATH met het volledige pad naar de formaten van een boek. Het separator argument is optioneel. Als het niet wordt meegegeven dan is het scheidingsteken ', (komma spatie). Als het scheidingsteken een komma is dan kun je de select() functie gebruiken om het pad voor een specifiek formaat te krijgen. Merk op dat formaatnamen altijd hoofdletters zijn, zoals in EPUB.

formats_sizes ¶

class calibre.utils.formatter_functions.BuiltinFormatsSizes[broncode]¶

formats_sizes() – retourneert een door komma’s gescheiden lijst van door dubbele punt gescheiden FMT:SIZE items die de grootte van de formaten van een boek in bytes geven. Je kunt de select() functie gebruiken om de grootte voor een specifiek formaat te krijgen. Merk op dat formaatnamen altijd hoofdletters zijn, zoals in EPUB.

get_link ¶

class calibre.utils.formatter_functions.BuiltinGetLink[broncode]¶

get_link(field_name, field_value) – haal de link op voor veld field_name met waarde field_value. Als er geen gekoppelde link is, retourneer dan de lege string. Voorbeelden:

Het volgende geeft de link terug die aan de tag Fictie is gekoppeld:

get_link('tags', 'Fictie')

[Dit sjabloon maakt een lijst van de links voor alle tags die aan een boek zijn gekoppeld in de vorm waarde:link, ...:

programma:
    ans = '';
    voor t in $tags:
        l = get_link('tags', t);
        als l dan
            ans = list_join(', ', ans, ',', t & ':' & get_link('tags', t), ',')
        fi
    rof;
ans

Deze functie werkt alleen in de GUI en de contentserver.

get_note ¶

class calibre.utils.formatter_functions.BuiltinGetNote[broncode]¶

get_note(field_name, field_value, plain_text) – haal de notitie op voor veld field_name met waarde field_value. Als plain_text leeg is, stuur dan de HTML van de notitie terug, inclusief afbeeldingen. Als plain_text 1 is (of '1'), stuur dan de platte tekst van de notitie terug. Als de notitie niet bestaat, retourneer de lege string in beide gevallen. Voorbeeld:

Geef de HTML terug van de notitie gekoppeld aan de tag Fictie:
```
programma:
    get_note('tags', 'Fiction', '')
```
Geef de platte tekst terug van de notitie bij de auteur Isaac Asimov:
```
programma:
    get_note('authors', 'Isaac Asimov', 1)
```

Deze functie werkt alleen in de GUI en de contentserver.

has_extra_files ¶

class calibre.utils.formatter_functions.BuiltinHasExtraFiles[broncode]¶

has_extra_files([pattern]) – geeft de telling van extra bestanden, anders ‘’ (de lege tekenreeks). Als de optionele parameter pattern (een reguliere expressie) wordt meegegeven, dan wordt de lijst gefilterd op bestanden die overeenkomen met pattern voordat de bestanden worden geteld. Het patroon is hoofdletterongevoelig. Zie ook de functies extra_file_names(), extra_file_size() en extra_file_modtime(). Deze functie kan alleen worden gebruikt in de GUI en de contentserver.

has_note ¶

class calibre.utils.formatter_functions.BuiltinHasNote[broncode]¶

has_note(veld_naam, veld_waarde). Controleer of een veld een noot heeft. Deze functie heeft twee varianten:

als field_value niet '' is (de lege tekenreeks) retourneer '1' als de waarde field_value in het veld field_name een noot heeft, anders ''.

Voorbeeld: has_note('tags', 'Fiction') geeft '1' als de tag fiction een bijgevoegde notitie heeft, anders ''.
Als veld_waarde '' is, retourneer dan een lijst met waarden in veld_naam die een noot hebben. Als geen enkel item in het veld een opmerking heeft, retourneer dan ''. Deze variant is handig voor het tonen van kolompictogrammen als elke waarde in het veld een opmerking heeft, in plaats van een specifieke waarde.

Voorbeeld: has_note('authors', '') geeft een lijst van auteurs terug die notities hebben, of '' als geen enkele auteur een notitie heeft.

Je kunt testen of alle waarden in field_name een noot hebben door de lijstlengte van de returnwaarde van deze functie te vergelijken met de lijstlengte van de waarden in field_name. Voorbeeld:

list_count(has_note('authors', ''), '&') ==# list_count_field('authors')

Deze functie werkt alleen in de GUI en de contentserver.

Datumfuncties ¶

date_arithmetic ¶

class calibre.utils.formatter_functions.BuiltinDateArithmetic[broncode]¶

date_arithmetic(value, calc_spec, fmt) – Bereken een nieuwe datum uit value met calc_spec. Geef de nieuwe datum geformatteerd terug volgens de optionele fmt: als deze niet wordt gegeven dan zal het resultaat in ISO formaat zijn. De calc_spec is een string gevormd door aaneenschakeling van vW paren (valueWhat) waarbij v een mogelijk negatief getal is en W een van de volgende letters: [LIJST]

days_between ¶

class calibre.utils.formatter_functions.BuiltinDaysBetween[broncode]¶

days_between(date1, date2) – geeft het aantal dagen terug tussen date1 en date2. Het getal is positief als date1 groter is dan date2, anders negatief. Als date1 of date2 geen datums zijn, retourneert de functie de lege tekenreeks.

today ¶

class calibre.utils.formatter_functions.BuiltinToday[broncode]¶

today() – retourneert een datum+tijd string voor vandaag (now). Deze waarde is ontworpen voor gebruik in format_date of days_between, maar kan worden gemanipuleerd zoals elke andere string. De datum is in ISO datum/tijd formaat.

GUI functions ¶

selected_books ¶

class calibre.utils.formatter_functions.BuiltinSelectedBooks[broncode]¶

selected_books([sorted_by, ascending]) – returns a list of book ids in selection order for the currently selected books.

This function can be used only in the GUI.

selected_column ¶

class calibre.utils.formatter_functions.BuiltinSelectedColumn[broncode]¶

selected_column() – returns the lookup name of the column containing the currently selected cell. It returns '' if no cell is selected.

This function can be used only in the GUI.

show_dialog ¶

class calibre.utils.formatter_functions.BuiltinShowDialog[broncode]¶

show_dialog(html_or_text) – show a dialog containing the html or text. The function returns '1' if the user presses OK, '' if Cancel.

This function can be used only in the GUI.

sort_book_ids ¶

class calibre.utils.formatter_functions.BuiltinSortBookIds[broncode]¶

sort_book_ids(book_ids, sorted_by, ascending [, sorted_by, ascending]*) – returns the list of book ids sorted by the column specified by the lookup name in sorted_by in the order specified by ascending. If ascending is '1' then the books are sorted by the value in the ‘sorted_by’ column in ascending order, otherwise in descending order. You can have multiple pairs of sorted_by, ascending. The first pair specifies the major order.

This function can be used only in the GUI.

Herhaling ¶

eval ¶

class calibre.utils.formatter_functions.BuiltinEval[broncode]¶

eval(string) – evalueert de string als een programma, waarbij de lokale variabelen worden doorgegeven. Dit maakt het mogelijk om de sjabloonprocessor te gebruiken om complexe resultaten te construeren uit lokale variabelen. In Template Program Mode, omdat de { en } karakters worden geïnterpreteerd voordat het sjabloon wordt geëvalueerd, moet je [[ voor het { karakter en ]] voor het } karakter gebruiken. Ze worden automatisch geconverteerd. Merk ook op dat voor- en achtervoegsels (de |prefix|suffix syntaxis) niet gebruikt kunnen worden in het argument van deze functie als de Template Program Mode gebruikt wordt.

template ¶

class calibre.utils.formatter_functions.BuiltinTemplate[broncode]¶

template(x) – evaluates x as a template. The evaluation is done in its own context, meaning that variables are not shared between the caller and the template evaluation. If not using General Program Mode, because the { and } characters are special, you must use [[ for the { character and ]] for the } character; they are converted automatically. For example, template(\'[[title_sort]]\') will evaluate the template {title_sort} and return its value. Note also that prefixes and suffixes (the |prefix|suffix syntax) cannot be used in the argument to this function when using template program mode.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “`” for italics on line 1 in “template”

Itereren op waarden ¶

first_non_empty ¶

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[broncode]¶

first_non_empty(value [, value]*) – retourneert de eerste value die niet leeg is. Als alle waarden leeg zijn, dan wordt de lege string geretourneerd. Je kunt zoveel waarden hebben als je wilt.

lookup ¶

class calibre.utils.formatter_functions.BuiltinLookup[broncode]¶

lookup(value, [ pattern, key, ]* else_key) – De patronen worden gecontroleerd tegen de value in volgorde. Als een pattern overeenkomt dan wordt de waarde van het veld genaamd door key geretourneerd. Als het patroon niet overeenkomt, wordt de waarde van het veld met de naam else_key geretourneerd. Zie ook de switch() functie.

switch ¶

class calibre.utils.formatter_functions.BuiltinSwitch[broncode]¶

switch(value, [patternN, valueN,]+ else_value) – controleert voor elk patternN, valueN paar of de value overeenkomt met de reguliere expressie patternN en geeft in dat geval de bijbehorende valueN. Als patternN niet overeenkomt, wordt else_value teruggegeven. Je kunt zoveel patroonN, waardeN paren hebben als je wilt. De eerste overeenkomst wordt geretourneerd.

switch_if ¶

class calibre.utils.formatter_functions.BuiltinSwitchIf[broncode]¶

switch_if([test_expression, value_expression,]+ else_expression) – controleert voor elk test_expression, value_expression paar of test_expression Waar is (niet-leeg) en geeft in dat geval het resultaat van value_expression terug. Als geen test_expression Waar is, wordt het resultaat van else_expression teruggegeven. Je kunt zoveel test_expression, value_expression paren hebben als je wilt.

Lijst manipulatie ¶

list_count ¶

class calibre.utils.formatter_functions.BuiltinCount[broncode]¶

list_count(value, separator) – interpreteert de waarde als een lijst van items gescheiden door separator en geeft het aantal items in de lijst. De meeste lijsten gebruiken een komma als scheidingsteken, maar authors gebruikt een ampersand (&).

Voorbeelden: {tags:list_count(,)}, {authors:list_count(&)}.

Aliassen: count(), list_count()

list_count_field ¶

class calibre.utils.formatter_functions.BuiltinFieldListCount[broncode]¶

list_count_field(lookup_name)- geeft de telling van items in het veld met de lookup naam lookup_name. Het veld moet meerdere waarden hebben zoals authors of tags, anders geeft de functie een fout. Deze functie is veel sneller dan list_count() omdat het direct op calibre data werkt zonder het eerst naar een string te converteren. Voorbeeld: list_count_field('tags').

list_count_matching ¶

class calibre.utils.formatter_functions.BuiltinListCountMatching[broncode]¶

list_count_matching(value, pattern, separator) – interpreteert value als een lijst van items gescheiden door separator, en geeft het aantal items in de lijst die overeenkomen met de reguliere expressie pattern.

Aliassen: list_count_matching(), count_matching()

list_difference ¶

class calibre.utils.formatter_functions.BuiltinListDifference[broncode]¶

list_difference(list1, list2, separator) – geeft een lijst terug die is gemaakt door uit list1 elk item te verwijderen dat is gevonden in list2 met behulp van een hoofdlettergevoelige vergelijking. De items in list1 en list2 worden gescheiden door separator, net als de items in de geretourneerde lijst.

list_equals ¶

class calibre.utils.formatter_functions.BuiltinListEquals[broncode]¶

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – return yes_val als list1 en list2 dezelfde items bevatten, anders return no_val. De items worden bepaald door elke lijst te splitsen met het juiste scheidingsteken (sep1 of sep2). De volgorde van de items in de lijsten is niet relevant. De vergelijking is hoofdletterongevoelig.

list_intersection ¶

class calibre.utils.formatter_functions.BuiltinListIntersection[broncode]¶

list_intersection(list1, list2, separator) – geeft een lijst terug die is gemaakt door uit list1 elk item te verwijderen dat niet voorkomt in list2 met behulp van een hoofdlettergevoelige vergelijking. De items in list1 en list2 worden gescheiden door separator, net als de items in de geretourneerde lijst.

list_join ¶

class calibre.utils.formatter_functions.BuiltinListJoin[broncode]¶

list_join(with_separator, list1, separator1 [, list2, separator2]*) – geeft een lijst terug die is gemaakt door de items in de bronlijsten (list1 etc) samen te voegen met behulp van with_separator tussen de items in de resultatenlijst. Items in elke bron list[123...] worden gescheiden door de bijbehorende separator[123...]. Een lijst kan nul waarden bevatten. Het kan een veld zijn zoals publisher dat één waarde heeft, in feite een lijst met één item. Duplicaten worden verwijderd met behulp van een hoofdlettergevoelige vergelijking. Items worden geretourneerd in de volgorde waarin ze voorkomen in de bronlijsten. Als items op lijsten alleen verschillen in hoofdletters, dan wordt de laatste gebruikt. Alle scheidingstekens kunnen meer dan één teken zijn.

Voorbeeld:

programma:
    list_join('#@#', $authors, '&', $tags, ',')

Je kunt list_join als volgt gebruiken op de resultaten van eerdere oproepen naar list_join:

programma:
    a = list_join('#@#', $authors, '&', $tags, ',');
    b = list_join('#@#', a, '#@#', $#genre, ',', $#people, '&', 'some value', ',')

Je kunt expressies gebruiken om een lijst te genereren. Stel bijvoorbeeld dat je items wilt voor auteurs en #genre, maar met het genre veranderd in het woord “Genre: “ gevolgd door de eerste letter van het genre, dus het genre “Fiction” wordt “Genre: F”. Het volgende zal dat doen:

program:
    list_join('#@#', $authors, '&', list_re($#genre, ',', '^(.).*$', 'Genre: \1'),  ',')

list_re ¶

class calibre.utils.formatter_functions.BuiltinListRe[broncode]¶

list_re(src_list, separator, include_re, opt_replace) – Construeer een lijst door eerst src_list in items te scheiden met het separator karakter. Controleer voor elk item in de lijst of het overeenkomt met include_re. Als dat zo is, voeg het dan toe aan de lijst die wordt geretourneerd. Als opt_replace niet de lege string is, pas dan de vervanging toe voordat het item wordt toegevoegd aan de geretourneerde lijst.

list_re_group ¶

class calibre.utils.formatter_functions.BuiltinListReGroup[broncode]¶

list_re_group(src_list, separator, include_re, search_re [,template_for_group]*) – Zoals list_re() behalve dat vervangingen niet optioneel zijn. Het gebruikt re_group(item, search_re, template ...) bij het doen van de vervangingen.

list_remove_duplicates ¶

class calibre.utils.formatter_functions.BuiltinListRemoveDuplicates[broncode]¶

list_remove_duplicates(list, separator) – retourneert een lijst die is gemaakt door dubbele items in list te verwijderen. Als items alleen verschillen in geval dan wordt de laatste geretourneerd. De items in list worden gescheiden door separator, net als de items in de geretourneerde lijst.

list_sort ¶

class calibre.utils.formatter_functions.BuiltinListSort[broncode]¶

list_sort(value, direction, separator) – retourneert value gesorteerd met behulp van een hoofdletterongevoelige lexicale sortering. Als direction nul is (getal of teken), wordt value oplopend gesorteerd, anders aflopend. De items in de lijst worden gescheiden door separator, net als de items in de geretourneerde lijst.

list_split ¶

class calibre.utils.formatter_functions.BuiltinListSplit[broncode]¶

list_split(list_val, sep, id_prefix) – splitst list_val in afzonderlijke waarden met sep, wijst vervolgens de waarden toe aan lokale variabelen met de naam id_prefix_N waarbij N de positie van de waarde in de lijst is. Het eerste element heeft positie 0 (nul). De functie geeft het laatste element in de lijst terug.

Voorbeeld:

list_split('one:two:foo', ':', 'var')

is gelijk aan:

var_0 = 'een'
    var_1 = 'twee
    var_2 = 'foo'

list_union ¶

class calibre.utils.formatter_functions.BuiltinListUnion[broncode]¶

list_union(list1, list2, separator) – geeft een lijst terug die is gemaakt door de items in list1 en list2 samen te voegen, waarbij dubbele items worden verwijderd met behulp van een hoofdlettergevoelige vergelijking. Als items verschillen in hoofdletter, wordt die van list1 gebruikt. De items in list1 en list2 worden gescheiden door separator, net als de items in de geretourneerde lijst.

Aliassen: merge_lists(), list_union()

range ¶

class calibre.utils.formatter_functions.BuiltinRange[broncode]¶

range(start, stop, stap, limiet) – geeft een lijst getallen terug die is gegenereerd door te lussen over het bereik dat is opgegeven door de parameters start, stop en stap, met een maximale lengte van limiet. De eerste waarde die wordt geproduceerd is start. De volgende waarden next_v = current_v + step. De lus gaat door zolang next_v < stop in de veronderstelling dat step positief is, anders zolang next_v > stop. Een lege lijst wordt geproduceerd als start de test niet doorstaat: start >= stop als step positief is. De limit stelt de maximale lengte van de lijst in en heeft als standaardwaarde 1000. De parameters start, stap en limiet zijn optioneel. Het aanroepen van range() met één argument specificeert stop. Twee argumenten geven start en stop. Drie argumenten geven start, stop en stap. Vier argumenten geven start, stop, stap en limiet.

Voorbeelden:

range(5) -> '0, 1, 2, 3, 4'
bereik(0, 5) -> '0, 1, 2, 3, 4'
bereik(-1, 5) -> '-1, 0, 1, 2, 3, 4'
bereik(1, 5) -> '1, 2, 3, 4'
bereik(1, 5, 2) -> '1, 3'
bereik(1, 5, 2, 5) -> '1, 3'
bereik(1, 5, 2, 1) -> fout(limiet overschreden)

subitems ¶

class calibre.utils.formatter_functions.BuiltinSubitems[broncode]¶

subitems(value, start_index, end_index) – Deze functie splitst lijsten van tag-achtige hiërarchische items zoals genres. Het interpreteert de value als een door komma’s gescheiden lijst van tag-achtige items, waarbij elk item een punt-gescheiden lijst is. Het retourneert een nieuwe lijst die is gemaakt door uit elk item de componenten van start_index tot end_index te extraheren en vervolgens de resultaten weer samen te voegen. Duplicaten worden verwijderd. Het eerste subitem in een periode-gescheiden lijst heeft een index van nul. Als een index negatief is, telt deze vanaf het einde van de lijst. Als een speciaal geval, wordt een end_index van nul verondersteld de lengte van de lijst te zijn.

Voorbeelden:

Uitgaande van een #genre kolom die “A.B.C” bevat:
- {#genre:subitems(0,1)} geeft “A” terug
- {#genre:subitems(0,2)} geeft “A.B” terug
- {#genre:subitems(1,0)} geeft “B.C” terug
Uitgaande van een #genre kolom die “A.B.C, D.E” bevat:
- {#genre:subitems(0,1)} geeft “A, D” terug
- {#genre:subitems(0,2)} geeft “A.B, D.E” terug

sublist ¶

class calibre.utils.formatter_functions.BuiltinSublist[broncode]¶

sublist(value, start_index, end_index, separator) – interpreteer de value als een lijst van items gescheiden door separator, en geef een nieuwe lijst terug gemaakt van de items van start_index tot end_index. Het eerste item is nummer nul. Als een index negatief is, dan telt deze vanaf het einde van de lijst. Als speciaal geval wordt aangenomen dat een eind_index van nul de lengte van de lijst is.

Voorbeelden waarbij wordt aangenomen dat de kolom tags (die door komma’s wordt gescheiden) “A, B, C” bevat:

{tags:sublist(0,1,\,)} geeft “A”
{tags:sublist(-1,0,\,)} geeft “C” terug
{tags:sublist(0,-1,\,)} geeft “A, B” terug

Lijst opzoeken ¶

identifier_in_list ¶

class calibre.utils.formatter_functions.BuiltinIdentifierInList[broncode]¶

identifier_in_list(val, id_name [, found_val, not_found_val]) behandel val als een lijst van identifiers gescheiden door komma’s. Een identifier heeft het formaat id_name:value. Een identifier heeft het formaat id_name:value. De id_name parameter is de id_name tekst om naar te zoeken, ofwel id_name of id_name:regexp. Het eerste geval komt overeen als er een identifier is die overeenkomt met die id_name. Het tweede geval komt overeen als id_name overeenkomt met een identifier en de regexp overeenkomt met de waarde van de identifier. Als found_val en not_found_val zijn opgegeven, retourneer dan found_val als er een overeenkomst is, anders not_found_val. Als found_val en not_found_val niet zijn opgegeven, retourneer dan als er een overeenkomst is het identifier:value paar, anders de lege tekenreeks ('').

list_contains ¶

class calibre.utils.formatter_functions.BuiltinInList[broncode]¶

list_contains(value, separator, [ pattern, found_val, ]* not_found_val) – interpreteer de value als een lijst van items gescheiden door separator, controleer het pattern tegen elk item in de lijst. Als het pattern overeenkomt met een item dan retourneert found_val, anders retourneert not_found_val. Het paar pattern en found_value kan zo vaak als gewenst worden herhaald, waardoor verschillende waarden kunnen worden geretourneerd, afhankelijk van de waarde van het item. De patronen worden in volgorde gecontroleerd en de eerste overeenkomst wordt geretourneerd.

Aliassen: in_list(), list_contains()

list_item ¶

class calibre.utils.formatter_functions.BuiltinListitem[broncode]¶

list_item(value, index, separator) – interpreteer de value als een lijst van items gescheiden door separator, en geef het index item terug. Het eerste item is nummer nul. Het laatste item heeft de index -1 zoals in list_item(-1,separator). Als het item niet in de lijst staat, wordt de lege tekenreeks geretourneerd. Het scheidingsteken heeft dezelfde betekenis als in de graaf-functie, meestal komma, maar is ampersand voor auteur-achtige lijsten.

select ¶

class calibre.utils.formatter_functions.BuiltinSelect[broncode]¶

select(value, key) – interpreteer de value als een door komma’s gescheiden lijst van items met elk item in de vorm id:id_value (het calibre identifier formaat). De functie vindt het eerste paar met id gelijk aan key en retourneert de bijbehorende id_value. Als er geen id overeenkomt, retourneert de functie de lege tekenreeks.

str_in_list ¶

class calibre.utils.formatter_functions.BuiltinStrInList[broncode]¶

str_in_list(value, separator, [ string, found_val, ]+ not_found_val) – interpreteer de value als een lijst van items gescheiden door separator en vergelijk vervolgens string met elke waarde in de lijst. De string is geen reguliere expressie. Als string gelijk is aan een item (zonder rekening te houden met het geval), retourneer dan de corresponderende found_val. Als string separators bevat dan wordt het ook behandeld als een lijst en elke subwaarde wordt gecontroleerd. De string en found_value paren kunnen zo vaak als gewenst worden herhaald, waardoor verschillende waarden kunnen worden teruggegeven, afhankelijk van de waarde van de string. Als geen van de strings overeenkomt, wordt not_found_value geretourneerd. De strings worden in volgorde gecontroleerd. De eerste overeenkomst wordt geretourneerd.

Manipulatie van snaren ¶

character ¶

class calibre.utils.formatter_functions.BuiltinCharacter[broncode]¶

character(character_name) – geeft het karakter met de naam character_name. Bijvoorbeeld, character('newline') geeft een newline karakter ('\n'). De ondersteunde karakternamen zijn newline, return, tab, en backslash. Deze functie wordt gebruikt om deze tekens in de uitvoer van sjablonen te zetten.

check_yes_no ¶

class calibre.utils.formatter_functions.BuiltinCheckYesNo[broncode]¶

check_yes_no(field_name, is_undefined, is_false, is_true) – controleert of de waarde van het ja/nee veld genaamd door de lookup naam field_name een van de waarden is gespecificeerd door de parameters, en retourneert Ja als een overeenkomst is gevonden, anders retourneert het de lege string. Stel de parameter is_undefined, is_false, of is_true in op 1 (het getal) om die voorwaarde te controleren, stel deze anders in op 0.

Voorbeeld: check_yes_no("#bool", 1, 0, 1) geeft Ja' als het ja/nee veld #bool waar of ongedefinieerd (noch waar noch onwaar) is.

Meer dan één van is_undefined, is_false, of is_true kan op 1 worden gezet.

contains ¶

class calibre.utils.formatter_functions.BuiltinContains[broncode]¶

contains(value, pattern, text_if_match, text_if_not_match) – controleert of de waarde overeenkomt met de reguliere expressie pattern. Geeft text_if_match als het patroon overeenkomt met de waarde, anders geeft text_if_not_match.

field_exists ¶

class calibre.utils.formatter_functions.BuiltinFieldExists[broncode]¶

field_exists(lookup_name) controleert of een veld (kolom) met de lookup naam lookup_name bestaat, en retourneert '1' als dat zo is en de lege string als dat niet zo is.

ifempty ¶

class calibre.utils.formatter_functions.BuiltinIfempty[broncode]¶

ifempty(value, text_if_empty) – als de value niet leeg is, retourneer dan die value, anders retourneer text_if_empty.

re ¶

class calibre.utils.formatter_functions.BuiltinRe[broncode]¶

re(value, pattern, replacement) – retourneert de waarde na het toepassen van de reguliere expressie. Alle exemplaren van pattern in de waarde worden vervangen door replacement. De sjabloontaal gebruikt hoofdletterongevoelige Python reguliere expressies.

re_group ¶

class calibre.utils.formatter_functions.BuiltinReGroup[broncode]¶

re_group(value, pattern [, template_for_group]*) – geef een tekenreeks terug die is gemaakt door de reguliere expressie pattern toe te passen op value en elke gevonden instantie te vervangen door de waarde die is teruggegeven door de corresponderende sjabloon. In Template Program Mode, zoals voor de template en de eval functies, gebruik je [[ voor { en ]] voor }.

Het volgende voorbeeld zoekt naar een reeks met meer dan één woord en zet het eerste woord bovenaan:

programma: re_group(field('series'), "(\S* )(.*)", "{$:uppercase()}", "{$}")'}

shorten ¶

class calibre.utils.formatter_functions.BuiltinShorten[broncode]¶

shorten(value, left_chars, middle_text, right_chars) – Geef een verkorte versie terug van de value, bestaande uit left_chars tekens vanaf het begin van de value, gevolgd door middle_text, gevolgd door right_chars tekens vanaf het einde van de value. left_chars en right_chars moeten gehele niet-negatieve getallen zijn.

Voorbeeld: stel dat je de titel wilt weergeven met een lengte van maximaal 15 karakters. Een sjabloon dat dit doet is {title:shorten(9,-,5)}. Voor een boek met de titel Ancient English Laws inthe Times of Ivanhoe zal het resultaat Ancient E-anhoe zijn: de eerste 9 karakters van de titel, een -, dan de laatste 5 karakters. Als de lengte van de waarde kleiner is dan linkse karakters + rechtse karakters + de lengte van middeltekst dan wordt de waarde ongewijzigd teruggegeven. Bijvoorbeeld, de titel DeDome zou niet worden gewijzigd.

strcat ¶

class calibre.utils.formatter_functions.BuiltinStrcat[broncode]¶

strcat(a [, b]*) – geeft een tekenreeks terug gevormd door alle argumenten aan elkaar te rijgen. Kan een willekeurig aantal argumenten aannemen. In de meeste gevallen kun je de & operator gebruiken in plaats van deze functie.

strcat_max ¶

class calibre.utils.formatter_functions.BuiltinStrcatMax[broncode]¶

strcat_max(max, string1 [, prefix2, string2]*) Retourneert een tekenreeks gevormd door het aan elkaar rijgen van de argumenten. De geretourneerde waarde wordt geïnitialiseerd tot string1. Strings gemaakt van prefix, string paren worden toegevoegd aan het einde van de waarde zolang de resulterende string lengte minder is dan max. Voorvoegsels kunnen leeg zijn. Geeft string1 terug, zelfs als string1 langer is dan max. Je kunt zoveel voorvoegsel, tekenreeks paren opgeven als je wilt.

strlen ¶

class calibre.utils.formatter_functions.BuiltinStrlen[broncode]¶

strlen(value) – Geeft de lengte van de string value terug.

substr ¶

class calibre.utils.formatter_functions.BuiltinSubstr[broncode]¶

substr(value, start, end) – geeft de start’e tot en met de end’e karakters van value terug. Het eerste karakter in value is het nul’e karakter. Als end negatief is dan geeft dit aan dat er zoveel karakters van rechts naar rechts zijn geteld. Als end nul is, dan geeft het het laatste teken aan. Bijvoorbeeld, substr('12345', 1, 0) geeft 2345', en substr('12345', 1, -1) geeft `` 234’``.

swap_around_articles ¶

class calibre.utils.formatter_functions.BuiltinSwapAroundArticles[broncode]¶

swap_around_articles(value, separator) – retourneert de value met artikelen verplaatst naar het einde, gescheiden door een puntkomma. De value kan een lijst zijn, in welk geval elk item in de lijst wordt verwerkt. Als de waarde een lijst is, dan moet je de separator opgeven. Als er geen separator is opgegeven of als het scheidingsteken een lege tekenreeks is, dan wordt de value behandeld als een enkele waarde en niet als een lijst. De artikelen zijn de artikelen die door calibre worden gebruikt om de title_sort te genereren.

swap_around_comma ¶

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[broncode]¶

swap_around_comma(value) – gegeven een waarde van de vorm B, A, retourneer A B. Dit is het handigst voor het converteren van namen in LN, FN formaat naar FN LN. Als er geen komma in de waarde staat, retourneert de functie de waarde ongewijzigd.

test ¶

class calibre.utils.formatter_functions.BuiltinTest[broncode]¶

test(value, text_if_not_empty, text_if_empty) return text_if_not_empty als de waarde niet leeg is, anders return text_if_empty.

transliterate ¶

class calibre.utils.formatter_functions.BuiltinTransliterate[broncode]¶

transliterate(value) – Geef een tekenreeks in een latijns alfabet terug, gevormd door de klank van de woorden in value te benaderen. Bijvoorbeeld, als value Фёдор Миха́йлович Достоевский is, geeft deze functie Fiodor Mikhailovich Dostoievskii terug.

Overige ¶

arguments ¶

class calibre.utils.formatter_functions.BuiltinArguments[broncode]¶

argumenten(id[=expressie] [, id[=expressie]]*) – Gebruikt in een opgeslagen sjabloon om de argumenten op te halen die in de aanroep zijn doorgegeven. Het declareert en initialiseert lokale variabelen met de opgegeven namen, de id``s, waardoor ze in feite parameters zijn. De variabelen zijn positioneel; ze krijgen de waarde van het argument dat in de aanroep op dezelfde positie is meegegeven. Als het corresponderende argument niet is meegegeven in de aanroep dan wijst ``arguments() die variabele de opgegeven standaardwaarde toe. Als er geen standaardwaarde is, dan wordt de variabele ingesteld op de lege tekenreeks.

assign ¶

class calibre.utils.formatter_functions.BuiltinAssign[broncode]¶

assign(id, value) – kent waarde toe aan id en geeft vervolgens waarde terug. id moet een identifier zijn, geen uitdrukking. In de meeste gevallen kun je de = operator gebruiken in plaats van deze functie.

globals ¶

class calibre.utils.formatter_functions.BuiltinGlobals[broncode]¶

globals(id[=expressie] [, id[=expressie]]*) Haalt “globale variabelen” op die kunnen worden doorgegeven aan de formatteerder. De naam id is de naam van de globale variabele. Het declareert en initialiseert lokale variabelen met de namen van de globale variabelen die zijn doorgegeven in de id parameters. Als de corresponderende variabele niet wordt gegeven in de globale variabelen, dan wordt aan die variabele de opgegeven standaardwaarde toegekend. Als er geen standaardwaarde is, wordt de variabele ingesteld op de lege tekenreeks.

is_dark_mode ¶

class calibre.utils.formatter_functions.BuiltinIsDarkMode[broncode]¶

is_dark_mode() – retourneert '1' als calibre in donkere modus draait, '' (de lege tekenreeks) anders. Deze functie kan worden gebruikt in geavanceerde kleur- en pictogramregels om verschillende kleuren/iconen te kiezen afhankelijk van de modus. Voorbeeld:

if_dark_mode() then 'dark.png' else 'light.png' fi

print ¶

class calibre.utils.formatter_functions.BuiltinPrint[broncode]¶

print(a [, b]*) – print de argumenten naar de standaarduitvoer. Tenzij je calibre start vanaf de commandoregel (calibre-debug -g), zal de uitvoer in een zwart gat verdwijnen. De print functie geeft altijd het eerste argument terug.

set_globals ¶

class calibre.utils.formatter_functions.BuiltinSetGlobals[broncode]¶

set_globals(id[=expressie] [, id[=expressie]]*)``Stelt `globalevariabelen` in die kunnen worden doorgegeven aan de formatteerder. De globals krijgen de naam van het ``id dat wordt doorgegeven. De waarde van het id wordt gebruikt tenzij er een expressie is opgegeven.

Rekenkunde ¶

add ¶

class calibre.utils.formatter_functions.BuiltinAdd[broncode]¶

add(x [, y]*) – geeft de som van de argumenten. Werpt een uitzondering als een argument geen getal is. In de meeste gevallen kun je de + operator gebruiken in plaats van deze functie.

ceiling ¶

class calibre.utils.formatter_functions.BuiltinCeiling[broncode]¶

ceiling(value) – geeft het kleinste gehele getal terug dat groter of gelijk is aan value. Gooit een uitzondering als value geen getal is.

divide ¶

class calibre.utils.formatter_functions.BuiltinDivide[broncode]¶

divide(x, y) – geeft x / y. Werpt een exceptie als x of y geen getallen zijn. Deze functie kan meestal worden vervangen door de / operator.

floor ¶

class calibre.utils.formatter_functions.BuiltinFloor[broncode]¶

floor(value) – geeft het grootste gehele getal terug dat kleiner is dan of gelijk is aan value. Gooit een uitzondering als value geen getal is.

fractional_part ¶

class calibre.utils.formatter_functions.BuiltinFractionalPart[broncode]¶

fractional_part(value) retourneert het deel van de waarde achter de komma. Bijvoorbeeld, fractional_part(3.14) retourneert 0.14. Werpt een uitzondering als waarde geen getal is.

mod ¶

class calibre.utils.formatter_functions.BuiltinMod[broncode]¶

mod(value, y) – geeft de floor van de rest van value / y. Werpt een exceptie als value of y geen getal is.

multiply ¶

class calibre.utils.formatter_functions.BuiltinMultiply[broncode]¶

multiply(x [, y]*) – geeft het product van de argumenten. Gooit een uitzondering als een argument geen getal is. Deze functie kan meestal worden vervangen door de * operator.

round ¶

class calibre.utils.formatter_functions.BuiltinRound[broncode]¶

round(value) – geeft het dichtstbijzijnde gehele getal voor value. Werpt een uitzondering als value geen getal is.

subtract ¶

class calibre.utils.formatter_functions.BuiltinSubtract[broncode]¶

subtract(x, y) – geeft x - y. Werpt een exceptie als x of y geen getallen zijn. Deze functie kan meestal worden vervangen door de - operator.

Relationeel ¶

cmp ¶

class calibre.utils.formatter_functions.BuiltinCmp[broncode]¶

cmp(value, y, lt, eq, gt) – vergelijkt value en y nadat beide zijn omgezet naar getallen. Geeft lt als value <# y, eq als value ==# y, anders gt. Deze functie kan meestal worden vervangen door een van de numerieke vergelijkingsoperatoren (=#, <#, >#, etc).

first_matching_cmp ¶

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[broncode]¶

first_matching_cmp(val, [ cmp, result, ]* else_result) vergelijkt val < cmp in volgorde, en geeft het bijbehorende result voor de eerste vergelijking die slaagt. Geeft else_result als geen vergelijking slaagt.

Voorbeeld:

i = 10;
first_matching_cmp(i,5,"small",10,"middle",15,"large","giant")

geeft "groot". Hetzelfde voorbeeld met een eerste waarde van 16 geeft "reus".

strcmp ¶

class calibre.utils.formatter_functions.BuiltinStrcmp[broncode]¶

strcmp(x, y, lt, eq, gt) – doet een hoofdletterongevoelige lexicale vergelijking van x en y. Geeft lt als x < y, eq als x == y, anders gt. Deze functie kan vaak worden vervangen door een van de lexicale vergelijkingsoperatoren (=, >, <, etc.)

strcmpcase ¶

class calibre.utils.formatter_functions.BuiltinStrcmpcase[broncode]¶

strcmpcase(x, y, lt, eq, gt) – doet een hoofdlettergevoelige lexicale vergelijking van x en y. Geeft lt als x < y, eq als x == y, anders gt.

Opmerking: Dit is NIET het standaard gedrag dat calibre gebruikt, bijvoorbeeld in de lexicale vergelijkingsoperatoren (=, >, <, etc.). Deze functie kan onverwachte resultaten veroorzaken, gebruik bij voorkeur strcmp() wanneer mogelijk.

URL-functies ¶

encode_for_url ¶

class calibre.utils.formatter_functions.BuiltinEncodeForURL[broncode]¶

encode_for_url(value, use_plus) – retourneert de waarde gecodeerd voor gebruik in een URL zoals gespecificeerd door use_plus. De waarde wordt eerst URL-gecodeerd. Vervolgens, als use_plus 0 is dan worden spaties vervangen door '+' (plus) tekens. Als het 1 is dan worden spaties vervangen door %20.

Als je niet wilt dat de waarde wordt gecodeerd maar dat spaties worden vervangen, gebruik dan de re() functie, zoals in re($series, ' ', '%20')

Zie ook de functies make_url(), make_url_extended() en query_string().

make_url ¶

class calibre.utils.formatter_functions.BuiltinMakeUrl[broncode]¶

make_url(path, [query_name, query_value]+) – deze functie is de eenvoudigste manier om een query URL te construeren. Het gebruikt een pad, de website en pagina die je wilt opvragen, en query_name, query_value paren waaruit de query wordt opgebouwd. In het algemeen moet de query_value URL-gecodeerd zijn. Met deze functie wordt het altijd gecodeerd en worden spaties altijd vervangen door '+' tekens.

Er moet ten minste één query_name, query_value-paar worden opgegeven.

Voorbeeld: het maken van een Wikipedia zoek-URL voor de auteur Niccolò Machiavelli:

make_url('https://en.wikipedia.org/w/index.php', 'search', 'Niccolò Machiavelli')

geeft

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Als je een aangepast URL-sjabloon voor kolomboekdetails schrijft, gebruik dan $item_name of field('item_name') om de waarde te verkrijgen van het veld waarop is geklikt. Voorbeeld: als er op Niccolò Machiavelli is geklikt dan kun je de URL maken met:

make_url('https://en.wikipedia.org/w/index.php', 'search', $item_name)

Zie ook de functies make_url_extended(), query_string() en encode_for_url().

make_url_extended ¶

class calibre.utils.formatter_functions.BuiltinMakeUrlExtended[broncode]¶

make_url_extended(...) – deze functie is vergelijkbaar met make_url() maar geeft je meer controle over de URL componenten. De componenten van een URL zijn

scheme:://authority/path?query string.

Zie Uniform Resource Locator op Wikipedia voor meer informatie.

De functie heeft twee varianten:

make_url_extended(schema, autoriteit, pad, [query_name, query_waarde]+)

en

make_url_extended(schema, autoriteit, pad, query_string)

Deze functie retourneert een URL opgebouwd uit het schema, autoriteit, pad en of de query_string of een querystring opgebouwd uit de query argumentparen. De authority kan leeg zijn, wat het geval is voor calibre schema URLs. Je moet of een query_string of ten minste één query_name, query_value paar opgeven. Als je query_string opgeeft en deze is leeg dan zal de resulterende URL geen query string sectie hebben.

Voorbeeld 1: het construeren van een Wikipedia zoek URL voor de auteur Niccolò Machiavelli:

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'search', 'Niccolò Machiavelli')

geeft

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Zie de query_string() functie voor een voorbeeld van het gebruik van make_url_extended() met een query_string.

Als je een aangepaste kolom boek details URL sjabloon aan het schrijven bent, gebruik dan $item_name of field('item_name') om de waarde te krijgen van het veld waarop geklikt is. Voorbeeld: als er op Niccolò Machiavelli is geklikt dan kun je de URL samenstellen met :

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'search', $item_name')

Zie ook de functies make_url(), query_string() en encode_for_url().

query_string ¶

class calibre.utils.formatter_functions.BuiltinQueryString[broncode]¶

query_string([query_name, query_value, how_to_encode]+)– retourneert een URL-querystring opgebouwd uit de query_name, query_value, how_to_encode triades. Een querystring is een serie items waarbij elk item eruit ziet als query_name=query_value waarbij query_value URL-gecodeerd is zoals aangegeven. De query items worden gescheiden door '&' (ampersand) karakters.

Als how_to_encode 0 is dan wordt query_value gecodeerd en worden spaties vervangen door '+' (plus) tekens. Als how_to_encode 1 is dan wordt query_value gecodeerd en worden de spaties vervangen door %20. Als how_to_encode 2 is dan wordt query_value ongewijzigd geretourneerd; er wordt niet gecodeerd en spaties worden niet vervangen. Als je wilt dat query_value niet wordt gecodeerd maar spaties worden vervangen, gebruik dan de re() functie, zoals in re($series, ' ', '%20')

Je gebruikt deze functie als je specifieke controle nodig hebt over hoe de delen van de querystring worden opgebouwd. Je kunt dan de resulterende querystring gebruiken in make_url_extended(), zoals in

make_url_extended(
       https', 'your_host', 'your_path',
       query_string('gecodeerd', 'Hendrik Bäßler', 0, 'niet-gecodeerd', 'Hendrik Bäßler', 2))

waardoor je

https://your_host/your_path?encoded=Hendrik+B%C3%A4%C3%9Fler&unencoded=Hendrik Bäßler

Je moet ten minste één query_name, query_value, how_to_encode triade hebben, maar je kunt er zoveel hebben als je wilt.

De geretourneerde waarde is een URL query string met alle opgegeven items, bijvoorbeeld: naam1=val1[&naamN=valN]*. Merk op dat het ?' pad / query string scheidingsteken niet wordt opgenomen in het geretourneerde resultaat.

Als je een aangepaste kolom boek details URL sjabloon schrijft, gebruik dan $item_name of field('item_name') om de ongecodeerde waarde van het veld waarop geklikt is te verkrijgen. Je hebt ook item_value_quoted waar de waarde al gecodeerd is met plustekens ter vervanging van spaties, en item_value_no_plus waar de waarde al gecodeerd is met %20 ter vervanging van spaties.

Zie ook de functies make_url(), make_url_extended() en encode_for_url().

to_hex ¶

class calibre.utils.formatter_functions.BuiltinToHex[broncode]¶

to_hex(val) – retourneert de tekenreeks val gecodeerd in hex. Dit is handig bij het construeren van calibre URL’s.

urls_from_identifiers ¶

class calibre.utils.formatter_functions.BuiltinUrlsFromIdentifiers[broncode]¶

urls_from_identifiers(identifiers, sort_results) – gegeven een door komma’s gescheiden lijst van identifiers, waarbij een identifier een door dubbele punt gescheiden paar waarden is (id_name:id_value`), geeft een door komma’s gescheiden lijst HTML URLs gegenereerd uit de identifiers.[/] De lijst is niet gesorteerd als sort_results ``0` is (karakter of nummer), anders is het alfabetisch gesorteerd op de identifier naam. De URL’s worden op dezelfde manier gegenereerd als de ingebouwde identifiers kolom in Boek Details.

Waarden ophalen uit metagegevens ¶

author_links ¶

class calibre.utils.formatter_functions.BuiltinAuthorLinks[broncode]¶

author_links(val_separator, pair_separator) – geeft een string terug met een lijst van auteurs en de linkwaarden van die auteurs in de vorm: author1 val_separator author1_link pair_separator author2 val_separator author2_link enz.

Een auteur wordt gescheiden van zijn linkwaarde door de val_separator string zonder toegevoegde spaties. Ervan uitgaande dat de val_separator een dubbele punt is, worden auteur:link waarde paren gescheiden door het pair_separator string argument zonder toegevoegde spaties. Het is aan jou om scheidingstekens te kiezen die niet voorkomen in auteursnamen of links. Een auteur wordt opgenomen zelfs als de auteur link leeg is.

author_sorts ¶

class calibre.utils.formatter_functions.BuiltinAuthorSorts[broncode]¶

author_sorts(val_separator) – geeft een tekenreeks terug met een lijst van sorteerwaarden voor de auteurs van het boek. De sortering is de sortering in de metagegevensinformatie van de auteur, die kan verschillen van de author_sort in boeken. De geretourneerde lijst heeft de vorm auteur sorteert 1 val_separator auteur sorteert 2 etc. zonder toegevoegde spaties. De author sort waarden in deze lijst staan in dezelfde volgorde als de auteurs van het boek. Als je spaties rond val_separator wilt, zet ze dan in de val_separator string.

booksize ¶

class calibre.utils.formatter_functions.BuiltinBooksize[broncode]¶

booksize() – geeft de waarde van het kaliber size veld. Geeft ‘’ terug als het boek geen formaten heeft.

Deze functie werkt alleen in de GUI. Als je deze waarde wilt gebruiken in sjablonen voor opslaan naar schijf of verzenden naar apparaat, dan moet je een aangepaste “Kolom opgebouwd uit andere kolommen” maken, de functie gebruiken in het sjabloon van die kolom en de waarde van die kolom gebruiken in je sjablonen voor opslaan/verzenden

connected_device_name ¶

class calibre.utils.formatter_functions.BuiltinConnectedDeviceName[broncode]¶

connected_device_name(storage_location_key) – als een apparaat is aangesloten, retourneer dan de apparaatnaam, anders retourneer de lege string. Elke opslaglocatie op een apparaat heeft zijn eigen apparaatnaam. De storage_location_key namen zijn 'main', 'carda' en 'cardb'. Deze functie werkt alleen in de GUI.

connected_device_uuid ¶

class calibre.utils.formatter_functions.BuiltinConnectedDeviceUUID[broncode]¶

connected_device_uuid(storage_location_key) – als een apparaat is aangesloten, retourneer dan de apparaat uuid (unieke id), anders retourneer de lege string. Elke opslaglocatie op een apparaat heeft een andere uuid. De storage_location_key locatienamen zijn 'main', 'carda' en 'cardb'. Deze functie werkt alleen in de GUI.

current_library_name ¶

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[broncode]¶

current_library_name() – geeft de laatste naam op het pad naar de huidige calibre bibliotheel terug.

current_library_path ¶

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[broncode]¶

current_library_path() – geeft het volledige pad naar de huidige calibre bibliotheek terug.

current_virtual_library_name ¶

class calibre.utils.formatter_functions.BuiltinCurrentVirtualLibraryName[broncode]¶

current_virtual_library_name() – retourneert de naam van de huidige virtuele bibliotheek als die er is, anders de lege tekenreeks. De hoofdletters en kleine letters van de bibliotheeknaam blijven behouden. Voorbeeld:

programma: huidige_virtuele_bibliotheek_naam()

Deze functie werkt alleen in de GUI.

field ¶

class calibre.utils.formatter_functions.BuiltinField[broncode]¶

field(lookup_name) – retourneert de waarde van het metagegevensveld met lookup naam lookup_name. Het $ voorvoegsel kan worden gebruikt in plaats van de functie, zoals in $tags.

has_cover ¶

class calibre.utils.formatter_functions.BuiltinHasCover[broncode]¶

has_cover() – geeft 'Yes' terug als het boek een omslag heeft, anders de lege string.

is_marked ¶

class calibre.utils.formatter_functions.BuiltinIsMarked[broncode]¶

is_gemarkeerd() – controleert of het boek gemarkeerd is in calibre. Als dat zo is, retourneer dan de waarde van de markering, ofwel waar (kleine letters) of een door komma’s gescheiden lijst van genoemde markeringen. Retourneert '' (de lege tekenreeks) als het boek niet is gemarkeerd. Deze functie werkt alleen in de GUI.

language_codes ¶

class calibre.utils.formatter_functions.BuiltinLanguageCodes[broncode]¶

language_codes(lang_strings) – retourneert de taalcodes voor de taalnamen doorgegeven in lang_strings. De strings moeten in de taal van de huidige locale zijn. lang_strings is een door komma’s gescheiden lijst.

language_strings ¶

class calibre.utils.formatter_functions.BuiltinLanguageStrings[broncode]¶

language_strings(value, localize) – retourneert de taalnamen voor de taalcodes (zie hier voor namen en codes) doorgegeven in value. Voorbeeld: {languages:language_strings()}. Als localize nul is, worden de tekenreeksen in het Engels weergegeven. Als localize niet nul is, worden de strings in de taal van de huidige locale weergegeven. lang_codes is een door komma’s gescheiden lijst.

ondevice ¶

class calibre.utils.formatter_functions.BuiltinOndevice[broncode]¶

ondevice() – retourneert de string Ja' als ondevice is ingesteld, anders retourneert het de lege string. Deze functie werkt alleen in de GUI. Als je deze waarde wilt gebruiken in sjablonen voor opslaan naar schijf of verzenden naar apparaat, moet je een aangepaste “Kolom opgebouwd uit andere kolommen” maken, de functie gebruiken in het sjabloon van die kolom en de waarde van die kolom gebruiken in je sjablonen voor opslaan/verzenden.

raw_field ¶

class calibre.utils.formatter_functions.BuiltinRawField[broncode]¶

raw_field(lookup_name [, optional_default]) – retourneert het metadata veld genaamd door lookup_name zonder enige opmaak toe te passen. Het evalueert en retourneert het optionele tweede argument optional_default als de waarde van het veld ongedefinieerd is (None). Het $$ voorvoegsel kan worden gebruikt in plaats van de functie, zoals in $$pubdate.

raw_list ¶

class calibre.utils.formatter_functions.BuiltinRawList[broncode]¶

raw_list(lookup_name, separator) – geeft de metagegevenslijst met de naam lookup_name zonder opmaak of sortering, met de items gescheiden door separator.

series_sort ¶

class calibre.utils.formatter_functions.BuiltinSeriesSort[broncode]¶

series_sort() – geeft de reekssorteerwaarde terug.

user_categories ¶

class calibre.utils.formatter_functions.BuiltinUserCategories[broncode]¶

user_categories() – retourneert een door komma’s gescheiden lijst van gebruikerscategorieën die dit boek bevatten. Deze functie werkt alleen in de GUI. Als je deze waarden wilt gebruiken in sjablonen voor opslaan naar schijf of verzenden naar apparaat, moet je een aangepaste kolom maken die is opgebouwd uit andere kolommen, de functie gebruiken in het sjabloon van die kolom en de waarde van die kolom gebruiken in je sjablonen voor opslaan/verzenden

virtual_libraries ¶

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[broncode]¶

virtual_libraries() – retourneert een door komma’s gescheiden lijst van Virtuele bibliotheken die dit boek bevatten. Deze functie werkt alleen in de GUI. Als je deze waarden wilt gebruiken in sjablonen voor opslaan naar schijf of verzenden naar apparaat, dan moet je een aangepaste kolom maken die is opgebouwd uit andere kolommen, de functie gebruiken in het sjabloon van die kolom en de waarde van die kolom gebruiken in je sjablonen voor opslaan/verzenden.

Waarden opmaken ¶

f_string ¶

class calibre.utils.formatter_functions.BuiltinFString[broncode]¶

f_string(string) – interpret string similar to how python interprets f strings. The intended use is to simplify long sequences of str & str or strcat(a,b,c) expressions.

Text between braces ({ and }) must be General Program Mode template expressions. The expressions, which can be expression lists, are evaluated in the current context (current book and local variables). Text not between braces is passed through unchanged.

Examples:

f_string('Here is the title: {$title}') - returns the string with {$title} replaced with the title of the current book. For example, if the book’s title is 20,000 Leagues Under the Sea then the f_string() returns Here is the title: 20,000 Leagues Under the Sea.
Assuming the current date is 18 Sept 2025, this f_string()
```
f_string("Today's date: the {d = today(); format_date(d, 'd')} of {format_date(d, 'MMMM')}, {format_date(d, 'yyyy')}")
```
returns the string Today’s date: the 18 of September, 2025. Note the expression list (an assignment then an if statement) used in the first { ... } group to assign today’s date to a local variable.

If the book is book #3 in a series named Foo that has 5 books then this template

program:
    if $series then
        series_count = book_count('series:"""=' & $series & '"""', 0);
        return f_string("{$series}, book {$series_index} of {series_count}")
    fi;
    return 'This book is not in a series'

returns Foo, book 3 of 5

finish_formatting ¶

class calibre.utils.formatter_functions.BuiltinFinishFormatting[broncode]¶

finish_formatting(value, format, prefix, suffix) – pas het format, prefix, en suffix toe op de value op dezelfde manier als in een sjabloon als {series_index:05.2f| - |- }. Deze functie wordt aangeboden om de conversie van complexe sjablonen in enkelvoudige functie- of sjabloonprogramma-modus naar GPM-sjablonen te vergemakkelijken. Het volgende programma produceert bijvoorbeeld dezelfde uitvoer als het bovenstaande sjabloon:

programma: finish_formatting(field("series_index"), "05.2f", " - ", " - ")

Een ander voorbeeld: voor de sjabloon:

{series:re(([^\s])[^\s]+(\s|$),\1)}{serie_index:0>2s| - | - }{title}

gebruiken:

programma:
    strcat(
        re(field('series'), '([^\s])[^\s]+(^s|$)', '\1'),
        finish_formatting(field('series_index'), '0>2s', ' - ', ' - '),
        veld("titel")
    )

format_date ¶

class calibre.utils.formatter_functions.BuiltinFormatDate[broncode]¶

format_date(value, format_string) – format the value, which must be a date string, using the format_string, returning a string. It is best if the date is in ISO format as using other date formats often causes errors because the actual date value cannot be unambiguously determined. Note that the format_date_field() function is both faster and more reliable.

The formatting codes are:

d : the day as number without a leading zero (1 to 31)
dd : the day as number with a leading zero (01 to 31)
ddd : the abbreviated localized day name (e.g. “Mon” to “Sun”)
dddd : the long localized day name (e.g. “Monday” to “Sunday”)
M : the month as number without a leading zero (1 to 12)
MM : the month as number with a leading zero (01 to 12)
MMM : the abbreviated localized month name (e.g. “Jan” to “Dec”)
MMMM : the long localized month name (e.g. “January” to “December”)
yy : the year as two digit number (00 to 99)
yyyy : the year as four digit number.
h : the hours without a leading 0 (0 to 11 or 0 to 23, depending on am/pm)
hh : the hours with a leading 0 (00 to 11 or 00 to 23, depending on am/pm)
m : the minutes without a leading 0 (0 to 59)
mm : the minutes with a leading 0 (00 to 59)
s : the seconds without a leading 0 (0 to 59)
ss : the seconds with a leading 0 (00 to 59)
ap : use a 12-hour clock instead of a 24-hour clock, with ‘ap’ replaced by the lowercase localized string for am or pm
AP : use a 12-hour clock instead of a 24-hour clock, with ‘AP’ replaced by the uppercase localized string for AM or PM
aP : use a 12-hour clock instead of a 24-hour clock, with ‘aP’ replaced by the localized string for AM or PM
Ap : use a 12-hour clock instead of a 24-hour clock, with ‘Ap’ replaced by the localized string for AM or PM
iso : the date with time and timezone. Must be the only format present
to_number : convert the date & time into a floating point number (a timestamp)
from_number : convert a floating point number (a timestamp) into an ISO-formatted date. If you want a different date format then add the desired formatting string after from_number and a colon (:). Example:
```
format_date(val, 'from_number:MMM dd yyyy')
```

You might get unexpected results if the date you are formatting contains localized month names, which can happen if you changed the date format to contain MMMM. Using format_date_field() avoids this problem.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “``” for CODE_TEXT on line 32 in “format_date”

format_date_field ¶

class calibre.utils.formatter_functions.BuiltinFormatDateField[broncode]¶

format_date_field(field_name, format_string) – formatteer de waarde in het veld field_name, dat de lookup naam moet zijn van een datumveld, standaard of aangepast. Zie format_date() voor de opmaakcodes. Deze functie is veel sneller dan format_date() en zou gebruikt moeten worden wanneer je de waarde in een veld (kolom) formatteert. Het is ook betrouwbaarder omdat het direct op de onderliggende datum werkt. Het kan niet gebruikt worden voor berekende datums of datums in stringvariabelen. Voorbeelden:

format_date_field('pubdate', 'jjjj.MM.dd')
format_date_field('#datum_lezen', 'MMM dd, jjjj')

format_duration ¶

class calibre.utils.formatter_functions.BuiltinFormatDuration[broncode]¶

format_duration(value, template, [largest_unit]) – format the value, a number of seconds, into a string showing weeks, days, hours, minutes, and seconds. If the value is a float then it is rounded to the nearest integer. You choose how to format the value using a template consisting of value selectors surrounded by [ and ] characters. The selectors are:

[w]: weeks
[d]: days
[h]: hours
[m]: minutes
[s]: seconds

You can put arbitrary text between selectors.

The following examples use a duration of 2 days (172,800 seconds) 1 hour (3,600 seconds) and 20 seconds, which totals to 176,420 seconds.

format_duration(176420, '[d][h][m][s]') will return the value 2d 1h 0m 20s.
format_duration(176420, '[h][m][s]') will return the value 49h 0m 20s.
format_duration(176420, 'Your reading time is [d][h][m][s]') returns the value Your reading time is 49h 0m 20s.
format_duration(176420, '[w][d][h][m][s]') will return the value 2d 1h 0m 20s. Note that the zero weeks value is not returned.

If you want to see zero values for items such as weeks in the above example, use an uppercase selector. For example, the following uses 'W' to show zero weeks:

format_duration(176420, '[W][d][h][m][s]') returns 0w 2d 1h 0m 20s.

By default the text following a value is the selector followed by a space. You can change that to whatever text you want. The format for a selector with your text is the selector followed by a colon followed by text segments separated by '|' characters. You must include any space characters you want in the output.

You can provide from one to three text segments.

If you provide one segment, as in [w: weeks ] then that segment is used for all values.
If you provide two segments, as in [w: weeks | week ] then the first segment is used for 0 and more than 1. The second segment is used for 1.
If you provide three segments, as in [w: weeks | week | weeks ] then the first segment is used for 0, the second segment is used for 1, and the third segment is used for more than 1.

The second form is equivalent to the third form in many languages.

For example, the selector:

[w: weeks | week | weeks ] produces '0 weeks ', '1 week ', or '2 weeks '.
[w: weeks | week ] produces '0 weeks ', '1 week ', or '2 weeks '.
[w: weeks ] produces 0 weeks ', 1 weeks ', or 2 weeks '.

The optional largest_unit parameter specifies the largest of weeks, days, hours, minutes, and seconds that will be produced by the template. It must be one of the value selectors. This can be useful to truncate a value.

format_duration(176420, '[h][m][s]', 'd') will return the value 1h 0m 20s instead of 49h 0m 20s.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “``” for CODE_TEXT on line 40 in “format_duration”

format_number ¶

class calibre.utils.formatter_functions.BuiltinFormatNumber[broncode]¶

format_number(value, template) – interprets the value as a number and formats that number using a Python formatting template such as {0:5.2f} or {0:,d} or ${0:5,.2f}. The formatting template must begin with {0: and end with } as in the above examples. Exception: you can leave off the leading “{0:” and trailing “}” if the format template contains only a format. See the Template Language and the Python documentation for more examples. Returns the empty string if formatting fails.

De documentatie in het Engels weergeven vanwege de fout FFML: Missing closing “`” for italics on line 1 in “format_number”

human_readable ¶

class calibre.utils.formatter_functions.BuiltinHumanReadable[broncode]¶

human_readable(value) – verwacht dat de waarde een getal is en geeft een tekenreeks terug die dat getal weergeeft in KB, MB, GB, enz.

rating_to_stars ¶

class calibre.utils.formatter_functions.BuiltinRatingToStars[broncode]¶

rating_to_stars(value, use_half_stars) – Geeft de waarde terug als een tekenreeks van sterren (★). De waarde moet een getal zijn tussen 0 en 5. Stel use_half_stars in op 1 als je halve ster-tekens wilt voor fractionele getallen die beschikbaar zijn met aangepaste beoordelingskolommen.

Zaak verandert ¶

capitalize ¶

class calibre.utils.formatter_functions.BuiltinCapitalize[broncode]¶

kapitaliseren(waarde) – geeft de waarde met de eerste letter in hoofdletters en de rest in kleine letters.

lowercase ¶

class calibre.utils.formatter_functions.BuiltinLowercase[broncode]¶

lowercase(value) – geeft de waarde in kleine letters.

titlecase ¶

class calibre.utils.formatter_functions.BuiltinTitlecase[broncode]¶

titlecase(value) – geeft de waarde in hoofdletters.

uppercase ¶

class calibre.utils.formatter_functions.BuiltinUppercase[broncode]¶

uppercase(value) – geeft de waarde in hoofdletters.

API of the Metadata objects ¶

The python implementation of the template functions is passed in a Metadata object. Knowing it’s API is useful if you want to define your own template functions.

class calibre.ebooks.metadata.book.base.Metadata(title, authors=('Onbekend',), other=None, template_cache=None, formatter=None)[broncode]¶

A class representing all the metadata for a book. The various standard metadata fields are available as attributes of this object. You can also stick arbitrary attributes onto this object.

Metadata from custom columns should be accessed via the get() method, passing in the lookup name for the column, for example: “#mytags”.

Use the is_null() method to test if a field is null.

This object also has functions to format fields into strings.

The list of standard metadata fields grows with time is in STANDARD_METADATA_FIELDS.

Please keep the method based API of this class to a minimum. Every method becomes a reserved field name.

is_null(field)[broncode]¶

Return True if the value of field is null in this object. ‘null’ means it is unknown or evaluates to False. So a title of _(‘Unknown’) is null or a language of ‘und’ is null.

Be careful with numeric fields since this will return True for zero as well as None.

Also returns True if the field does not exist.

deepcopy(class_generator=<function Metadata.<lambda>>)[broncode]¶: Do not use this method unless you know what you are doing, if you want to create a simple clone of this object, use deepcopy_metadata() instead. Class_generator must be a function that returns an instance of Metadata or a subclass of it.

get_identifiers()[broncode]¶: Return a copy of the identifiers dictionary. The dict is small, and the penalty for using a reference where a copy is needed is large. Also, we don’t want any manipulations of the returned dict to show up in the book.

set_identifiers(identifiers)[broncode]¶: Set all identifiers. Note that if you previously set ISBN, calling this method will delete it.

set_identifier(typ, val)[broncode]¶: If val is empty, deletes identifier of type typ

standard_field_keys()[broncode]¶: return a list of all possible keys, even if this book doesn’t have them

custom_field_keys()[broncode]¶: return a list of the custom fields in this book

all_field_keys()[broncode]¶: All field keys known by this instance, even if their value is None

metadata_for_field(key)[broncode]¶: return metadata describing a standard or custom field.

all_non_none_fields()[broncode]¶: Return a dictionary containing all non-None metadata fields, including the custom ones.

get_standard_metadata(field, make_copy)[broncode]¶: return field metadata from the field if it is there. Otherwise return None. field is the key name, not the label. Return a copy if requested, just in case the user wants to change values in the dict.

get_all_standard_metadata(make_copy)[broncode]¶: return a dict containing all the standard field metadata associated with the book.

get_all_user_metadata(make_copy)[broncode]¶: return a dict containing all the custom field metadata associated with the book.

get_user_metadata(field, make_copy)[broncode]¶: return field metadata from the object if it is there. Otherwise return None. field is the key name, not the label. Return a copy if requested, just in case the user wants to change values in the dict.

set_all_user_metadata(metadata)[broncode]¶: store custom field metadata into the object. Field is the key name not the label

set_user_metadata(field, metadata)[broncode]¶: store custom field metadata for one column into the object. Field is the key name not the label

remove_stale_user_metadata(other_mi)[broncode]¶: Remove user metadata keys (custom column keys) if they don’t exist in ‘other_mi’, which must be a metadata object

template_to_attribute(other, ops)[broncode]¶: Takes a list [(src,dest), (src,dest)], evaluates the template in the context of other, then copies the result to self[dest]. This is on a best-efforts basis. Some assignments can make no sense.

smart_update(other, replace_metadata=False)[broncode]¶: Merge the information in other into self. In case of conflicts, the information in other takes precedence, unless the information in other is NULL.

format_field(key, series_with_index=True)[broncode]¶: Returns the tuple (display_name, formatted_value)

to_html()[broncode]¶: A HTML representation of this object.

calibre.ebooks.metadata.book.base.STANDARD_METADATA_FIELDS¶: The set of standard metadata fields.

'''
All fields must have a NULL value represented as None for simple types,
an empty list/dictionary for complex types and (None, None) for cover_data
'''

SOCIAL_METADATA_FIELDS = frozenset((
    'tags',             # Ordered list
    'rating',           # A floating point number between 0 and 10
    'comments',         # A simple HTML enabled string
    'series',           # A simple string
    'series_index',     # A floating point number
    # Of the form { scheme1:value1, scheme2:value2}
    # For example: {'isbn':'123456789', 'doi':'xxxx', ... }
    'identifiers',
))

'''
The list of names that convert to identifiers when in get and set.
'''

TOP_LEVEL_IDENTIFIERS = frozenset((
    'isbn',
))

PUBLICATION_METADATA_FIELDS = frozenset((
    'title',            # title must never be None. Should be _('Unknown')
    # Pseudo field that can be set, but if not set is auto generated
    # from title and languages
    'title_sort',
    'authors',          # Ordered list. Must never be None, can be [_('Unknown')]
    'author_sort_map',  # Map of sort strings for each author
    # Pseudo field that can be set, but if not set is auto generated
    # from authors and languages
    'author_sort',
    'book_producer',
    'timestamp',        # Dates and times must be timezone aware
    'pubdate',
    'last_modified',
    'rights',
    # So far only known publication type is periodical:calibre
    # If None, means book
    'publication_type',
    'uuid',             # A UUID usually of type 4
    'languages',        # ordered list of languages in this publication
    'publisher',        # Simple string, no special semantics
    # Absolute path to image file encoded in filesystem_encoding
    'cover',
    # Of the form (format, data) where format is, e.g. 'jpeg', 'png', 'gif'...
    'cover_data',
    # Either thumbnail data, or an object with the attribute
    # image_path which is the path to an image file, encoded
    # in filesystem_encoding
    'thumbnail',
))

BOOK_STRUCTURE_FIELDS = frozenset((
    # These are used by code, Null values are None.
    'toc', 'spine', 'guide', 'manifest',
))

USER_METADATA_FIELDS = frozenset((
    # A dict of dicts similar to field_metadata. Each field description dict
    # also contains a value field with the key #value#.
    'user_metadata',
))

DEVICE_METADATA_FIELDS = frozenset((
    'device_collections',   # Ordered list of strings
    'lpath',                # Unicode, / separated
    'size',                 # In bytes
    'mime',                 # Mimetype of the book file being represented
))

CALIBRE_METADATA_FIELDS = frozenset((
    'application_id',   # An application id, currently set to the db_id.
    'db_id',            # the calibre primary key of the item.
    'formats',          # list of formats (extensions) for this book
    # a dict of user category names, where the value is a list of item names
    # from the book that are in that category
    'user_categories',
    # a dict of items to associated hyperlink
    'link_maps',
))

ALL_METADATA_FIELDS =      SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           USER_METADATA_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS)

# All fields except custom fields
STANDARD_METADATA_FIELDS = SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS)

# Metadata fields that smart update must do special processing to copy.
SC_FIELDS_NOT_COPIED =     frozenset(('title', 'title_sort', 'authors',
                                      'author_sort', 'author_sort_map',
                                      'cover_data', 'tags', 'languages',
                                      'identifiers'))

# Metadata fields that smart update should copy only if the source is not None
SC_FIELDS_COPY_NOT_NULL =  frozenset(('device_collections', 'lpath', 'size', 'comments', 'thumbnail'))

# Metadata fields that smart update should copy without special handling
SC_COPYABLE_FIELDS =       SOCIAL_METADATA_FIELDS.union(
                           PUBLICATION_METADATA_FIELDS).union(
                           BOOK_STRUCTURE_FIELDS).union(
                           DEVICE_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS) - \
                           SC_FIELDS_NOT_COPIED.union(
                           SC_FIELDS_COPY_NOT_NULL)

SERIALIZABLE_FIELDS =      SOCIAL_METADATA_FIELDS.union(
                           USER_METADATA_FIELDS).union(
                           PUBLICATION_METADATA_FIELDS).union(
                           CALIBRE_METADATA_FIELDS).union(
                           DEVICE_METADATA_FIELDS) - \
                           frozenset(('device_collections', 'formats',
                               'cover_data'))
# these are rebuilt when needed