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.

Alteração de maiúsculas/minúsculas ¶

capitalize ¶

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

capitalize(value) – retorna o value com a primeira letra em maiúscula e o restante em minúsculas.

lowercase ¶

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

lowercase(value) – retorna o value em minúsculas.

titlecase ¶

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

titlecase(value) – retorna o value em título (capitalização).

uppercase ¶

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

uppercase(value) – retorna o value em maiúsculas.

Aritmético ¶

add ¶

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 dos argumentos não for um número. Na maioria dos casos, pode ser utilizado o operador + em vez dessa função.

ceiling ¶

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

ceiling(value) – retorna o menor inteiro maior ou igual a value. Lança uma exceção se value não for um número.

divide ¶

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 geralmente pode ser substituída pelo operador /.

floor ¶

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

floor(value) – retorna o maior inteiro menor ou igual a value. Lança uma exceção se value não for um número.

fractional_part ¶

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

fractional_part(value) – retorna a parte do valor após o ponto decimal. Por exemplo, fractional_part(3.14) retorna 0.14. Lança uma exceção se value não for um número.

mod ¶

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

mod(value, y) – retorna o floor do resto de value / y. Lança uma exceção se value ou y não for um número.

multiply ¶

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

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

round ¶

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

round(value) – retorna o inteiro mais próximo de value. Lança uma exceção se value não for um número.

subtract ¶

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 geralmente pode ser substituída pelo operador -.

Booleano ¶

and ¶

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

and(value [, value]*) – returns the string '1' if all values are not empty, otherwise returns the empty string. You can have as many values as you want. In most cases you can use the && operator instead of this function. One reason not to replace and() with && is when short-circuiting can change the results because of side effects. For example, and(a='',b=5) will always do both assignments, where the && operator won’t do the second.

Mostrando a documentação em inglês devido ao erro FFML: Missing closing “``” for CODE_TEXT on line 1 in “and”

not ¶

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

not(value) – retorna a string '1' se o valor estiver vazio, caso contrário, retorna a string vazia. Esta função geralmente pode ser substituída pelo operador unário not (!).

or ¶

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

or(valor [, valor]*) – retorna a string '1' se qualquer valor não estiver vazio; caso contrário, retorna uma string vazia. Você pode ter quantos valores desejar. Esta função geralmente pode ser substituída pelo operador ||. Um motivo para não ser substituída é se o curto-circuito alterar os resultados devido a efeitos colaterais.

Formatação de valores ¶

f_string ¶

class calibre.utils.formatter_functions.BuiltinFString[código-fonte]¶

f_string(string) – interpreta string de forma semelhante a como o Python interpreta strings f. O uso pretendido é simplificar longas sequências de expressões str & str ou strcat(a,b,c).

Texto entre chaves ({ e }) deve ser expressões de template no Modo de Programa Geral. As expressões, que podem ser listas de expressões, são avaliadas no contexto atual (livro atual e variáveis locais). Texto não entre chaves é passado inalterado.

Exemplos:

f_string('Aqui está o título: {$title}') - retorna a string com {$title} substituído pelo título do livro atual. Por exemplo, se o título do livro for 20.000 Léguas Submarinas, então f_string() retorna Aqui está o título: 20.000 Léguas Submarinas.
Supondo que a data atual seja 18 de setembro de 2025, este f_string()
```
f_string("Data de hoje: {d = today(); format_date(d, 'd')} de {format_date(d, 'MMMM')}, {format_date(d, 'yyyy')}")
```
retorna a string Data de hoje: 18 de setembro, 2025. Observe a lista de expressões (uma atribuição e então uma declaração if) usada no primeiro grupo { ... } para atribuir a data de hoje a uma variável local.

Se o livro for o livro #3 em uma série chamada Foo que tem 5 livros, então este template

program:
    if $series then
        series_count = book_count('series:"""=' & $series & '"""', 0);
        return f_string("{$series}, livro {$series_index} de {series_count}")
    fi;
    return 'Este livro não está em uma série'

retorna Foo, livro 3 de 5

finish_formatting ¶

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

finish_formatting(value, format, prefix, suffix) – aplica o format, prefix e suffix ao value da mesma forma que em um modelo como {series_index:05.2f| - |- }. Esta função é fornecida para facilitar a conversão de modelos complexos de função única ou em modo de programa de modelo para modelos GPM. Por exemplo, o seguinte programa produz a mesma saída que o modelo acima:

program: finish_formatting(field("series_index"), "05.2f", " - ", " - ")

Outro exemplo: para o modelo:

{series:re(([^\s])[^\s]+(\s|$),\1)}{series_index:0>2s| - | - }{title}

use:

program:
    strcat(
        re(field('series'), '([^\s])[^\s]+(\s|$)', '\1'),
        finish_formatting(field('series_index'), '0>2s', ' - ', ' - '),
        field('title')
    )

format_date ¶

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

format_date(value, format_string) – formata o value, que deve ser uma string de data, usando o format_string, retornando uma string. É melhor se a data estiver no formato ISO, pois usar outros formatos de data frequentemente causa erros porque o valor real da data não pode ser determinado de forma inequívoca. Observe que a função format_date_field() é mais rápida e confiável.

Os códigos de formatação são:

d : o dia como número sem um zero à esquerda (1 a 31)
dd : o dia como número com um zero à esquerda (01 a 31)
ddd : o nome do dia localizado abreviado (ex.: “Seg” a “Dom”)
dddd : o nome do dia localizado longo (ex.: “Segunda” a “Domingo”)
M : o mês como número sem um zero à esquerda (1 a 12)
MM : o mês como número com um zero à esquerda (01 a 12)
MMM : o nome do mês localizado abreviado (ex.: “Jan” a “Dez”)
MMMM : o nome do mês localizado longo (ex.: “Janeiro” a “Dezembro”)
yy : o ano como número de dois dígitos (00 a 99)
yyyy : o ano como número de quatro dígitos.
h : as horas sem um 0 à esquerda (0 a 11 ou 0 a 23, dependendo de am/pm)
hh : as horas com um 0 à esquerda (00 a 11 ou 00 a 23, dependendo de am/pm)
m : os minutos sem um 0 à esquerda (0 a 59)
mm : os minutos com um 0 à esquerda (00 a 59)
s : os segundos sem um 0 à esquerda (0 a 59)
ss : os segundos com um 0 à esquerda (00 a 59)
ap : usa um relógio de 12 horas em vez de 24 horas, com ‘ap’ substituído pela string localizada em minúsculas para am ou pm
AP : usa um relógio de 12 horas em vez de 24 horas, com ‘AP’ substituído pela string localizada em maiúsculas para AM ou PM
aP : usa um relógio de 12 horas em vez de 24 horas, com ‘aP’ substituído pela string localizada para AM ou PM
Ap : usa um relógio de 12 horas em vez de 24 horas, com ‘Ap’ substituído pela string localizada para AM ou PM
iso : a data com hora e fuso horário. Deve ser o único formato presente
to_number : converte a data e hora em um número de ponto flutuante (um timestamp)
from_number : converte um número de ponto flutuante (um timestamp) em uma data formatada em ISO. Se você quiser um formato de data diferente, adicione a string de formatação desejada após from_number e dois pontos (:). Exemplo:
```
format_date(val, 'from_number:MMM dd yyyy')
```

Você pode obter resultados inesperados se a data que está formatando contiver nomes de meses localizados, o que pode acontecer se você alterou o formato da data para conter MMMM. Usar format_date_field() evita esse problema.

format_date_field ¶

class calibre.utils.formatter_functions.BuiltinFormatDateField[código-fonte]¶

