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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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_date_field(nome_do_campo, string_de_formatacao)

class calibre.utils.formatter_functions.BuiltinFormatDateField

format_date_field(nome_do_campo, string_de_formatacao) – formata o valor no campo ‘nome_do_campo’, o qual deve ser o nome para pesquisa da coluna de data, seja ela padrão ou personalizada. Veja ‘format_date’ para os códigos de formatação. Esta função é muito mais rápida do que ‘format_date’ e deve ser utilizada quando você estiver formatando o valor de um campo (coluna). Ela não pode ser usada para datas computadas ou datas em variáveis de texto. Exemplo: format_date_field(‘pubdate’, ‘yyyy.MM.dd’)

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber

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

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

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

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

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

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_links(val_separator, pair_separator)

class calibre.utils.formatter_functions.BuiltinAuthorLinks

author_links(val_separator, pair_separator) – retorna uma sequência contendo uma lista de autores e valores de link que do autor na forma author1 val_separator author1link pair_separator author2 val_separator author2link etc. Um autor é separado de seu valor de ligação pela sequência val_separator sem espaços adicionais. autor: pares linkvalue são separados pelo argumento string pair_separator sem espaços adicionais. Cabe a você escolher sequências de separação que não ocorrem em nomes de autores ou links. Um autor é incluído, mesmo se o link autor estiver em branco.

author_sorts(val_separator)

class calibre.utils.formatter_functions.BuiltinAuthorSorts

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

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

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

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

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

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

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

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

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

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths

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

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

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

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

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

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

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

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

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

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

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries

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

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

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

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

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

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

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

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

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

switch_if([expressao_teste, expressao_valor,]+ expressão_senao)

class calibre.utils.formatter_functions.BuiltinSwitchIf

switch_if([expressao_teste, expressao_valor,]+ expressão_senao) – para cada par “expressao_teste, expressao_valor”, verifica se a expressao_teste é Verdadeira (não-vazia) e, se sim, retorna o resultado da expressao_valor. Se nenhuma expressao_teste for Verdadeira, então o resultado o resultado da expressao_senao é retornado. Você pode ter tantos pares “expressao_teste, expressao_valor” quanto quiser.

List lookup

identifier_in_list(val, nome_id [, val_encontrado, val_nao_encontrado])

class calibre.utils.formatter_functions.BuiltinIdentifierInList

identifier_in_list(val, nome_id [, val_encontrado, val_nao_encontrado]) – trata val como uma lista de identificadores separados por vírgula. Um identificador tem o formato “nome_id: valor”. O parâmetro nome_id é o texto a ser buscado, pode ser “nome_id” ou “nome_id:regexp”. O primeiro caso irá corresponder se houver qualquer identificador correspondente a nome_id. O segundo caso irá corresponder se nome_id combinar com um identificador e a expressão regular (regexp) combinar com o valor do identificador. Se val_encontrado e val_nao_encontrado forem fornecidos, então se houver correspondência será retornado val_encontrado, do contrário irá retornar val_nao_encontrado. Se val_encontrado e val_nao_encontrado não forem fornecidos, então se houver uma correspondência, será retornado o par identificador:valor, do contrário uma string vazia.

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

class calibre.utils.formatter_functions.BuiltinInList

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

print(a[, b]*)

class calibre.utils.formatter_functions.BuiltinPrint

print(a[, b]*) – imprime os argumentos para a saída padrão. A menos que você inicie o calibre a partir da linha de comando (calibre-debug -g), a saída irá para um buraco negro.

Recursion

eval(template)

class calibre.utils.formatter_functions.BuiltinEval

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

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

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

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

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

strcmpcase(x, y, lt, eq, gt) – faz uma comparação entre x e y como strings, com distinção entre maiúsculas e minúsculas. Retorna lt se x < y. Retorna eq se x == y. Do contrário retorna gt. Nota: Este NÃO é o comportamento padrão usado pelo calibre, por exemplo, nos operadores de comparação léxica (==, >, <, etc.). Esta função pode causar resultados inesperados. Utilize strcmp() sempre que possível..

String case changes

capitalize(val)

class calibre.utils.formatter_functions.BuiltinCapitalize

capitalize(val) – retorna o valor do campo capitalizado

lowercase(val)

class calibre.utils.formatter_functions.BuiltinLowercase

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

titlecase(val)

class calibre.utils.formatter_functions.BuiltinTitlecase

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

uppercase(val)

class calibre.utils.formatter_functions.BuiltinUppercase

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

String manipulation

character(nome_caractere)

class calibre.utils.formatter_functions.BuiltinCharacter

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

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

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

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

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

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

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

substr(str, inicio, fim)

class calibre.utils.formatter_functions.BuiltinSubstr

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

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

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

to_hex(val) – retorna a string codificada em hex. Isto é útil ao construir URLs do calibre.

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate

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

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

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.

