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[código fonte]

add(x [,y]*) – retorna a soma de seus argumentos. Lança uma exceção se um argumento não for um número. Esta função muitas vezes pode ser substituída pelo operador +.

ceiling(x)

class calibre.utils.formatter_functions.BuiltinCeiling[código fonte]

ceiling(x) – retorna o menor inteiro maior ou igual a x. Lança uma exceção caso x não seja um número.

divide(x, y)

class calibre.utils.formatter_functions.BuiltinDivide[código fonte]

divide(x, y) – retorna x / y. Lança uma exceção se x ou y não forem números. Esta função pode muitas vezes ser substituída pelo operador /.

floor(x)

class calibre.utils.formatter_functions.BuiltinFloor[código fonte]

floor(x) – retorna o maior inteiro menor ou igual a x. Lança uma exceção caso x não seja um número.

fraction_part(x)

class calibre.utils.formatter_functions.BuiltinFractionalPart[código fonte]

fraction_part(x) – retorna o valor depois da casa decimal. Por exemplo, fractional_part(3.14) retorna 0.14. Lança uma exceção caso x não seja um número.

mod(x)

class calibre.utils.formatter_functions.BuiltinMod[código fonte]

mod(x) – retorna o resto (da divisão x / y). Lança uma exceção caso x ou y não for um número.

multiply(x [,y]*)

class calibre.utils.formatter_functions.BuiltinMultiply[código fonte]

multiply(x [,y]*) – retorna o produto de seus argumentos. Lança uma exceção se um argumento não for um número. Esta função muitas vezes pode ser substituída pelo operador *.

round(x)

class calibre.utils.formatter_functions.BuiltinRound[código fonte]

round(x) – retorna o inteiro mais próximo de x. Lança uma exceção caso x não seja um número.

subtract(x, y)

class calibre.utils.formatter_functions.BuiltinSubtract[código fonte]

subtract(x, y) – retorna x - y. Lança uma exceção se X ou Y não forem números. Esta função pode muitas vezes ser substituída pelo operador -.

Boolean

and(valor [,valor]*)

class calibre.utils.formatter_functions.BuiltinAnd[código fonte]

and(valor [,valor]*) – retorna a string “1” se todos os valores forem não vazios, caso contrário, retorna a string vazia. Esta função funciona bem com o ‘test’ ou ‘first_non_empty’. Você pode ter quantos valores você quiser. Em muitos casos, o operador && pode substituir esta função.

not(valor)

class calibre.utils.formatter_functions.BuiltinNot[código fonte]

not(valor) – retorna a string “1” se o valor for vazio, caso contrário, retorna a string vazia. Esta função funciona bem com o ‘test’ ou ‘first_non_empty’. Em muitos casos, o operador ! pode substituir esta função.

or(valor [,valor]*)

class calibre.utils.formatter_functions.BuiltinOr[código fonte]

or(valor [,valor]*) – retorna a string “1” se qualquer dos valores for não vazio, caso contrário, retorna a string vazia. Esta função funciona bem com o ‘test’ ou ‘first_non_empty’. Você pode ter quantos valores você quiser. Em muitos casos, o operador || pode substituir esta função.

Date functions

date_arithmetic(data, calc_spec, fmt)

class calibre.utils.formatter_functions.BuiltinDateArithmetic[código fonte]

date_arithmetic(data, calc_spec, fmt) – Calcula uma nova data a partir de ‘data’ usando ‘calc_spec’. Retorna a nova data formatada de acordo com o parâmetro opcional ‘fmt’: se não fornecido, então o resultado estará no formato iso. O ‘calc_spec’ é uma string formada pela concatenação de pares de ‘vQ’ (valorQue), onde ‘v’ é número que pode ser negativo e Q é um das letras a seguir: s: adiciona ‘v’ segundos à ‘data’ m: adiciona ‘v’ minutos à ‘data’ h: adiciona ‘v’ horas à ‘data’ d: adiciona ‘v’ dias à ‘data’ w: adiciona ‘v’ semanas à ‘data’ y: adiciona ‘v’ anos à ‘data’, onde um anor são 365 dias. Exemplo: ‘1s3d-1m’ irá adicionar 1 segundo, adicionar 3 dias, e subtrair 1 minuto a partir da ‘data’.

days_between(date1, date2)

class calibre.utils.formatter_functions.BuiltinDaysBetween[código fonte]

days_between(date1, date2) – retornar o número de dias entre date1 e date2. O número é positivo se date1 é maior do que date2, caso contrário, negativo. Se ambos date1 ou date2 não são datas, a função retorna a string vazia.

today()

class calibre.utils.formatter_functions.BuiltinToday[código fonte]

today() – retorna uma string de data para o dia de hoje. Esse valor é projetado para uso no formato_data ou dias_entre, mas pode ser manipulado como qualquer outra string. A data está no formato ISO.

Formatting values

finish_formatting(val, fmt, prefix, suffix)

class calibre.utils.formatter_functions.BuiltinFinishFormatting[código fonte]

finish_formatting(val, fmt, prefix, suffix) – aplicar o formato, de prefixo, sufixo e para um valor da mesma forma como foi feito em um modelo como {series_index:05.2f| - |- }. Por exemplo, o seguinte programa produz a mesma saída que o modelo acima: programa: finish_formatting(field(“series_index”), “05.2f”, “ - “, “ - “)

format_date(val, format_string)

class calibre.utils.formatter_functions.BuiltinFormatDate[código fonte]

