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[source]

add(x [, y]*) – återger summan av sina argument. Ger ett undantag om ett argument inte är ett tal. Denna funktion kan ofta ersättas med +-operatören.

ceiling(x)

class calibre.utils.formatter_functions.BuiltinCeiling[source]

ceiling(x) – återger det minsta heltalet större än eller lika med x. Ger ett undantag om x inte är ett tal.

divide(x, y)

class calibre.utils.formatter_functions.BuiltinDivide[source]

divide(x, y) – returns x / y. Ger ett undantag om antingen x eller y inte är siffror. Denna funktion kan ofta ersättas med operatören /.

floor(x)

class calibre.utils.formatter_functions.BuiltinFloor[source]

floor(x) – återger det största heltalet mindre än eller lika med x. Ger ett undantag om x inte är ett tal.

fractional_part(x)

class calibre.utils.formatter_functions.BuiltinFractionalPart[source]

fractional_part(x) – återger värdet efter decimalpunkten. Till exempel fractional_part(3.14) återger 0.14. Ger ett undantag om x inte är ett tal.

mod(x)

class calibre.utils.formatter_functions.BuiltinMod[source]

mod(x) – återges floor(remainder of x / y). Kasta ett undantag om antingen x eller y inte är ett nummer.

multiply(x [, y]*)

class calibre.utils.formatter_functions.BuiltinMultiply[source]

multiply(x [, y]*) – återger produkten av sina argument. Ger ett undantag om något argument inte är ett tal. Denna funktion kan ofta ersättas med operatören *.

round(x)

class calibre.utils.formatter_functions.BuiltinRound[source]

round(x) – återger närmaste heltal till x. Ger ett undantag om x inte är ett tal.

subtract(x, y)

class calibre.utils.formatter_functions.BuiltinSubtract[source]

subtract(x, y) – återger x - y. Ger ett undantag om antingen x eller y inte är siffror. Denna funktion kan ofta ersättas med operatören -.

Boolean

and(value [, value]*)

class calibre.utils.formatter_functions.BuiltinAnd[source]

and(value [, value]*) – återger strängen ”1” om alla värden inte är tomma, annars återges den tomma strängen. Denna funktion fungerar bra med test eller first_non_empty. Du kan ha så många värden som du vill. I många fall kan &&-operatören ersätta denna funktion.

not (värde)

class calibre.utils.formatter_functions.BuiltinNot[source]

not (värde) - återger strängen ”1” om värdet är tomt, annars återges en tom sträng. Denna funktion fungerar bra med test eller first_non_empty. I många fall kan operatören ! ersätta denna funktion.

or(value [, value]*)

class calibre.utils.formatter_functions.BuiltinOr[source]

or(value [, value]*) – återger strängen ”1” om något värde inte är tomt, annars återges en tom sträng. Denna funktion fungerar bra med test eller first_non_empty. Du kan ha så många värden som du vill. I många fall kan operatören || ersätta denna funktion.

Date functions

date_arithmetic(date, calc_spec, fmt)

class calibre.utils.formatter_functions.BuiltinDateArithmetic[source]

date_arithmetic(date, calc_spec, fmt) – Calculate a new date from ’date’ using ’calc_spec’. Return the new date formatted according to optional ’fmt’: if not supplied then the result will be in iso format. The calc_spec is a string formed by concatenating pairs of ’vW’ (valueWhat) where ’v’ is a possibly-negative number and W is one of the following letters: s: add ’v’ seconds to ’date’ m: add ’v’ minutes to ’date’ h: add ’v’ hours to ’date’ d: add ’v’ days to ’date’ w: add ’v’ weeks to ’date’ y: add ’v’ years to ’date’, where a year is 365 days. Example: ’1s3d-1m’ will add 1 second, add 3 days, and subtract 1 minute from ’date’.

days_between(date1, date2)

class calibre.utils.formatter_functions.BuiltinDaysBetween[source]

days_between(date1, date2) – återger antalet dagar mellan date1 och date2. Numret är positivt om date1 är större än date2, annars negativ. Om någon date1 eller date2 inte är datum, återger funktionen tomma strängen.

today()

class calibre.utils.formatter_functions.BuiltinToday[source]

today() – återger en datumsträng för idag. Detta värde är avsedd för användning i format_date eller days_between, men kan manipuleras som alla andra strängen. Datumet är i ISO format.

Formatting values

finish_formatting(val, fmt, prefix, suffix)

class calibre.utils.formatter_functions.BuiltinFinishFormatting[source]