format_date_field(field_name, format_string) – formata o valor no campo field_name, que deve ser o nome de pesquisa de um campo de data, seja padrão ou personalizado. Veja format_date() para os códigos de formatação. Esta função é muito mais rápida que format_date() e deve ser usada quando você estiver formatando o valor em um campo (coluna). Também é mais confiável porque trabalha diretamente sobre a data subjacente. Não pode ser usada para datas calculadas ou datas em variáveis de string. Exemplos:

format_date_field('pubdate', 'yyyy.MM.dd')
format_date_field('#date_read', 'MMM dd, yyyy')

format_duration ¶

class calibre.utils.formatter_functions.BuiltinFormatDuration[código-fonte]¶

format_duration(value, template, [largest_unit]) – formata o valor, um número de segundos, em uma string mostrando semanas, dias, horas, minutos e segundos. Se o valor for um float, ele é arredondado para o inteiro mais próximo. Você escolhe como formatar o valor usando um modelo que consiste em seletores de valor cercados por caracteres [ e ]. Os seletores são:

[w]: semanas
[d]: dias
[h]: horas
[m]: minutos
[s]: segundos

Você pode colocar texto arbitrário entre os seletores.

Os exemplos a seguir usam uma duração de 2 dias (172.800 segundos) 1 hora (3.600 segundos) e 20 segundos, totalizando 176.420 segundos.

format_duration(176420, '[d][h][m][s]') retornará o valor 2d 1h 0m 20s.
format_duration(176420, '[h][m][s]') retornará o valor 49h 0m 20s.
format_duration(176420, 'Seu tempo de leitura é [d][h][m][s]') retorna o valor Seu tempo de leitura é 49h 0m 20s.
format_duration(176420, '[w][d][h][m][s]') retornará o valor 2d 1h 0m 20s. Observe que o valor zero de semanas não é retornado.

Se você quiser ver valores zero para itens como semanas no exemplo acima, use um seletor em maiúsculas. Por exemplo, o seguinte usa 'W' para mostrar zero semanas:

format_duration(176420, '[W][d][h][m][s]') retorna 0w 2d 1h 0m 20s.

Por padrão, o texto após um valor é o seletor seguido por um espaço. Você pode alterar isso para qualquer texto que desejar. O formato para um seletor com seu texto é o seletor seguido por dois pontos e depois segmentos de texto separados por caracteres '|'. Você deve incluir quaisquer caracteres de espaço que desejar na saída.

Você pode fornecer de um a três segmentos de texto.

Se você fornecer um segmento, como em [w: semanas ], esse segmento é usado para todos os valores.
Se você fornecer dois segmentos, como em [w: semanas | semana ], o primeiro segmento é usado para 0 e mais de 1. O segundo segmento é usado para 1.
Se você fornecer três segmentos, como em [w: semanas | semana | semanas ], o primeiro segmento é usado para 0, o segundo segmento é usado para 1 e o terceiro segmento é usado para mais de 1.

A segunda forma é equivalente à terceira forma em muitos idiomas.

Por exemplo, o seletor:

[w: semanas | semana | semanas ] produz '0 semanas ', '1 semana ' ou '2 semanas '.
[w: semanas | semana ] produz '0 semanas ', '1 semana ' ou '2 semanas '.
[w: semanas ] produz 0 semanas ', 1 semanas ' ou 2 semanas '.

O parâmetro opcional largest_unit especifica a maior unidade entre semanas, dias, horas, minutos e segundos que será produzida pelo modelo. Ele deve ser um dos seletores de valor. Isso pode ser útil para truncar um valor.

format_duration(176420, '[h][m][s]', 'd') retornará o valor 1h 0m 20s em vez de 49h 0m 20s.

format_number ¶

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

format_number(value, template) – interpreta o value como um número e formata esse número usando um modelo de formatação Python como {0:5.2f} ou {0:,d} ou ${0:5,.2f}. O modelo de formatação deve começar com {0: e terminar com } como nos exemplos acima. Exceção: você pode omitir o “{0:” inicial e o “}” final se o modelo de formatação contiver apenas um formato. Consulte a Linguagem de Template e a documentação Python para mais exemplos. Retorna a string vazia se a formatação falhar.

human_readable ¶

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

human_readable(value) – espera que o value seja um número e retorna uma string representando esse número em KB, MB, GB, etc.

rating_to_stars ¶

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

rating_to_stars(value, use_half_stars) – Retorna o value como uma string de caracteres de estrela (★). O valor deve ser um número entre 0 e 5. Defina use_half_stars como 1 se quiser caracteres de meia estrela para números fracionários disponíveis com colunas de classificação personalizadas.

Funções da GUI ¶

selected_books ¶

class calibre.utils.formatter_functions.BuiltinSelectedBooks[código-fonte]¶

selected_books([sorted_by, ascending]) – retorna uma lista de IDs de livros na ordem de seleção para os livros atualmente selecionados.

Esta função só pode ser usada na GUI.

selected_column ¶

class calibre.utils.formatter_functions.BuiltinSelectedColumn[código-fonte]¶

selected_column() – retorna o nome de pesquisa da coluna que contém a célula atualmente selecionada. Retorna '' se nenhuma célula estiver selecionada.

Esta função só pode ser usada na GUI.

show_dialog ¶

class calibre.utils.formatter_functions.BuiltinShowDialog[código-fonte]¶

show_dialog(html_ou_texto) – mostra uma caixa de diálogo contendo o html ou texto. A função retorna '1' se o usuário pressionar OK, '' se Cancelar.

Esta função pode ser usada apenas na interface gráfica.

sort_book_ids ¶

class calibre.utils.formatter_functions.BuiltinSortBookIds[código-fonte]¶

sort_book_ids(ids_dos_livros, ordenado_por, ascendente [, ordenado_por, ascendente]*) – retorna a lista de IDs de livros ordenada pela coluna especificada pelo nome de pesquisa em ordenado_por na ordem especificada por ascendente. Se ascendente for '1', os livros serão ordenados pelo valor na coluna ‘ordenado_por’ em ordem crescente; caso contrário, em ordem decrescente. Você pode ter vários pares de ordenado_por, ascendente. O primeiro par especifica a ordem principal.

Esta função pode ser usada apenas na interface gráfica.

width_from_pages ¶

class calibre.utils.formatter_functions.BuiltinWidthFromPages[código-fonte]¶

width_from_pages(value [, num_of_pages_for_max_width, logarithmic_factor, default_width]) – retorna a largura da lombada do livro como uma fração entre '0' e '1', dado um número de páginas. Isso é usado para calcular a largura da lombada na visualização da Estante, a partir da contagem de páginas. Os argumentos opcionais controlam como a largura é calculada.

num_of_pages_for_max_width – controla a largura dos livros mais largos; qualquer livro com pelo menos o número de páginas especificado recebe largura 1. O padrão é 1500.
logarithmic_factor – controla a rapidez com que a largura varia conforme o número de páginas varia de 0 até o máximo. O padrão é 2.
default_width – é a largura para livros com um número inválido de páginas.

Funções de banco de dados ¶

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 livro atual. Esta função funciona apenas na GUI e no servidor de conteúdo.

approximate_formats ¶

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

approximate_formats() – retorna uma lista separada por vírgulas dos formatos associados com o livro. Como a lista vem do banco de dados do calibre, em vez do sistema de arquivos, não há garantia de que a lista esteja correta, embora provavelmente esteja. Note que o nome dos formatos resultantes estão sempre em maiúsculo, como em EPUB. A função approximate_formats() é muito mais rápida do que as funções formats_....

Esta função funciona somente na interface gráfica. Caso deseje utilizar estes valores nos modelos de salvar no disco ou enviar para o dispositivo, então você terá que criar uma coluna do tipo “Coluna criada a partir de outras colunas”, usar a função no modelo daquela coluna, e usar o valor daquela coluna nos seus modelos de salvar/enviar.

