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