format_date(val, format_string) – formata o valor, o qual deve ser uma data, usando a format_string, retornando uma string. Os códigos de formatação são: d : dia sem o número zero à esquerda (1 à 31) dd : dia como número com um zero à esquerda (01 à 31) ddd : nome do dia traduzido abreviado (por exemplo, “Seg” à “Dom”). dddd : nome longo do dia traduzido abreviado (por exemplo, “Segunda” à “Domingo”). M : mês como um número sem o zero à esquerda (1 à 12). MM : mês como número com um zero à esquerda (01 à 12) MMM : nome do mês traduzido abreviado (por exemplo, “Jan” à “Dez”). MMMM : nome longo do mês traduzido (por exemplo, “Janeiro” à “Dezembro”). yy : ano como um número de dois dígitos (00 à 99). yyyy : ano como um número de quatro dígitos. h : horas sem o zero à esquerda (0 à 11 ou 0 à 23, dependendo de am/pm) hh : horas com zero à esquerda (00 à 11 ou 00 à 23, dependendo de am/pm) m : minutos sem zero à esquerda (0 à 59) mm : minutos com zero à esquerda (00 à 59) s : segundos sem zero à esquerda (0 à 59) ss : segundos com zero à esquerda (00 à 59) ap : usa um relógio de 12-horas em vez de um relógio de 24-horas, com “ap” substituído pela string traduzida de am ou pm AP : usa um relógio de 12-horas em vez de um relógio de 24-horas, com “AP” substituído pela string traduzida de AM ou PM iso : data com hora e fuso-horário. Deve ser o único formato presente to_number: a data como número de ponto flutuante from_number[:fmt]: formata o timestamp usando fmt caso esteja presente e, do contrário, utiliza o iso

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber[código fonte]

