def test_export_annotations(self):
page = DatabaseBook('demo').page('page_test_monodi_export_001')
self.call_operation(page, 'preprocessing', {'automaticLd': True})
self.client.post('/api/book/{}/page/{}/operation')
response: FileResponse = self.client.post(
'/api/book/{}/download/annotations.zip'.format(page.book.book),
{'pages': [page.page]},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.filename)
import io
import zipfile
by = io.BytesIO(b''.join(response.streaming_content))
files_to_expect = [
'color_original', 'color_norm_x2', 'binary_norm_x2', 'pcgts',
'meta'
]
with zipfile.ZipFile(by) as f:
zip_files = [z.filename for z in f.infolist()]
files_to_expect = [
"{}/{}{}".format(file, page.page,
page.file(file).ext())
for file in files_to_expect
]
self.assertListEqual(files_to_expect, zip_files)
self.assertEqual(len(zip_files), len(files_to_expect))
def test_export_monodi(self):
page = DatabaseBook('demo').page('page_test_monodi_export_001')
response: FileResponse = self.client.post(
'/api/book/{}/download/monodiplus.json'.format(page.book.book),
{'pages': [page.page]},
format='json')
self.assertEqual(response.status_code, status.HTTP_200_OK,
response.filename)
data = b''.join(response.streaming_content).decode('utf-8')
data = json.loads(data)
drop_all_attributes(data, 'uuid')
with open(page.local_file_path('monodi.json')) as f:
self.assertEqual(data, json.load(f))
def test_book_preprocessing(self):
book = DatabaseBook('demo')
params = AlgorithmRequest(
store_to_pcgts=False,
params=AlgorithmPredictorParams(automaticLd=True),
selection=PageSelectionParams(
count=PageCount.CUSTOM,
pages=['page_test_preprocessing_001'],
))
self.call_book_operation(book, AlgorithmTypes.PREPROCESSING, params)
def test_book_symbol_detection(self):
book = DatabaseBook('demo')
params = AlgorithmRequest(store_to_pcgts=False,
params=AlgorithmPredictorParams(),
selection=PageSelectionParams(
count=PageCount.CUSTOM,
pages=[
'page_test_symbol_detection_001',
'page_test_symbol_detection_002'
],
))
self.call_book_operation(book, AlgorithmTypes.SYMBOLS_PC, params)
def test_book_layout_detection_complex(self):
book = DatabaseBook('demo')
params = AlgorithmRequest(store_to_pcgts=False,
params=AlgorithmPredictorParams(),
selection=PageSelectionParams(
count=PageCount.CUSTOM,
pages=[
'page_test_layout_detection_001',
'page_test_layout_detection_002'
],
))
self.call_book_operation(book, AlgorithmTypes.LAYOUT_COMPLEX_STANDARD,
params)
def list_available_models_for_book(self, book: DatabaseBook) -> DatabaseAvailableModels:
from database.models.bookstyles import BookStyle
meta = self.algorithm_meta()
return DatabaseAvailableModels(
book=book.book,
book_meta=book.get_meta(),
newest_model=meta.newest_model_for_book(book).meta() if meta.newest_model_for_book(book) else None,
selected_model=meta.selected_model_for_book(book).meta() if meta.selected_model_for_book(book) else None,
book_models=[m.meta() for m in meta.models_for_book(book).list_models()],
default_book_style_model=meta.model_of_book_style(book).meta() if meta.model_of_book_style(book) else None,
models_of_same_book_style=[(b.get_meta(), meta.newest_model_for_book(b).meta()) for b in DatabaseBook.list_available_of_style(book.get_meta().notationStyle) if b.book != book.book and meta.newest_model_for_book(b)],
default_models=[DefaultModel(o.id, meta.default_model_for_style(o.id).meta()) for o in BookStyle.objects.all() if meta.default_model_for_style(o.id)],
)
def _test_list_models(self, operation: AlgorithmTypes):
from database.database_available_models import DatabaseAvailableModels
from database.model import ModelsId, MetaId
book = DatabaseBook('demo')
response = self.client.get('/api/book/{}/operation/{}/models'.format(
book.book, operation.value))
self.assertEqual(response.status_code, status.HTTP_200_OK, response)
models_id = ModelsId.from_internal('french14',
AlgorithmTypes.STAFF_LINES_PC)
models = DatabaseAvailableModels.from_dict(response.data)
self.assertEqual(models.newest_model, None)
self.assertEqual(
models.selected_model.id,
str(MetaId(models_id, models_id.algorithm_type.value)))
self.assertEqual(
models.default_book_style_model.id,
str(MetaId(models_id, models_id.algorithm_type.value)))
self.assertListEqual(models.book_models, [])
self.assertListEqual(models.models_of_same_book_style, [])
def _test_predictor(self, page, algorithm: AlgorithmTypes):
page = DatabaseBook('demo').page(page)
data = self.call_operation(page, algorithm.value, {
'pcgts': page.pcgts().to_json(),
})
return data
def test_preprocessing_001(self):
page = DatabaseBook('demo').page('page_test_preprocessing_001')
self._test_preprocessing_of_page(page)
pcgts.page.image_width, pcgts.page.image_height = image_shape
return pcgts
def to_json(self):
output = {
'version': self.version,
'meta': self.meta.to_json(),
'page': self.page.to_json(),
}
if self.mei_head_meta:
output['meiHeadMeta'] = self.mei_head_meta.to_json()
return output
if __name__ == '__main__':
from database.file_formats.pcgts import TextRegion, TextRegionType, Page, Meta
from database.database_page import DatabaseBook
import json
page = DatabaseBook('demo').pages()[0]
pcgts = PcGts(Meta(), Page(
[
TextRegion(
'1',
TextRegionType.LYRICS
)
]
))
print(pcgts.to_json())
print(PcGts.from_json(pcgts.to_json(), page).to_json() == pcgts.to_json())
def from_dict(d: dict, book: DatabaseBook):
return PageSelection(book,
PageCount(d.get('count', PageCount.ALL.value)),
[book.page(page) for page in d.get('pages', [])])
def from_params(params: PageSelectionParams, book: DatabaseBook):
return PageSelection(book, PageCount(params.count),
[book.page(page) for page in params.pages])
