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

add(x, y) – x + y’yi döndürür. x veya y sayı olmadığında bir istisna döndürür.

divide(x, y)

class calibre.utils.formatter_functions.BuiltinDivide[kaynak]

divide(x, y) – x / y’yi döndürür. x veya y sayı olmadığında bir istisna döndürür.

multiply(x, y)

class calibre.utils.formatter_functions.BuiltinMultiply[kaynak]

multiply(x, y) – x * y’yi döndürür. x veya y sayı olmadığında bir istisna döndürür.

subtract(x, y)

class calibre.utils.formatter_functions.BuiltinSubtract[kaynak]

subtract(x, y) – x - y’yi döndürür. x veya y sayı olmadığında bir istisna döndürür.

Boolean

and(value, value, …)

class calibre.utils.formatter_functions.BuiltinAnd[kaynak]

and(value, value, …) – returns the string “1” if all values are not empty, otherwise returns the empty string. This function works well with test or first_non_empty. You can have as many values as you want.

not(value)

class calibre.utils.formatter_functions.BuiltinNot[kaynak]

not(value) – returns the string “1” if the value is empty, otherwise returns the empty string. This function works well with test or first_non_empty.

or(değer, değer, …)

class calibre.utils.formatter_functions.BuiltinOr[kaynak]

or(değer, değer, …) – Herhangi bir değer boş değilse “1” karakter dizisini döndürür, aksi halde boş karakter dizisini. Bu fonksiyon test veya first_non_empty ile iyi çalışır. İstediğiniz kadar değer verebilirsiniz.

Date functions

days_between(tarih1, tarih2)

class calibre.utils.formatter_functions.BuiltinDaysBetween[kaynak]

days_between(tarih1, tarih2) – tarih1 ve tarih2 arasındaki gün sayısını döndürür. Tarih1 tarih2’den büyükse değer pozitiftir, aksi halde negatif. tarih1 veya tarih2 tarih değillerse, fonksiyon boş karakter dizisi döndürür.

today()

class calibre.utils.formatter_functions.BuiltinToday[kaynak]

today() – bugün için bir tarih karakter dizisi döndür. Bu değer format_date veya days_between ile kullanılmak üzere tasarlanmıştır, ama herhangi bir karakter dizisi gibi oynanabilir. Tarih ISO biçimindedir.

Formatting values

finish_formatting(val, fmt, önek, sonek)

class calibre.utils.formatter_functions.BuiltinFinishFormatting[kaynak]

finish_formatting(val, fmt, önek, sonek) – Değere biçim, önek ve soneki {series_index:05.2f| - |- } gibi bir şablonda olduğu gibi uygular. Örneğin, şu program aşağıdaki şablonla aynı çıktıyı üretir: program: finish_formatting(field(“series_index”), “05.2f”, ” - “, ” - “)

format_date(val, biçim_karakter_dizisi)

class calibre.utils.formatter_functions.BuiltinFormatDate[kaynak]

format_date(val, biçim_karakter_dizisi) – tarih olması gereken val değerini biçim_karakter_dizisi ile biçimler ve karakter dizisi döndürür. Biçimleme kodları şunlardır: d :sonunda sıfır olmadan gün (1’den 31’e) dd :sonunda sıfır olan gün (01’den 31’e) ddd : yerelleştirilmiş gün adı (örn. “Pazartesi”den “Pazar”a). M : sonunda sıfır olmadan ay numarası (1’den 12’ye). MM : sıfırlı ay numarası (01’den 12’ye) MMM : Yerelleştirilmiş ay ismi (örn. “Oca“‘dan “Ara”ya). MMMM : Yerelleştirilmiş uzun ay ismi (örn “Ocak”dan “Aralık”a). yy :yılın iki basamaklı gösterimi (00’dan 99’a). yyyy : dört basamakla yıl gösterimi. h : sıfırsız saat numarası (0’dan 11’e veya 0’dan 23’e, am/pm durumuna göre) m : sıfırsız dakika gösterimi (0’dan 59’a) mm : sıfırlı dakika gösterimi (00’dan 59’a) s : saniyelerin sıfırsız gösterimi (0’dan 59’a) ss : saniyelerin sıfırlı gösterimi (00’dan 59’a) ap : 24 saat yerine 12’lik saat kullan, “ap” am veya pm’nin yerelleştirilmiş metnini içerir AO : 24 saat yerine 12’lik saat kullan, “AP” AM veya PM yerine yerelleştirilmiş metni kullanır iso : zaman ve zaman dilimini içeren tarih. Mevcut olan tek biçim olmalıdır