finish_formatting(val, fmt, prefix, suffix) – tillämpa formatet, prefix och suffix till ett värde på samma sätt som görs i en mall som {series_index: 05.2f | - | -}. Till exempel ger följande program samma resultat som ovanstående mall: program: finish_formatting(field(”series_index”), ”05.2f”, ” - ”, ” - ”)

format_date(val, format_string)

class calibre.utils.formatter_functions.BuiltinFormatDate[source]

format_date(val, format_string) – formaterar värdet, som måste vara ett datum, genom att använda format_string återges en sträng. Formateringskoderna är: d : dagen som tal utan en inledande nolla (1 till 31) dd: dagen som tal med en inledande nolla (01 till 31) ddd : det förkortade lokaliserade dagnamnet (t.ex. ”mån” till ”sön”). dddd : det långa lokaliserade dagnamnet (t.ex. ”måndag” till ”söndag”). M: månaden som tal utan en inledande nolla (1 till 12). MM: månaden som tal med en inledande nolla (01 till 12) MMM : den förkortade lokaliserade månadens namn (t.ex. ”jan” till ”dec”). MMMM : den långa lokaliserade månadens namn (t.ex. ”januari” till ”december”). yy: året som två siffror (00 till 99). yyyy : året som fyrsiffrigt nummer. h: timmarna utan en inledande 0 (0 till 11 eller 0 till 23, beroende på am/pm) hh: timmarna med en inledande 0 (00 till 11 eller 00 till 23, beroende på am/pm) m: protokollet en utan inledande 0 (0 till 59) mm: minuterna med en inledande 0 (00 till 59) s: sekunderna utan en inledande 0 (0 till 59) ss: sekunderna med en inledande 0 (00 till 59) ap: använd en 12-timmars klocka istället för en 24-timmars klocka, med ”ap” ersatt med den lokaliserade strängen för am eller pm ap: använd en 12-timmars klocka istället för en 24-timmars klocka, med ”ap” ersatt av den lokaliserade strängen för am eller pm iso: datumet med tid och tidszon. Måste vara det enda närvarande formatet to_number: datumet som ett flyttalsnummer from_number[:fmt]: formatera tidsstämpeln med hjälp av fmt om det finns i annat fall iso

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber[source]

