From 5ebf4e07c3674251fee49e718ca063875ef343a1 Mon Sep 17 00:00:00 2001 From: Ivan Beloborodov Date: Mon, 14 Sep 2020 06:53:41 +0300 Subject: [PATCH] 'Save dictionary' with sounds option #282 Error message should inform user to login if he wants to save dictionary #278 Uploaded file cannot be opened. #195 --- development.ini | 13 +- docker/docker-compose-proxy.yml | 2 + docker/docker-compose.yml | 2 + docker/docker-proxy.ini | 7 + docker/docker.ini | 7 + docker/nginx/lingvodoc.conf | 2 +- lingvodoc/__init__.py | 20 +- lingvodoc/models.py | 7 + lingvodoc/schema/query.py | 16 +- lingvodoc/scripts/save_dictionary.py | 801 +++++++++++++++++---- lingvodoc/views/v2/save_dictionary/core.py | 2 + server-requirements.txt | 3 +- 12 files changed, 739 insertions(+), 143 deletions(-) diff --git a/development.ini b/development.ini index c4f99205b..c1a84401a 100644 --- a/development.ini +++ b/development.ini @@ -71,12 +71,12 @@ formatter = generic [handler_filelog] class = handlers.RotatingFileHandler -args = ('%(here)s/pyramid.log', 'a', 16777216, 1) +args = ('%(here)s/pyramid.log', 'a', 16777216, 8) level = NOTSET formatter = generic [formatter_generic] -format = %(asctime)s %(levelname)-5.5s [%(name)s][%(threadName)s] %(message)s +format = %(asctime)s %(levelname)-5.5s [%(name)s][%(threadName)s] %(pathname)s:%(lineno)d: %(message)s [app:accounts] use = egg:lingvodoc @@ -97,6 +97,13 @@ static_route = objects/ #auth_version = 2.0 #tenant_name = admin +[backend:storage.temporary] +host = minio.at.ispras.ru +access_key = ld_development_access_key +secret_key = ld_development_secret_key +bucket = lingvodoc-temp-files +prefix = dev/ + # Info of the SMTP server account used to send emails, e.g. emails of user signup approval. [smtp] host = mail.ispras.ru @@ -137,7 +144,7 @@ callable = lingvodoc # Caching. [cache:dogpile] -expiration_time = 36000 +expiration_time = 3600000 backend = dogpile.cache.redis ;backend = dogpile.cache.memcached diff --git a/docker/docker-compose-proxy.yml b/docker/docker-compose-proxy.yml index 3c7493c3d..9ffbd2196 100644 --- a/docker/docker-compose-proxy.yml +++ b/docker/docker-compose-proxy.yml @@ -29,6 +29,7 @@ services: - ./frontend/dist:/dist - ./nginx:/etc/nginx/conf.d - ./sock:/sock + - /tmp:/tmp depends_on: - pg - api @@ -75,6 +76,7 @@ services: - ./sock:/sock - /api/build/ - ../:/api + - /tmp:/tmp env_file: - ./locale_env.sh diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml index d0b67f785..31a541ac9 100644 --- a/docker/docker-compose.yml +++ b/docker/docker-compose.yml @@ -20,6 +20,7 @@ services: - ./frontend/dist:/dist - ./nginx:/etc/nginx/conf.d - ./sock:/sock + - /tmp:/tmp depends_on: - pg - api @@ -46,6 +47,7 @@ services: - ./sock:/sock - /api/build/ - ../:/api + - /tmp:/tmp env_file: - ./locale_env.sh diff --git a/docker/docker-proxy.ini b/docker/docker-proxy.ini index ff405a2dc..e808a03cf 100644 --- a/docker/docker-proxy.ini +++ b/docker/docker-proxy.ini @@ -99,6 +99,13 @@ path = /tmp/ prefix = http://localhost/ static_route = objects/ +[backend:storage.temporary] +host = minio.at.ispras.ru +access_key = ld_development_access_key +secret_key = ld_development_secret_key +bucket = lingvodoc-temp-files +prefix = dev/ + [cache:dogpile] expiration_time = 3600000 backend = dogpile.cache.redis diff --git a/docker/docker.ini b/docker/docker.ini index c06eb8ece..bdd5757dc 100644 --- a/docker/docker.ini +++ b/docker/docker.ini @@ -93,6 +93,13 @@ path = /tmp/ prefix = http://localhost/ static_route = objects/ +[backend:storage.temporary] +host = minio.at.ispras.ru +access_key = ld_development_access_key +secret_key = ld_development_secret_key +bucket = lingvodoc-temp-files +prefix = dev/ + [cache:dogpile] expiration_time = 3600000 backend = dogpile.cache.redis diff --git a/docker/nginx/lingvodoc.conf b/docker/nginx/lingvodoc.conf index 9141d4759..72236e7f3 100644 --- a/docker/nginx/lingvodoc.conf +++ b/docker/nginx/lingvodoc.conf @@ -20,7 +20,7 @@ server { location /objects/ { - root /tmp; + alias /tmp/; } location ~* \.(?:manifest|appcache|html?|xml|json)$ { diff --git a/lingvodoc/__init__.py b/lingvodoc/__init__.py index be0d58cd8..7aa941a13 100755 --- a/lingvodoc/__init__.py +++ b/lingvodoc/__init__.py @@ -1021,9 +1021,23 @@ def main(global_config, **settings): # TODO: DANGER - settings['storage'] = dict(parser.items( - 'backend:storage' if parser.has_section('backend:storage') else - 'storage')) + storage_dict = ( + + dict(parser.items( + 'backend:storage' if parser.has_section('backend:storage') else + 'storage'))) + + if parser.has_section('backend:storage.temporary'): + + storage_dict['temporary'] = ( + dict(parser.items('backend:storage.temporary'))) + + elif parser.has_section('storage.temporary'): + + storage_dict['temporary'] = ( + dict(parser.items('storage.temporary'))) + + settings['storage'] = storage_dict if parser.has_section('app:desktop'): storage = dict() diff --git a/lingvodoc/models.py b/lingvodoc/models.py index 4a20cfef6..124a7b7e9 100755 --- a/lingvodoc/models.py +++ b/lingvodoc/models.py @@ -796,6 +796,13 @@ def data_type(self): return translation + @property + def data_type_translation_gist_id(self): + + return ( + self.data_type_translation_gist_client_id, + self.data_type_translation_gist_object_id) + class Field(CompositeIdMixin, Base, diff --git a/lingvodoc/schema/query.py b/lingvodoc/schema/query.py index 3b484d73f..b42da8b6a 100644 --- a/lingvodoc/schema/query.py +++ b/lingvodoc/schema/query.py @@ -7459,6 +7459,7 @@ def save_dictionary( user_id, locale_id, publish, + sound_flag, synchronous = False, debug_flag = False): @@ -7483,6 +7484,7 @@ def save_dictionary( my_args["task_key"] = task.key if not synchronous else None my_args["cache_kwargs"] = request.registry.settings["cache_kwargs"] my_args["published"] = publish + my_args['sound_flag'] = sound_flag my_args['__debug_flag__'] = debug_flag res = (sync_save_dictionary if synchronous else async_save_dictionary.delay)(**my_args) @@ -7493,6 +7495,7 @@ class SaveDictionary(graphene.Mutation): class Arguments: id = LingvodocID(required=True) mode = graphene.String(required=True) + sound_flag = graphene.Boolean() synchronous = graphene.Boolean() debug_flag = graphene.Boolean() @@ -7501,14 +7504,18 @@ class Arguments: @staticmethod # @client_id_check() def mutate(root, info, **args): + request = info.context.request locale_id = int(request.cookies.get('locale_id') or 2) dict_id = args['id'] mode = args['mode'] - variables = {'auth': authenticated_userid(request)} - client = DBSession.query(Client).filter_by(id=variables['auth']).first() - user = DBSession.query(dbUser).filter_by(id=client.user_id).first() - user_id = user.id + sound_flag = args.get('sound_flag', False) + + client_id = authenticated_userid(request) + + user_id = ( + Client.get_user_by_client_id(client_id).id + if client_id else anonymous_userid(request)) dictionary_obj = DBSession.query(dbDictionary).filter_by(client_id=dict_id[0], object_id=dict_id[1]).first() @@ -7531,6 +7538,7 @@ def mutate(root, info, **args): user_id, locale_id, publish, + sound_flag, args.get('synchronous', False), args.get('debug_flag', False)) diff --git a/lingvodoc/scripts/save_dictionary.py b/lingvodoc/scripts/save_dictionary.py index d73fcd25c..ea9eea01a 100644 --- a/lingvodoc/scripts/save_dictionary.py +++ b/lingvodoc/scripts/save_dictionary.py @@ -13,13 +13,23 @@ import pprint import re import shutil -import transaction +import sndhdr import tempfile -from pydub import AudioSegment +import transaction +import zipfile + +import collections from collections import defaultdict + from pathvalidate import sanitize_filename + +import urllib from urllib import request +import minio + +from pydub import AudioSegment + import sqlalchemy from sqlalchemy.orm.exc import NoResultFound from sqlalchemy import and_, create_engine, func @@ -47,6 +57,7 @@ from lingvodoc.utils import explain_analyze, sanitize_worksheet_name from lingvodoc.utils.search import recursive_sort from lingvodoc.utils.static_fields import fields_static +from lingvodoc.views.v2.utils import as_storage_file, storage_file from sqlalchemy.orm import ( aliased, sessionmaker, @@ -718,12 +729,15 @@ def __init__( locale_id, session, cognates_flag = True, + sound_flag = False, + storage = None, __debug_flag__ = False): self.locale_id = locale_id self.session = session self.cognates_flag = cognates_flag + self.sound_flag = sound_flag self.stream = io.BytesIO() self.workbook = xlsxwriter.Workbook(self.stream, {'in_memory': True}) @@ -733,6 +747,8 @@ def __init__( self.session.execute( 'refresh materialized view text_field_id_view;') + # Preparation for etymology listing. + if cognates_flag: self.etymology_dict = {} @@ -777,6 +793,13 @@ def __init__( self.pid_fid_table_name = 'pid_fid_table_' + uuid_str self.eid_pid_table_name = 'eid_pid_table_' + uuid_str + sound_fid_str = ( + + ''' + sound_client_id BIGINT, + sound_object_id BIGINT, + ''') + self.session.execute(''' create temporary table @@ -787,7 +810,7 @@ def __init__( transcription_client_id BIGINT, transcription_object_id BIGINT, translation_client_id BIGINT, - translation_object_id BIGINT, + translation_object_id BIGINT,{sound_str} primary key ( perspective_client_id, @@ -810,8 +833,15 @@ def __init__( on commit drop; '''.format( - pid_fid_table_name = self.pid_fid_table_name, - eid_pid_table_name = self.eid_pid_table_name)) + + pid_fid_table_name = + self.pid_fid_table_name, + + eid_pid_table_name = + self.eid_pid_table_name, + + sound_str = + sound_fid_str if sound_flag else '')) # Some commonly used etymological SQL queries. @@ -845,6 +875,65 @@ def __init__( '''.format( eid_pid_table_name = self.eid_pid_table_name)) + sound_fid_str = ( + + ''', + Tp.sound_client_id, + Tp.sound_object_id + ''') + + sound_cte_str = ( + + ''', + + sound_cte as ( + + select + E.parent_client_id, + E.parent_object_id, + jsonb_agg( + jsonb_build_array( + E.content, + extract(epoch from E.created_at))) content_list + + from + eid_pid_fid_cte T, + public.entity E, + publishingentity P + + where + E.parent_client_id = T.entry_client_id and + E.parent_object_id = T.entry_object_id and + E.field_client_id = T.sound_client_id and + E.field_object_id = T.sound_object_id and + E.content is not null and + E.marked_for_deletion is false and + P.client_id = E.client_id and + P.object_id = E.object_id and + P.accepted = true{0} + + group by + E.parent_client_id, + E.parent_object_id) + + ''') + + sound_select_str = ( + + ''', + S.content_list + ''') + + sound_join_str = ( + + ''' + left outer join + sound_cte S + on + S.parent_client_id = T.entry_client_id and + S.parent_object_id = T.entry_object_id + ''') + self.sql_etymology_str_b = (''' with @@ -859,7 +948,7 @@ def __init__( Tp.transcription_client_id, Tp.transcription_object_id, Tp.translation_client_id, - Tp.translation_object_id + Tp.translation_object_id{sound_fid_str} from {eid_pid_table_name} Te, @@ -921,7 +1010,7 @@ def __init__( group by E.parent_client_id, - E.parent_object_id) + E.parent_object_id){sound_cte_str} select T.entry_client_id, @@ -929,7 +1018,7 @@ def __init__( T.perspective_client_id, T.perspective_object_id, Xc.content_list, - Xl.content_list + Xl.content_list{sound_select_str} from eid_pid_fid_cte T @@ -944,15 +1033,59 @@ def __init__( translation_cte Xl on Xl.parent_client_id = T.entry_client_id and - Xl.parent_object_id = T.entry_object_id; + Xl.parent_object_id = T.entry_object_id{sound_join_str}; '''.format( - pid_fid_table_name = self.pid_fid_table_name, - eid_pid_table_name = self.eid_pid_table_name)) + + pid_fid_table_name = + self.pid_fid_table_name, + + eid_pid_table_name = + self.eid_pid_table_name, + + sound_fid_str = + sound_fid_str if sound_flag else '', + + sound_cte_str = + sound_cte_str if sound_flag else '', + + sound_select_str = + sound_select_str if sound_flag else '', + + sound_join_str = + sound_join_str if sound_flag else '')) self.format_gray = ( self.workbook.add_format({'bg_color': '#e6e6e6'})) + # If we need to export sounds, we will need some sound fields info. + + if sound_flag: + + self.storage = storage + + self.storage_f = ( + as_storage_file if __debug_flag__ else storage_file) + + self.sound_type_id = ( + + self.session + + .query( + TranslationGist.client_id, + TranslationGist.object_id) + + .join(TranslationAtom) + + .filter( + TranslationGist.marked_for_deletion == False, + TranslationGist.type == 'Service', + TranslationAtom.marked_for_deletion == False, + TranslationAtom.content == 'Sound', + TranslationAtom.locale_id == 2) + + .first()) + if __debug_flag__: # Simple text field ids query. @@ -1057,20 +1190,50 @@ def ready_perspective( # Getting field data. + if self.sound_flag: + + self.field_condition = ( + + or_( + + tuple_( + DictionaryPerspectiveToField.field_client_id, + DictionaryPerspectiveToField.field_object_id) + + .in_( + sqlalchemy.text('select * from text_field_id_view')), + + and_( + Field.data_type_translation_gist_client_id == self.sound_type_id[0], + Field.data_type_translation_gist_object_id == self.sound_type_id[1]))) + + else: + + self.field_condition = ( + + tuple_( + DictionaryPerspectiveToField.field_client_id, + DictionaryPerspectiveToField.field_object_id) + + .in_( + sqlalchemy.text('select * from text_field_id_view'))) + field_query = ( self.session - .query(DictionaryPerspectiveToField) - .filter_by( - parent_client_id=perspective.client_id, - parent_object_id=perspective.object_id, - marked_for_deletion=False) - - .filter(tuple_( - DictionaryPerspectiveToField.field_client_id, - DictionaryPerspectiveToField.field_object_id) - .in_(sqlalchemy.text('select * from text_field_id_view'))) + .query( + DictionaryPerspectiveToField, + Field) + + .filter( + DictionaryPerspectiveToField.parent_client_id == perspective.client_id, + DictionaryPerspectiveToField.parent_object_id == perspective.object_id, + DictionaryPerspectiveToField.marked_for_deletion == False, + Field.client_id == DictionaryPerspectiveToField.field_client_id, + Field.object_id == DictionaryPerspectiveToField.field_object_id, + Field.marked_for_deletion == False, + self.field_condition) .order_by(DictionaryPerspectiveToField.position)) @@ -1085,7 +1248,22 @@ def ready_perspective( log.debug(''.join( '\n' + row[0] for row in row_list)) - self.fields = field_query.all() + field_info_list = field_query.all() + + # All perspective fields we are to extract, and separately just the sound field ids. + + self.fields = [ + + to_field + for to_field, field in field_info_list] + + if self.sound_flag: + + self.sound_field_id_set = set( + + field.id + for to_field, field in field_info_list + if field.data_type_translation_gist_id == self.sound_type_id) # Etymology field, if required. @@ -1135,6 +1313,7 @@ def ready_perspective( self.row += 1 self.perspective_fail_set = set() + self.perspective_snd_fail_set = set() def update_dictionary_info( self, perspective_id_set): @@ -1151,13 +1330,20 @@ def update_dictionary_info( if perspective_info: - order_key, name_str, xcript_fid, xlat_fid = perspective_info + order_key, name_str, xcript_fid, xlat_fid, snd_fid = perspective_info if xcript_fid is None or xlat_fid is None: self.perspective_fail_set.add( (order_key, name_str)) + elif ( + self.sound_flag and + snd_fid is None): + + self.perspective_snd_fail_set.add( + (order_key, name_str)) + else: update_pid_set.add(perspective_id) @@ -1235,16 +1421,10 @@ def update_dictionary_info( DictionaryPerspectiveToField.parent_client_id == perspective.client_id, DictionaryPerspectiveToField.parent_object_id == perspective.object_id, DictionaryPerspectiveToField.marked_for_deletion == False, - - tuple_( - DictionaryPerspectiveToField.field_client_id, - DictionaryPerspectiveToField.field_object_id) - - .in_(sqlalchemy.text('select * from text_field_id_view')), - Field.client_id == DictionaryPerspectiveToField.field_client_id, Field.object_id == DictionaryPerspectiveToField.field_object_id, Field.marked_for_deletion == False, + self.field_condition, Field.translation_gist_client_id == TranslationAtom.parent_client_id, Field.translation_gist_object_id == TranslationAtom.parent_object_id, TranslationAtom.marked_for_deletion == False) @@ -1265,11 +1445,12 @@ def update_dictionary_info( field_name_info_list, width = 192)) # Choosing perspective transcription and translation fields. - + # # At first, we look for standard fields. transcription_fid = None translation_fid = None + sound_fid = None for field_cid, field_oid, name_dict in field_name_info_list: @@ -1279,15 +1460,20 @@ def update_dictionary_info( elif field_cid == 66 and field_oid == 10: translation_fid = (field_cid, field_oid) + elif field_cid == 66 and field_oid == 12: + sound_fid = (field_cid, field_oid) + # If we don't have standard fields, we look through fields by names. if transcription_fid is None or translation_fid is None: en_xcript_fid = None en_xlat_fid = None + en_snd_fid = None ru_xcript_fid = None ru_xlat_fid = None + ru_snd_fid = None for field_cid, field_oid, name_dict in field_name_info_list: @@ -1302,6 +1488,9 @@ def update_dictionary_info( elif en_name == 'meaning': en_xlat_fid = (field_cid, field_oid) + elif en_name == 'sound': + en_snd_fid = (field_cid, field_oid) + if '1' in name_dict: ru_name = ( @@ -1313,15 +1502,20 @@ def update_dictionary_info( elif ru_name == 'лексема': ru_xlat_fid = (field_cid, field_oid) + elif ru_name == 'звук': + ru_snd_fid = (field_cid, field_oid) + if en_xcript_fid is not None and en_xlat_fid is not None: transcription_fid = en_xcript_fid translation_fid = en_xlat_fid + sound_fid = en_snd_fid elif ru_xcript_fid is not None and ru_xlat_fid is not None: transcription_fid = ru_xcript_fid translation_fid = ru_xlat_fid + sound_fid = ru_snd_fid # If we don't have fields with standard names, maybe this is paradigmatic perspective with # paradigmatic fields? @@ -1330,9 +1524,11 @@ def update_dictionary_info( en_xcript_fid = None en_xlat_fid = None + en_snd_fid = None ru_xcript_fid = None ru_xlat_fid = None + ru_snd_fid = None for field_cid, field_oid, name_dict in field_name_info_list: @@ -1347,6 +1543,9 @@ def update_dictionary_info( elif en_name == 'translationofparadigmaticforms': en_xlat_fid = (field_cid, field_oid) + elif en_name == 'soundofparadigmaticforms': + en_snd_fid = (field_cid, field_oid) + if '1' in name_dict: ru_name = ( @@ -1358,17 +1557,24 @@ def update_dictionary_info( elif ru_name == 'переводпарадигматическихформ': ru_xlat_fid = (field_cid, field_oid) + elif ru_name == 'звукпарадигматическихформ': + ru_snd_fid = (field_cid, field_oid) + if en_xcript_fid is not None and en_xlat_fid is not None: transcription_fid = en_xcript_fid translation_fid = en_xlat_fid + sound_fid = en_snd_fid elif ru_xcript_fid is not None and ru_xlat_fid is not None: transcription_fid = ru_xcript_fid translation_fid = ru_xlat_fid + sound_fid = ru_snd_fid # Finally, if it is a Starling-related perspective, we can try Starling-specific fields. + # + # No sound field for such a perspective. if ((transcription_fid is None or translation_fid is None) and perspective_name_str.lower().find('starling') != -1): @@ -1422,17 +1628,30 @@ def update_dictionary_info( else: + if (self.sound_flag and + sound_fid is None): + + self.perspective_snd_fail_set.add( + (order_key, name_str)) + + format_str = ( + '({}, {}, {}, {}, {}, {}, {}, {})' if self.sound_flag else + '({}, {}, {}, {}, {}, {})') + insert_list.append( - '({}, {}, {}, {}, {}, {})'.format( + + format_str.format( perspective.client_id, perspective.object_id, transcription_fid[0], transcription_fid[1], translation_fid[0], - translation_fid[1])) + translation_fid[1], + sound_fid[0] if sound_fid is not None else 'null', + sound_fid[1] if sound_fid is not None else 'null')) self.perspective_info_dict[perspective.id] = ( - order_key, name_str, transcription_fid, translation_fid) + order_key, name_str, transcription_fid, translation_fid, sound_fid) # Updating perspectives' transcription / transpation field info, if required. @@ -1494,13 +1713,17 @@ def get_etymology_info( info_list = [] - for ( - entry_cid, - entry_oid, - perspective_cid, - perspective_oid, - transcription_list, - translation_list) in result_list: + for result_item in result_list: + + ( + entry_cid, + entry_oid, + perspective_cid, + perspective_oid, + transcription_list, + translation_list) = ( + + result_item[:6]) perspective_info = ( @@ -1510,13 +1733,21 @@ def get_etymology_info( if perspective_info is None: continue + sound_list = ( + result_item[-1] if self.sound_flag else []) + if transcription_list is None: transcription_list = [] if translation_list is None: translation_list = [] - order_key, name_str, _, _ = perspective_info + if sound_list is None: + sound_list = [] + + # Preparing info of another cognate lexical entry. + + order_key, name_str, _, _, _ = perspective_info row_list = ( @@ -1527,6 +1758,8 @@ def get_etymology_info( for t in transcription_list], ['\'' + t.strip() + '\'' for t in translation_list], + [[self.get_sound_link(*args)] + for args in sound_list], fillvalue = ''))) info_list.append(( @@ -1579,12 +1812,34 @@ def save_lexical_entry( ent_field_ids = field_ids_to_str(entity) + # Processing text and sound entities. + if ent_field_ids in self.field_to_column: - (rows_to_write[ - self.field_to_column[ent_field_ids]] - - .append(entity.content)) + if (self.sound_flag and + entity.field_id in self.sound_field_id_set): + + # Sound entity, getting sound file link. + + sound_link = ( + + self.get_sound_link( + entity.content, + entity.created_at)) + + (rows_to_write[ + self.field_to_column[ent_field_ids]] + + .append([sound_link])) + + else: + + # Text entity, simply getting its text content. + + (rows_to_write[ + self.field_to_column[ent_field_ids]] + + .append(entity.content)) # Adding etymologycal info, if required. @@ -1613,7 +1868,7 @@ def save_lexical_entry( len(rows_to_write)) rows_to_write.extend( - ([], [], [])) + ([], [], [], [])) for _, cognate_entry_id, row_list in etymology_info: @@ -1642,16 +1897,137 @@ def save_lexical_entry( for index, cell in enumerate(cell_list): + # Tuple means with format, list means a local link. + if isinstance(cell, tuple): - self.worksheet.write(self.row, index, *cell) + + value, cell_format = cell + + if isinstance(value, list): + + self.worksheet.write_url( + self.row, index, './' + value[0], cell_format, value[0]) + + else: + + self.worksheet.write( + self.row, index, value, cell_format) + + elif isinstance(cell, list): + + self.worksheet.write_url( + self.row, index, './' + cell[0], None, cell[0]) else: - self.worksheet.write(self.row, index, cell) + + self.worksheet.write( + self.row, index, cell) self.row += 1 + def get_zip_info( + self, + name, + hash = None, + date = None): + """ + Prepares file for saving into the zip archive, changes file name if it is a duplicate. + """ + + zip_name = ( + + self.zip_hash_dict.get( + (name, hash))) + + if zip_name is not None: + return zip_name + + if date is None: + date = datetime.datetime.utcnow() + + name_count = ( + self.zip_name_dict[name]) + + self.zip_name_dict[name] += 1 + + if name_count >= 1: + + name_root, name_ext = ( + path.splitext(name)) + + zip_name = ( + + '{}_{}{}'.format( + name_root, name_count, name_ext)) + + else: + zip_name = name + + self.zip_hash_dict[(name, hash)] = zip_name + + zip_date = ( + date.year, + date.month, + date.day, + date.hour, + date.minute, + date.second) + + return zipfile.ZipInfo(zip_name, zip_date) + + def get_sound_link( + self, + sound_url, + created_at): + """ + Processes linked sound file, adding it to the archive if necessary. + """ + + with self.storage_f( + self.storage, sound_url) as sound_stream: + + sound_bytes = sound_stream.read() + + # Checking if we need to save the file, and if we need to rename it to avoid duplicate + # names. + + zip_info = ( + + self.get_zip_info( + + path.basename( + urllib.parse.urlparse(sound_url).path), + + hashlib.sha256( + sound_bytes).digest(), + + datetime.datetime.utcfromtimestamp( + created_at))) + + # Saving sound file to the archive, if required. + + if isinstance(zip_info, str): + return zip_info + + if sndhdr.test_wav( + sound_bytes, io.BytesIO(sound_bytes)): + + zip_info.compress_type = zipfile.ZIP_DEFLATED + + self.zip_file.writestr(zip_info, sound_bytes) -def compile_workbook(context, client_id, object_id, session, locale_id, published): + return zip_info.filename + + +def compile_workbook( + context, + client_id, + object_id, + session, + locale_id, + published, + storage = None, + __debug_flag__ = False): """ Compiles analysis results into an Excel workbook. """ @@ -1679,7 +2055,10 @@ def compile_workbook(context, client_id, object_id, session, locale_id, publishe lexical_entries = lexical_entries.filter(PublishingEntity.published == published) for lex in lexical_entries: - context.save_lexical_entry(lex, published) + + context.save_lexical_entry( + lex, + published) # Writing out additional perspective info, if we have any. @@ -1701,6 +2080,26 @@ def compile_workbook(context, client_id, object_id, session, locale_id, publishe context.row += 1 + # The same for missing sound fields. + + if context.perspective_snd_fail_set: + + context.row += 1 + + context.worksheet.write( + context.row, 0, + 'Perspective{} without appropriate sound field:'.format( + '' if len(context.perspective_snd_fail_set) == 1 else 's')) + + context.row += 1 + + for _, name_str in sorted(context.perspective_snd_fail_set): + + context.worksheet.write( + context.row, 0, name_str) + + context.row += 1 + context.workbook.close() @@ -1715,6 +2114,7 @@ def save_dictionary( dict_name, locale_id, published, + sound_flag, __debug_flag__ = False ): # :( @@ -1730,122 +2130,261 @@ def save_dictionary( if task_status: task_status.set(3, 20, 'Running async process') - save_context = Save_Context( - locale_id, session, True, __debug_flag__) - try: - compile_workbook(save_context, client_id, object_id, session, locale_id, published) - except Exception as exception: + # Creating saving context, compiling dictionary data to a workbook. - traceback_string = ''.join(traceback.format_exception( - exception, exception, exception.__traceback__))[:-1] + save_context = ( + + Save_Context( + locale_id, + session, + True, + sound_flag, + storage, + __debug_flag__)) - log.debug('compile_workbook: exception') - log.debug(traceback_string) + if sound_flag: - # If we failed to create an Excel file, we terminate with error. + temporary_zip_file = ( + + tempfile.NamedTemporaryFile( + delete = False)) - if task_status: - task_status.set(4, 100, 'Finished (ERROR), result compilation error') + save_context.zip_file = ( + zipfile.ZipFile(temporary_zip_file, 'w')) - return {'error': 'result compilation error'} + save_context.zip_name_dict = ( + collections.Counter()) - # Name(s) of the resulting file(s) includes dictionary name, perspective name and current date. + save_context.zip_hash_dict = {} - current_datetime = datetime.datetime.now(datetime.timezone.utc) + compile_workbook( + save_context, + client_id, + object_id, + session, + locale_id, + published, + storage, + __debug_flag__ = __debug_flag__) - result_filename = '{0} - {1:04d}.{2:02d}.{3:02d}'.format( - dict_name[:64], - current_datetime.year, - current_datetime.month, - current_datetime.day) + # Name(s) of the resulting file(s) includes dictionary name, perspective name and current date. - table_filename = sanitize_filename(result_filename + '.xlsx') + current_datetime = datetime.datetime.now(datetime.timezone.utc) - # cur_time = time.time() - dictionary = session.query(Dictionary).filter_by(client_id=client_id, object_id=object_id).one() - dict_status_atom = session.query(TranslationAtom).filter_by( - parent_client_id=dictionary.state_translation_gist_client_id, - parent_object_id=dictionary.state_translation_gist_object_id, - locale_id=2).first() - if not dict_status_atom: - dict_status = 'translation_failure' - else: - dict_status = dict_status_atom.content + result_filename = '{0} - {1:04d}.{2:02d}.{3:02d}'.format( + dict_name[:64], + current_datetime.year, + current_datetime.month, + current_datetime.day) - if published is None: - cur_folder = 'edit' - elif published is True: - cur_folder = 'view' - else: - cur_folder = 'should_be_impossible' + table_filename = sanitize_filename(result_filename + '.xlsx') - storage_dir = path.join(storage['path'], 'save_dictionary', dict_status, cur_folder) - makedirs(storage_dir, exist_ok=True) + if __debug_flag__: - # Storing file with the results. + with open(table_filename, 'wb') as xlsx_file: - storage_path = path.join(storage_dir, table_filename) - directory = path.dirname(storage_path) + save_context.stream.seek(0) + copyfileobj(save_context.stream, xlsx_file) - try: - makedirs(directory) + # Either addint XLSX file to the Zip archive... - except OSError as exception: - if exception.errno != EEXIST: - raise + if sound_flag: - # If the name of the result file is too long, we try again with a shorter name. + zip_info = ( - try: - with open(storage_path, 'wb+') as workbook_file: + save_context.get_zip_info( + table_filename)) save_context.stream.seek(0) - copyfileobj(save_context.stream, workbook_file) - except OSError as os_error: + save_context.zip_file.writestr( + zip_info, + save_context.stream.read()) - if os_error.errno != 36: - raise + save_context.zip_file.close() + temporary_zip_file.close() - result_filename = '{0} - {1:04d}.{2:02d}.{3:02d}'.format( - dict_name[:32], - current_datetime.year, - current_datetime.month, - current_datetime.day) + zip_filename = ( + sanitize_filename(result_filename + '.zip')) - table_filename = sanitize_filename(result_filename + '.xlsx') - storage_path = path.join(storage_dir, table_filename) + zip_file_path = temporary_zip_file.name - with open(storage_path, 'wb+') as workbook_file: + # Saving a local copy of the archive, if required. - save_context.stream.seek(0) - copyfileobj(save_context.stream, workbook_file) + if __debug_flag__: - if __debug_flag__: + shutil.move( + temporary_zip_file.name, + zip_filename) - with open(table_filename, 'wb') as xlsx_file: + zip_file_path = zip_filename - save_context.stream.seek(0) - copyfileobj(save_context.stream, xlsx_file) + storage_temporary = storage['temporary'] - # Successfully saved dictionary, finishing and returning links to files with results. + host = storage_temporary['host'] + bucket = storage_temporary['bucket'] - url_list = [ + minio_client = ( + + minio.Minio( + host, + access_key = storage_temporary['access_key'], + secret_key = storage_temporary['secret_key'], + secure = True)) + + object_name = ( - ''.join([ - storage['prefix'], - storage['static_route'], - 'save_dictionary', '/', - dict_status, '/', - cur_folder, '/', - filename]) + storage_temporary['prefix'] + + + '/'.join(( + 'save_dictionary', + '{:.6f}'.format(time.time()), + zip_filename))) - for filename in [table_filename]] + (etag, version_id) = ( - if task_status: - task_status.set(4, 100, 'Finished', result_link_list=url_list) + minio_client.fput_object( + bucket, + object_name, + zip_file_path, + 'application/zip')) + + url = ( + + '/'.join(( + 'https:/', + host, + bucket, + object_name))) + + log.debug( + '\nobject_name:\n{}' + '\netag:\n{}' + '\nversion_id:\n{}' + '\nurl:\n{}'.format( + object_name, + etag, + version_id, + url)) + + url_list = [url] + + if not __debug_flag__: + + os.remove( + temporary_zip_file.name) + + # Or saving it in the object storage. + + else: + + dictionary = session.query(Dictionary).filter_by(client_id=client_id, object_id=object_id).one() + + dict_status_atom = session.query(TranslationAtom).filter_by( + parent_client_id=dictionary.state_translation_gist_client_id, + parent_object_id=dictionary.state_translation_gist_object_id, + locale_id=2).first() + + if not dict_status_atom: + dict_status = 'translation_failure' + else: + dict_status = dict_status_atom.content + + if published is None: + cur_folder = 'edit' + elif published is True: + cur_folder = 'view' + else: + cur_folder = 'should_be_impossible' + + cur_time = '{:.6f}'.format(time.time()) + + storage_dir = ( + + path.join( + storage['path'], + 'save_dictionary', + dict_status, + cur_folder, + cur_time)) + + makedirs(storage_dir, exist_ok=True) + + # Storing file with the results. + + storage_path = path.join(storage_dir, table_filename) + directory = path.dirname(storage_path) + + try: + + makedirs(directory) + + except OSError as exception: + if exception.errno != EEXIST: + raise + + # If the name of the result file is too long, we try again with a shorter name. + + try: + + with open(storage_path, 'wb+') as workbook_file: + + save_context.stream.seek(0) + copyfileobj(save_context.stream, workbook_file) + + except OSError as os_error: + + if os_error.errno != 36: + raise + + result_filename = '{0} - {1:04d}.{2:02d}.{3:02d}'.format( + dict_name[:32], + current_datetime.year, + current_datetime.month, + current_datetime.day) + + table_filename = sanitize_filename(result_filename + '.xlsx') + storage_path = path.join(storage_dir, table_filename) + + with open(storage_path, 'wb+') as workbook_file: + + save_context.stream.seek(0) + copyfileobj(save_context.stream, workbook_file) + + # Successfully saved dictionary, finishing and returning links to files with results. + + url_list = [ + + ''.join([ + storage['prefix'], + storage['static_route'], + 'save_dictionary', '/', + dict_status, '/', + cur_folder, '/', + cur_time, '/', + table_filename])] + + if task_status: + task_status.set(4, 100, 'Finished', result_link_list=url_list) + + except Exception as exception: + + traceback_string = ''.join(traceback.format_exception( + exception, exception, exception.__traceback__))[:-1] + + log.debug('save_dictionary: exception') + log.debug(traceback_string) + + # If we failed to save the dictionary, we terminate with error. + + if task_status: + + task_status.set(4, 100, + 'Finished (ERROR), exception:\n' + traceback_string) + + return {'error': 'result compilation error'} session.commit() engine.dispose() diff --git a/lingvodoc/views/v2/save_dictionary/core.py b/lingvodoc/views/v2/save_dictionary/core.py index 79bbf6303..76f079e4c 100644 --- a/lingvodoc/views/v2/save_dictionary/core.py +++ b/lingvodoc/views/v2/save_dictionary/core.py @@ -12,6 +12,7 @@ def async_save_dictionary(client_id, dict_name, locale_id, published, + sound_flag, __debug_flag__ = False): save_dictionary(client_id, object_id, @@ -22,6 +23,7 @@ def async_save_dictionary(client_id, dict_name, locale_id, published, + sound_flag, __debug_flag__ = __debug_flag__ ) return diff --git a/server-requirements.txt b/server-requirements.txt index 52b77778f..294d4103d 100644 --- a/server-requirements.txt +++ b/server-requirements.txt @@ -14,10 +14,11 @@ graf-python==0.3.1 graphene==2.0.1 iso8601==0.1.11 kombu==3.0.37 +minio==6.0.0 Mako==1.0.4 MarkupSafe==0.23 matplotlib==1.5.3 -multiprocess==0.70.4 +multiprocess==0.70.6 numpy==1.11.2 numpydoc==0.9.1 numpydoc==0.9.1