book_count ¶

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

book_count(query, use_vl) – retorna a contagem de livros encontrados ao pesquisar por query. Se use_vl for 0 (zero), então as bibliotecas virtuais são ignoradas. Esta função e sua companheira book_values() são particularmente úteis em pesquisas com templates, suportando pesquisas que combinam informações de muitos livros, como procurar por séries com apenas um livro. Não pode ser usada em colunas compostas, a menos que a opção allow_template_database_functions_in_composites esteja definida como True. Só pode ser usada na GUI.

Por exemplo, esta pesquisa com template usa esta função e sua companheira para encontrar todas as séries com apenas um livro:

Defina um template armazenado (usando Preferências → Avançado → Funções de template) chamado series_only_one_book (o nome é arbitrário). O template é:
```
program:
    vals = globals(vals='');
    if !vals then
        all_series = book_values('series', 'series:true', ',', 0);
        for series in all_series:
            if book_count('series:="' & series & '"', 0) == 1 then
                vals = list_join(',', vals, ',', series, ',')
            fi
        rof;
        set_globals(vals)
    fi;
    str_in_list(vals, ',', $series, 1, '')
```
A primeira vez que o template é executado (o primeiro livro verificado) ele armazena os resultados das consultas ao banco de dados em uma variável global de template chamada vals. Esses resultados são usados para verificar os livros subsequentes sem refazer as consultas.
Use o template armazenado em uma pesquisa com template:

template:"program: series_only_one_book()#@#:n:1"
Usar um template armazenado em vez de colocar o template na pesquisa elimina problemas causados pela necessidade de escapar aspas em expressões de pesquisa.

Esta função só pode ser usada na GUI e no servidor de conteúdo.

book_values ¶

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

book_values(column, query, sep, use_vl) – retorna uma lista dos valores únicos contidos na coluna column (um nome de pesquisa), separados por sep, nos livros encontrados ao buscar por query. Se use_vl for 0 (zero), então bibliotecas virtuais são ignoradas. Esta função e sua companheira book_count() são particularmente úteis em buscas de modelos, permitindo pesquisas que combinam informações de muitos livros, como procurar séries com apenas um livro. Ela não pode ser usada em colunas compostas, a menos que o ajuste allow_template_database_functions_in_composites esteja definido como True. Esta função pode ser usada apenas na GUI e no servidor de conteúdo.

extra_file_modtime ¶

class calibre.utils.formatter_functions.BuiltinExtraFileModtime[código-fonte]¶

extra_file_modtime(file_name, format_string) – retorna a data de modificação do arquivo extra file_name na pasta data/ do livro se existir, caso contrário -1. A data de modificação é formatada de acordo com format_string (veja format_date() para detalhes). Se format_string for uma string vazia, retorna a data de modificação como o número de segundos em ponto flutuante desde a época. Veja também as funções has_extra_files(), extra_file_names() e extra_file_size(). A época depende do sistema operacional. Esta função pode ser usada apenas na GUI e no servidor de conteúdo.

extra_file_names ¶

class calibre.utils.formatter_functions.BuiltinExtraFileNames[código-fonte]¶

extra_file_names(sep [, pattern]) – retorna uma lista separada por sep de arquivos extras na pasta data/ do livro. Se o parâmetro opcional pattern, uma expressão regular, for fornecido, a lista será filtrada para arquivos que correspondam a pattern. A correspondência do padrão não diferencia maiúsculas de minúsculas. Veja também as funções has_extra_files(), extra_file_modtime() e extra_file_size(). Esta função só pode ser usada na GUI e no servidor de conteúdo.

extra_file_size ¶

class calibre.utils.formatter_functions.BuiltinExtraFileSize[código-fonte]¶

extra_file_size(file_name) – retorna o tamanho em bytes do arquivo extra file_name na pasta data/ do livro se ele existir, caso contrário, retorna -1. Veja também as funções has_extra_files(), extra_file_names() e extra_file_modtime(). Esta função só pode ser usada na GUI e no servidor de conteúdo.

formats_modtimes ¶

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

formats_modtimes(date_format_string) – retorna uma lista separada por vírgulas de itens separados por dois pontos FMT:DATE representando os horários de modificação dos formatos de um livro. O parâmetro date_format_string especifica como a data deve ser formatada. Consulte a função format_date() para detalhes. Você pode usar a função select() para obter o horário de modificação de um formato específico. Observe que os nomes dos formatos estão sempre em maiúsculas, como em EPUB.

formats_path_segments ¶

class calibre.utils.formatter_functions.BuiltinFormatsPathSegments[código-fonte]¶

formats_path_segments(with_author, with_title, with_format, with_ext, sep) – retorna partes do caminho para um formato de livro na biblioteca do calibre separadas por sep. O parâmetro sep geralmente deve ser uma barra ('/'). Um uso é garantir que os caminhos gerados nos templates Salvar em disco e Enviar para dispositivo sejam encurtados de forma consistente. Outro é garantir que os caminhos no dispositivo correspondam aos caminhos na biblioteca do calibre.

Um caminho de livro consiste em 3 segmentos: o autor, o título incluindo o ID do banco de dados do calibre entre parênteses e o formato (autor - título). O calibre pode encurtar qualquer um dos três devido a limitações de comprimento do nome do arquivo. Você escolhe quais segmentos incluir passando 1 para esse segmento. Se você não quiser um segmento, passe 0 ou a string vazia para esse segmento. Por exemplo, o seguinte retorna apenas o nome do formato sem a extensão:

formats_path_segments(0, 0, 1, 0, '/')

Como há apenas um segmento, o separador é ignorado.

Se houver vários formatos (várias extensões), uma das extensões será escolhida aleatoriamente. Se você se importa com qual extensão é usada, obtenha o caminho sem a extensão e adicione a extensão desejada a ele.

Exemplos: Suponha que haja um livro na biblioteca do calibre com um formato epub de Joe Blogs com o título ‘Help’. Ele teria o caminho

Joe Blogs/Help - (calibre_id)/Help - Joe Blogs.epub

O seguinte mostra o que é retornado para vários parâmetros:

formats_path_segments(0, 0, 1, 0, '/') retorna Help - Joe Blogs
formats_path_segments(0, 0, 1, 1, '/') retorna Help - Joe Blogs.epub
formats_path_segments(1, 0, 1, 1, '/') retorna Joe Blogs/Help - Joe Blogs.epub
formats_path_segments(1, 0, 1, 0, '/') retorna Joe Blogs/Help - Joe Blogs
formats_path_segments(0, 1, 0, 0, '/') retorna Help - (calibre_id)

formats_paths ¶

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

formats_paths([separator]) – retorna uma lista separada por separator de itens separados por dois pontos FMT:PATH fornecendo o caminho completo para os formatos de um livro. O argumento separator é opcional. Se não fornecido, o separador é ', ' (vírgula e espaço). Se o separador for uma vírgula, você pode usar a função select() para obter o caminho para um formato específico. Observe que os nomes dos formatos estão sempre em maiúsculas, como em EPUB.

formats_sizes ¶

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

formats_sizes() – retorna uma lista separada por vírgulas de itens separados por dois pontos FMT:SIZE fornecendo os tamanhos dos formatos de um livro em bytes. Você pode usar a função select() para obter o tamanho de um formato específico. Observe que os nomes dos formatos estão sempre em maiúsculas, como em EPUB.

get_link ¶

class calibre.utils.formatter_functions.BuiltinGetLink[código-fonte]¶

get_link(field_name, field_value) – busca o link para o campo field_name com valor field_value. Se não houver link anexado, retorna a string vazia. Exemplos:

O seguinte retorna o link anexado à tag Fiction:
```
get_link('tags', 'Fiction')
```

Este template faz uma lista dos links para todas as tags associadas a um livro na forma valor:link, ...:

program:
    ans = '';
    for t in $tags:
        l = get_link('tags', t);
        if l then
            ans = list_join(', ', ans, ',', t & ':' & get_link('tags', t), ',')
        fi
    rof;
ans

Esta função funciona apenas na GUI e no servidor de conteúdo.

get_note ¶

class calibre.utils.formatter_functions.BuiltinGetNote[código-fonte]¶

get_note(field_name, field_value, plain_text) – busca a anotação para o campo field_name com valor field_value. Se plain_text estiver vazio, retorna o HTML da anotação, incluindo imagens. Se plain_text for 1 (ou '1'), retorna o texto simples da anotação. Se a anotação não existir, retorna a string vazia em ambos os casos. Exemplo:

Retorna o HTML da anotação anexada à tag Fiction:

program:
    get_note('tags', 'Fiction', '')

Retorna o texto simples da anotação anexada ao autor Isaac Asimov:
```
program:
    get_note('authors', 'Isaac Asimov', 1)
```

Esta função funciona apenas na GUI e no servidor de conteúdo.

has_extra_files ¶

class calibre.utils.formatter_functions.BuiltinHasExtraFiles[código-fonte]¶

has_extra_files([pattern]) – retorna a contagem de arquivos extras, caso contrário, ‘’ (a string vazia). Se o parâmetro opcional pattern (uma expressão regular) for fornecido, a lista é filtrada para arquivos que correspondam a pattern antes que os arquivos sejam contados. A correspondência do padrão não diferencia maiúsculas de minúsculas. Veja também as funções extra_file_names(), extra_file_size() e extra_file_modtime(). Esta função só pode ser usada na GUI e no servidor de conteúdo.

has_note ¶

class calibre.utils.formatter_functions.BuiltinHasNote[código-fonte]¶

has_note(field_name, field_value). Verifica se um campo tem uma anotação. Esta função tem duas variantes:

se field_value não for '' (a string vazia), retorna '1' se o valor field_value no campo field_name tiver uma anotação, caso contrário, retorna ''.

Exemplo: has_note('tags', 'Fiction') retorna '1' se a tag fiction tiver uma anotação anexada, caso contrário, retorna ''.
Se field_value for '', retorna uma lista de valores em field_name que têm uma anotação. Se nenhum item no campo tiver uma anotação, retorna ''. Esta variante é útil para mostrar ícones de coluna se qualquer valor no campo tiver uma anotação, em vez de um valor específico.

Exemplo: has_note('authors', '') retorna uma lista de autores que têm anotações, ou '' se nenhum autor tiver uma anotação.

Você pode testar se todos os valores em field_name têm uma anotação comparando o comprimento da lista do valor de retorno desta função com o comprimento da lista dos valores em field_name. Exemplo:

list_count(has_note('authors', ''), '&') ==# list_count_field('authors')

Esta função funciona apenas na GUI e no servidor de conteúdo.

reading_progress ¶

class calibre.utils.formatter_functions.BuiltinReadingProgress[código-fonte]¶

reading_progress(book_id, [user, output_fmt, which, fmt]) – returns the reading progress, in the specified output format.The user parameter defaults to match any user. Use the value local to match reading progress in the calibre e-book viewer. Use _ to match reading progress for anonymous users of the Content server viewer. Any other value matches the corresponding username as used in the Content server.

The output_fmt parameter controls the format of the text returned by this function. It takes three values:

page_count - the default, outputs pages read / total pages. If page counting is not enabled outputs percent read instead.
percent - outputs percent read
pos_frac - outputs a fraction between zero and one.

The which parameter controls how the specific reading progress record for the specified user is selected. There can be more than one record if no user is specified or if the book has been read in multiple formats or on multiple devices. It accepts two values:

most_recent - the progress of the most recent reader of the book (the default value)
furthest - the furthest progress of all matching records

The fmt parameter controls which book format is used. The default is to return records for all formats, the specific record is then selected by the which parameter.

Some examples:

{id:reading_progress()} -- the reading progress as pages read / total pages
                           for the most recent reading session of this book
{id:reading_progress(,percent)} -- same as above, but as a percentage
{id:reading_progress(,pos_frac,furthest)} -- same as above, but as a fraction and using the
                                             furthest progress on this book.
{id:reading_progress(bob,pos_frac,furthest,EPUB)} -- for the user "bob" and the "EPUB format

Mostrando a documentação em inglês devido ao erro FFML: Missing [*] in list near text:”O parâmet” on line 11 in “reading_progress”

Funções de data ¶

date_arithmetic ¶

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

date_arithmetic(value, calc_spec, fmt) – Calcula uma nova data a partir de value usando calc_spec. Retorna a nova data formatada de acordo com fmt opcional: se não fornecido, o resultado estará no formato ISO. O calc_spec é uma string formada pela concatenação de pares de vW (valueWhat) onde v é um número possivelmente negativo e W é uma das seguintes letras:

s: adiciona v segundos a date
m: adiciona v minutos a date
h: adiciona v horas a date
d: adiciona v dias a date
w: adiciona v semanas a date
y: adiciona v anos a date, onde um ano tem 365 dias.

Exemplo: '1s3d-1m' adicionará 1 segundo, adicionará 3 dias e subtrairá 1 minuto de date.

days_between ¶

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

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

today ¶

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

today() – retorna uma string de data+hora para hoje (agora). Este valor é projetado para uso em format_date ou days_between, mas pode ser manipulado como qualquer outra string. A data está no formato de data/hora ISO.

Funções do URL ¶

encode_for_url ¶

class calibre.utils.formatter_functions.BuiltinEncodeForURL[código-fonte]¶

encode_for_url(value, use_plus) – retorna o value codificado para uso em uma URL conforme especificado por use_plus. O valor é primeiro codificado para URL. Em seguida, se use_plus for 0, os espaços são substituídos por sinais '+' (mais). Se for 1, os espaços são substituídos por %20.

Se você não quiser que o valor seja codificado, mas que os espaços sejam substituídos, use a função re(), como em re($series, ' ', '%20')

Veja também as funções make_url(), make_url_extended() e query_string().

make_url ¶

class calibre.utils.formatter_functions.BuiltinMakeUrl[código-fonte]¶

make_url(path, [query_name, query_value]+) – esta função é a maneira mais fácil de construir uma URL de consulta. Ela usa um path, o site e a página que você deseja consultar, e pares query_name, query_value a partir dos quais a consulta é construída. Em geral, o query_value deve ser codificado para URL. Com esta função, ele é sempre codificado e os espaços são sempre substituídos por sinais '+'.

Pelo menos um par query_name, query_value deve ser fornecido.

Exemplo: construindo uma URL de pesquisa da Wikipedia para o autor Niccolò Machiavelli:

make_url('https://en.wikipedia.org/w/index.php', 'search', 'Niccolò Machiavelli')

retorna

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Se você estiver escrevendo um template de URL de detalhes do livro para uma coluna personalizada, use $item_name ou field('item_name') para obter o valor do campo que foi clicado. Exemplo: se Niccolò Machiavelli foi clicado, você pode construir a URL usando:

make_url('https://en.wikipedia.org/w/index.php', 'search', $item_name)

Veja também as funções make_url_extended(), query_string() e encode_for_url().

make_url_extended ¶

class calibre.utils.formatter_functions.BuiltinMakeUrlExtended[código-fonte]¶

make_url_extended(...) – esta função é semelhante a make_url(), mas oferece mais controle sobre os componentes da URL. Os componentes de uma URL são