format_number(v, template) – format numret v med hjälp av en Python-formateringsmall som ”{0:5.2f}” eller ”{0:,d}” eller ”${0:5,.2f}”. field_name del av mallen ska vara en 0 (noll) ( ”{0:” i exemplen ovan). Se språkmallen och Python-dokumentationen för fler exempel. Du kan lämna den ledande ”{0:” och efterföljande ”}” om mallen innehåller ett format. Återger tom sträng om formatering misslyckas.

human_readable(v)

class calibre.utils.formatter_functions.BuiltinHumanReadable[source]

human_readable(v) - återger en sträng som representerar antalet v i KB, MB, GB o.s.v.

rating_to_stars(value, use_half_stars)

class calibre.utils.formatter_functions.BuiltinRatingToStars[source]

rating_to_stars(value, use_half_stars) – Återger betygsättningen som sträng av stjärntecken. Värdet är ett tal mellan 0 och 5. Ställ in use_half_stars till 1 om du vill ha halvstjärntecken för anpassade betygskolumner som stöder icke-heltalsklassificering, till exempel 2.5.

Get values from metadata

annotation_count()

class calibre.utils.formatter_functions.BuiltinAnnotationCount[source]

annotation_count() – återge det totala antalet noteringar av alla typer som bifogas den aktuella boken. Den här funktionen fungerar bara i det grafiska gränssnittet.

approximate_formats()

class calibre.utils.formatter_functions.BuiltinApproximateFormats[source]

approximate_formats() – återger en kommaseparerad lista över format som vid ett tillfälle var i samband med boken. Det finns ingen garanti för att denna lista är korrekt, även om den antagligen är det. Denna funktion kan anropas i mallprogramläge med mallen ”{:’approximate_formats()’}”. Observera att formatnamnen alltid är versaler, som i EPUB. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda dessa värden på spara-till-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använda den kolumnens värde i din spar/skicka mallar

author_sorts(val_separator)

class calibre.utils.formatter_functions.BuiltinAuthorSorts[source]

author_sorts(val_separator) – återger en sträng med en lista med författarens sorteringsvärden för författarna till boken. Sorteringen är ett i författarens metadata (som skiljer sig från den author_sort i böcker). Den återgivna listan har formen författaren sorterings 1 val_separator författare sort 2 o.s.v. Författaren sortera värdena i denna lista är i samma ordning som författarna till boken. Om du vill ha utrymmen runt val_separator sedan inkludera dem i avskiljarsträngen

booksize()

class calibre.utils.formatter_functions.BuiltinBooksize[source]

booksize() – återger värdet av storleken fältet. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda detta värde i Save-to-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använda den kolumnens värde i din spara/skicka mallar

connected_device_name(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceName[source]

connected_device_name(storage_location) – om en enhet är ansluten, återge enhetsnamnet, annars återge den tomma strängen. Varje lagringsplats på en enhet kan ha olika namn. Platsnamnen är ”main”, ”carda” och ”cardb”. Den här funktionen fungerar bara i det grafiska gränssnittet.

connected_device_uuid(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceUUID[source]

connected_device_uuid(storage_location) – om en enhet är ansluten, återge enhetens uuid (unikt id), annars återge den tomma strängen. Varje lagringsplats på en enhet har olika hjälpmedel. Platsnamnen är ”main”, ”carda” och ”cardb”. Denna funktion fungerar endast i det grafiska gränssnittet.

current_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[source]

current_library_name() – återger efternamnet på sökvägen till den nuvarande calibre-biblioteket. Denna funktion kan anropas i mallprogrammeringsläget genom att använda mallen ”{:’current_library_name()’}”.

current_library_path ()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[source]

current_library_path () – återger sökvägen till det aktuella calibre-biblioteket. Denna funktion kan anropas i mallens programmeringsläge genom att använda mallen ”{:’current_library_path ()’}”.

field(lookup_name)

class calibre.utils.formatter_functions.BuiltinField[source]

field(lookup_name) – återger metadatafält med namnet efter lookup_name

formats_modtimes(date_format)

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[source]

formats_modtimes(date_format) – återger en kommaseparerad lista över kolonseparerade post som representerar modifieringstider för formaten i en bok. Den date_format parametern anger hur datumet ska formateras. Se date_format funktionen för detaljer. Du kan använda funktionen för val för att få modifieringstider för ett visst format. Observera att formatnamn är alltid versaler, som i EPUB.

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths[source]

formats_paths() – återger en kommaseparerad lista över kolonseparerade poster som representerar fullständig sökväg till formaten i en bok. Du kan använda markeringsfunktionen för att få sökvägen för ett visst format. Observera att formatnamnen alltid är i versaler, som i EPUB.

formats_sizes()

class calibre.utils.formatter_functions.BuiltinFormatsSizes[source]

formats_sizes() – återger en kommaseparerad lista över kolonseparerade poster som representerar storlekar i oktetter av formaten i en bok. Du kan använda select-funktionen för att få storleken för ett visst format. Observera att formatnamn är alltid versaler, som i EPUB.

has_cover ()

class calibre.utils.formatter_functions.BuiltinHasCover[source]

has_cover () - återge Ja om boken har ett omslag, annars återge den tomma strängen

is_marked()

class calibre.utils.formatter_functions.BuiltinIsMarked[source]

is_marked() – kontrollera om boken är ’marked’ i calibre. Om det är så återges värdet på markeringen, antingen ’true’ eller den kommaseparerade listan med namngivna markeringar. återger ’’ om boken inte är markerad.

language_codes(lang_strings)

class calibre.utils.formatter_functions.BuiltinLanguageCodes[source]

language_codes(lang_strings) – återger språkkoderna för strängarna som finns i lang_strings. Strängarna ska vara på samma språk som den aktuella platsen. Lang_strings är en kommaseparerad lista.

language_strings(lang_codes, localize)

class calibre.utils.formatter_functions.BuiltinLanguageStrings[source]

language_strings(lang_codes, localize) – återger strängarna för språkkoder som finns i lang_codes. Om lokalisera är noll, återges strängarna på engelska. Om lokalisera inte är noll, återges strängarna tillbaka på språket på den aktuella platsen. Lang_codes är en kommaseparerad lista.

ondevice()

class calibre.utils.formatter_functions.BuiltinOndevice[source]

ondevice() – återge Ja om ondevice är inställt, annars återges den tomma strängen. Den här funktionen fungerar bara i grafiska gränssnittet. Om du vill använda detta värde i Save-to-disk eller skicka-till-enhet-mallar måste du göra en egen ”kolumn byggd från andra kolumner”, använder du funktionen i kolumnmallen och använder den kolumnen värde i din spara/skicka mallar

raw_field(lookup_name [, optional_default])

class calibre.utils.formatter_functions.BuiltinRawField[source]

raw_field(lookup_name [, optional_default]) – återger metadatafältet med lookup_name utan att använda någon formatering. Det utvärderar och återger det valfria andra argumentet ’default’ om fältet är odefinierat (’None’).

raw_list(lookup_name, separator)

class calibre.utils.formatter_functions.BuiltinRawList[source]

raw_list(lookup_name, separator) – återger metadatalistan namngiven av lookup_name utan att använda någon formatering eller sortering och med poster avskiljda med avskiljare.

series_sort()

class calibre.utils.formatter_functions.BuiltinSeriesSort[source]

series_sort() – återge seriesorteringsvärde

user_categories()

class calibre.utils.formatter_functions.BuiltinUserCategories[source]

user_categories() – återger en kommaseparerad lista över de användarkategorier som den här boken innehåller. Den här funktionen fungerar endast i det grafiska gränssnittet. Om du vill använda dessa värden i mallarna save-to-disk eller send-to-device måste du skapa en anpassad ”kolumn byggd från andra kolumner”, använd funktionen i den kolumnens mall och använda kolumnens värde i dina spara/skicka mallar

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[source]

virtual_libraries() – återger en kommaseparerad lista över virtuella bibliotek som innehåller den här boken. Den här funktionen fungerar bara i det grafiska gränssnittet. Om du vill använda dessa värden i mallarna spara-till-disk eller skicka-till-enhet måste du göra en anpassad ”Kolumn byggd från andra kolumner”, använda funktionen i kolumnens mall och använda den kolumnens värde i dina spara/skicka mallar

If-then-else

check_yes_no(field_name, is_undefined, is_false, is_true)

class calibre.utils.formatter_functions.BuiltinCheckYesNo[source]

check_yes_no(field_name, is_undefined, is_false, is_true) – kontrollerar värdet på fältet ja/nej som heter genom sökningsnyckelens field_name för ett värde som anges av parametrarna, återger ”ja” om en matchning hittas, annars återges en tom sträng. Ställ in parametern is_undefined, is_false eller is_true till 1 (numret) för att kontrollera det villkoret, annars ställ in på 0. Exempel: check_yes_no(”# bool”, 1, 0, 1) återger ”ja” om fältet ja/nej ”#bool” är antingen odefinierad (varken sant eller falskt) eller sant. Mer än en av is_undefined, is_false eller is_true kan ställas in på 1. Den här funktionen används vanligtvis av funktionerna test() eller is_empty().

contains(val, pattern, text if match, text if not match)

class calibre.utils.formatter_functions.BuiltinContains[source]

contains(val, pattern, text if match, text if not match) – kontrollerar om val innehåller träffar för det reguljära uttrycket pattern ”mönster”. Återger text if match (”text om matchning”) om träffar hittas annars återges text if no match (”text om ingen matchning”)

field_exists(field_name)

class calibre.utils.formatter_functions.BuiltinFieldExists[source]

field_exists(field_name) – kontrollerar om ett fält (kolumn) med namnet field_name finns, återger ”1” om så är fallet och ”” om inte.

ifempty(val, text if empty)

class calibre.utils.formatter_functions.BuiltinIfempty[source]

ifempty(val, text if empty) – återger val om val inte är tom, annars återge text if empty

test(val, text if not empty, text if empty)

class calibre.utils.formatter_functions.BuiltinTest[source]

test(val, text if not empty, text if empty) – återger text if empty om val inte är tomt, annars återges text if empty

Iterating over values

first_non_empty(value [, value]*)

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[source]

first_non_empty(value [, value]*) – återger det första värdet som inte är tomt. Om alla värden är tomma, då återges den tomma strängen. Du kan ha så många värden som du vill.

lookup(val, [pattern, field,]+ else_field)

class calibre.utils.formatter_functions.BuiltinLookup[source]

lookup(val, [pattern, field,]+ else_field) – som switch, förutom argumenten fält (metadata) namn, inte text. Värdet på lämpligt fält kommer att hämtas och användas. Observera att eftersom sammansatta kolumner är fält, kan du använda denna funktion i ett sammansatt fält och använda värdet av vissa andra sammansatta fältet. Detta är mycket användbart vid konstruerandet av variabla sparvägar

switch(val, [pattern, value,]+ else_value)

class calibre.utils.formatter_functions.BuiltinSwitch[source]

switch(val, [pattern, value,]+ else_value) – för varje pattern, value par, kontrollerar om fältet överensstämmer med det reguljära uttrycket pattern och i så fall återger det som`value`. Om inget mönster passar, då återges else_value. Du kan ha så många pattern, value par som du vill

List lookup

identifier_in_list(val, id, found_val, not_found_val)

class calibre.utils.formatter_functions.BuiltinIdentifierInList[source]

identifier_in_list(val, id, found_val, not_found_val) – behandla val som en lista med identifierare separerade med kommatecken och jämför strängen mot varje värde i listan. En identifierare har formatet ”identifier:value”. ID-parametern ska vara antingen ”id” eller ”id:regexp”. Det första fallet ger träff om det finns någon identifierare med detta ID. Det andra fallet ger träff om regexp matchar identifierarens värde. Om det är en träff, återges found_val, annars återges not_found_val.

in_list(val, separator, [ pattern, found_val, ]+ not_found_val)

class calibre.utils.formatter_functions.BuiltinInList[source]

in_list(val, separator, [ pattern, found_val, ]+ not_found_val) – behandla val som en lista med objekt separerade med avskiljare, om mönstret matchar något av listvärdena återges found_val. Om mönstret inte matchar något listvärde återges not_found_val. Mönstret och found_value par kan upprepas så många gånger som önskas. Mönstren kontrolleras i ordning. found_val för den första matchningen återges. Alias: in_list(), list_contains()

list_item(val, index, separator)

class calibre.utils.formatter_functions.BuiltinListitem[source]

list_item(val, index, separator) - tolka värdet som en lista med element åtskilda av separator, återger posten index`th. Den första punkten är siffran noll. Den sista komponenten kan återges med hjälp av `list_item(-1,separator). Om posten inte finns i listan, kommer det tomma värdet återges. Avskiljaren har samma betydelse som i antal-funktionen.

select(val, key)

class calibre.utils.formatter_functions.BuiltinSelect[source]

select(val, key) – tolka värdet som en kommaseparerad lista med poster, med posterna ”id:värde”. Hitta paret med id lika med tangent och återge motsvarande värde. Återger den tomma strängen om ingen träff hittas.

tr_in_list(val, separator, [string, found_val, ]+ not_found_val)

class calibre.utils.formatter_functions.BuiltinStrInList[source]

tr_in_list(val, separator, [string, found_val, ]+ not_found_val) – behandlar val som en lista med objekt separerade med avskiljare, om strängen matchar något av listvärdena återges found_val. Om strängen inte matchar något listvärde återges not_found_val. Jämförelsen är exakt matchning (innehåller inte) och är skiftlägeskänslig. Paren string och found_value kan upprepas så många gånger som önskas. Mönstren kontrolleras i ordning. Found_val för den första matchningen återges.

List manipulation

count(val, separator)

class calibre.utils.formatter_functions.BuiltinCount[source]

count(val, separator) – tolkar värdet som en lista med element åtskilda av ”separator”, återger antalet poster i listan. De flesta listor använder kommatecken som skiljetecken, men författarna använder ett et-tecken. Exempel: {tags:count(,)}, {authors:count(&)}. Alias: count(), list_count()

list_count_matching(list, pattern, separator)

class calibre.utils.formatter_functions.BuiltinListCountMatching[source]

list_count_matching(list, pattern, separator) – tolkar ’list’ som en lista med poster som skiljs åt av ’separator’, återger antalet poster i listan som matchar det reguljära uttrycket ’pattern’. Alias: list_count_matching(), count_matching()

list_difference(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListDifference[source]

list_difference(list1, list2, separator) – återger en lista genom att ta bort list1 alla post som finns i list2 med en skiftlägeskänslig jämförelse. Posterna i list1 och list2 skiljs åt av avskiljare, liksom posterna i den återgivna listan.

list_equals(list1, sep1, list2, sep2, yes_val, no_val)

class calibre.utils.formatter_functions.BuiltinListEquals[source]

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – återger yes_val om list1 och list2 innehåller samma poster, annars återge no_val. Föremålen bestäms genom att dela upp varje lista med lämpliga avskiljare (sep1 eller sep2). Ordningen på posterna i listorna är inte relevant. Jämförelsen är inte skiftlägeskänslig.

list_intersection(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListIntersection[source]

list_intersection(list1, list2, separator) – återger en lista genom att ta bort list1 alla post som finns i list2 med en skiftlägeskänslig jämförelse. Posterna i list1 och list2 skiljs åt av avskiljare, liksom posterna i den återgivna listan.

list_re(src_list, separator, include_re, opt_replace)

class calibre.utils.formatter_functions.BuiltinListRe[source]

list_re(src_list, separator, include_re, opt_replace) – Konstruera en lista genom att först separera src_list till poster med hjälp av avskiljartecknet. För varje post i listan, kontrollera om det matchar include_re. Om den gör det, sedan lägga till den i listan som ska återges. Om opt_replace inte är den tomma strängen, tillämpa sedan bytet innan du lägger till posten i den återgivna listan.

list_re_group(src_list, separator, include_re, search_re [, group_template]+)

class calibre.utils.formatter_functions.BuiltinListReGroup[source]

list_re_group(src_list, separator, include_re, search_re [, group_template]+) – Som list_re utom ersättare är inte valfritt. Den använder re_group(list_item, search_re, group_template, …) när du gör ersättare på den resulterande listan.

list_remove_duplicates(list, separator)

class calibre.utils.formatter_functions.BuiltinListRemoveDuplicates[source]

list_remove_duplicates(list, separator) – återger en lista som gjorts genom att ta bort dubbletter i källistan. Om poster endast skiljer sig åt i skiftläge, återges den sista av dem. Posterna i källistan är separerade med avskiljare, liksom posten i den återgivna listan.

list_sort(list, direction, separator)

class calibre.utils.formatter_functions.BuiltinListSort[source]

list_sort(list, direction, separator) – återge en lista sorterad med en skiftlägesokänslig sortering. Om riktningen är noll sorteras listan stigande, annars fallande. Listposterna skiljs åt med avskiljare, liksom posterna i den återgivna listan.

list_split(list_val, sep, id_prefix)

class calibre.utils.formatter_functions.BuiltinListSplit[source]

list_split(list_val, sep, id_prefix) – delar list_val i separata värden med hjälp av ”sep” och tilldelar sedan värdena till variabler med namnen ”id_prefix_N” där N är positionen för värdet i listan. Den första posten har position 0 (noll). Funktionen returnerar det sista elementet i listan. Exempel: split(’one:two:foo’, ’:’, ’var’) motsvarar var_0 = ’one’; var_1 = ’two’; var_2 = ’foo’.

list_union(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListUnion[source]

list_union(list1, list2, separator) – återger en lista som görs av en sammanslagning av poster i list1 och list2, ta bort dubbletter med en skiftlägeskänslig jämförelse. Om post skiljer sig i fallet är den i list1 används. Posterna i list1 och list2 skiljs åt av avskiljare, liksom posterna i den återgivna listan. Alias: list_union(), merge_lists()

subitems(val, start_index, end_index)

class calibre.utils.formatter_functions.BuiltinSubitems[source]

subitems(val, start_index, end_index) – Den här funktionen används för att bryta isär listor över poster som genrer. Det tolkar värdet som en kommaseparerad lista över poster, där varje post är en period-separerad lista. Återger en ny lista genom att först hitta alla period-separerade poster, då för varje sådan post utvinna start_index till end_index komponenter och sedan kombinera resultaten tillbaka tillsammans. Den första komponenten i en periodseparerad lista har ett index på noll. Om ett index är negativ, så det räknas från slutet av listan. Som ett specialfall, är en end_index på noll antas vara längden på listan. Exempel med grundläggande malläge och antar ett #genre värde av ”A.B.C”: {#genre:subitems(0,1)} återger ”A”. {#genre:subitems(0,2)} återger ”A.B”. {#genre:subitems(1,0)} återger ”B.C”. Förutsatt ett #genre värde av ”A.B.C, D.E.F”, {#genre:subitems(0,1)} återger ”A, D”. {#genre:subitems(0,2)} återger ”A.B, D.E”

sublist(val, start_index, end_index, separator)

class calibre.utils.formatter_functions.BuiltinSublist[source]

sublist(val, start_index, end_index, separator) – tolka värdet som en lista av element separerade av separator, återger en ny lista med post från start_index till end_index. Det första postnumret är noll. Om ett index är negativt räknas det från slutet på listan. Som ett specialfall, om end_index är noll antas det motsvara längden på listan. Exempel på användning av grundläggande mallläge och antagandet att (de kommaseparerade) taggkolumnerna innehåller ”A, B, C”: {tags:sublist(0,1,\,)} återger ”A”. {tags:sublist(-1,0,\,)} återger ”C”. {tags:sublist(0,-1,\,)} återger ”A, B”.

Other

assign(id, val)

class calibre.utils.formatter_functions.BuiltinAssign[source]

assign(id, val) – tilldelar val till id och återger sedan val. id måste vara en identifierare, inte ett uttryck. Denna funktion kan ofta ersättas med operatören =.

Recursion

eval(template)

class calibre.utils.formatter_functions.BuiltinEval[source]

eval(template) – utvärderar mallen, sänder de lokala variablerna (de ’assign’ed till) istället för bokens metadata. Detta möjliggör användning av mallprocessorn för att konstruera komplexa resultat från lokala variabler. Eftersom {- and }-tecken är speciella, måste du använda [[ för {-tecknet och ]] för }-tecknet; de konverteras automatiskt. Observera också att prefix och suffix (|prefix|suffix-syntax) inte kan användas i argumentet för denna funktion när du använder mallprogramläget.

template(x)

class calibre.utils.formatter_functions.BuiltinTemplate[source]

template(x) – utvärderar x som en mall. Utvärderingen görs i sitt eget sammanhang, vilket innebär att variabler inte delas mellan den som anropande och mallutvärderingen. Eftersom tecknen { och } är speciella, måste du använda [[ för {-tecknet och ]] för }-tecknet, och de konverteras automatiskt. Till exempel template(’[[title_sort]]’) kommer att utvärdera mallen {title_sort} och återge dess värde. Observera också att prefix och suffix (|prefix|suffix-syntax) inte kan användas i argumentet för denna funktion när du använder mallprogramläget.

Relational

cmp(x, y, lt, eq, gt)

class calibre.utils.formatter_functions.BuiltinCmp[source]

cmp(x, y, lt, eq, gt) – jämför x och y efter konvertering av båda till siffror. Återger lt om x < y. Återger eq om x == y. Annars återges gt. I många fall kan de numeriska jämförelseoperatörerna (>#, <#, ==# o.s.v.) ersätta denna funktion.

first_matching_cmp(val, [cmp1, result1,]+, else_result)

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[source]

first_matching_cmp(val, [cmp1, result1,]+, else_result) – jämför ”val < cmpN” i sekvens och återger resultN för den första jämförelsen som lyckas. Återger else_result om ingen jämförelse lyckas. Exempel: first_matching_cmp(10,5,”small”,10,”middle”,15,”large”,”giant”) återger ”large”. Samma exempel med ett första värde på 16 returnerar ”giant”.

strcmp(x, y, lt, eq, gt)

class calibre.utils.formatter_functions.BuiltinStrcmp[source]

strcmp(x, y, lt, eq, gt) – gör en skiftlägeskänslig jämförelse av x och y som strängar. återger lt om x < y. Återger eq om x == y. Annars återges gt. I många fall kan de lexikala jämförelsesoperatorerna (>, <, == o.s.v.) ersätta denna funktion.

String case changes

capitalize(val)

class calibre.utils.formatter_functions.BuiltinCapitalize[source]

capitalize(val) – återger värdet av fältet med versaler

lowercase(val)

class calibre.utils.formatter_functions.BuiltinLowercase[source]

lowercase(val) – återger värdet i fältet med gemener

titlecase(val)

class calibre.utils.formatter_functions.BuiltinTitlecase[source]

titlecase(val) – återger värdet i fältet i titelformat

uppercase(val)

class calibre.utils.formatter_functions.BuiltinUppercase[source]

uppercase(val) – återger värdet i fältet med versaler

String manipulation

character(character_name)

class calibre.utils.formatter_functions.BuiltinCharacter[source]

character(character_name) - återger tecknet som heter character_name. Till exempel återger character(’newline’) ett nyradstecken (’n’). De tecken som stöds är ’newline’, ’return’, ’tab’ och ’backslash’.

re(val, mönster, ersättning)

class calibre.utils.formatter_functions.BuiltinRe[source]

re(val, mönster, ersättning) - Returvärdet på området efter tillämpning av reguljära uttryck. Alla förekomster av ”mönster” ersättas med ”ersättning”. Som allid i calibre, dessa är Python-kompatibla reguljära uttryck

re_group(val, pattern [, template_for_group]*)

class calibre.utils.formatter_functions.BuiltinReGroup[source]

re_group(val, pattern [, template_for_group]*) – återge en sträng gjord genom att tillämpa det reguljära uttrycksmönstret på val och ersätta varje matchad instans med strängen beräknad genom att ersätta varje matchad grupp med det värde som återges av motsvarande mall. Det ursprungliga matchade värdet för gruppen finns som $. I mallprogramläge, som för mallen och eval-funktionerna, använder du [[ för { och ]] för }. Följande exempel i mallprogramläget letar efter serier med mer än ett ord och versaler det första ordet: {series:’re_group($, ”(S* )(.*)”, ”[[$:uppercase()]]”, ”[[$]]”)’}

shorten(val, left chars, middle text, right chars)

class calibre.utils.formatter_functions.BuiltinShorten[source]

shorten(val, left chars, middle text, right chars) – Återger en förkortad version av fältet, som består av left chars, tecken från början av fältet, följt av middle text, följt av right chars tecken från slutet av strängen. Left chars och right chars, måste vara heltal. Antag exempelvis titeln på boken är Ancient English Laws in the Times of Ivanhoe, och du vill att den ska passa i ett utrymme på högst 15 tecken. Om du använder {title:shorten(9,-,5)}, kommer resultatet att bli Ancient E-nhoe. Om fältets längd är mindre än left chars + right chars + längden på middle text, då kommer fältet att användas intakt. Till exempel titeln The Dome skulle inte ändras.

strcat(a [, b]*)

class calibre.utils.formatter_functions.BuiltinStrcat[source]

strcat(a [, b]*) – kan ta valfritt antal argument. Återger strängen som bildats genom att sammanfoga alla argument

strcat_max(max, string1 [, prefix2, string2]*)

class calibre.utils.formatter_functions.BuiltinStrcatMax[source]

strcat_max(max, string1 [, prefix2, string2]*) – Återger en sträng som bildats genom att sammanfoga argumenten. Det återgivna värdet initialiseras till string1. Prefix, string-par läggs till i slutet av värde så länge den resulterande strängens längd är mindre än max. String1 återges även om string1 är längre än max. Du kan skicka så många prefix, string-par som du vill.

strlen(a)

class calibre.utils.formatter_functions.BuiltinStrlen[source]

strlen(a) - Återger längden av den sträng som skickas som argument

substr(str, start, slut)

class calibre.utils.formatter_functions.BuiltinSubstr[source]

substr(str, start, slut) - återger starttecknet till och med sluttecknet i str. Det första tecknet i STR är nollkaraktär. Om slutet är negativt, då det tyder på att för många tecken räknas från höger. Om slutet är noll, indikeras det sista tecknet. Till exempel substr (’12345 ’, 1, 0) återger ’2345’, och substr (’12345 ’, 1, -1) återger ’234’.

swap_around_articles(val, separator)

class calibre.utils.formatter_functions.BuiltinSwapAroundArticles[source]

swap_around_articles(val, separator) – återger valet med artiklar flyttade till slutet. Värdet kan vara en lista, i vilket fall varje medlem av listan behandlas. Om värdet är en lista måste du ange listvärdesseparatorn. Om ingen separator tillhandahålls behandlas värdet som ett enda värde, inte en lista.

swap_around_comma(val)

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[source]

swap_around_comma(val) – ges ett värde av formen ”B, A” återger ”A B”. Detta är mest användbar för att konvertera namn i EN, FN format till FN EN. Om det inte finns något komma, återger funktionen val oförändrad

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate[source]

transliterate(a) – återger en sträng i ett latinskt alfabet som bildas genom en tillnärmning av ljudet av orden i källsträngen. Till exempel om källan är ”Фёдор Миха́йлович Достоевский” återger funktionen ”Fiodor Mikhailovich Dostoievskii”.

other

arguments(id[=expression] [, id[=expression]]*)

class calibre.utils.formatter_functions.BuiltinArguments[source]

arguments(id[=expression] [, id[=expression]]*) – Används i en lagrad mall för att hämta argumenten som skickats i samtalet. Det både deklarerar och initialiserar lokala variabler, effektivt parametrar. Variablerna är positionella; de får värdet av det värde som ges i samtalet i samma position. Om motsvarande parameter inte tillhandahålls i samtalet tilldelar argumenten variabeln det angivna standardvärdet. Om det inte finns något standardvärde ställs variabeln in på den tomma strängen.

globals(id[=expression] [, id[=expression]]*)

class calibre.utils.formatter_functions.BuiltinSetGlobals[source]

globals(id[=expression] [, id[=expression]]*) – Hämtar ”globala variabler” som kan skickas till formateraren. Den både deklarerar och initialiserar lokala variabler med namnen på de globala variablerna som skickats in. Om motsvarande variabel inte tillhandahålls i de skickade globalerna tilldelas den variabeln det angivna standardvärdet. Om det inte finns något standardvärde ställs variabeln in som den tomma strängen.

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=('Okänd',), other=None, template_cache=None, formatter=None)[source]

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

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

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

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

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

set_identifier(typ, val)[source]

If val is empty, deletes identifier of type typ

standard_field_keys()[source]

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

custom_field_keys()[source]

return a list of the custom fields in this book

all_field_keys()[source]

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

metadata_for_field(key)[source]

return metadata describing a standard or custom field.

all_non_none_fields()[source]

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

get_standard_metadata(field, make_copy)[source]

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

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

get_all_user_metadata(make_copy)[source]

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

get_user_metadata(field, make_copy)[source]

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

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

set_user_metadata(field, metadata)[source]

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

remove_stale_user_metadata(other_mi)[source]

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

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

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

Returns the tuple (display_name, formatted_value)

to_html()[source]

A HTML representation of this object.

calibre.ebooks.metadata.book.base.STANDARD_METADATA_FIELDS

The set of standard metadata fields.

__docformat__ = 'restructuredtext en'

'''
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