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.

Arithmetic

add(x, y)

class calibre.utils.formatter_functions.BuiltinAdd[Quellcode]

add(x, y) – Gibt x + y zurück. Löst einen Ausnahmefehler aus, falls x und/oder y keine Zahl ist.

divide(x, y)

class calibre.utils.formatter_functions.BuiltinDivide[Quellcode]

divide(x, y) – Gibt x / y zurück. Löst einen Ausnahmefehler aus, falls x und/oder y keine Zahl ist.

multiply(x, y)

class calibre.utils.formatter_functions.BuiltinMultiply[Quellcode]

multiply(x, y) – Gibt x * y zurück. Löst einen Ausnahmefehler aus, falls x und/oder y keine Zahl ist.

subtract(x, y)

class calibre.utils.formatter_functions.BuiltinSubtract[Quellcode]

subtract(x, y) – Gibt x - y zurück. Löst einen Ausnahmefehler aus, falls x und/oder y keine Zahl ist.

Boolean

and(Wert, Wert, …)

class calibre.utils.formatter_functions.BuiltinAnd[Quellcode]

and(Wert, Wert, …) – gibt die Zeichenkette „1“ zurück, falls alle Werte nicht leer sind, andernfalls wird eine leere Zeichenkette zurückgegeben. Diese Funktion arbeitet gut mit den Funktionen „test“ oder „first_non_empty“ zusammen. Sie können so viele Werte wie gewünscht angeben.

not(Wert)

class calibre.utils.formatter_functions.BuiltinNot[Quellcode]

not(Wert) – gibt die Zeichenkette „1“ zurück, falls der Wert leer ist, andernfalls wird eine leere Zeichenkette zurückgegeben. Diese Funktion arbeitet gut mit den Funktionen „test“ oder „first_non_empty“ zusammen.

or(Wert, Wert, …)

class calibre.utils.formatter_functions.BuiltinOr[Quellcode]

or(Wert, Wert, …) – gibt die Zeichenkette „1“ zurück, falls mindestens ein Wert nicht leer ist, andernfalls wird eine leere Zeichenkette zurückgegeben. Diese Funktion arbeitet gut mit den Funktionen „test“ oder „first_non_empty“ zusammen. Sie können so viele Werte wie gewünscht angeben.

Date functions

days_between(Datum1, Datum2)

class calibre.utils.formatter_functions.BuiltinDaysBetween[Quellcode]

days_between(Datum1, Datum2) – gibt die Anzahl der Tage zwischen Datum1 und Datum2 zurück. Die Zahl ist positiv, falls Datum1 größer als Datum2 ist, andernfalls negativ. Falls Datum1 und/oder Datum2 keine Kalenderdaten sind, wird eine leere Zeichenkette zurückgegeben.

today()

class calibre.utils.formatter_functions.BuiltinToday[Quellcode]

today() – gibt eine Datumszeichenkette für den aktuellen Tag zurück. Dieser Wert ist für den Einsatz in den Funktionen „format_date“ oder „days_between“ gedacht, kann aber wie jede andere Zeichenkette verändert werden. Das Datum entspricht dem ISO-Format.

Formatting values

finish_formatting(Wert, Format, Präfix, Suffix)

class calibre.utils.formatter_functions.BuiltinFinishFormatting[Quellcode]

finish_formatting(Wert, Format, Präfix, Suffix) – wendet das Format, den Präfix und den Suffix auf einen Wert in der gleichen Weise an, wie in einer Vorlage wie {series_index:05.2f| - |- }. Beispielsweise bewirkt das folgende Programm die gleiche Ausgabe, wie die obige Vorlage: finish_formatting(field(„series_index“), „05.2f“, “ - „, “ - „)

format_date(Wert, Formatzeichenkette)

class calibre.utils.formatter_functions.BuiltinFormatDate[Quellcode]

format_date(Wert, Formatzeichenkette) - formatiert den Wert, der ein Datum sein muss, entsprechend der Formatzeichenkette. Die Formatierungscodes lauten: d: der Tag als Zahl ohne führende Null (1 bis 31). dd: der Tag als Zahl mit führender Null (01 bis 31). ddd: der abgekürzte, lokalisierte Wochentagsname (z. B. „Mon“ bis „Son“). dddd: der volle, lokalisierte Wochentagsname (z. B.: „Montag“ bis „Sonntag“). M: der Monat als Zahl ohne führende Null (1 bis 12). MM: der Monat als Zahl mit führender Null (01 bis 12). MMM: der abgekürzte, lokalisierte Monatsname (z. B. „Jan“ bis „Dez“). MMMM: der volle, lokalisierte Monatsname (z. B. „Januar“ bis „Dezember“). yy: das Jahr als zweistellige Zahl (00 bis 99). yyyy: das Jahr als vierstellige Zahl. h: die Stunden ohne eine führende Null (0 bis 11 bzw. 0 bis 23, abhängig von am/pm). hh: die Stunden mit einer führenden Null (00 bis 12 bzw. 00 bis 23, abhängig von am/pm). m: die Minuten ohne eine führende Null (0 bis 59). mm: die Minuten mit einer führenden Null (00 bis 59). s: die Sekunden ohne eine führende Null (0 bis 59). ss: die Sekunden mit einer führenden Null (00 bis 59). ap: Verwendung einer 12-Stunden-Uhr anstatt einer 24-Stunden-Uhr, wobei „ap“ durch die lokalisierte Zeichenkette für „am“ oder „pm“ ersetzt wird. AP: Verwendung einer 12-Stunden-Uhr anstatt einer 24-Stunden-Uhr, wobei „AP“ durch die lokalisierte Zeichenkette für „AM“ oder „PM“ ersetzt wird. iso: das Datum mit Uhrzeit und Zeitzone. Muss das einzige angegebene Format sein.

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber[Quellcode]