format_number(v, template)

class calibre.utils.formatter_functions.BuiltinFormatNumber[kaynak]

format_number(v, template) – format the number v using a Python formatting template such as “{0:5.2f}” or “{0:,d}” or “${0:5,.2f}”. The field_name part of the template must be a 0 (zero) (the “{0:” in the above examples). See the template language and Python documentation for more examples. You can leave off the leading “{0:” and trailing “}” if the template contains only a format. Returns the empty string if formatting fails.

human_readable(v)

class calibre.utils.formatter_functions.BuiltinHumanReadable[kaynak]

human_readable(v) – v sayısını KB, MB, GB, vs. olarak temsil eden karakter dizisi döndür

Get values from metadata

approximate_formats()

class calibre.utils.formatter_functions.BuiltinApproximateFormats[kaynak]

approximate_formats() – Bir noktada kitaplarla bağlantılı olan virgülle ayrılmış biçimler listesi döndürür. Bu listenin doğru olacağının garantisi yoktur, ama muhtemelen doğrudur. Bu fonksiyon şablon program kipinde “{:’approximate_formats()’}” ile çağrılabilir. Biçim isimlerinin EPUB gibi hep büyük harfli olduğunu unutmayın. Bu fonksiyon yalnızca grafik arayüzde çalışır. Bu değerleri diske-kaydet veya aygıta-gönder şablonlarında kullanmak istiyorsanız özel bir “Diğer sütunlardan oluşturulmuş sütun” yapmalı, fonksiyonu bu sütunun şablonunda, ve bu sütunun değerini kaydet/gönder şablonlarınızda kullanmalısınız

author_sorts(val_separator)

class calibre.utils.formatter_functions.BuiltinAuthorSorts[kaynak]

author_sorts(val_separator) – kitabın yazarları için yazar sıralama değerleri listesi içeren karakter dizisi döndürür. Sıralama yazar metadata’sında olandır (kitaplardaki author_sort’dan farklı). Döndürülen liste yazar sıra 1 val_separator yazar sıra 2 vs. biçimindedir. Bu listedeki yazar sıralama alanları kitabın yazarlarıyla aynı sıradadır. val_separator arasında boşluk isterseniz ayraç karakter dizisine ekleyebilirsiniz.

booksize()

class calibre.utils.formatter_functions.BuiltinBooksize[kaynak]

booksize() – boyut alanının değerini döndürür. Bu fonksiyon yalnızca grafik arayüzde çalışır. Bu değeri diske-kaydet veya aygıta-gönder şablonlarında kullanmak istiyorsanız, özel bir “Diğer sütunlardan oluşturulmuş sütun” yapmalı, fonksiyonu bu sütunun şablonunda kullanmalısınız, ve bu sütunun değerini kaydet/gönder şablonlarınızda kullanmalısınız

current_library_name()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryName[kaynak]

current_library_name() – Mevcut Calibre kitaplığına yoldaki son ismi döndürür. Bu fonksiyon şablon program kipinde “{:’current_library_name()’}” ile kullanılabilir.

current_library_path()

class calibre.utils.formatter_functions.BuiltinCurrentLibraryPath[kaynak]

current_library_path() – Mevcut Calibre kitaplığı yolunu döndür. Bu fonksiyon şablon program kipinde “{:’current_library_path()’}” ile kullanılabilir.

field(isim)

class calibre.utils.formatter_functions.BuiltinField[kaynak]

field(isim) – isim olarak adlandırılmış metadata alanını döndürür

formats_modtimes(date_format)

class calibre.utils.formatter_functions.BuiltinFormatsModtimes[kaynak]

formats_modtimes(date_format) – return a comma-separated list of colon-separated items representing modification times for the formats of a book. The date_format parameter specifies how the date is to be formatted. See the format_date function for details. You can use the select function to get the mod time for a specific format. Note that format names are always uppercase, as in EPUB.

formats_paths()

class calibre.utils.formatter_functions.BuiltinFormatsPaths[kaynak]

formats_paths() – return a comma-separated list of colon-separated items representing full path to the formats of a book. You can use the select function to get the path for a specific format. Note that format names are always uppercase, as in EPUB.

formats_sizes()

class calibre.utils.formatter_functions.BuiltinFormatsSizes[kaynak]

formats_sizes() – return a comma-separated list of colon-separated items representing sizes in bytes of the formats of a book. You can use the select function to get the size for a specific format. Note that format names are always uppercase, as in EPUB.

has_cover()

class calibre.utils.formatter_functions.BuiltinHasCover[kaynak]

has_cover() – kitabın kapağı varsa Yes döndürür, aksi halde boş karakter dizisi döndürür

language_codes(lang_strings)

class calibre.utils.formatter_functions.BuiltinLanguageCodes[kaynak]

language_codes(lang_strings) – lang_strings içinde gönderilen karakter dizileri için dil kodlarını döndür. Karakter dizileri mevcut yerelin dilinde olmalıdır. Lang_strings virgülle ayrılmış listedir.

language_strings(lang_codes, localize)

class calibre.utils.formatter_functions.BuiltinLanguageStrings[kaynak]

language_strings(lang_codes, localize) – lang_codes ile verilen dil kodları için karakter dizisi döndür. localize sıfır ise, karakter dizilerini İngilizce döndürür. Sıfır değilse, karakter dizilerini mevcut yerelin dilinde döndür. Lang_codes virgülle ayrılmış listedir.

ondevice()

class calibre.utils.formatter_functions.BuiltinOndevice[kaynak]

ondevice() – ondevice ayarlanmışsa Yes döndürür. Bu fonksiyon yalnızca grafik arayüzde çalışır. Bu değeri diske-kaydet veya aygıta-gönder şablonlarında kullanmak istiyorsanız, özel bir “Diğer sütunlardan oluşturulmuş sütun” yapmalı, fonksiyonu bu sütunun şablonunda kullanmalısınız, ve bu sütunun değerini kaydet/gönder şablonlarınızda kullanmalısınız

raw_field(isim)

class calibre.utils.formatter_functions.BuiltinRawField[kaynak]

raw_field(isim) – isim ile adlandırılmış metadata alanını herhangi bir biçimleme yapmadan döndürür.

raw_list(isim, ayraç)

class calibre.utils.formatter_functions.BuiltinRawList[kaynak]

raw_list(isim, ayraç) – isim ile adlandırılmış metadata listesini herhangi bir biçimleme veya sıralama uygulamadan ve öğeleri ayraç ile ayırarak döndürür.

series_sort()

class calibre.utils.formatter_functions.BuiltinSeriesSort[kaynak]

series_sort() – seri sıralama değerini döndürür

user_categories()

class calibre.utils.formatter_functions.BuiltinUserCategories[kaynak]

user_categories() – Bu kitabı içeren kullanıcı kategorilerinin virgülle ayrılmış listesini döndürür. Bu fonksiyon yalnızca grafik arayüzde kullanılabilir. Bu değerleri diske-kaydet veya aygıta-gönder şablonlarında kullanmak istiyorsanız önce “Diğer sütunlarda özel oluşturulmuş sütun” yapmalı, fonksiyonu bu sütunun şablonunda kullanmalı, ve bu sütunun değerini kaydet/gönder şablonunuzda kullanmalısınız.

virtual_libraries()

class calibre.utils.formatter_functions.BuiltinVirtualLibraries[kaynak]

virtual_libraries() – Bu kitabı içeren sanal kitaplıkların virgülle ayrılmış listesini döndürür. Bu fonksiyon yalnızca grafik arayüzde kullanılabilir. Bu değerleri diske-kaydet veya aygıta-gönder şablonlarında kullanmak istiyorsanız önce “Diğer sütunlarda özel oluşturulmuş sütun” yapmalı, fonksiyonu bu sütunun şablonunda kullanmalı, ve bu sütunun değerini kaydet/gönder şablonunuzda kullanmalısınız.

If-then-else

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

class calibre.utils.formatter_functions.BuiltinContains[kaynak]

contains(val, pattern, text if match, text if not match) – checks if val contains matches for the regular expression pattern. Returns text if match if matches are found, otherwise it returns text if no match

ifempty(val, boşsa metin)

class calibre.utils.formatter_functions.BuiltinIfempty[kaynak]

ifempty(val, boşsa metin) – val boş değilse val, aksi halde boşsa metin döndürür

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

class calibre.utils.formatter_functions.BuiltinTest[kaynak]

test(val, text if not empty, text if empty) – return text if not empty if val is not empty, otherwise return text if empty

Iterating over values

first_non_empty(değer, değer, …)

class calibre.utils.formatter_functions.BuiltinFirstNonEmpty[kaynak]

first_non_empty(değer, değer, …) – boş olmayan ilk değeri döndürür. Tüm değerler boşsa, boş değer döndürülür. İstediğiniz kadar değer verebilirsiniz.

lookup(val, örüntü, alan, örüntü, alan, …, diger_alan)

class calibre.utils.formatter_functions.BuiltinLookup[kaynak]

lookup(val, örüntü, alan, örüntü, alan, …, diger_alan) – switch gibidir, yalnızca bağımsız değişkenler alan (metadata) isimleridir, metin değil. Uygun alanın değeri çekilir ve kullanılır. Bileşik sütunlar alan olduklarından, bu fonksiyonu bir bileşik alanda başka bir bileşik alanın değerini kullanarak kullanabilirsiniz. Bu, değişken kayıt yolları oluştururken oldukça faydalıdır.

switch(val, pattern, value, pattern, value, …, else_value)

class calibre.utils.formatter_functions.BuiltinSwitch[kaynak]

switch(val, pattern, value, pattern, value, …, else_value) – for each pattern, value pair, checks if val matches the regular expression pattern and if so, returns that value. If no pattern matches, then else_value is returned. You can have as many pattern, value pairs as you want

List lookup

identifier_in_list(val, id, bulundu_değer, bulunamadı_değer)

class calibre.utils.formatter_functions.BuiltinIdentifierInList[kaynak]

identifier_in_list(val, id, bulundu_değer, bulunamadı_değer) – val virgülle ayrılmış tanımlayıcılar listesi olmak üzere, karakter dizisini listedeki tüm değerlerle karşılaştırır. Tanımlayıcı “tanımlayıcı:değer” şeklindedir. id parametresi ya “id” ya da “id:regexp” olmalıdır. Bu id’ye sahip herhangi bir tanımlayıcı varsa ilk durum eşleşir. Düzenli ifade tanımlayıcının değeriyle eşleşirse de ikinci durum eşleşir. Bir eşleşme varsa, bulundu_değer, aksi halde bulunamadı_değer döndür.

in_list(val, separator, pattern, found_val, …, not_found_val)

class calibre.utils.formatter_functions.BuiltinInList[kaynak]

in_list(val, separator, pattern, found_val, …, not_found_val) – treat val as a list of items separated by separator, evaluating the pattern against each value in the list. If the pattern matches a value, return found_val, otherwise return not_found_val. The pattern and found_value can be repeated as many times as desired, permitting returning different values depending on the search. The patterns are checked in order. The first match is returned.

list_item(val, indis, ayraç)

class calibre.utils.formatter_functions.BuiltinListitem[kaynak]

list_item(val, indis, ayraç) – değeri ayraç ile ayrılmış öğeler listesi olarak yorumla, indis`inci öğeyi döndür. İlk öğe sıfır numaradır. Son öğe `list_item(-1,ayraç) ile döndürülebilir. Öğe listede değilse, boş değer döndürülür. Ayraç count fonksiyonundakiyle aynı anlama sahiptir.

select(val, key)

class calibre.utils.formatter_functions.BuiltinSelect[kaynak]

select(val, key) – değeri, öğeler “id:değer” olacak şekilde virgülle ayrılmış öğeler olarak değerlendirir. id’nin key’e eşit olduğu çifti bulur, ve karşılık gelen değeri döndürür.

str_in_list(val, separator, string, found_val, …, not_found_val)

class calibre.utils.formatter_functions.BuiltinStrInList[kaynak]

str_in_list(val, separator, string, found_val, …, not_found_val) – treat val as a list of items separated by separator, comparing the string against each value in the list. If the string matches a value (ignoring case) then return found_val, otherwise return not_found_val. If the string contains separators, then it is also treated as a list and each value is checked. The string and found_value can be repeated as many times as desired, permitting returning different values depending on the search. The strings are checked in order. The first match is returned.

List manipulation

count(val, ayraç)

class calibre.utils.formatter_functions.BuiltinCount[kaynak]

count(val, ayraç) – değeri ayraç ile ayrılmış öğeler listesi olarak yorumlar, listedeki öğe sayısını döndürür. Çoğu liste ayraç olarak virgül kullanır, ama yazarlar ampersand kullanır. Örnekler: {tags:count(,)}, {authors:count(&)}

list_difference(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListDifference[kaynak]

list_difference(list1, list2, separator) – return a list made by removing from list1 any item found in list2, using a case-insensitive comparison. The items in list1 and list2 are separated by separator, as are the items in the returned list.

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

class calibre.utils.formatter_functions.BuiltinListEquals[kaynak]

list_equals(list1, sep1, list2, sep2, yes_val, no_val) – return yes_val if list1 and list2 contain the same items, otherwise return no_val. The items are determined by splitting each list using the appropriate separator character (sep1 or sep2). The order of items in the lists is not relevant. The comparison is case insensitive.

list_intersection(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListIntersection[kaynak]

list_intersection(list1, list2, separator) – return a list made by removing from list1 any item not found in list2, using a case-insensitive comparison. The items in list1 and list2 are separated by separator, as are the items in the returned list.

list_re(src_list, ayraç, include_re, opt_replace)

class calibre.utils.formatter_functions.BuiltinListRe[kaynak]

list_re(src_list, ayraç, include_re, opt_replace) – Ayraç karakteriyle src_list’in öğelere ayrılmasıyla bir liste oluşturulur. Listedeki her öğe için, include_re kuralına uyup uymadığı kontrol edilir. Eşleşiyorsa, döndürülecek listeye eklenir. opt_replace boş karakter dizisi değilse, öğe döndürülecek listeye eklenmeden önce değiştirme yapılır.

list_re_group(src_list, ayraç, include_re, search_re, grup_1_şablon, …)

class calibre.utils.formatter_functions.BuiltinListReGroup[kaynak]

list_re_group(src_list, ayraç, include_re, search_re, grup_1_şablon, …) – list_re gibidir, farkı yer değiştirmenin isteğe bağlı olmamasıdır. Döndürülecek listede yer değiştirme yaparken re_group(list_item, search_re, grup_1_şablon, …) kullanır.

list_sort(list, yön, ayraç)

class calibre.utils.formatter_functions.BuiltinListSort[kaynak]

list_sort(list, yön, ayraç) – büyük küçük harf duyarsız sıralamayla sıralanmış listeyi döndürür. Yön sıfırsa, liste artan sırada, aksi halde azalan sırada sıralanır. list öğeleri ve döndürülen listedeki öğeler ayraç ile ayrılır.

list_union(list1, list2, separator)

class calibre.utils.formatter_functions.BuiltinListUnion[kaynak]

list_union(list1, list2, separator) – return a list made by merging the items in list1 and list2, removing duplicate items using a case-insensitive comparison. If items differ in case, the one in list1 is used. The items in list1 and list2 are separated by separator, as are the items in the returned list.

subitems(val, başlangıç_indisi, bitiş_indisi)

class calibre.utils.formatter_functions.BuiltinSubitems[kaynak]

subitems(val, başlangıç_indisi, bitiş_indisi) –Bu fonksiyon tarzlar gibi öğe listelerini ayırmak için kullanılır. Değeri virgülle ayrılmış öğeler listesi olarak yorumlar, her öğe noktayla ayrılmış listedir. Önce noktayla ayrılmış öğeleri bulur, sonra her öğe için `başlangıç_indisi`nden `bitiş_indisi`ne bileşenler çıkarılır, sonra sonuçlar bir araya getirilir ve döndürülür. Noktayla ayrılmış listedeki ilk bileşenin indisi sıfırdır. Bir indis eksi değerdeyse, listenin sonundan saymaya başlar. Özel bir durum olarak, bitiş_indisi sıfır olursa listenin boyutu anlamına gelir. Örnek olarak basit şablon kipinde #genre değeri “A.B.C”: {#genre:subitems(0,1)} olursa “A” döner. {#genre:subitems(0,2)} “A.B” döndürür. {#genre:subitems(1,0)} “B.C” döndürür. #genre değerinin “A.B.C, D.E.F” olduğu varsayılırsa, {#genre:subitems(0,1)} “A, D” döndürür. {#genre:subitems(0,2)} “A.B, D.E” döndürür

sublist(val, start_index, end_index, separator)

class calibre.utils.formatter_functions.BuiltinSublist[kaynak]

sublist(val, start_index, end_index, separator) – interpret the value as a list of items separated by separator, returning a new list made from the start_index to the end_index item. The first item is number zero. If an index is negative, then it counts from the end of the list. As a special case, an end_index of zero is assumed to be the length of the list. Examples using basic template mode and assuming that the tags column (which is comma-separated) contains “A, B, C”: {tags:sublist(0,1,\,)} returns “A”. {tags:sublist(-1,0,\,)} returns “C”. {tags:sublist(0,-1,\,)} returns “A, B”.

Other

assign(id, val)

class calibre.utils.formatter_functions.BuiltinAssign[kaynak]

assign(id, val) – val değerini id’ye atar, ve val döndürür. id bir tanımlayıcı olmalıdır, ifade değil

Recursion

eval(şablon)

class calibre.utils.formatter_functions.BuiltinEval[kaynak]

eval(şablon) – şablonu, kitap metadata’sı yerine yerel değişkenleri (‘atama’ yapılanlar) vererek değerlendirir. Bu, şablon işlemciyi kullanarak yerel değişkenlerle karmaşık sonuçlar oluşturmaya yarar. { ve } karakterleri özel olduğundan } karakteri yerine ]] ve { karakteri yerine [[ kullanmalısınız; otomatik olarak dönüştürülürler. Ön ek ve son eklerin (|önek|sonek söz dizimi) şablon program kipinde bu fonksiyona bağımsız değişken olarak verileemeyeceğini unutmayın.

template(x)

class calibre.utils.formatter_functions.BuiltinTemplate[kaynak]

template(x) – x’i şablon olarak değerlendirir. Değerlendirme kendi bağlamında yapılır, yani değişkenler çağıran ve şablon değerlendirme tarafından paylaşılmaz. Çünkü { ve } karakterleri özeldir, { karakteri için [[ ve } karakteri için }} kullanmanız gerekir; otomatik olarak dönüştürülürler. Örneğin, template(‘[[title_sort]]’) {title_sort} şablonunu değerlendirir ve değerini döndürür. Ön ek ve son eklerin (|önek|sonek söz dizimi) şablon program kipinde bu fonksiyona bağımsız değişken olarak verilemeyeceğini unutmayın.

Relational

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

class calibre.utils.formatter_functions.BuiltinCmp[kaynak]

cmp(x, y, lt, eq, gt) – her ikisini de sayıya çevirdikten sonra x ve y’yi karşılaştırır. x < y ise lt döndürür. x == y ise eq döndürür. Aksi halde gt döndürür.

first_matching_cmp(val, cmp1, result1, cmp2, r2, …, else_result)

class calibre.utils.formatter_functions.BuiltinFirstMatchingCmp[kaynak]

first_matching_cmp(val, cmp1, result1, cmp2, r2, …, else_result) – “val < cmpN”i sırayla karşılaştırır, başarılı olan ilk eşleşmeyi resultN olarak döndürür. Hiçbir karşılaştırma başarılı olmazsa else_result döndürür. Örneğin: first_matching_cmp(10,5,”küçük”,10,”orta”,15,”büyük”,”devasa”) “büyük” döndürür. Aynı örnekte ilk değer 16 olursa “devasa” döndürür.

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

class calibre.utils.formatter_functions.BuiltinStrcmp[kaynak]

strcmp(x, y, lt, eq, gt) – x ve y’nin karakter dizisi olarak büyük küçük harf bağımsız karşılaştırmasını yapar. x < y ise lt döndürür. if x == y ise eq döndürür. Aksi halde gt döndürür.

String case changes

capitalize(val)

class calibre.utils.formatter_functions.BuiltinCapitalize[kaynak]

capitalize(val) – return val capitalized

lowercase(val)

class calibre.utils.formatter_functions.BuiltinLowercase[kaynak]

lowercase(val) – return val in lower case

titlecase(val)

class calibre.utils.formatter_functions.BuiltinTitlecase[kaynak]

titlecase(val) – return val in title case

uppercase(val)

class calibre.utils.formatter_functions.BuiltinUppercase[kaynak]

uppercase(val) – return val in upper case

String manipulation

re(val, pattern, replacement)

class calibre.utils.formatter_functions.BuiltinRe[kaynak]

re(val, pattern, replacement) – return val after applying the regular expression. All instances of pattern are replaced with replacement. As in all of calibre, these are Python-compatible regular expressions

re_group(val, pattern, template_for_group_1, for_group_2, …)

class calibre.utils.formatter_functions.BuiltinReGroup[kaynak]

re_group(val, pattern, template_for_group_1, for_group_2, …) – return a string made by applying the regular expression pattern to the val and replacing each matched instance with the string computed by replacing each matched group by the value returned by the corresponding template. The original matched value for the group is available as $. In template program mode, like for the template and the eval functions, you use [[ for { and ]] for }. The following example in template program mode looks for series with more than one word and uppercases the first word: {series:’re_group($, “(S* )(.*)”, “[[$:uppercase()]]”, “[[$]]”)’}

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

class calibre.utils.formatter_functions.BuiltinShorten[kaynak]

shorten(val, left chars, middle text, right chars) – Return a shortened version of val, consisting of left chars characters from the beginning of val, followed by middle text, followed by right chars characters from the end of the string. Left chars and right chars must be integers. For example, assume the title of the book is Ancient English Laws in the Times of Ivanhoe, and you want it to fit in a space of at most 15 characters. If you use {title:shorten(9,-,5)}, the result will be Ancient E-nhoe. If the field’s length is less than left chars + right chars + the length of middle text, then the field will be used intact. For example, the title The Dome would not be changed.

strcat(a, b, …)

class calibre.utils.formatter_functions.BuiltinStrcat[kaynak]

strcat(a, b, …) – herhangi bir sayıda değişken alabilir. Tüm değişkenleri bitiştiren bir çıktı döndürür

strcat_max(max, string1, prefix2, string2, …)

class calibre.utils.formatter_functions.BuiltinStrcatMax[kaynak]

strcat_max(max, string1, prefix2, string2, …) – Bağımsız değişkenlerin uç uca eklenmesiyle oluşan karakter dizisini döndürür. Dönen değer string1’e atanır. Prefix, string çiftleri nihai karater dizisi uzunluğu max değerini geçmediği sürece değerin sonuna eklenir. string1 max’dan uzun olsa bile String1 döndürülür. İstediğiniz kadar prefix, string çifti verebilirsiniz.

strlen(a)

class calibre.utils.formatter_functions.BuiltinStrlen[kaynak]

strlen(a) – Değişken olarak aldığı karakter dizisinin uzunluğunu döndürür

substr(str, start, end)

class calibre.utils.formatter_functions.BuiltinSubstr[kaynak]

substr(str, start, end) – str’nin start’dan end karakterine kadar aralığını döndürür. str’deki İlk karakter sıfırıncı karakterdir. end eksi bir değerse, sağdak bu kadar karakter anlamına gelir. end sıfırsa, son karakter anlamına gelir. Örneğin, substr(‘12345’, 1, 0) ‘2345’ döndürür, substr(‘12345’, 1, -1) ‘234’ döndürür.

swap_around_comma(val)

class calibre.utils.formatter_functions.BuiltinSwapAroundComma[kaynak]

swap_around_comma(val) – “B, A” biçiminde bir değer verildiğinde, “A B” döndür. Bu en çok Soyad Ad şeklindeki isimleri Ad Soyada çevirmede kullanılır. Virgül yoksa, fonksiyon val değerini değiştirmeden döndürür

transliterate(a)

class calibre.utils.formatter_functions.BuiltinTransliterate[kaynak]

transliterate(a) – kaynak karakter dizisindeki seslerin yaklaşık halleriyle oluşturulmuş latin alfabesinde bir karakter dizisi döndürür. Örneğin, kaynak “Фёдор Миха́йлович Достоевский” ise fonksiyon “Fiodor Mikhailovich Dostoievskii” döndürür.

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=(u'Bilinmiyor', ), other=None, template_cache=None, formatter=None)[kaynak]

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

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 <lambda>>)[kaynak]

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

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

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

set_identifier(typ, val)[kaynak]

If val is empty, deletes identifier of type typ

standard_field_keys()[kaynak]

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

custom_field_keys()[kaynak]

return a list of the custom fields in this book

all_field_keys()[kaynak]

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

metadata_for_field(key)[kaynak]

return metadata describing a standard or custom field.

all_non_none_fields()[kaynak]

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

get_standard_metadata(field, make_copy)[kaynak]

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

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

get_all_user_metadata(make_copy)[kaynak]

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

get_user_metadata(field, make_copy)[kaynak]

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

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

set_user_metadata(field, metadata)[kaynak]

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

template_to_attribute(other, ops)[kaynak]

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

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

Returns the tuple (display_name, formatted_value)

to_html()[kaynak]

A HTML representation of this object.

calibre.ebooks.metadata.book.base.STANDARD_METADATA_FIELDS

The set of standard metadata fields.

__docformat__ = 'restructuredtext en'

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

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

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

TOP_LEVEL_IDENTIFIERS = frozenset((
    'isbn',
))

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

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

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

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

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

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

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

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

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

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

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