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

class calibre.utils.formatter_functions.BuiltinFormatDateField[código-fonte]¶: 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[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_links(val_separator, pair_separator)¶

class calibre.utils.formatter_functions.BuiltinAuthorLinks[código-fonte]¶: 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[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

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

class calibre.utils.formatter_functions.BuiltinSwitchIf[código-fonte]¶: 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[código-fonte]¶: 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[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.

print(a[, b]*)¶

class calibre.utils.formatter_functions.BuiltinPrint[código-fonte]¶: 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[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) – 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[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) – retorna a string codificada em hex. Isto é útil ao construir URLs do calibre.

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.

extra_file_modtime(nome_arquivo, formato_string)¶

class calibre.utils.formatter_functions.BuiltinExtraFileModtime[código-fonte]¶: 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[código-fonte]¶: 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[código-fonte]¶: 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[código-fonte]¶: 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(field_name, field_value, plain_text)¶

class calibre.utils.formatter_functions.BuiltinGetNote[código-fonte]¶: get_note(field_name, field_value, plain_text) – fetch the note for field ‘field_name’ with value ‘field_value’. If ‘plain_text’ is empty, return the note’s HTML includingimages. If ‘plain_text’ is 1 (or ‘1’), return the note’s plain text. If the note doesn’t exist, return the empty string in both cases. Example: get_note(‘tags’, ‘Fiction’, ‘’) returns the HTML of the note attached to the tag ‘Fiction’.

has_extra_files([padrao])¶

class calibre.utils.formatter_functions.BuiltinHasExtraFiles[código-fonte]¶: 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[código-fonte]¶: 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[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 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