format_number(v, template) – formatieren Sie die Zahl v mit Hilfe einer Python-Formatierungsvorlage wie „{0:5.2f}“ oder „{0:,d}“ oder „${0:5,.2f}“. Der field_name Teil des Templates muss eine 0 (Null) sein (das „{0:“ in den obigen Beispielen). Weitere Beispiele finden Sie in der Template-Sprache und in der Python-Dokumentation. Sie können das führende „{0:“ und das abschließende „}“ weglassen, wenn das Template nur ein Format enthält. Gibt die leere Zeichenkette zurück, wenn die Formatierung fehlschlägt.

human_readable(w)

class calibre.utils.formatter_functions.BuiltinHumanReadable[Quellcode]

human_readable(w) – gibt eine Zeichenkette zurück, die die Zahl w in KB, MB, GB etc. darstellt.

Get values from metadata

approximate_formats()

class calibre.utils.formatter_functions.BuiltinApproximateFormats[Quellcode]

approximate_formats() – gibt eine kommagetrennte Liste von Formaten zurück, die zu einem bestimmten Zeitpunkt zu dem Buch gehörten. Es existiert keine Garantie, dass diese Liste korrekt ist, wahrscheinlich ist sie es allerdings. Diese Funktion kann im Vorlageprogrammmodus unter Verwendung der Vorlage „{program:‘approximate_formats()‘}“ aufgerufen werden. Beachten Sie, dass Formatnamen immer aus Großbuchstaben bestehen, wie z. B. in „EPUB“. Diese Funktion funktioniert nur in der grafischen Benutzeroberfläche. Falls Sie diese Werte in den Vorlagen für „Exportieren“ oder „Auf Gerät übertragen“ verwenden wollen, müssen eine benutzerdefinierte Spalte des Typs „Aus anderen Spalten aufgebaute Spalte“ erstellen, die Funktion in der Vorlage jener Spalte verwenden, und den Wert jener Spalte in Ihren Vorlagen für „Speichern“ und „Senden“ verwenden.

author_sorts(Wertetrennzeichen)

class calibre.utils.formatter_functions.BuiltinAuthorSorts[Quellcode]

author_sorts(Wertetrennzeichen) – gibt eine Zeichenkette zurück, die eine Liste von Autorensortierungswerten für die Autoren des Buchs enthält. Die Sortierung ist jene in den Autormetadaten (unterscheidet sich von der Autorensortierung in Büchern). Die zurückgegebene Liste besitzt die Form „Autorensortierung1 Wertetrennzeichen Autorensortierung2 …“ Die Autorensortierungswerte in dieser Liste besitzen die gleiche Reihenfolge wie die Autoren des Buches. Falls Sie Leerzeichen um das Wertetrennzeichen herum wollen, so schließen Sie diese in die Trennzeichen-Zeichenkette mit ein.

booksize()

class calibre.utils.formatter_functions.BuiltinBooksize[Quellcode]

booksize() – gibt den Wert des Größenfeldes zurück. Diese Funktion funktioniert nur in der grafischen Benutzeroberfläche. Falls Sie diesen Wert in den Vorlagen für „Exportieren“ oder „Auf Gerät übertragen“ verwenden wollen, müssen eine benutzerdefinierte Spalte des Typs „Aus anderen Spalten aufgebaute Spalte“ erstellen, die Funktion in der Vorlage jener Spalte verwenden, und den Wert jener Spalte in Ihren Vorlagen für „Speichern“ und „Senden“ verwenden.

current_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[Quellcode]

current_library_name() – gibt den letzten Namen im Pfad zur aktuellen Calibre-Bibliothek zurück. Diese Funktion kann im Vorlageprogrammmodus durch Verwendung der Vorlage „{:‘current_library_name()‘}“ aufgerufen werden.

current_library_path()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[Quellcode]

current_library_path() – gibt den Pfad zur aktuellen Calibe-Bibliothek zurück. Diese Funktion kann im Vorlageprogrammmodus durch Verwendung der Vorlage „{:‘current_library_path()‘}“ aufgerufen werden.

field(Name)

class calibre.utils.formatter_functions.BuiltinField[Quellcode]

field(Name) – gibt das durch Name bezeichnete Metadatenfeld zurück.

formats_modtimes(Datumsformat)

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[Quellcode]

formats_modtimes(Datumsformat) – gibt eine kommagetrennte Liste von doppelpunktgetrennten Elementen zurück, welche die Änderungszeitpunkte für die Formate eines Buches darstellen. Der Parameter Datumsformat gibt die Formatierung des Datums an. Siehe die Funktion „format_date“ für Details. Sie können die Funktion „select“ verwenden, um den Änderungszeitpunkt für ein bestimmtes Format zu erhalten. Beachten Sie, dass Formatnamen immer aus Großbuchstaben bestehen, wie z. B. in „EPUB“.

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths[Quellcode]

formats_paths() – gibt eine kommagetrennte Liste von doppelpunktgetrennten Elementen zurück, welche den vollen Pfad zu den Formaten eines Buches darstellen. Sie können die Funktion „select“ verwenden, um den Pfad für ein bestimmtes Format zu erhalten. Beachten Sie, dass Formatnamen immer aus Großbuchstaben bestehen, wie z. B. in „EPUB“.

formats_sizes()

class calibre.utils.formatter_functions.BuiltinFormatsSizes[Quellcode]

formats_sizes() – gibt eine kommagetrennte Liste von doppelpunktgetrennten Elementen zurück, welche die Größen in Bytes der Formate eines Buches darstellen. Sie können die Funktion „select“ verwenden, um die Größe für ein bestimmtes Format zu erhalten. Beachten Sie, dass Formatnamen immer aus Großbuchstaben bestehen, wie z. B. in „EPUB“.

has_cover()

class calibre.utils.formatter_functions.BuiltinHasCover[Quellcode]

has_cover() – gibt „Yes“ zurück, falls das Buch ein Titelbild besitzt, andernfalls wird eine leere Zeichenkette zurückgegeben.

language_codes(Sprachzeichenketten)

class calibre.utils.formatter_functions.BuiltinLanguageCodes[Quellcode]

language_codes(Sprachzeichenketten) – gibt die Sprachcodes für die in Sprachzeichenketten übergebenen Zeichenketten zurück. Die Zeichenketten müssen der Sprache des aktuellen Gebietsschemas entsprechen. Sprachzeichenketten ist eine kommagetrennte Liste.

language_strings(Sprachcodes, lokalisieren)

class calibre.utils.formatter_functions.BuiltinLanguageStrings[Quellcode]

language_strings(Sprachcodes, lokalisieren) – gibt die Zeichenketten für die in Sprachcodes übergebenen Sprachcodes zurück. Falls lokalisieren gleich null ist, werden die Zeichenketten in Englisch zurückgegeben. Falls lokalisieren ungleich null ist, werden die Zeichenketten in der Sprache das aktuellen Gebietsschemas zurückgegeben. Sprachcodes ist eine kommagetrennte Liste.

ondevice()

class calibre.utils.formatter_functions.BuiltinOndevice[Quellcode]

ondevice() – gibt „Yes“ zurück, falls „ondevice“ gesetzt ist, andernfalls wird eine leere Zeichenkette zurückgegeben. Diese Funktion funktioniert nur in der grafischen Benutzeroberfläche. Falls Sie diesen Wert in den Vorlagen für „Exportieren“ oder „Auf Gerät übertragen“ verwenden wollen, müssen eine benutzerdefinierte Spalte des Typs „Aus anderen Spalten aufgebaute Spalte“ erstellen, die Funktion in der Vorlage jener Spalte verwenden, und den Wert jener Spalte in Ihren Vorlagen für „Speichern“ und „Senden“ verwenden.

raw_field(Name)

class calibre.utils.formatter_functions.BuiltinRawField[Quellcode]

raw_field(Name) – gibt das durch Name bezeichnete Metadatenfeld ohne jegliche Formatierung zurück.

raw_list(Name, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinRawList[Quellcode]

raw_list(Name, Trennzeichen) – gibt die durch Name bezeichnete Metadatenliste ohne jegliche Formatierung oder Sortierung zurück. Die einzelnen Elemente werden durch Verwendung des Trennzeichens voneinander getrennt.

series_sort()

class calibre.utils.formatter_functions.BuiltinSeriesSort[Quellcode]

series_sort() – gibt den Seriensortierungswert zurück.

user_categories()

class calibre.utils.formatter_functions.BuiltinUserCategories[Quellcode]

user_categories() – gibt eine kommagetrennte Liste der Benutzerkategorien zurück, die dieses Buch enthalten. Diese Funktion funktioniert nur in der grafischen Benutzeroberfläche. Falls Sie diesen Wert in den Vorlagen für „Exportieren“ oder „Auf Gerät übertragen“ verwenden wollen, müssen eine benutzerdefinierte Spalte des Typs „Aus anderen Spalten aufgebaute Spalte“ erstellen, die Funktion in der Vorlage jener Spalte verwenden, und den Wert jener Spalte in Ihren Vorlagen für „Speichern“ und „Senden“ verwenden.

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[Quellcode]

virtual_libraries() – gibt eine kommagetrennte Liste virtuellen Bibliotheken zurück, die dieses Buch enthalten. Diese Funktion funktioniert nur in der grafischen Benutzeroberfläche. Falls Sie diesen Wert in den Vorlagen für „Exportieren“ oder „Auf Gerät übertragen“ verwenden wollen, müssen eine benutzerdefinierte Spalte des Typs „Aus anderen Spalten aufgebaute Spalte“ erstellen, die Funktion in der Vorlage jener Spalte verwenden, und den Wert jener Spalte in Ihren Vorlagen für „Speichern“ und „Senden“ verwenden.

If-then-else

contains(Wert, Muster, Text_bei_Übereinstimmung, Text_bei_keiner_Übereinstimmung)

class calibre.utils.formatter_functions.BuiltinContains[Quellcode]

contains(Wert, Muster, Text_bei_Übereinstimmung, Text_bei_keiner_Übereinstimmung) – überprüft, ob Wert Übereinstimmungen mit dem regulären Ausdruck Muster enthält. Gibt Text_bei_Übereinstimmung zurück, falls Übereinstimmungen gefunden wurden, andernfalls wird Text_bei_keiner_Übereinstimmung zurückgegeben.

ifempty(Wert, Text_falls_leer)

class calibre.utils.formatter_functions.BuiltinIfempty[Quellcode]

ifempty(Wert, Text_falls_leer) – gibt Wert zurück, falls Wert nicht leer ist, andernfalls wird Text_falls_leer zurückgegeben.

test(Wert, Text_falls_nicht_leer, Text_falls_leer)

class calibre.utils.formatter_functions.BuiltinTest[Quellcode]

test(Wert, Text_falls_nicht_leer, Text_falls_leer) – gibt Text_falls_nicht_leer zurück, falls Wert nicht leer ist, andernfalls Text_falls_leer.

Iterating over values

first_non_empty(Wert, Wert, …)

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[Quellcode]

first_non_empty(Wert, Wert, …) – gibt den ersten nicht leeren Wert zurück. Falls alle Werte leer sind, wird ein leerer Wert zurückgegeben. Sie können so viele Werte wie gewünscht angeben.

lookup(Wert, Muster, Feld, Muster, Feld, …, sonst_Feld)

class calibre.utils.formatter_functions.BuiltinLookup[Quellcode]

lookup(Wert, Muster, Feld, Muster, Feld, …, sonst_Feld) – wie die Funktion „switch“, außer, dass die Argumente Feldnamen (Metadaten) sind, und kein Text. Der Wert des entsprechenden Feldes wird abgerufen und verwendet. Beachten Sie, dass - da zusammengesetzte Spalten Felder sind - Sie diese Funktion in einem zusammengesetzten Feld verwenden können, um den Wert eines anderen zusammengesetzen Feldes zu verwenden. Dies ist äußerst hilfreich bei der Konstruktion von variablen Speicherpfaden.

switch(w, Muster, Wert, Muster, Wert, …, sonst_Wert)

class calibre.utils.formatter_functions.BuiltinSwitch[Quellcode]

switch(w, Muster, Wert, Muster, Wert, …, sonst_Wert) – für jedes Muster, Wert-Paar wird überprüft, ob w dem regulären Ausdruck Muster entspricht, und falls ja, wird der entsprechende Wert zurückgegeben. Falls kein Muster übereinstimmt, wird sonst_Wert zurückgegeben. Sie können so viele Muster, Wert-Paare angeben, wie Sie möchten.

List lookup

identifier_in_list(Wert, ID, gefunden_Wert, nicht_gefunden_Wert)

class calibre.utils.formatter_functions.BuiltinIdentifierInList[Quellcode]

identifier_in_list(Wert, ID, gefunden_Wert, nicht_gefunden_Wert) – behandelt Wert wie eine kommagetrennte Liste von Kennungen und vergleicht die Zeichenkette mit jedem Wert in der Liste. Eine Kennung hat das Format „Kennung:Wert“. Der ID-Parameter sollte entweder das Format „ID“ oder „ID:RegExp“ besitzen. Der erste Fall stimmt überein, falls eine der Kennungen mit dieser ID übereinstimmt. Der zweite Fall stimmt überein, wenn der reguläre Ausdruck (RegExp) mit dem Wert der Kennung übereinstimmt. Im Falle einer Übereinstimmung wird gefunden_Wert zurückgegeben, andernfalls nicht_gefunden_Wert.

in_list(val, separator, pattern, found_val, …, not_found_val)

class calibre.utils.formatter_functions.BuiltinInList[Quellcode]

in_list(val, separator, pattern, found_val, …, not_found_val) – behandelt val als eine Liste von Elementen, die durch ein Trennzeichen getrennt sind, und wertet das Muster gegen jeden Wert in der Liste aus. Wenn das Muster mit einem Wert übereinstimmt, geben Sie found_val zurück, andernfalls not_found_val. Pattern und found_value können beliebig oft wiederholt werden, so dass je nach Suche unterschiedliche Werte zurückgegeben werden können. Die Muster werden der Reihe nach geprüft. Die erste Übereinstimmung wird zurückgegeben.

list_item(Wert, Index, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinListitem[Quellcode]

list_item(Wert, Index, Trennzeichen) – interpretiert den Wert als eine durch Trennzeichen voneinander getrennte Liste von Elementen und gibt das index-te Element zurück. Das erste Element besitzt die Indexnummer null. Das letzte Element kann durch „list_item(-1,`Trennzeichen`)“ zurückgegeben werden. Falls sich das Element nicht in der Liste befindet, wird ein leerer Wert zurückgegeben. Das Trennzeichen hat die gleiche Bedeutung wie in der Funktion „count“.

select(Wert, Schlüssel)

class calibre.utils.formatter_functions.BuiltinSelect[Quellcode]

select(Wert, Schlüssel) – interpretiert den Wert als eine kommagetrennte Liste von Elementen, wobei die Elemente die Form „ID:Wert“ besitzen. Findet das Paar, bei dem die ID gleich dem Schlüssel ist, und gibt den entsprechenden Wert zurück.

str_in_list(val, separator, string, found_val, …, not_found_val)

class calibre.utils.formatter_functions.BuiltinStrInList[Quellcode]

str_in_list(val, separator, string, found_val, …, not_found_val) – behandelt val als eine Liste von Elementen, die durch ein Trennzeichen getrennt sind und vergleicht die Zeichenkette mit jedem Wert in der Liste. Wenn die Zeichenkette mit einem Wert übereinstimmt (Groß-/Kleinschreibung wird ignoriert), geben Sie found_val zurück, andernfalls not_found_val. Wenn der String Trennzeichen enthält, dann wird er auch als Liste behandelt und jeder Wert wird geprüft. Der String und found_value können beliebig oft wiederholt werden, so dass je nach Suche unterschiedliche Werte zurückgegeben werden können. Die Zeichenketten werden nacheinander geprüft. Die erste Übereinstimmung wird zurückgegeben.

List manipulation

count(Wert, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinCount[Quellcode]

count(Wert, Trennzeichen) – interpretiert den Wert als eine durch Trennzeichen voneinander getrennte Liste von Elementen und gibt die Anzahl der Elemente in der Liste zurück. Die meisten Listen verwenden ein Komma als Trennzeichen, aber „Autoren“ verwendet ein Et-Zeichen („&“). Beispiele: {tags:count(,)}, {authors:count(&)}

list_difference(Liste1, Liste2, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinListDifference[Quellcode]

list_difference(Liste1, Liste2, Trennzeichen) – gibt eine Liste zurück, die durch Entfernen jedes Elements von Liste1, das in Liste2 gefunden wird, unter Verwendung eines von Groß-/Kleinschreibung unabhängigen Vergleichs erstellt wird. Die Elemente in Liste1 und Liste2 werden durch Trennzeichen voneinander getrennt, ebenso wie die Elemente der zurückgegebenen Liste.

list_equals(Liste1, Trennzeichen1, Liste2, Trennzeichen2, ja_Wert, nein_Wert)

class calibre.utils.formatter_functions.BuiltinListEquals[Quellcode]

list_equals(Liste1, Trennzeichen1, Liste2, Trennzeichen2, ja_Wert, nein_Wert) – gibt ja_Wert zurück, falls Liste1 und Liste2 die gleichen Elemente enthalten, andernfalls wird nein_Wert zurückgegeben. Die Elemente werden durch Aufteilen jeder Liste unter Verwendung des entsprechenden Trennzeichens (Trennzeichen1 oder Trennzeichen2) bestimmt. Die Reihenfolge der Elemente in den Listen ist dabei irrelevant. Der Vergleich ignoriert die Groß-/Kleinschreibung.

list_intersection(Liste1, Liste2, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinListIntersection[Quellcode]

list_intersection(Liste1, Liste2, Trennzeichen) – gibt eine Liste zurück, die durch Entfernen jedes Elements von Liste1, das in Liste2 nicht gefunden wird, unter Verwendung eines von Groß-/Kleinschreibung unabhängigen Vergleichs erstellt wird. Die Elemente in Liste1 und Liste2 werden durch Trennzeichen voneinander getrennt, ebenso wie die Elemente der zurückgegebenen Liste.

list_re(Quellliste, Trennzeichen, einschließen_RegExp, optional_ersetzen)

class calibre.utils.formatter_functions.BuiltinListRe[Quellcode]

list_re(Quellliste, Trennzeichen, einschließen_RegExp, optional_ersetzen) – Erstellt eine Liste, indem zuerst Quellliste in einzelnen Elemente unter Verwendung des Trennzeichens voneinander getrennt wird. Für jedes Element in der Liste wird überprüft, ob es dem regulären Ausdruck einschließen_RegExp entspricht. Falls es dies tut, wird es zur zurückzugebenden Liste hinzugefügt. Falls optional_ersetzen keine leere Zeichenkette ist, wird das Ersetzen durchgeführt, bevor das Element zur zurückgegebenen Liste hinzugefügt wird.

list_re_group(Quellliste, Trennzeichen, einschließen_RegExp, suchen_RegExp, Gruppe1_Vorlage, …)

class calibre.utils.formatter_functions.BuiltinListReGroup[Quellcode]

list_re_group(Quellliste, Trennzeichen, einschließen_RegExp, suchen_RegExp, Gruppe1_Vorlage, …) – Wie die Funktion „list_re“, nur sind hier Ersetzungen nicht optional. Die Funktion verwendet „re_group(Listenelement, suchen_RegExp, Gruppe1_Vorlage, …)“ beim Ersetzen auf der resultierenden Liste.

list_sort(Liste, Richtung, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinListSort[Quellcode]

list_sort(Liste, Richtung, Trennzeichen) – gibt Liste in ohne Berücksichtigung von Groß-/Kleinschreibung sortierter Form zurück. Falls Richtung null ist, wird die Liste aufsteigend sortiert, andernfalls absteigend. Die Listenelemente werden durch Trennzeichen voneinander getrennt, ebenso wie die Elemente der zurückgegebenen Liste.

list_union(Liste1, Liste2, Trennzeichen)

class calibre.utils.formatter_functions.BuiltinListUnion[Quellcode]

list_union(Liste1, Liste2, Trennzeichen) – gibt eine Liste zurück, die durch Zusammenführen der Elemente aus Liste1 und Liste2 erstellt wird, wobei Elementduplikate durch einen von Groß-/Kleinschreibung unabhängigen Vergleich entfernt werden. Falls sich Elemente in der Groß-/Kleinschreibung unterscheiden, wird das Element aus Liste1 verwendet. Die Elemente in Liste1 und Liste2 werden durch Trennzeichen voneinander getrennt, ebenso wie die Elemente der zurückgegebenen Liste.

subitems(Wert, Startindex, Endindex)

class calibre.utils.formatter_functions.BuiltinSubitems[Quellcode]

subitems(Wert, Startindex, Endindex) – Diese Funktion wird zum Aufteilen von Elementelisten, wie z. B. Genres verwendet. Sie interpretiert den Wert als eine kommagetrennte Liste von Elementen, wobei jedes Element eine punktgetrennte Liste darstellt. Es wird eine neue Liste zurückgegeben, die dadurch erstellt wird, dass zuerst alle punktgetrennten Elemente gesucht, für jedes so gefundene Element dessen Bestandteile von Startindex bis Endindex extrahiert, und dann die Ergebnisse wieder zusammengesetzt werden. Der erste Bestandteil einer punktgetrennten Liste besitzt die Indexnummer null. Falls ein Index negativ ist, wird vom Ende der Liste her gezählt. Einen Sonderfall stellt ein Endindex von null dar; dieser wird als die Länge der Liste interpretiert. Beispiele bei Verwenden des einfachen Vorlagemodus und unter der Annahme eines „#genre“-Werts von „A.B.C“: {#genre:subitems(0,1)} gibt „A“ zurück. {#genre:subitems(0,2)} gibt „A.B“ zurück. {#genre:subitems(1,0)} gibt „B.C“ zurück. Unter Annahme eines „#genre“-Werts von „A.B.C, D.E.F“: {#genre:subitems(0,1)} gibt „A, D“ zurück. {#genre:subitems(0,2)} gibt „A.B, D.E“ zurück.

sublist(val, start_index, end_index, separator)

class calibre.utils.formatter_functions.BuiltinSublist[Quellcode]

sublist(val, start_index, end_index, separator) – interpretiert den Wert als eine Liste von Elementen, getrennt durch ein separator (Trennzeichen). Gibt eine neue Liste, erstellt aus dem start_index zum end_index Element aus. Das erste Element hat die Zahl Null. Wenn eine Index negativ ist, dann zählt er vom Ende der Liste. Im Sonderfall, wenn end_index Null ist, wird es als Länge der Liste angenommen. Beispielsweise verwenden wir ein Basis-Template Modus und nehmen an, dass die Schlagwörter-Spalte (die durch Kommata getrennt ist) „A, B, C“: {tags:sublist(0,1,\,)} gibt „A“. {tags:sublist(-1,0,\,)} gibt „C“. {tags:sublist(0,-1,\,)} gibt „A, B“ aus.

Other

assign(ID, Wert)

class calibre.utils.formatter_functions.BuiltinAssign[Quellcode]

assign(ID, Wert) – weist Wert der ID zu und gibt dann Wert zurück. ID muss eine Kennung sein, kein Ausdruck.

Recursion

eval(Vorlage)

class calibre.utils.formatter_functions.BuiltinEval[Quellcode]

eval(Vorlage) - wertet die Vorlage aus und gibt die lokalen Variablen (jene, die mittels der Funktion „assign“ zugewiesen wurden) anstelle der Buchmetadaten weiter. Dies erlaubt die Verwendung des Vorlagenprozessors zum Erstellen komplexer Ergebnisse aus lokalen Variablen. Da die „{„- und „}“-Zeichen Spezialfälle sind, müssen Sie „[[“ für „{“ und „]]“ für „}“ verwenden; diese werden automatisch umgewandelt. Beachten Sie, dass Präfixe und Suffixe (der Syntax |prefix|suffix) nicht innerhalb des Arguments dieser Funktion verwendet werden können, wenn der Vorlageprogrammmodus benutzt wird.

template(x)

class calibre.utils.formatter_functions.BuiltinTemplate[Quellcode]

template(x) – wertet x als eine Vorlage aus. Die Auswertung findet in ihrem eigenen Kontext statt, das heißt, dass Variablen nicht zwischen dem Aufrufer und der Vorlagenauswertung geteilt werden. Da die „{„- und „}“-Zeichen Spezialfälle sind, müssen Sie „[[“ für „{“ und „]]“ für „}“ verwenden; diese werden automatisch umgewandelt. Zum Beispiel: template(‚[[title_sort]]‘) wertet die Vorlage „{title_sort}“ aus und gibt deren Wert zurück. Beachten Sie, dass Präfixe und Suffixe (der Syntax |prefix|suffix) nicht innerhalb des Arguments dieser Funktion verwendet werden können, wenn der Vorlageprogrammmodus benutzt wird.

Relational

cmp(x, y, kleiner_als, gleich, größer_als)

class calibre.utils.formatter_functions.BuiltinCmp[Quellcode]

cmp(x, y, kleiner_als, gleich, größer_als) – vergleicht x und y nach deren Konvertierung in Zahlenwerte. Gibt kleiner_als zurück, wenn x < y. Gibt gleich zurück, wenn x == y. Andernfalls wird größer_als zurückgegeben.

first_matching_cmp(Wert, Vergleichswert1, Ergebnis1, Vergleichswert2, Ergebnis2, …, sonst_Ergebnis)

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[Quellcode]

first_matching_cmp(Wert, Vergleichswert1, Ergebnis1, Vergleichswert2, Ergebnis2, …, sonst_Ergebnis) – vergleicht nacheinander Wert < VergleichswertN und gibt für den ersten erfolgreichen Vergleich ErgebnisN zurück. Falls kein Vergleich erfolgreich ist, wird sonst_Ergebnis zurückgegeben. Beispiel: first_matching_cmp(10,5,“klein“,10,“mittel“,15,“groß“,“riesig“) gibt „groß“ zurück. Das gleiche Beispiel mit einem ersten Wert von 16 gibt „riesig“ zurück.

strcmp(x, y, kleiner_als, gleich, größer_als)

class calibre.utils.formatter_functions.BuiltinStrcmp[Quellcode]

strcmp(x, y, kleiner_als, gleich, größer_als) – führt einen Vergleich der Zeichenketten x und y ohne Berücksichtigung von Groß-/Kleinschreibung durch. Gibt kleiner_als zurück, wenn x < y Gibt gleich zurück, wenn x == y. Andernfalls wird größer_als zurückgegeben.

String case changes

capitalize(Wert)

class calibre.utils.formatter_functions.BuiltinCapitalize[Quellcode]

capitalize(Wert) – gibt Wert mit großen Anfangsbuchstaben zurück.

lowercase(Wert)

class calibre.utils.formatter_functions.BuiltinLowercase[Quellcode]

lowercase(Wert) – gibt Wert in Kleinbuchstaben zurück.

titlecase(Wert)

class calibre.utils.formatter_functions.BuiltinTitlecase[Quellcode]

titlecase(Wert) – gibt Wert in Überschriftenschreibweise zurück.

uppercase(Wert)

class calibre.utils.formatter_functions.BuiltinUppercase[Quellcode]

uppercase(Wert) – gibt Wert in Großbuchstaben zurück.

String manipulation

re(Wert, Muster, Ersatz)

class calibre.utils.formatter_functions.BuiltinRe[Quellcode]

re(Wert, Muster, Ersatz) – gibt Wert nach Anwenden des regulären Ausdrucks zurück. Alle Fälle von Muster werden mit Ersatz ersetzt. Wie überall in Calibre sind dies zu Python kompatible reguläre Ausdrücke.

re_group(Wert, Muster, Vorlage_für_Gruppe_1, für_Gruppe_2, …)

class calibre.utils.formatter_functions.BuiltinReGroup[Quellcode]

re_group(Wert, Muster, Vorlage_für_Gruppe_1, für_Gruppe_2, …) – gibt eine Zeichenkette zurück, die erstellt wird durch Anwenden eines Regulären-Ausdrucks-Musters auf Wert, und Ersetzen jedes übereinstimmenden Falls mit der berechneten Zeichenkette durch Ersetzen jeder übereinstimmenden Gruppe durch den von der entsprechenden Vorlage zurückgegebenen Wert. Der ursprüngliche übereinstimmende Wert für die Gruppe ist als $ verfügbar. Im Vorlageprogrammmodus, wie z. B. für die Funktionen „template“ und „eval“, verwenden Sie „[[“ für „{“ und „]]“ für „}“. Das folgende Beispiel im Vorlageprogrammmodus sucht nach Serien mit mehr als einem Wort und gibt das erste Wort in Großbuchstaben zurück: {series:‘re_group($, „(S* )(.*)“, „[[$:uppercase()]]“, „[[$]]“)‘}

strcat(a, b, …)

class calibre.utils.formatter_functions.BuiltinStrcat[Quellcode]

strcat(a, b, …) – kann eine beliebige Anzahl von Argumenten verarbeiten. Gibt eine Zeichenkette zurück, die durch Verkettung aller Argumente gebildet wird.

strcat_max(Max, Zeichenkette1, Präfix2, Zeichenkette2, …)

class calibre.utils.formatter_functions.BuiltinStrcatMax[Quellcode]

strcat_max(Max, Zeichenkette1, Präfix2, Zeichenkette2, …) – gibt eine Zeichenkette zurück, die durch Aneinanderhängen der Argumente gebildet wird. Der zurückgegebene Wert wird mit Zeichenkette1 initialisiert. Präfix, Zeichenkette-Paare werden an das Ende der Zeichenkette angehängt, solange die resultierende Zeichenkette kürzer als Max ist. Zeichenkette1 wird auch dann zurückgegeben, falls Zeichenkette1 länger als Max ist. Sie können so viele Präfix, Zeichenkette-Paare angeben, wie Sie möchten.

strlen(a)

class calibre.utils.formatter_functions.BuiltinStrlen[Quellcode]

strlen(a) – Gibt die Länge der als Argument übergebenen Zeichenkette zurück.

substr(Zeichenkette, Start, Ende)

class calibre.utils.formatter_functions.BuiltinSubstr[Quellcode]

substr(Zeichenkette, Start, Ende) – gibt die Zeichen an den Positionen Start bis Ende der Zeichenkette zurück. Das erste Zeichen der Zeichenkette ist das nullte Zeichen. Falls Ende ein negativer Wert ist, werden die Zeichen entsprechend von rechts gezählt. Falls Ende null ist, steht dies für das letzte Zeichen. Zum Beispiel gibt substr(‚12345‘, 1, 0) „2345“, und substr(‚12345‘, 1, -1) „234“ zurück.

swap_around_comma(Wert)

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[Quellcode]

swap_around_comma(Wert) – gibt bei einem gegebenen Wert der Form „B, A“, „A B“ zurück. Dies ist am hilfreichsten, um Namen im Format „Nachname, Vorname“ in „Vorname Nachname“ umzuwandeln. Falls kein Komma existiert, gibt die Funktion Wert unverändert zurück.

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate[Quellcode]

transliterate(a) – gibt eine Zeichenkette in einem lateinischen Alphabet zurück, gebildet durch Annähern des Klangs der Wörter in der Quellzeichenkette a. Falls beispielsweise die Quelle „Фёдор Миха́йлович Достоевский“ ist, gibt die Funktion „Fiodor Mikhailovich Dostoievskii“ zurück.

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=(u'Unbekannt', ), other=None, template_cache=None, formatter=None)[Quellcode]

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)[Quellcode]

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 <lambda>>)[Quellcode]

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()[Quellcode]

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)[Quellcode]

Set all identifiers. Note that if you previously set ISBN, calling this method will delete it.

set_identifier(typ, val)[Quellcode]

If val is empty, deletes identifier of type typ

standard_field_keys()[Quellcode]

return a list of all possible keys, even if this book doesn’t have them

custom_field_keys()[Quellcode]

return a list of the custom fields in this book

all_field_keys()[Quellcode]

All field keys known by this instance, even if their value is None

metadata_for_field(key)[Quellcode]

return metadata describing a standard or custom field.

all_non_none_fields()[Quellcode]

Return a dictionary containing all non-None metadata fields, including the custom ones.

get_standard_metadata(field, make_copy)[Quellcode]

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)[Quellcode]

return a dict containing all the standard field metadata associated with the book.

get_all_user_metadata(make_copy)[Quellcode]

return a dict containing all the custom field metadata associated with the book.

get_user_metadata(field, make_copy)[Quellcode]

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)[Quellcode]

store custom field metadata into the object. Field is the key name not the label

set_user_metadata(field, metadata)[Quellcode]

store custom field metadata for one column into the object. Field is the key name not the label

template_to_attribute(other, ops)[Quellcode]

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)[Quellcode]

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)[Quellcode]

Returns the tuple (display_name, formatted_value)

to_html()[Quellcode]

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, for 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 author to an associated hyperlink
    'author_link_map',

    ]
)

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