format_number(v, template) – formatar o número v usando um modelo de formatação, como python “{0:5.2f}” ou “{0:,d}” ou “${0:5,.2f}”. A parte field_name do modelo deve ser um 0 (zero) (o “{0:” nos exemplos acima). Consulte a documentação do modelo de linguagem e python para mais exemplos. Retorna a string vazia se a formatação falhar.

human_readable(v)

class calibre.utils.formatter_functions.BuiltinHumanReadable[código fonte]

human_readable(v) – retorna uma string representando o número v em KB, MB, CB, etc.

rating_to_stars(valor, use_half_stars)

class calibre.utils.formatter_functions.BuiltinRatingToStars[código fonte]

rating_to_stars(valor, use_half_stars) – Retorna a avaliação como uma cadeia de caracteres de estrela. O valor é um número entre 0 e 5. Defina use_half_stars como 1 se você deseja caracteres de meia estrela para avaliações personalizadas que suportam não-inteiros, por exemplo 2.5.

urls_from_identifiers(identificadores, ordenar_resultados)

class calibre.utils.formatter_functions.BuiltinUrlsFromIdentifiers[código fonte]

urls_from_identifiers(identificadores, ordenar_resultados) – dada uma lista de identificadores separada por vírgula, onde uma identificador é um par de valores separado por dois pontos (nome:valor_do_id), retorna uma lista de URLs HTML separada por vírgula, gerada a partir dos identificadores. A lista não será ordenada caso ordenar_resultados for 0 (caractere ou número). Do contrário, será ordenada alfabeticamente pelo nome do identificador. Os URLs são gerados da mesma maneira que a coluna de identificadores padrão ao ser exibida no Painel de Detalhes do livro.

Get values from metadata

annotation_count()

class calibre.utils.formatter_functions.BuiltinAnnotationCount[código fonte]

annotation_count() – retorna o número total de anotações de todos os tipos anexadas ao livros atual. Esta função funciona somente na GUI.

approximate_formats()

class calibre.utils.formatter_functions.BuiltinApproximateFormats[código fonte]

approximate_formats() – retornar uma lista de formatos que em um ponto foram associados com o livro, separados por vírgulas. Não há garantia de que esta lista esteja correta, embora provavelmente deva estar. Esta função pode ser chamada no modo de programação de modelo usando o modelo “{:’approximate_formats()’}”. Observe que os nomes de formato são sempre maiúsculas, como em EPUB. Esta função só funciona na GUI. Se você quiser usar esses valores nos modelos save-to-disk ou send-to-device, então você deve fazer um personalizado “Coluna construída de outras colunas”, use a função de modelo que da coluna, e usar o valor dessa coluna em seus modelos salvar/enviar

author_sorts(val_separator)

class calibre.utils.formatter_functions.BuiltinAuthorSorts[código fonte]

author_sorts(val_separator) – retorna uma sequência contendo uma lista de valores de autor ordenado para os autores do livro. A ordem é a única nos metadados autor (diferente do author_sort em livros). A lista retornada tem o autor do formulário ordem 1 val_separator autor ordem 2, etc. Os valores de autor ordenado nesta lista estão na mesma ordem que os autores do livro. Se você quiser espaços em torno de val_separator então inclua-os na sequência separador

booksize()

class calibre.utils.formatter_functions.BuiltinBooksize[código fonte]

booksize() – valor do campo de tamanho retornar. Esta função funciona apenas na GUI. Se você quiser usar este valor nos modelos save-to-disk ou send-to-device, então você deve fazer uma “Coluna construída de outras colunas” personalizada, use a função no modelo da coluna, e use o valor dessa coluna em seus modelos salvos/enviados

ch formats_modtimes(date_format) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[código fonte]

ch formats_modtimes(date_format) – retornar uma lista de itens separados por vírgula colon_separated que representam horas de modificação para os formatos de um livro. O parâmetro date_format especifica como a data deve para ser formatada. Veja a função date_format para mais detalhes. Você pode usar a função de seleção para obter a hora de modificação para um formato específico. Observe que o formato dos nomes são sempre maiúsculas, como em EPUB.

connected_device_name(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceName[código fonte]

connected_device_name(storage_location) – se um dispositivo estiver conectado, então retorna o nome do dispositivo; do contrário, retorna uma string vazia. Cada local de armazenamento em um dispositivo pode ter um nome diferente. Os nomes dos locais são ‘main’, ‘carda’ e ‘cardb’. Esta função funciona somente na interface gráfica.

connected_device_uuid(storage_location)

class calibre.utils.formatter_functions.BuiltinConnectedDeviceUUID[código fonte]

connected_device_uuid(storage_location) – se um dispositivo estiver conectado, então retorna o uuid (id único) do dispositivo; do contrário, retorna uma string vazia. Cada local de armazenamento em um dispositivo tem um uuid diferente. Os nomes dos locais são ‘main’, ‘carda’ e ‘cardb’. Esta função funciona somente na interface gráfica.

current_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[código fonte]

current_library_name() – retorna o último nome do caminho para a biblioteca atual do calibre. Esta função pode ser chamada no modo de programa modelo usando o modelo “{:’current_library_name()’}”.

current_library_path()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[código fonte]

current_library_path() – retorna o caminho para a biblioteca atual do calibre. Esta função pode ser chamada no modo de programa modelo usando o modelo “{:’current_library_path()’}”.

current_virtual_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentVirtualLibraryName[código fonte]

current_virtual_library_name() – retornar o nome da biblioteca virtual atual, caso exista uma, do contrário retorna uma string vazia. Maísculas/minúsculas no nome da biblioteca são preservadas. Exemplo: “program: current_virtual_library_name()”.

field(nome_para_pesquisa)

class calibre.utils.formatter_functions.BuiltinField[código fonte]

field(nome_para_pesquisa) – retorna o campo de metadado nomeado nome_para_pesquisa.

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths[código fonte]

formats_paths() – retornar uma lista de itens separados por vírgula colon_separated que representam caminhos completos para os formatos de um livro. Você pode usar a função de seleção para obter o caminho para um formato específico. Observe que o formato dos nomes são sempre maiúsculas, como em EPUB.

formats_sizes()

class calibre.utils.formatter_functions.BuiltinFormatsSizes[código fonte]

formats_sizes() – retornar uma lista de itens separados por vírgula colon_separated que representam tamanhos em bytes dos formatos de um livro. Você pode usar a função de seleção para obter o tamanho de um formato específico. Observe que o formato dos nomes são sempre maiúsculas, como em EPUB.

has_cover()

class calibre.utils.formatter_functions.BuiltinHasCover[código fonte]

has_cover() – retorna Sim se o livro tem uma capa, do contrário retorna uma string vazia

is_marked()

class calibre.utils.formatter_functions.BuiltinIsMarked[código fonte]

is_marked() – verifica se o livro está marcado (‘marked’) no calibre. Se estiver, então retorna o valor da marca, que será ‘true’ ou uma lista de nomes de marcas separados por vírgula. Retorna ‘’ se o livro não estiver marcado.

language_codes(lang_strings)

class calibre.utils.formatter_functions.BuiltinLanguageCodes[código fonte]

language_codes(lang_strings) – retorna os códigos de idiomas para as strings passadas no lang_strings. As strings devem ser no idioma do local atual. Lang_strings é uma lista separada por vírgulas.

language_strings(lang_codes, localize)

class calibre.utils.formatter_functions.BuiltinLanguageStrings[código fonte]

language_strings(lang_codes, localize) – retornar as strings para os códigos de idioma passados em lang_codes. Se localize é zero, retornar as strings em Inglês. Se localize não é zero, retornar as strings no idioma da localidade atual. Lang_codes é uma lista separada por vírgula.

ondevice()

class calibre.utils.formatter_functions.BuiltinOndevice[código fonte]

ondevice() – retorna Yes se no dispositivo está definido, caso contrário retorna uma string vazia. Esta função funciona apenas na GUI. Se você quiser usar este valor nos modelos save-to-disk ou send-to-device, então você deve fazer uma “Coluna construída de outras colunas” personalizada, use a função no modelo da coluna, e use o valor dessa coluna em seus modelos salvos/enviados

raw_field(nome_para_pesquisa [, padrao_opcional])

class calibre.utils.formatter_functions.BuiltinRawField[código fonte]

raw_field(nome_para_pesquisa [, padrao_opcional]) – retorna o campo de metadados chamado ‘nome_para_pesquisa’, sem aplicar qualquer formatação. Ele avalia e retorna o segundo argumento opcional ‘padrao’ se o campo estiver indefinido (‘None’).

raw_list(nome_para_pesquisa, separador)

class calibre.utils.formatter_functions.BuiltinRawList[código fonte]

raw_list(nome_para_pesquisa, separador) – retorna a lista de metadados nomeado pelo nome_para_pesquisa sem aplicar nenhuma formatação ou ordenação, e com itens separados pelo separador.

series_sort()

class calibre.utils.formatter_functions.BuiltinSeriesSort[código fonte]

series_sort() – retorna o valor de série ordenada

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[código fonte]

virtual_libraries() – retornar uma lista de Bibliotecas virtuais que contêm este livro, separados por vírgulas. Esta função funciona apenas na GUI. Se você quiser usar esses valores nos modelos save-to-disk ou send-to-device então você deve fazer uma “Coluna construída de outras colunas” personalizada, use a função no modelo da coluna, e use o valor dessa coluna em seus modelos salvos/enviados

If-then-else

check_yes_no(nome_do_campo, é_indefinido, é_falso, é_verdadeiro)

class calibre.utils.formatter_functions.BuiltinCheckYesNo[código fonte]

check_yes_no(nome_do_campo, é_indefinido, é_falso, é_verdadeiro) – verifica o valor do campo sim/não definido pela chave de busca nome_do_campo de acordo com os valores especificados pelos parâmetros, retornando “sim” se uma correspondência for encontrada, ou retornando vazio caso contrário. Defina os parâmetros é_indefinido, é_falso, ou é_verdadeiro como 1 (o número) para verificar aquela condição; caso contrário, definida como 0. Exemplo: check_yes_no(“#bool”, 1, 0, 1) retorna “sim” se o campo sim/não “#bool” for não definido (nem Verdadeiro, nem Falso) ou Verdadeiro. Mais de um parâmetro (é_indefinido, é_falso ou é_verdadeiro) podem ser definidos como 1. Esta função geralmente é utilizada pelas funções test() ou is_empty().

contains(val, expressão, texto se corresponder, texto se não corresponder)

class calibre.utils.formatter_functions.BuiltinContains[código fonte]

contains(val, expressão, texto se corresponder, texto se não corresponder) – verifica se val contém correspondências para a expressão regular expressão. Retorna texto se corresponder se combinações forem encontradas, caso contrário retorna texto se não corresponder

field_exists(nome_campo)

class calibre.utils.formatter_functions.BuiltinFieldExists[código fonte]

field_exists(nome_campo) – verifica se um campo (coluna) com o nome ‘nome_campo’ existe, retornando ‘1’ se sim e ‘’ se não.

ifempty(val,texto se vazio)

class calibre.utils.formatter_functions.BuiltinIfempty[código fonte]

ifempty(val,texto se vazio) – retorna val se val não for vazio, do contrário retorna “texto se vazio”

test(val, texto se não-vazio, texto se vazio)

class calibre.utils.formatter_functions.BuiltinTest[código fonte]

test(val, texto se não-vazio, texto se vazio) – retorna “texto se não-vazio” se o campo não estiver vazio, caso contrário retorna “texto se vazio”

Iterating over values

first_non_empty(valor [,valor]*)

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[código fonte]

first_non_empty(valor [,valor]*) – retorna o primeiro valor que não é vazio. Se todos os valores estiverem vazios, então uma string vazia é retornada. Você pode ter quantos valores você quiser.

lookup(val, [expressão, campo,]+ campo_senão)

class calibre.utils.formatter_functions.BuiltinLookup[código fonte]

lookup(val, [expressão, campo,]+ campo_senão) – como switch, exceto que os argumentos são nomes de campos (metadados), e não texto. O valor do campo apropriado será obtido e usado. Observe que, como colunas compostas são campos, você pode usar esta função em um campo composto para usar o valor de algum outro campo composto. Isto é extremamente útil quando a variável construir caminhos salvos

switch(val, [expressão, valor,]+ valor_senão)

class calibre.utils.formatter_functions.BuiltinSwitch[código fonte]

switch(val, [expressão, valor,]+ valor_senão) – para cada par expressão, valor, verifica se val corresponde à expressão regular expressão e se assim for, retorna valor. Se nenhum padrão é correspondido, então valor_senão é retornado. Você pode ter quantos pares expressão, valor você quiser

List lookup

identifier_in_list(val, id, found_val, not_found_val)

class calibre.utils.formatter_functions.BuiltinIdentifierInList[código fonte]

identifier_in_list(val, id, found_val, not_found_val) – tratar val como uma lista de identificadores separados por vírgulas, comparando a string contra cada valor na lista. Um identificador tem o formato “identifier:value”. O parâmetro id deve ser “id” ou “id:regexp”. O primeiro caso corresponde, se houver qualquer identificador com esse id. O segundo caso corresponde se a expressão regular corresponde ao valor do identificador. Se houver uma correspondência, retorna found_val, caso contrário retorna not_found_val.

in_list(val, separador, [ padrao, val_encontrado, ]+ val_nao_encontrado)

class calibre.utils.formatter_functions.BuiltinInList[código fonte]

in_list(val, separador, [ padrao, val_encontrado, ]+ val_nao_encontrado) – tratando val como uma lista de itens separados por ‘separador’, caso o padrão corresponda a algum dos valores da lista, então retorna val_encontrado. Caso o padrão não corresponda a nenhum valor da lista, então retorna val_nao_encontrado. Os pares ‘padrao’ e ‘val_encontrado’ podem ser repetidos quantas vezes desejar. Os padrões são verificados em ordem. O val_encontrado para a primeira correspondência é retornado. Variantes: in_list(), list_contains()

list_item(val, index, separator)

class calibre.utils.formatter_functions.BuiltinListitem[código fonte]

list_item(val, index, separator) – interpretar o valor como uma lista de itens separados por separator, retornando o item index`th. O primeiro item é o número zero. O último item pode ser retornado usando `list_item(-1,separator). Se o item não estiver na lista, então o valor vazio é retornado. O separador tem o mesmo significado como na função de contagem.

select(val, chave)

class calibre.utils.formatter_functions.BuiltinSelect[código fonte]

select(val, chave) – interpreta o valor como uma lista de itens separados por vírgula, com os itens sendo “id:valor”. Encontra o emparelhamento do ‘id’ igual a ‘chave’, e retorna o valor correspondente. Retorna uma string vazia se nenhuma correspondência for encontrada.

str_in_list(val, separador, [string, val_encontrado, ]+ val_nao_encontrado)

class calibre.utils.formatter_functions.BuiltinStrInList[código fonte]

str_in_list(val, separador, [string, val_encontrado, ]+ val_nao_encontrado) – tratando ‘val’ como uma lista de itens separados por ‘separador’, caso a string corresponda a algum dos valores da lista, então retorna val_encontrado. Caso a string não corresponda a nenhum dos valores da lista, então retorna val_nao_encontrado. A comparação é do tipo exata (não ‘contém’) e não diferencia maiúsculas/minúsculas. Os pares ‘string’ and ‘val_encontrado’ pode ser repetidos quantas vezes desejar. Os padrões são verificados em ordem. O ‘val_encontrado’ para a primeira correspondência é retornado.

List manipulation

count(val, separador)

class calibre.utils.formatter_functions.BuiltinCount[código fonte]

count(val, separador) – interpreta o valor como uma lista de itens separados por separador, retornando o número de itens na lista. A maioria das listas usam uma vírgula como separador, mas autores usam um E comercial. Exemplos: {tags:count(,)}, {authors:count(&)}. Variantes: count(), list_count()

list_count_matching(lista, padrao, separador)

class calibre.utils.formatter_functions.BuiltinListCountMatching[código fonte]

list_count_matching(lista, padrao, separador) – interpreta ‘lista’ como uma lista de itens separados por ‘separdor’, retornando o número de itens na lista que correspondem à expressão regular ‘padrao’. Variantes: list_count_matching(), count_matching()

list_difference(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListDifference[código fonte]

list_difference(list1, list2, separator) – retorna uma lista feita removendo de list1 qualquer item encontrado em list2, usando uma comparação de maiúsculas e minúsculas. Os itens em list1 e list2 são separados pelo separador, como são os itens da lista resultante.

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

class calibre.utils.formatter_functions.BuiltinListEquals[código fonte]

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – retornar yes_val se list1 e list2 contêm os mesmos itens, caso contrário retornar no_val. Os itens são determinados dividindo cada lista usando o caractere separador apropriado (sep1 ou sep2). A ordem dos itens das listas não é relevante. A comparação é diferenciada de maiúsculas de minúsculas.

list_intersection(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListIntersection[código fonte]

list_intersection(list1, list2, separator) – retorna uma lista feita removendo de list1 qualquer item não encontrado em list2, usando uma comparação de maiúsculas e minúsculas. Os itens em list1 e list2 são separados pelo separador, como são os itens da lista resultante.

list_join(com_separador, lista1, separador1 [, lista2, separador2]*)

class calibre.utils.formatter_functions.BuiltinListJoin[código fonte]

list_join(com_separador, lista1, separador1 [, lista2, separador2]*) – retorna uma lista feita unindo os itens das listas fonte (lista1, etc) usando o com_separador entre os itens na lista resultante. Itens em cada lista fonte [123…] são separados pelo separador associado [123…]. Uma lista pode conter zero valores. Ela pode ser um campo, como Editora, que tem valor único, efetivamente uma lista de único item. Duplicatas serão removidas usando uma comparação que diferencia entre maiúsculas e minúsculas. Itens são retornados na ordem em que aparecem nas listas fonte. Se os itens nas listas diferem apenas por maiúsculo/minúsculo, então o último item é utilizado. Todos os separadores podem ter mais de um caractere. Exemplo:

program:

list_join(‘#@#’, $authors, ‘&’, $tags, ‘,’)

Você pode usar list_join nos resultados de chamadas anteriores a list_join da seguinte forma:

program:

a = list_join(‘#@#’, $authors, ‘&’, $tags, ‘,’); b = list_join(‘#@#’, a, ‘#@#’, $#genre, ‘,’, $#people, ‘&’)

Você pode usar expressões para gerar uma lista. Por exemplo, imagine que você queira itens para autores e #gênero, mas com o gênero alterado para a palavra ‘Gênero: ‘ seguida da primeira letra do gênero, ou seja, o gênero ‘Ficção’ torna-se ‘Gênero: F’. A expressão abaixo fará isto:
program:

list_join(‘#@#’, $authors, ‘&’, list_re($#genre, ‘,’, ‘^(.).*$’, ‘Genre: 1’), ‘,’)

list_re(src_list, separator, include_re, opt_replace)

class calibre.utils.formatter_functions.BuiltinListRe[código fonte]

list_re(src_list, separator, include_re, opt_replace) – Construir uma lista, primeiro pela separação src_list em itens usando o caractere separador. Para cada item da lista, verifique se ele corresponde a include_re. Se isso acontecer, então adicione-o à lista para retornar. Se opt_replace não é a string vazia, então aplique a substituição antes de adicionar o item à lista retornada.

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

class calibre.utils.formatter_functions.BuiltinListReGroup[código fonte]

list_re_group(src_list, separador, include_re, search_re [, group_template]+) – Como list_re exceto que as substituições não são opcionais. Ele usa re_group(list_item, search_re, group_template, …) ao fazer as substituições na lista resultante.

list_remove_duplicates(lista, separador)

class calibre.utils.formatter_functions.BuiltinListRemoveDuplicates[código fonte]

list_remove_duplicates(lista, separador) – retorna uma lista feita removendo os itens duplicados na lista original. Se os itens diferem apenas por minúsculo/maiúsculo, o último deles é retornado. Os itens na lista original são separados pelo separador, assim como os itens na lista retornada.

list_sort(lista, direção, separador)

class calibre.utils.formatter_functions.BuiltinListSort[código fonte]

list_sort(lista, direção, separador) – retorna uma lista ordenada usando uma ordenação insensível a maiúsculas e minúsculas. Se a direção é zero, a lista é ordenada de maneira ascendente, caso contrário descendente. Os itens da lista são separados por separador, como são os itens da lista retornada.

list_split(list_val, sep, id_prefix)

class calibre.utils.formatter_functions.BuiltinListSplit[código fonte]

list_split(list_val, sep, id_prefix) – separa list_val em valores separados usando ‘sep’, e então atribui os valores a variáveis nomeadas ‘id_prefix_N’, onde N é a posição do valor na lista. O primeiro item tem uma posição 0 (zero). A função retorna o último elemento da lista. Exemplo: split(‘um:dois:blah’, ‘:’, ‘var’) é o equivalente a var_0 = ‘um’; var_1 = ‘dois’; var_2 = ‘blah’.

list_union(lista1, lista2, separador)

class calibre.utils.formatter_functions.BuiltinListUnion[código fonte]

list_union(lista1, lista2, separador) – retorna uma lista feita pela fusão dos itens na lista1 e lista2, removendo itens duplicados usando uma comparação de maiúsculas e minúsculas. Se os itens forem diferentes por maiúsculo/minúsculo, o item na lista1 é usado. Os itens em lista1 e lista2 são separados pelo separador, assim como na lista resultante. Variantes: list_union(), merge_lists()

range(início, fim, passo, limite)

class calibre.utils.formatter_functions.BuiltinRange[código fonte]

range(início, fim, passo, limite) – retorna uma lista de números gerada percorrendo o intervalo especificado pelos parâmetros ‘início’, ‘fim’ e ‘passo’, com um comprimento máximo de ‘limite’. O primeiro valor produzido é ‘início’. Os valores subsequentes próximo_v são v_atual+passo. O loop continua enquanto próximo_v < ‘fim’, caso ‘passo’ seja positivo, do contrário enquanto próximo_v > ‘fim’. Uma lista vazia é produzida caso ‘início’ falhe no teste: ‘início’ >= ‘fim’ caso o ‘passo’ seja positivo. O ‘limite’ define o máximo comprimento da lista e tem um valor padrão de 1000. O parâmetro ‘início’, ‘passo’ e ‘limite’ são opcionais. Chamar range() com um argumento especifica o ‘fim’. Dois argumentos especificam ‘início’ e ‘fim’. Três argumentos especificam ‘início’, ‘fim’, e ‘passo’. Quatro argumentos especificam ‘início’, ‘fim’, ‘passo’ e ‘limite’. Exemplos: range(5)-> ‘0,1,2,3,4’. range(0,5)-> ‘0,1,2,3,4’. range(-1,5)-> ‘-1,0,1,2,3,4’. range(1,5)-> ‘1,2,3,4’. range(1,5,2)-> ‘1,3’. range(1,5,2,5)-> ‘1,3’. range(1,5,2,1)-> erro(limite excedido).

subitems(val, start_index, end_index)

class calibre.utils.formatter_functions.BuiltinSubitems[código fonte]

subitems(val, start_index, end_index) – Esta função é usada para quebrar as listas de itens, tais como gêneros. Ela interpreta o valor como uma lista de itens, onde cada item é uma lista separada por período separados por vírgula. Retorna uma nova lista feita pela primeira encontrando todos os itens separados por pontos, em seguida, para cada um desses itens extrair os componentes start_index para end_index, em seguida, combinando os resultados de volta juntos. O primeiro componente em uma lista separada por período tem um índice de zero. Se o índice é negativo, então conta do fim da lista. Conforme um caso especial, um end_index de zero é considerado como o comprimento da lista. Exemplo usando o modo de modelo básico e assumindo um valor de #genre “A.B.C”: {#genre:subitems(0,1)} retorna “A”. {#genre:subitems(0,2)} retorna “A.B”. {#genre:subitems(1,0)} retorna “B.C”. Assumindo um valor de #genre “A.B.C, D.E.F”, {#genre:subitems(0,1)} retorna “A, D”. {#genre:subitems(0,2)} retorna “A.B, D.E”

sublist(val, start_index, end_index, separator)

class calibre.utils.formatter_functions.BuiltinSublist[código fonte]

sublist(val, start_index, end_index, separator) – interpreta o valor como uma lista de itens separados por separator, retornando uma nova lista criada a partir de start_index até o item end_index . O primeiro item é o número zero. Se um índice for negativo, então será contado a partir do final da lista. Como um caso especial, um end_index igual a zero será considerado como igual ao comprimento da lista. Exemplos usando o modo de modelo básico e considerando que a coluna de etiquetas (a qual é separada por vírgulas) contém “A, B, C”: {tags:sublist(0,1,\,)} retorna “A”. {tags:sublist(-1,0,\,)} retorna “C”. {tags:sublist(0,-1,\,)} retorna “A, B”.

Other

arguments(id[=expressão] [, id[=expressão]]*)

class calibre.utils.formatter_functions.BuiltinArguments[código fonte]

arguments(id[=expressão] [, id[=expressão]]*) – Usada em um modelo salvo para recuperar os argumentos passados na chamada. Ela tanto declara como inicializa variáveis locais, parâmetros efetivos. As variáveis são posicionais; elas recebem o valor do parâmetro dado na chamada na mesma posição. Se o parâmetro correspondente não for fornecido na chamada, então a função arguments atribui àquela variável o valor padrão fornecido. Caso não haja valor padrão, então a variável será definida como uma string vazia.

assign(id, val)

class calibre.utils.formatter_functions.BuiltinAssign[código fonte]

assign(id, val) – atribui val para id e então retorna val. id deve ser um identificador, não uma expressão. Esta função pode muitas vezes ser substituída pelo operador =.

globals(id[=expressão] [, id[=expressão]]*)

class calibre.utils.formatter_functions.BuiltinGlobals[código fonte]

globals(id[=expressão] [, id[=expressão]]*) – Recupera “variáveis globais” que podem ser passadas para o formatador. Ela tanto declara como inicializa variáveis locais com os nomes das variáveis globais passadas. Se a variável correspondente não for fornecida nas variáveis globais passadas, então será atribuída à variável o valor padrão fornecido. Caso não haja valor padrão, então a variável será definida como uma string vazia.

Recursion

eval(template)

class calibre.utils.formatter_functions.BuiltinEval[código fonte]

eval(template) – avalia o modelo, passando as variáveis ​​locais (aquelas atribuídas) em vez dos metadados do livro. Isto permite usar o processador de modelo para a construção de resultados complexos de variáveis ​​locais. Como os caracteres { e } são especiais, você deve usar o caractere [[ para o caractere { e ]] para }; então eles serão convertidos automaticamente. Note também que prefixos e sufixos (a sintaxe |prefixo|sufixo syntax) não podem ser usados no argumento para esta função ao usar o modo de programação do modelo.

template(x)

class calibre.utils.formatter_functions.BuiltinTemplate[código fonte]

template(x) – avalia x como um modelo. A avaliação é feita em seu próprio contexto, o que significa que as variáveis não são compartilhadas entre o modelo de chamada e avaliação. Como os caracteres { e } são especiais, você deve usar o caractere [[ para o caractere { e ]] para }; então eles serão convertidos automaticamente. Por exemplo, template(‘[[title_sort]]’) irá avaliar o modelo {title_sort} e retornar o seu valor. Note também que prefixos e sufixos (a sintaxe |prefixo|sufixo) não podem ser usados no argumento para esta função ao usar o modo de programação do modelo.

Relational

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

class calibre.utils.formatter_functions.BuiltinCmp[código fonte]

cmp(x, y, lt, eq, gt) – compara x e y depois de converter ambos para números. Retorna ‘lt’ se x < y. Retorna ‘eq’ se x == y. Do contrário, retorna ‘gt’. Em muitos casos, os operadores de comparação numéricos (>#, <#, ==#, etc) podem substituir esta função.

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

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[código fonte]

first_matching_cmp(val, [cmp1, result1]+, else_result) – compara “val < cmpN” na sequência, retornando resultN para a primeira comparação bem sucedida. Retorna else_result se nenhuma comparação for bem sucedida. Exemplo: first_matching_cmp(10,5,”pequeno”,10,”médio”,15,”grande”,”gigante”) retorna “grande”. O mesmo exemplo com um primeiro valor de 16, retorna “gigante”.

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

class calibre.utils.formatter_functions.BuiltinStrcmp[código fonte]

strcmp(x, y, lt, eq, gt) – faz uma comparação de maiúsculas e minúsculas de x e y com strings. Retorna ‘lt’ se x < y. Retorna ‘eq’ se x == y. Do contrário, retorna ‘gt’. Em muitos casos, os operadores de comparação lexicais (>, <, ==, etc) podem substituir esta função.

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

class calibre.utils.formatter_functions.BuiltinStrcmpcase[código fonte]

strcmpcase(x, y, lt, eq, gt) – does a case-sensitive comparison of x and y as strings. Returns lt if x < y. Returns eq if x == y. Otherwise returns gt. Note: This is NOT the default behavior used by calibre, for example, in the lexical comparison operators (==, >, <, etc.). This function could cause unexpected results, preferably use strcmp() whenever possible.

String case changes

capitalize(val)

class calibre.utils.formatter_functions.BuiltinCapitalize[código fonte]

capitalize(val) – retorna o valor do campo capitalizado

lowercase(val)

class calibre.utils.formatter_functions.BuiltinLowercase[código fonte]

lowercase(val) – retorna o valor do campo em caixa-baixa

titlecase(val)

class calibre.utils.formatter_functions.BuiltinTitlecase[código fonte]

titlecase(val) – retorna o valor do campo em formato de título

uppercase(val)

class calibre.utils.formatter_functions.BuiltinUppercase[código fonte]

uppercase(val) – retorna o valor do campo em caixa-alta

String manipulation

character(nome_caractere)

class calibre.utils.formatter_functions.BuiltinCharacter[código fonte]

character(nome_caractere) – retorna o caractere nomeado por nome_caractere. Por exemplo, character(‘newline’) retornar um caractere newline (nova linha) (’n’). Os nomes de caractere suportados são ‘newline’, ‘return’, ‘tab’, e ‘backslash’.

re(val, pattern, replacement)

class calibre.utils.formatter_functions.BuiltinRe[código fonte]

re(val, pattern, replacement) – retorna val depois de aplicar a expressão regular. Todas as instâncias de pattern são substituídas por` replacement`. Como em todo o calibre, estas são expressões regulares compatíveis com Python

re_group(val, pattern [, template_for_group]*)

class calibre.utils.formatter_functions.BuiltinReGroup[código fonte]

re_group(val, pattern [, template_for_group]*) – retorna uma string feita aplicando o padrão de expressão regular ao val e substituindo cada instância correspondente com a string calculada substituindo cada grupo acompanhado pelo valor retornado pelo modelo correspondente. O valor combinado original para o grupo está disponível como $. No modo de programa modelo, como para o modelo e as funções eval, você usa [[ para { e ]] para }. O exemplo a seguir no modo de programação modelo olha para a série com mais de uma palavra e a primeira palavra em maiúsculas: {series:’re_group($, “(S* )(.*)”, “[[$:uppercase()]]”, “[[$]]”)’}

shorten(val, caracteres à esquerda, texto do meio, caracteres à direita)

class calibre.utils.formatter_functions.BuiltinShorten[código fonte]

shorten(val, caracteres à esquerda, texto do meio, caracteres à direita) – Retorna uma versão abreviada de val, formada pela quantidade de caracteres à esquerda a partir do início de val, seguido por texto do meio, seguido pela quantidade de caracteres à direita do fim da string. Caracteres à esquerda e caracteres à direita devem ser inteiros. Por exemplo, suponha que o título do livro é Antigas leis inglesas nos tempos de Ivanhoe, e quer que ele se ajuste a uma dimensão de, no máximo, 15 caracteres. Se usar {title:shorten(9,-,5)}, o resultado será Antigas I-anhoe. Se o comprimento do campo for menor que os caracteres à esquerda + caracteres à direita + comprimento de texto do meio, então o campo será usado intacto. Por exemplo, o título A redoma não seria alterado.

strcat(a [, b]*)

class calibre.utils.formatter_functions.BuiltinStrcat[código fonte]

strcat(a [, b]*) – pode levar qualquer número de argumentos. Retorna a string formada ao concatenar todos os argumentos

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

class calibre.utils.formatter_functions.BuiltinStrcatMax[código fonte]

strcat_max(max, string1 [, prefix2, string2]*) – Retorna uma string formada pela concatenação dos argumentos. O valor retornado é inicializado para string1. Pares Prefix, string são adicionados ao fim do valor enquanto o comprimento da string resultante é inferior a max. String1 é retornado se string1 for maior que max. Você pode passar quantos pares prefix, string você quiser.

strlen(a)

class calibre.utils.formatter_functions.BuiltinStrlen[código fonte]

strlen(a) – Retorna o comprimento da string passada como argumento

substr(str, inicio, fim)

class calibre.utils.formatter_functions.BuiltinSubstr[código fonte]

substr(str, inicio, fim) – retorna os caracteres a partir da posição ‘início’ até a posição ‘fim’ de ‘str’. O primeiro caractere de ‘str’ é a posição zero. Se ‘fim’ é negativo, então isso indica que será contado esse número de caracteres a partir da direita. Se ‘fim’ é zero, então isso indica o último caractere. Por exemplo, substr(‘12345’, 1, 0) retorna ‘2345’, e substr(‘12345’, 1, -1) retorna ‘234’.

swap_around_articles(valor, separador)

class calibre.utils.formatter_functions.BuiltinSwapAroundArticles[código fonte]

swap_around_articles(valor, separador) – retorna o valor com os artigos movidos para o final. O valor pode ser uma lista, a qual terá cada membro processado. Se o valor é uma lista, então você deve informar o separador de valores. Se nenhum separador for fornecido, então o valor será tratado como sendo um único valor, e não uma lista.

swap_around_comma(val)

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[código fonte]

swap_around_comma(val) – determinar um valor de forma “B, A”, retorna “A B”. Isto é muito útil para a conversão de nomes em formatos LN, FN para FN LN. Se não houver nenhuma vírgula, a função val retorna sem alteração

to_hex(val)

class calibre.utils.formatter_functions.BuiltinToHex[código fonte]

to_hex(val) – returns the string encoded in hex. This is useful when constructing calibre URLs.

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate[código fonte]

transliterate(a) – Retorna uma string no alfabeto latino formado pelo som aproximado das palavras na sequência de origem. Por exemplo, se a origem for “Фёдор Миха́йлович Достоевский” a função retorna “Fiodor Mikhailovich Dostoievskii”.

Template database functions

book_count(termo_de_busca, usar_bv)

class calibre.utils.formatter_functions.BuiltinBookCount[código fonte]

book_count(termo_de_busca, usar_bv) – retorna a contagem de livros encontrados aos pesquisar pelo termo_de_busca. Caso usar_bv seja 0 (zero), então bibliotecas virtuais são ignoradas. Esta função pode ser usada apenas na Interface Gráfica.

book_values(col, termo_de_busca, sep, usar_bv)

class calibre.utils.formatter_functions.BuiltinBookValues[código fonte]

book_values(col, termo_de_busca, sep, usar_bv) – retorna uma lista de valores contidos na coluna “col”, separados por “sep”, nos livros encontrados ao pesquisar pelo “termo_de_busca”. Caso usar_bv seja 0 (zero), então bibliotecas virtuais são ignoradas. Esta função pode ser usada apenas na Interface Gráfica.

other

set_globals(id[=expressão] [, id[=expressão]]*)

class calibre.utils.formatter_functions.BuiltinSetGlobals[código fonte]

set_globals(id[=expressão] [, id[=expressão]]*) – Define “variáveis globais” que podem ser passadas para o formatador. As variáveis globais recebem o nome do id passado. O valor do id é usado a não ser que uma expressão seja fornecida.

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=('Desconhecido',), other=None, template_cache=None, formatter=None)[código fonte]

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)[código fonte]

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>>)[código fonte]

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()[código fonte]

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)[código fonte]

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

set_identifier(typ, val)[código fonte]

If val is empty, deletes identifier of type typ

standard_field_keys()[código fonte]

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

custom_field_keys()[código fonte]

return a list of the custom fields in this book

all_field_keys()[código fonte]

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

metadata_for_field(key)[código fonte]

return metadata describing a standard or custom field.

all_non_none_fields()[código fonte]

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

get_standard_metadata(field, make_copy)[código fonte]

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)[código fonte]

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

get_all_user_metadata(make_copy)[código fonte]

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

get_user_metadata(field, make_copy)[código fonte]

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)[código fonte]

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

set_user_metadata(field, metadata)[código fonte]

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

remove_stale_user_metadata(other_mi)[código fonte]

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)[código fonte]

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)[código fonte]

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)[código fonte]

Returns the tuple (display_name, formatted_value)

to_html()[código fonte]

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