scheme:://authority/path?query string.

Consulte Uniform Resource Locator na Wikipedia para mais detalhes.

A função tem duas variantes:

make_url_extended(scheme, authority, path, [query_name, query_value]+)

e

make_url_extended(scheme, authority, path, query_string)

Esta função retorna uma URL construída a partir do scheme, authority, path e da query_string ou de uma string de consulta construída a partir dos pares de argumentos de consulta. O authority pode estar vazio, o que é o caso das URLs do esquema calibre. Você deve fornecer uma query_string ou pelo menos um par query_name, query_value. Se você fornecer query_string e ela estiver vazia, a URL resultante não terá uma seção de string de consulta.

Exemplo 1: construindo uma URL de pesquisa da Wikipedia para o autor Niccolò Machiavelli:

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'search', 'Niccolò Machiavelli')

retorna

https://en.wikipedia.org/w/index.php?search=Niccol%C3%B2+Machiavelli

Consulte a função query_string() para um exemplo usando make_url_extended() com uma query_string.

Se você estiver escrevendo um template de URL de detalhes do livro para uma coluna personalizada, use $item_name ou field('item_name') para obter o valor do campo que foi clicado. Exemplo: se Niccolò Machiavelli foi clicado, você pode construir a URL usando:

make_url_extended('https', 'en.wikipedia.org', '/w/index.php', 'search', $item_name')

Veja também as funções make_url(), query_string() e encode_for_url().

query_string ¶

class calibre.utils.formatter_functions.BuiltinQueryString[código-fonte]¶

query_string([query_name, query_value, how_to_encode]+)– retorna uma string de consulta URL construída a partir das tríades query_name, query_value, how_to_encode. Uma string de consulta é uma série de itens onde cada item se parece com query_name=query_value, onde query_value é codificado para URL conforme instruído. Os itens de consulta são separados por caracteres '&' (e comercial).

Se how_to_encode for 0, então query_value é codificado e os espaços são substituídos por sinais '+' (mais). Se how_to_encode for 1, então query_value é codificado com espaços substituídos por %20. Se how_to_encode for 2, então query_value é retornado inalterado; nenhuma codificação é feita e os espaços não são substituídos. Se você quiser que query_value não seja codificado, mas que os espaços sejam substituídos, use a função re(), como em re($series, ' ', '%20')

Você usa esta função se precisar de controle específico sobre como as partes da string de consulta são construídas. Você poderia então usar a string de consulta resultante em make_url_extended(), como em

make_url_extended(
       'https', 'your_host', 'your_path',
       query_string('encoded', 'Hendrik Bäßler', 0, 'unencoded', 'Hendrik Bäßler', 2))

dando a você

https://your_host/your_path?encoded=Hendrik+B%C3%A4%C3%9Fler&unencoded=Hendrik Bäßler

Você deve ter pelo menos uma tríade query_name, query_value, how_to_encode, mas pode ter quantas desejar.

O valor retornado é uma string de consulta URL com todos os itens especificados, por exemplo: name1=val1[&nameN=valN]*. Observe que o separador '?' path / query string não está incluído no resultado retornado.

Se você estiver escrevendo um template de URL de detalhes do livro para uma coluna personalizada, use $item_name ou field('item_name') para obter o valor não codificado do campo que foi clicado. Você também tem item_value_quoted, onde o valor já está codificado com sinais de mais substituindo espaços, e item_value_no_plus, onde o valor já está codificado com %20 substituindo espaços.

Veja também as funções make_url(), make_url_extended() e encode_for_url().

to_hex ¶

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

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

urls_from_identifiers ¶

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

urls_from_identifiers(identifiers, sort_results) – dada uma lista separada por vírgulas de identifiers, onde um identifier é um par de valores separados por dois pontos (id_name:id_value), retorna uma lista separada por vírgulas de URLs HTML geradas a partir dos identificadores. A lista não é ordenada se sort_results for 0 (caractere ou número), caso contrário, é ordenada alfabeticamente pelo nome do identificador. As URLs são geradas da mesma forma que a coluna de identificadores integrada quando mostrada em Detalhes do Livro.

Manipulação de listas ¶

list_count ¶

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

list_count(value, separator) – interpreta o valor como uma lista de itens separados por separator e retorna o número de itens na lista. A maioria das listas usa vírgula como separador, mas authors usa o e comercial (&).

Exemplos: {tags:list_count(,)}, {authors:list_count(&)}.

Apelidos: count(), list_count()

list_count_field ¶

class calibre.utils.formatter_functions.BuiltinFieldListCount[código-fonte]¶

list_count_field(lookup_name)– retorna a contagem de itens no campo com o nome de pesquisa lookup_name. O campo deve ser multivalorado, como authors ou tags, caso contrário a função gera um erro. Esta função é muito mais rápida que list_count() porque opera diretamente nos dados do calibre sem convertê-los primeiro em string. Exemplo: list_count_field('tags').

list_count_matching ¶

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

list_count_matching(value, pattern, separator) – interpreta value como uma lista de itens separados por separator, retornando o número de itens na lista que correspondem à expressão regular pattern.

Apelidos: list_count_matching(), count_matching()

list_difference ¶

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 que não diferencia maiúsculas de minúsculas. Os itens em list1 e list2 são separados por separator, assim como os itens na lista retornada.

list_equals ¶

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

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

list_intersection ¶

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 que não diferencia maiúsculas de minúsculas. Os itens em list1 e list2 são separados por separator, assim como os itens na lista retornada.

list_join ¶

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

list_join(with_separator, list1, separator1 [, list2, separator2]*) – retorna uma lista feita unindo os itens nas listas de origem (list1 etc.) usando with_separator entre os itens na lista resultante. Os itens em cada lista de origem list[123...] são separados pelo separator[123...] associado. Uma lista pode conter valores zero. Pode ser um campo como publisher que tem um único valor, efetivamente uma lista de um item. Duplicatas são removidas usando uma comparação que não diferencia maiúsculas de minúsculas. Os itens são retornados na ordem em que aparecem nas listas de origem. Se os itens nas listas diferirem apenas em maiúsculas/minúsculas, o último é usado. 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, '&', 'some value', ',')

Você pode usar expressões para gerar uma lista. Por exemplo, suponha que você queira itens para authors e #genre, mas com o gênero alterado para a palavra “Gênero: “ seguida pela primeira letra do gênero, ou seja, o gênero “Fiction” se torna “Gênero: F”. O seguinte fará isso:

program:
    list_join('#@#', $authors, '&', list_re($#genre, ',', '^(.).*$', 'Genre: \1'),  ',')

list_re ¶

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

list_re(src_list, separator, include_re, opt_replace) – Constrói uma lista primeiro separando src_list em itens usando o caractere separator. Para cada item na lista, verifica se corresponde a include_re. Se corresponder, adiciona-o à lista a ser retornada. Se opt_replace não for a string vazia, aplica a substituição antes de adicionar o item à lista retornada.

list_re_group ¶

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

list_re_group(src_list, separator, include_re, search_re [,template_for_group]*) – Semelhante a list_re(), exceto que as substituições não são opcionais. Usa re_group(item, search_re, template ...) ao fazer as substituições.

list_remove_duplicates ¶

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

list_remove_duplicates(list, separator) – retorna uma lista feita removendo itens duplicados em list. Se os itens diferirem apenas em maiúsculas/minúsculas, o último é retornado. Os itens em list são separados por separator, assim como os itens na lista retornada.

list_sort ¶

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

list_sort(value, direction, separator) – retorna value ordenado usando uma ordenação lexical que não diferencia maiúsculas de minúsculas. Se direction for zero (número ou caractere), value é ordenado em ordem crescente, caso contrário, decrescente. Os itens da lista são separados por separator, assim como os itens na lista retornada.

list_split ¶

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

list_split(list_val, sep, id_prefix) – divide list_val em valores separados usando sep, depois atribui os valores a variáveis locais nomeadas id_prefix_N onde N é a posição do valor na lista. O primeiro item tem posição 0 (zero). A função retorna o último elemento da lista.

Exemplo:

list_split('one:two:foo', ':', 'var')

é equivalente a:

var_0 = 'one'
    var_1 = 'two'
    var_2 = 'foo'

list_union ¶

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

list_union(list1, list2, separator) – retorna uma lista feita mesclando os itens em list1 e list2, removendo itens duplicados usando uma comparação que não diferencia maiúsculas de minúsculas. Se os itens diferirem em maiúsculas/minúsculas, o que estiver em list1 é usado. Os itens em list1 e list2 são separados por separator, assim como os itens na lista retornada.

Apelidos: merge_lists(), list_union()

range ¶

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

range(start, stop, step, limit) – retorna uma lista de números gerados percorrendo o intervalo especificado pelos parâmetros start, stop e step, com um comprimento máximo de limit. O primeiro valor produzido é ‘start’. Valores subsequentes next_v = current_v + step. O loop continua enquanto next_v < stop, assumindo que step é positivo, caso contrário, enquanto next_v > stop. Uma lista vazia é produzida se start falhar no teste: start >= stop se step for positivo. O limit define o comprimento máximo da lista e tem um padrão de 1000. Os parâmetros start, step e limit são opcionais. Chamar range() com um argumento especifica stop. Dois argumentos especificam start e stop. Três argumentos especificam start, stop e step. Quatro argumentos especificam start, stop, step e limit.

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 ¶

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

subitems(value, start_index, end_index) – Esta função separa listas de itens hierárquicos semelhantes a tags, como gêneros. Ela interpreta o value como uma lista separada por vírgulas de itens semelhantes a tags, onde cada item é uma lista separada por pontos. Retorna uma nova lista feita extraindo de cada item os componentes de start_index a end_index e, em seguida, mesclando os resultados novamente. Duplicatas são removidas. O primeiro subitem em uma lista separada por pontos tem um índice zero. Se um índice for negativo, ele conta a partir do final da lista. Como caso especial, um end_index de zero é considerado como o comprimento da lista.

Exemplos:

Supondo uma coluna #genre contendo “A.B.C”:
- {#genre:subitems(0,1)} retorna “A”
- {#genre:subitems(0,2)} retorna “A.B”
- {#genre:subitems(1,0)} retorna “B.C”
Supondo uma coluna #genre contendo “A.B.C, D.E”:
- {#genre:subitems(0,1)} retorna “A, D”
- {#genre:subitems(0,2)} retorna “A.B, D.E”

sublist ¶

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

sublist(value, start_index, end_index, separator) – interpreta o value como uma lista de itens separados por separator, retornando uma nova lista feita dos itens de start_index a end_index. O primeiro item é o número zero. Se um índice for negativo, ele conta a partir do final da lista. Como caso especial, um end_index de zero é considerado como o comprimento da lista.

Exemplos supondo que a coluna tags (que é separada por vírgulas) contenha “A, B, C”:

{tags:sublist(0,1,\,)} retorna “A”
{tags:sublist(-1,0,\,)} retorna “C”
{tags:sublist(0,-1,\,)} retorna “A, B”

Manipulação de strings ¶

character ¶

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

character(character_name) – retorna o caractere nomeado por character_name. Por exemplo, character('newline') retorna um caractere de nova linha ('\n'). Os nomes de caracteres suportados são newline, return, tab e backslash. Esta função é usada para inserir esses caracteres na saída de modelos.

check_yes_no ¶

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

check_yes_no(field_name, is_undefined, is_false, is_true) – verifica se o valor do campo sim/não identificado pelo nome de pesquisa field_name corresponde a um dos valores especificados pelos parâmetros, retornando 'Yes' se houver correspondência, caso contrário retorna a string vazia. Defina o parâmetro is_undefined, is_false ou is_true como 1 (o número) para verificar essa condição, caso contrário defina como 0.

Exemplo: check_yes_no("#bool", 1, 0, 1) retorna 'Yes' se o campo sim/não #bool for True ou indefinido (nem True nem False).

Mais de um dos parâmetros is_undefined, is_false ou is_true pode ser definido como 1.

contains ¶

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

contains(value, pattern, text_if_match, text_if_not_match) – verifica se o valor corresponde à expressão regular pattern. Retorna text_if_match se o padrão corresponder ao valor, caso contrário retorna text_if_not_match.

field_exists ¶

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

field_exists(lookup_name) – verifica se um campo (coluna) com o nome de pesquisa lookup_name existe, retornando '1' se sim e a string vazia se não.

ifempty ¶

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

ifempty(value, text_if_empty) – se o value não estiver vazio, retorna esse value, caso contrário, retorna text_if_empty.

re ¶

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

re(value, pattern, replacement) – retorna o value após aplicar a expressão regular. Todas as instâncias de pattern no valor são substituídas por replacement. A linguagem de template usa expressões regulares Python que não diferenciam maiúsculas de minúsculas.

re_group ¶

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

re_group(value, pattern [, template_for_group]*) – retorna uma string feita aplicando a expressão regular pattern a value e substituindo cada instância correspondida pelo valor retornado pelo template correspondente. No Modo de Programa de Template, como para as funções template e eval, você usa [[ para { e ]] para }.

O exemplo a seguir procura por uma série com mais de uma palavra e coloca a primeira palavra em maiúsculas:

program: re_group(field('series'), "(\S* )(.*)", "{$:uppercase()}", "{$}")'}

shorten ¶

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

shorten(value, left_chars, middle_text, right_chars) – Retorna uma versão encurtada do value, consistindo de left_chars caracteres do início do value, seguidos por middle_text, seguidos por right_chars caracteres do final do value. left_chars e right_chars devem ser inteiros não negativos.

Exemplo: suponha que você queira exibir o título com um comprimento de no máximo 15 caracteres. Um template que faz isso é {title:shorten(9,-,5)}. Para um livro com o título Ancient English Laws inthe Times of Ivanhoe o resultado será Ancient E-anhoe: os primeiros 9 caracteres do título, um - e depois os últimos 5 caracteres. Se o comprimento do valor for menor que left chars + right chars + o comprimento de middle text, o valor será retornado inalterado. Por exemplo, o título TheDome não seria alterado.

strcat ¶

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

strcat(a [, b]*) – retorna uma string formada pela concatenação de todos os argumentos. Pode receber qualquer número de argumentos. Na maioria dos casos, você pode usar o operador & em vez desta função.

strcat_max ¶

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 como string1. Strings feitas de pares prefix, string são adicionadas ao final do valor, desde que o comprimento da string resultante seja menor que max. Prefixos podem estar vazios. Retorna string1 mesmo que string1 seja mais longo que max. Você pode passar quantos pares prefix, string desejar.

strlen ¶

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

strlen(value) – Retorna o comprimento da string value.

substr ¶

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

substr(value, start, end) – retorna os caracteres de start até end de value. O primeiro caractere em value é o caractere zero. Se end for negativo, indica essa quantidade de caracteres contando a partir da direita. Se end for zero, indica o último caractere. Por exemplo, substr('12345', 1, 0) retorna '2345' e substr('12345', 1, -1) retorna '234'.

swap_around_articles ¶

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

swap_around_articles(value, separator) – retorna o value com artigos movidos para o final, separados por um ponto e vírgula. O value pode ser uma lista, caso em que cada item na lista é processado. Se o value for uma lista, você deve fornecer o separator. Se nenhum separator for fornecido ou o separador for a string vazia, o value é tratado como um único valor, não como uma lista. Os artigos são aqueles usados pelo calibre para gerar o title_sort.

swap_around_comma ¶

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

swap_around_comma(value) – dado um value na forma B, A, retorna A B. Isso é mais útil para converter nomes no formato LN, FN para FN LN. Se não houver vírgula no value, a função retorna o valor inalterado.

test ¶

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

test(value, text_if_not_empty, text_if_empty) – retorna text_if_not_empty se o valor não estiver vazio, caso contrário, retorna text_if_empty.

transliterate ¶

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

transliterate(value) – Retorna uma string em um alfabeto latino formada aproximando o som das palavras em value. Por exemplo, se value for Фёдор Миха́йлович Достоевский, esta função retorna Fiodor Mikhailovich Dostoievskii.

Obter valores dos metadados ¶

author_links ¶

class calibre.utils.formatter_functions.BuiltinAuthorLinks[código-fonte]¶

author_links(val_separator, pair_separator) – retorna uma string contendo uma lista de autores e os valores de link desses autores na forma: autor1 val_separator link_autor1 pair_separator autor2 val_separator link_autor2 etc.

Um autor é separado de seu valor de link pela string val_separator sem espaços adicionados. Assumindo que o val_separator seja dois pontos, os pares autor:valor_link são separados pelo argumento string pair_separator sem espaços adicionados. Cabe a você escolher separadores que não ocorram em nomes de autores ou links. Um autor é incluído mesmo que o link do autor esteja vazio.

author_sorts ¶

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

author_sorts(val_separator) – retorna uma string contendo uma lista de valores de ordenação dos autores do livro. A ordenação é a que está nas informações de metadados do autor, que pode ser diferente de author_sort nos livros. A lista retornada tem a forma ordenacao_autor1 val_separator ordenacao_autor2 etc. sem espaços adicionados. Os valores de ordenação dos autores nesta lista estão na mesma ordem que os autores do livro. Se você quiser espaços em torno de val_separator, inclua-os na string val_separator.

booksize ¶

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

booksize() – retorna o valor do campo size do calibre. Retorna ‘’ se o livro não tiver formatos.

Esta função funciona apenas na GUI. Se você quiser usar este valor em modelos de salvar em disco ou enviar para dispositivo, então deve criar uma coluna personalizada “Coluna construída a partir de outras colunas”, usar a função no modelo dessa coluna e usar o valor dessa coluna em seus modelos de salvar/enviar.

connected_device_name ¶

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

connected_device_name(storage_location_key) – se um dispositivo estiver conectado, retorna o nome do dispositivo, caso contrário retorna a string vazia. Cada local de armazenamento em um dispositivo tem seu próprio nome. Os nomes storage_location_key são 'main', 'carda' e 'cardb'. Esta função funciona apenas na GUI.

connected_device_uuid ¶

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

connected_device_uuid(storage_location_key) – se um dispositivo estiver conectado, retorna o uuid (identificador único) do dispositivo, caso contrário retorna a string vazia. Cada local de armazenamento em um dispositivo possui um uuid diferente. Os nomes storage_location_key são 'main', 'carda' e 'cardb'. Esta função funciona apenas na GUI.

current_library_name ¶

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

current_library_name() – retorna o último nome no caminho para a biblioteca calibre atual.

current_library_path ¶

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

current_library_path() – retorna o caminho completo para a biblioteca calibre atual.

current_virtual_library_name ¶

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

current_virtual_library_name() – retorna o nome da biblioteca virtual atual se houver uma, caso contrário, retorna a string vazia. A caixa (maiúsculas/minúsculas) do nome da biblioteca é preservada. Exemplo:

program: current_virtual_library_name()

Esta função funciona apenas na GUI.

field ¶

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

field(lookup_name) – retorna o valor do campo de metadados com o nome de pesquisa lookup_name. O prefixo $ pode ser usado em vez da função, como em $tags.

has_cover ¶

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

has_cover() – retorna 'Sim' se o livro tiver uma capa; caso 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 no calibre. Se estiver, retorna o valor da marca, seja 'true' (minúsculas) ou uma lista separada por vírgulas de marcas nomeadas. Retorna '' (a string vazia) se o livro não estiver marcado. Esta função funciona apenas na GUI.

language_codes ¶

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

language_codes(lang_strings) – retorna os códigos de idioma para os nomes de idioma passados em lang_strings. As strings devem estar no idioma da localidade atual. lang_strings é uma lista separada por vírgulas.

language_strings ¶

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

language_strings(value, localize) – retorna os nomes dos idiomas para os códigos de idioma (veja aqui para nomes e códigos) passados em value. Exemplo: {languages:language_strings()}. Se localize for zero, retorna as strings em inglês. Se localize não for zero, retorna as strings no idioma da localidade atual. lang_codes é uma lista separada por vírgulas.

ondevice ¶

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

ondevice() – retorna a string 'Yes' se ondevice estiver definido, caso contrário, retorna a string vazia. Esta função funciona apenas na GUI. Se você quiser usar este valor em templates Salvar em disco ou Enviar para dispositivo, deve criar uma “Coluna construída a partir de outras colunas” personalizada, usar a função no template dessa coluna e usar o valor dessa coluna em seus templates de salvar/enviar.

raw_field ¶

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

raw_field(lookup_name [, optional_default]) – retorna o campo de metadados nomeado por lookup_name sem aplicar nenhuma formatação. Avalia e retorna o segundo argumento opcional optional_default se o valor do campo for indefinido (None). O prefixo $$ pode ser usado em vez da função, como em $$pubdate.

raw_list ¶

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

raw_list(lookup_name, separator) – retorna a lista de metadados nomeada por lookup_name sem aplicar nenhuma formatação ou ordenação, com os itens separados por separator.

series_sort ¶

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

series_sort() – devolve o valor de ordenação da série.

user_categories ¶

class calibre.utils.formatter_functions.BuiltinUserCategories[código-fonte]¶

user_categories() – retorna uma lista separada por vírgulas das categorias do usuário que contêm este livro. Esta função funciona apenas na GUI. Se você quiser usar esses valores em templates Salvar em disco ou Enviar para dispositivo, deve criar uma Coluna construída a partir de outras colunas personalizada, usar a função no template dessa coluna e usar o valor dessa coluna em seus templates de salvar/enviar

virtual_libraries ¶

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

virtual_libraries() – retorna uma lista separada por vírgulas das bibliotecas virtuais que contêm este livro. Esta função funciona apenas na GUI. Se você quiser usar esses valores em templates Salvar em disco ou Enviar para dispositivo, deve criar uma Coluna construída a partir de outras colunas personalizada, usar a função no template dessa coluna e usar o valor dessa coluna em seus templates de salvar/enviar.

Outro ¶

arguments ¶

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

arguments(id[=expression] [, id[=expression]]*) — Usado em um template armazenado para recuperar os argumentos passados na chamada. Ele declara e inicializa variáveis locais com os nomes fornecidos (os id), funcionando na prática como parâmetros. As variáveis são posicionais: elas recebem o valor do argumento passado na chamada na mesma posição. Se o argumento correspondente não for fornecido na chamada, arguments() atribui à variável o valor padrão informado. Se não houver valor padrão, a variável é definida como uma string vazia.

assign ¶

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

assign(id, value) – atribui value a id, e então retorna value. id deve ser um identificador, não uma expressão. Na maioria dos casos você pode usar o operador = em vez desta função.

globals ¶

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. O nome id é o nome da variável global. Ele declara e inicializa variáveis locais com os nomes das variáveis globais passadas nos parâmetros id. Se a variável correspondente não for fornecida nas globais, ele atribui a essa variável o valor padrão fornecido. Se não houver um valor padrão, a variável é definida como uma string vazia.

is_dark_mode ¶

class calibre.utils.formatter_functions.BuiltinIsDarkMode[código-fonte]¶

is_dark_mode() – retorna '1' se o calibre estiver sendo executado no modo escuro, '' (a string vazia) caso contrário. Esta função pode ser usada em regras avançadas de cores e ícones para escolher cores/ícones diferentes de acordo com o modo. Exemplo:

if is_dark_mode() then 'dark.png' else 'light.png' fi

print ¶

class calibre.utils.formatter_functions.BuiltinPrint[código-fonte]¶

print(a [, b]*) – imprime os argumentos na 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. A função print sempre retorna seu primeiro argumento.

set_globals ¶

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

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

Pesquisa de listas ¶

identifier_in_list ¶

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

identifier_in_list(val, id_name [, found_val, not_found_val]) – trata val como uma lista de identificadores separados por vírgulas. Um identificador tem o formato id_name:value. O parâmetro id_name é o texto id_name a ser pesquisado, seja id_name ou id_name:regexp. O primeiro caso corresponde se houver qualquer identificador correspondente a esse id_name. O segundo caso corresponde se id_name corresponder a um identificador e a regexp corresponder ao valor do identificador. Se found_val e not_found_val forem fornecidos, se houver uma correspondência, retorna found_val, caso contrário, retorna not_found_val. Se found_val e not_found_val não forem fornecidos, se houver uma correspondência, retorna o par identifier:value, caso contrário, a string vazia ('').

list_contains ¶

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

list_contains(value, separator, [ pattern, found_val, ]* not_found_val) – interpreta o value como uma lista de itens separados por separator, verificando o pattern contra cada item na lista. Se o pattern corresponder a um item, retorna found_val, caso contrário, retorna not_found_val. O par pattern e found_value pode ser repetido quantas vezes desejado, permitindo retornar valores diferentes dependendo do valor do item. Os padrões são verificados em ordem, e a primeira correspondência é retornada.

Apelidos: in_list(), list_contains()

list_item ¶

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

list_item(value, index, separator) – interpreta o value como uma lista de itens separados por separator, retornando o item ‘index’ésimo. O primeiro item é o número zero. O último item tem o índice -1 como em list_item(-1,separator). Se o item não estiver na lista, a string vazia é retornada. O separador tem o mesmo significado que na função count, geralmente vírgula, mas é ‘e comercial’ para listas semelhantes a autores.

select ¶

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

select(value, key) – interpreta o value como uma lista separada por vírgulas de itens, onde cada item tem a forma id:id_value (o formato identifier do calibre). A função encontra o primeiro par com o id igual a key e retorna o id_value correspondente. Se nenhum id corresponder, a função retorna a string vazia.

str_in_list ¶

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

str_in_list(value, separator, [ string, found_val, ]+ not_found_val) – interpreta o value como uma lista de itens separados por separator e depois compara string com cada valor na lista. O string não é uma expressão regular. Se string for igual a qualquer item (ignorando maiúsculas/minúsculas), retorna o found_val correspondente. Se string contiver separators, ele também é tratado como uma lista e cada subvalor é verificado. Os pares string e found_value podem ser repetidos quantas vezes desejado, permitindo retornar valores diferentes dependendo do valor da string. Se nenhuma das strings corresponder, not_found_value é retornado. As strings são verificadas em ordem. A primeira correspondência é retornada.

Recorrência ¶

eval ¶

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

eval(string) – avalia a string como um programa, passando as variáveis locais. Isso permite usar o processador de template para construir resultados complexos a partir de variáveis locais. No Modo de Programa de Template, como os caracteres { e } são interpretados antes do template ser avaliado, você deve usar [[ para o caractere { e ]] para o caractere }. Eles são convertidos automaticamente. Observe também que prefixos e sufixos (a sintaxe |prefix|suffix) não podem ser usados no argumento desta função ao usar o Modo de Programa de Template.

template ¶

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

template(x) – avalia x como um template. A avaliação é feita em seu próprio contexto, o que significa que as variáveis não são compartilhadas entre o chamador e a avaliação do template. Se não estiver usando o Modo de Programa Geral, como os caracteres { e } são especiais, você deve usar [[ para o caractere { e ]] para o caractere }; eles são convertidos automaticamente. Por exemplo, template(\'[[title_sort]]\') avaliará o template {title_sort} e retornará seu valor. Observe também que prefixos e sufixos (a sintaxe |prefix|suffix) não podem ser usados no argumento desta função ao usar o modo de programa de template.

Relacional ¶

cmp ¶

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

cmp(value, y, lt, eq, gt) – compara value e y após converter ambos para números. Retorna lt se value <# y, eq se value ==# y, caso contrário gt. Esta função geralmente pode ser substituída por um dos operadores de comparação numérica (==#, <#, >#, etc).

first_matching_cmp ¶

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

first_matching_cmp(val, [ cmp, result, ]* else_result) – compara val < cmp em sequência, retornando o result associado para a primeira comparação que tiver sucesso. Retorna else_result se nenhuma comparação tiver sucesso.

Exemplo:

i = 10;
first_matching_cmp(i,5,"small",10,"middle",15,"large","giant")

retorna "large". O mesmo exemplo com um valor inicial de 16 retorna "giant".

strcmp ¶

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

strcmp(x, y, lt, eq, gt) – faz uma comparação lexical que não diferencia maiúsculas de minúsculas entre x e y. Retorna lt se x < y, eq se x == y, caso contrário, gt. Esta função geralmente pode ser substituída por um dos operadores de comparação lexical (==, >, <, etc.)

strcmpcase ¶

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

strcmpcase(x, y, lt, eq, gt) – faz uma comparação lexical que diferencia maiúsculas de minúsculas entre x e y. Retorna lt se x < y, eq se x == y, caso contrário, gt.

Nota: Este NÃO é o comportamento padrão usado pelo calibre, por exemplo, nos operadores de comparação lexical (==, >, <, etc.). Esta função pode causar resultados inesperados, prefira usar strcmp() sempre que possível.

Repetir sobre valores ¶

first_non_empty ¶

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

first_non_empty(value [, value]*) – retorna o primeiro value que não estiver vazio. Se todos os valores estiverem vazios, então retorna a string vazia. Você pode ter quantos valores quiser.

lookup ¶

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

lookup(value, [ pattern, key, ]* else_key) – Os padrões serão verificados contra o value em ordem. Se um pattern corresponder, o valor do campo nomeado por key é retornado. Se nenhum padrão corresponder, o valor do campo nomeado por else_key é retornado. Veja também a função switch().

switch ¶

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

switch(value, [patternN, valueN,]+ else_value) – para cada par patternN, valueN, verifica se o value corresponde à expressão regular patternN e, se corresponder, retorna o valueN associado. Se nenhum patternN corresponder, else_value é retornado. Você pode ter quantos pares patternN, valueN desejar. A primeira correspondência é retornada.

switch_if ¶

class calibre.utils.formatter_functions.BuiltinSwitchIf[código-fonte]¶

switch_if([expressão_de_teste, expressão_de_valor,]+ expressão_else) – para cada par expressão_de_teste, expressão_de_valor, verifica se a expressão_de_teste é Verdadeira (não vazia) e, se for, retorna o resultado da expressão_de_valor. Se nenhuma expressão_de_teste for Verdadeira, o resultado da expressão_else será retornado. Você pode ter quantos pares de expressão_de_teste, expressão_de_valor desejar.

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',
    # Calculated page count, null values are None or 0. -1 is no countable
    # formats. -2 is error processing formats, -3 is DRMed.
    'pages',
))

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