extra_file_modtime(nome_arquivo, formato_string)

class calibre.utils.formatter_functions.BuiltinExtraFileModtime

extra_file_modtime(nome_arquivo, formato_string) – retorna a data de modificação do arquivo extra ‘nome_arquivo’ na pasta ‘data/’ do livro se ela existir, do contrário retorna -1.0. A data de modificação é formatada de acordo com ‘format_string’ (veja format_date()). Se ‘format_string’ for vazio, retorna a data de modificação como o número de ponto flutuante dos segundos desde a ‘epoch’. A ‘epoch’ depende do Sistema Operacional. Esta função pode ser usada somente na GUI (Interface Gráfica).

extra_file_names(sep [, padrao])

class calibre.utils.formatter_functions.BuiltinExtraFileNames

extra_file_names(sep [, padrao]) – retorna uma lista de arquivos extras separados por ‘sep’ na pasta ‘data/’ do livro. Se o padrão opcional ‘padrao’, uma expressão regular, for fornecido, então a lista é filtrada com os arquivos que correspondem ao padrão. O de padrão de correspondência faz distinção entre maiúsculas e minúsculas. Esta função pode ser usada somente na GUI (Interface Gráfica).

extra_file_size(nome_arquivo)

class calibre.utils.formatter_functions.BuiltinExtraFileSize

extra_file_size(nome_arquivo) – retorna o tamanho em bytes do arquivo extra ‘nome_arquivo’ na pasta ‘data/’ do livro ela existir, do contrário retorna -1. Esta função só pode ser usada na GUI (Interface Gráfica).

get_link(nome_do_campo, valor_do_campo)

class calibre.utils.formatter_functions.BuiltinGetLink

get_link(nome_do_campo, valor_do_campo) – obtém o linke para o campo ‘nome_do_campo’ com o valor ‘valor_do_campo’. Caso não exista um link vinculado, retorna ‘’. Exemplo: get_link(‘tags’, ‘Ficção’) retorna o link vinculado à etiqueta ‘Ficção’.

get_note(nome_do_campo, valor_do_campo, texto_simples)

class calibre.utils.formatter_functions.BuiltinGetNote

get_note(nome_do_campo, valor_do_campo, texto_simples) – obtém a nota para o campo ‘nome_do_campo’ com o valor ‘valor_do_campo’. Se ‘texto_simples’ for vazio, retorna a versão HTML da nota. Se ‘plain_text’ não for vazio, retorna o texto da nota sem formatação. Caso a nota não exista, retorna ‘’ em ambos os casos. Exemplo: get_note(‘tags’, ‘Ficção’, ‘’) retorna a versão HTML da nota vinculada à etiqueta ‘Ficção’.

has_extra_files([padrao])

class calibre.utils.formatter_functions.BuiltinHasExtraFiles

has_extra_files([padrao]) – retorna a contagem de arquivos extras, do contrário ‘’ (a string vazia). Se o parâmetro opcional ‘padrao’ (uma expressão regular) for fornecido, então a lista é filtrada com os arquivos que correspondem ao padrão antes de os arquivos serem contados. A correspondência ao padrão é sensível a maiúsculas / minúsculas. Esta função pode ser usada somente na GUI (Interface Gráfica).

has_note(nome_do_campo, valor_do_campo)

class calibre.utils.formatter_functions.BuiltinHasNote

has_note(nome_do_campo, valor_do_campo) – retorna ‘1’ se o valor ‘valor_do_campo’ no campo ‘nome_do_campo’ tiver uma nota vinculada, do contrário retorna ‘’. Exemplo: has_note(‘tags’, ‘Ficção’) retorna ‘1’ se a etiqueta ‘Ficção’ tiver uma nota vinculada, do contrário retorna ‘’.

other

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

class calibre.utils.formatter_functions.BuiltinSetGlobals

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)

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)

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

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

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)

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

set_identifier(typ, val)

If val is empty, deletes identifier of type typ

standard_field_keys()

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

custom_field_keys()

return a list of the custom fields in this book

all_field_keys()

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

metadata_for_field(key)

return metadata describing a standard or custom field.

all_non_none_fields()

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

get_standard_metadata(field, make_copy)

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)

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

get_all_user_metadata(make_copy)

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

get_user_metadata(field, make_copy)

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)

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

set_user_metadata(field, metadata)

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

remove_stale_user_metadata(other_mi)

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)

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)

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)

Returns the tuple (display_name, formatted_value)

to_html()

A HTML representation of this object.

calibre.ebooks.metadata.book.base.STANDARD_METADATA_FIELDS

The set of standard metadata fields.

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

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

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

TOP_LEVEL_IDENTIFIERS = frozenset((
    'isbn',
))

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

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

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

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

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

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

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

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

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

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

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

© Direitos Autorais Kovid Goyal. Última atualização em abr. 19, 2024.