idx int64 0 251k | question stringlengths 53 3.53k | target stringlengths 5 1.23k | len_question int64 20 893 | len_target int64 3 238 |
|---|---|---|---|---|
226,000 | def send_to_back ( self ) : if not self . parent : return self . z_order = self . parent . _z_ordered_sprites [ 0 ] . z_order - 1 | adjusts sprite s z - order so that the sprite is behind it s siblings | 43 | 16 |
226,001 | def blur ( self ) : scene = self . get_scene ( ) if scene and scene . _focus_sprite == self : scene . _focus_sprite = None | removes focus from the current element if it has it | 37 | 11 |
226,002 | def get_parents ( self ) : res = [ ] parent = self . parent while parent and isinstance ( parent , Scene ) == False : res . insert ( 0 , parent ) parent = parent . parent return res | returns all the parent sprites up until scene | 45 | 9 |
226,003 | def get_extents ( self ) : if self . _sprite_dirty : # redrawing merely because we need fresh extents of the sprite context = cairo . Context ( cairo . ImageSurface ( cairo . FORMAT_A1 , 0 , 0 ) ) context . transform ( self . get_matrix ( ) ) self . emit ( "on-render" ) self . __dict__ [ "_sprite_dirty" ] = False self . graphics . _draw ( context , 1 ) if not self . graphics . paths : self . graphics . _draw ( cairo . Context ( cairo . ImageSurface ( cairo . FORMAT_A1 , 0 , 0 ) ) , 1 ) if not self . graphics . paths : return None context = cairo . Context ( cairo . ImageSurface ( cairo . FORMAT_A1 , 0 , 0 ) ) # bit of a hack around the problem - looking for clip instructions in parent # so extents would not get out of it clip_extents = None for parent in self . get_parents ( ) : context . transform ( parent . get_local_matrix ( ) ) if parent . graphics . paths : clip_regions = [ ] for instruction , type , path in parent . graphics . paths : if instruction == "clip" : context . append_path ( path ) context . save ( ) context . identity_matrix ( ) clip_regions . append ( context . fill_extents ( ) ) context . restore ( ) context . new_path ( ) elif instruction == "restore" and clip_regions : clip_regions . pop ( ) for ext in clip_regions : ext = get_gdk_rectangle ( int ( ext [ 0 ] ) , int ( ext [ 1 ] ) , int ( ext [ 2 ] - ext [ 0 ] ) , int ( ext [ 3 ] - ext [ 1 ] ) ) intersect , clip_extents = gdk . rectangle_intersect ( ( clip_extents or ext ) , ext ) context . transform ( self . get_local_matrix ( ) ) for instruction , type , path in self . graphics . paths : if type == "path" : context . append_path ( path ) else : getattr ( context , instruction ) ( * path ) context . identity_matrix ( ) ext = context . path_extents ( ) ext = get_gdk_rectangle ( int ( ext [ 0 ] ) , int ( ext [ 1 ] ) , int ( ext [ 2 ] - ext [ 0 ] ) , int ( ext [ 3 ] - ext [ 1 ] ) ) if clip_extents : intersect , ext = gdk . rectangle_intersect ( clip_extents , ext ) if not ext . width and not ext . height : ext = None self . __dict__ [ '_stroke_context' ] = context return ext | measure the extents of the sprite s graphics . | 621 | 11 |
226,004 | def check_hit ( self , x , y ) : extents = self . get_extents ( ) if not extents : return False if extents . x <= x <= extents . x + extents . width and extents . y <= y <= extents . y + extents . height : return self . _stroke_context is None or self . _stroke_context . in_fill ( x , y ) else : return False | check if the given coordinates are inside the sprite s fill or stroke path | 94 | 14 |
226,005 | def get_matrix ( self ) : if self . parent : return self . get_local_matrix ( ) * ( self . _prev_parent_matrix or self . parent . get_matrix ( ) ) else : return self . get_local_matrix ( ) | return sprite s current transformation matrix | 61 | 6 |
226,006 | def from_scene_coords ( self , x = 0 , y = 0 ) : matrix = self . get_matrix ( ) matrix . invert ( ) return matrix . transform_point ( x , y ) | Converts x y given in the scene coordinates to sprite s local ones coordinates | 46 | 15 |
226,007 | def stop_animation ( self , sprites ) : if isinstance ( sprites , list ) is False : sprites = [ sprites ] for sprite in sprites : self . tweener . kill_tweens ( sprite ) | stop animation without firing on_complete | 45 | 7 |
226,008 | def redraw ( self ) : if self . __drawing_queued == False : #if we are moving, then there is a timeout somewhere already self . __drawing_queued = True self . _last_frame_time = dt . datetime . now ( ) gobject . timeout_add ( 1000 / self . framerate , self . __redraw_loop ) | Queue redraw . The redraw will be performed not more often than the framerate allows | 82 | 18 |
226,009 | def __redraw_loop ( self ) : self . queue_draw ( ) # this will trigger do_expose_event when the current events have been flushed self . __drawing_queued = self . tweener and self . tweener . has_tweens ( ) return self . __drawing_queued | loop until there is nothing more to tween | 69 | 9 |
226,010 | def all_mouse_sprites ( self ) : def all_recursive ( sprites ) : if not sprites : return for sprite in sprites : if sprite . visible : yield sprite for child in all_recursive ( sprite . get_mouse_sprites ( ) ) : yield child return all_recursive ( self . get_mouse_sprites ( ) ) | Returns flat list of the sprite tree for simplified iteration | 76 | 10 |
226,011 | def get_sprite_at_position ( self , x , y ) : over = None for sprite in self . all_mouse_sprites ( ) : if sprite . interactive and sprite . check_hit ( x , y ) : over = sprite return over | Returns the topmost visible interactive sprite for given coordinates | 55 | 10 |
226,012 | def start_drag ( self , sprite , cursor_x = None , cursor_y = None ) : cursor_x , cursor_y = cursor_x or sprite . x , cursor_y or sprite . y self . _mouse_down_sprite = self . _drag_sprite = sprite sprite . drag_x , sprite . drag_y = self . _drag_sprite . x , self . _drag_sprite . y self . __drag_start_x , self . __drag_start_y = cursor_x , cursor_y self . __drag_started = True | start dragging given sprite | 135 | 4 |
226,013 | def pretty_print ( self , as_list = False , show_datetime = True ) : ppl = [ entry . pretty_print ( show_datetime ) for entry in self . entries ] if as_list : return ppl return u"\n" . join ( ppl ) | Return a Unicode string pretty print of the log entries . | 63 | 11 |
226,014 | def log ( self , message , severity = INFO , tag = u"" ) : entry = _LogEntry ( severity = severity , time = datetime . datetime . now ( ) , tag = tag , indentation = self . indentation , message = self . _sanitize ( message ) ) self . entries . append ( entry ) if self . tee : gf . safe_print ( entry . pretty_print ( show_datetime = self . tee_show_datetime ) ) return entry . time | Add a given message to the log and return its time . | 108 | 12 |
226,015 | def write ( self , path ) : with io . open ( path , "w" , encoding = "utf-8" ) as log_file : log_file . write ( self . pretty_print ( ) ) | Output the log to file . | 46 | 6 |
226,016 | def pretty_print ( self , show_datetime = True ) : if show_datetime : return u"[%s] %s %s%s: %s" % ( self . severity , gf . object_to_unicode ( self . time ) , u" " * self . indentation , self . tag , self . message ) return u"[%s] %s%s: %s" % ( self . severity , u" " * self . indentation , self . tag , self . message ) | Returns a Unicode string containing the pretty printing of a given log entry . | 112 | 14 |
226,017 | def _log ( self , message , severity = Logger . DEBUG ) : return self . logger . log ( message , severity , self . TAG ) | Log generic message | 31 | 3 |
226,018 | def log_exc ( self , message , exc = None , critical = True , raise_type = None ) : log_function = self . log_crit if critical else self . log_warn log_function ( message ) if exc is not None : log_function ( [ u"%s" , exc ] ) if raise_type is not None : raise_message = message if exc is not None : raise_message = u"%s : %s" % ( message , exc ) raise raise_type ( raise_message ) | Log exception and possibly raise exception . | 113 | 7 |
226,019 | def add_waveform ( self , waveform ) : if not isinstance ( waveform , PlotWaveform ) : self . log_exc ( u"waveform must be an instance of PlotWaveform" , None , True , TypeError ) self . waveform = waveform self . log ( u"Added waveform" ) | Add a waveform to the plot . | 70 | 8 |
226,020 | def add_timescale ( self , timescale ) : if not isinstance ( timescale , PlotTimeScale ) : self . log_exc ( u"timescale must be an instance of PlotTimeScale" , None , True , TypeError ) self . timescale = timescale self . log ( u"Added timescale" ) | Add a time scale to the plot . | 70 | 8 |
226,021 | def add_labelset ( self , labelset ) : if not isinstance ( labelset , PlotLabelset ) : self . log_exc ( u"labelset must be an instance of PlotLabelset" , None , True , TypeError ) self . labelsets . append ( labelset ) self . log ( u"Added labelset" ) | Add a set of labels to the plot . | 77 | 9 |
226,022 | def draw_png ( self , output_file_path , h_zoom = 5 , v_zoom = 30 ) : # check that output_file_path can be written if not gf . file_can_be_written ( output_file_path ) : self . log_exc ( u"Cannot write to output file '%s'" % ( output_file_path ) , None , True , OSError ) # get widths and cumulative height, in modules widths = [ ls . width for ls in self . labelsets ] sum_height = sum ( [ ls . height for ls in self . labelsets ] ) if self . waveform is not None : widths . append ( self . waveform . width ) sum_height += self . waveform . height if self . timescale is not None : sum_height += self . timescale . height # in modules image_width = max ( widths ) image_height = sum_height # in pixels image_width_px = image_width * h_zoom image_height_px = image_height * v_zoom # build image object self . log ( [ u"Building image with size (modules): %d %d" , image_width , image_height ] ) self . log ( [ u"Building image with size (px): %d %d" , image_width_px , image_height_px ] ) image_obj = Image . new ( "RGB" , ( image_width_px , image_height_px ) , color = PlotterColors . AUDACITY_BACKGROUND_GREY ) current_y = 0 if self . waveform is not None : self . log ( u"Drawing waveform" ) self . waveform . draw_png ( image_obj , h_zoom , v_zoom , current_y ) current_y += self . waveform . height timescale_y = current_y if self . timescale is not None : # NOTE draw as the last thing # COMMENTED self.log(u"Drawing timescale") # COMMENTED self.timescale.draw_png(image_obj, h_zoom, v_zoom, current_y) current_y += self . timescale . height for labelset in self . labelsets : self . log ( u"Drawing labelset" ) labelset . draw_png ( image_obj , h_zoom , v_zoom , current_y ) current_y += labelset . height if self . timescale is not None : self . log ( u"Drawing timescale" ) self . timescale . draw_png ( image_obj , h_zoom , v_zoom , timescale_y ) self . log ( [ u"Saving to file '%s'" , output_file_path ] ) image_obj . save ( output_file_path ) | Draw the current plot to a PNG file . | 629 | 9 |
226,023 | def text_bounding_box ( self , size_pt , text ) : if size_pt == 12 : mult = { "h" : 9 , "w_digit" : 5 , "w_space" : 2 } elif size_pt == 18 : mult = { "h" : 14 , "w_digit" : 9 , "w_space" : 2 } num_chars = len ( text ) return ( num_chars * mult [ "w_digit" ] + ( num_chars - 1 ) * mult [ "w_space" ] + 1 , mult [ "h" ] ) | Return the bounding box of the given text at the given font size . | 134 | 15 |
226,024 | def draw_png ( self , image , h_zoom , v_zoom , current_y ) : # PIL object draw = ImageDraw . Draw ( image ) mws = self . rconf . mws pixels_per_second = int ( h_zoom / mws ) current_y_px = current_y * v_zoom # create font, as tall as possible font_height_pt = 18 font = ImageFont . truetype ( self . FONT_PATH , font_height_pt ) # draw a tick every self.time_step seconds for i in range ( 0 , 1 + int ( self . max_time ) , self . time_step ) : # base x position begin_px = i * pixels_per_second # tick left_px = begin_px - self . TICK_WIDTH right_px = begin_px + self . TICK_WIDTH top_px = current_y_px bottom_px = current_y_px + v_zoom draw . rectangle ( ( left_px , top_px , right_px , bottom_px ) , fill = PlotterColors . BLACK ) # text time_text = self . _time_string ( i ) left_px = begin_px + self . TICK_WIDTH + self . TEXT_MARGIN top_px = current_y_px + ( v_zoom - self . text_bounding_box ( font_height_pt , time_text ) [ 1 ] ) // 2 draw . text ( ( left_px , top_px ) , time_text , PlotterColors . BLACK , font = font ) | Draw this time scale to PNG . | 362 | 7 |
226,025 | def draw_png ( self , image , h_zoom , v_zoom , current_y ) : draw = ImageDraw . Draw ( image ) mws = self . rconf . mws rate = self . audio_file . audio_sample_rate samples = self . audio_file . audio_samples duration = self . audio_file . audio_length current_y_px = current_y * v_zoom half_waveform_px = ( self . height // 2 ) * v_zoom zero_y_px = current_y_px + half_waveform_px samples_per_pixel = int ( rate * mws / h_zoom ) pixels_per_second = int ( h_zoom / mws ) windows = len ( samples ) // samples_per_pixel if self . label is not None : font_height_pt = 18 font = ImageFont . truetype ( self . FONT_PATH , font_height_pt ) draw . text ( ( 0 , current_y_px ) , self . label , PlotterColors . BLACK , font = font ) for i in range ( windows ) : x = i * samples_per_pixel pos = numpy . clip ( samples [ x : ( x + samples_per_pixel ) ] , 0.0 , 1.0 ) mpos = numpy . max ( pos ) * half_waveform_px if self . fast : # just draw a simple version, mirroring max positive samples draw . line ( ( i , zero_y_px + mpos , i , zero_y_px - mpos ) , fill = PlotterColors . AUDACITY_DARK_BLUE , width = 1 ) else : # draw a better version, taking min and std of positive and negative samples neg = numpy . clip ( samples [ x : ( x + samples_per_pixel ) ] , - 1.0 , 0.0 ) spos = numpy . std ( pos ) * half_waveform_px sneg = numpy . std ( neg ) * half_waveform_px mneg = numpy . min ( neg ) * half_waveform_px draw . line ( ( i , zero_y_px - mneg , i , zero_y_px - mpos ) , fill = PlotterColors . AUDACITY_DARK_BLUE , width = 1 ) draw . line ( ( i , zero_y_px + sneg , i , zero_y_px - spos ) , fill = PlotterColors . AUDACITY_LIGHT_BLUE , width = 1 ) | Draw this waveform to PNG . | 569 | 7 |
226,026 | def print_result ( self , audio_len , start , end ) : msg = [ ] zero = 0 head_len = start text_len = end - start tail_len = audio_len - end msg . append ( u"" ) msg . append ( u"Head: %.3f %.3f (%.3f)" % ( zero , start , head_len ) ) msg . append ( u"Text: %.3f %.3f (%.3f)" % ( start , end , text_len ) ) msg . append ( u"Tail: %.3f %.3f (%.3f)" % ( end , audio_len , tail_len ) ) msg . append ( u"" ) zero_h = gf . time_to_hhmmssmmm ( 0 ) start_h = gf . time_to_hhmmssmmm ( start ) end_h = gf . time_to_hhmmssmmm ( end ) audio_len_h = gf . time_to_hhmmssmmm ( audio_len ) head_len_h = gf . time_to_hhmmssmmm ( head_len ) text_len_h = gf . time_to_hhmmssmmm ( text_len ) tail_len_h = gf . time_to_hhmmssmmm ( tail_len ) msg . append ( "Head: %s %s (%s)" % ( zero_h , start_h , head_len_h ) ) msg . append ( "Text: %s %s (%s)" % ( start_h , end_h , text_len_h ) ) msg . append ( "Tail: %s %s (%s)" % ( end_h , audio_len_h , tail_len_h ) ) msg . append ( u"" ) self . print_info ( u"\n" . join ( msg ) ) | Print result of SD . | 419 | 5 |
226,027 | def sync_map_leaves ( self , fragment_type = None ) : if ( self . sync_map is None ) or ( self . sync_map . fragments_tree is None ) : return [ ] return [ f for f in self . sync_map . leaves ( fragment_type ) ] | Return the list of non - empty leaves in the sync map associated with the task . | 64 | 17 |
226,028 | def output_sync_map_file ( self , container_root_path = None ) : if self . sync_map is None : self . log_exc ( u"The sync_map object has not been set" , None , True , TypeError ) if ( container_root_path is not None ) and ( self . sync_map_file_path is None ) : self . log_exc ( u"The (internal) path of the sync map has been set" , None , True , TypeError ) self . log ( [ u"container_root_path is %s" , container_root_path ] ) self . log ( [ u"self.sync_map_file_path is %s" , self . sync_map_file_path ] ) self . log ( [ u"self.sync_map_file_path_absolute is %s" , self . sync_map_file_path_absolute ] ) if ( container_root_path is not None ) and ( self . sync_map_file_path is not None ) : path = os . path . join ( container_root_path , self . sync_map_file_path ) elif self . sync_map_file_path_absolute : path = self . sync_map_file_path_absolute gf . ensure_parent_directory ( path ) self . log ( [ u"Output sync map to %s" , path ] ) eaf_audio_ref = self . configuration [ "o_eaf_audio_ref" ] head_tail_format = self . configuration [ "o_h_t_format" ] levels = self . configuration [ "o_levels" ] smil_audio_ref = self . configuration [ "o_smil_audio_ref" ] smil_page_ref = self . configuration [ "o_smil_page_ref" ] sync_map_format = self . configuration [ "o_format" ] self . log ( [ u"eaf_audio_ref is %s" , eaf_audio_ref ] ) self . log ( [ u"head_tail_format is %s" , head_tail_format ] ) self . log ( [ u"levels is %s" , levels ] ) self . log ( [ u"smil_audio_ref is %s" , smil_audio_ref ] ) self . log ( [ u"smil_page_ref is %s" , smil_page_ref ] ) self . log ( [ u"sync_map_format is %s" , sync_map_format ] ) self . log ( u"Calling sync_map.write..." ) parameters = { gc . PPN_TASK_OS_FILE_EAF_AUDIO_REF : eaf_audio_ref , gc . PPN_TASK_OS_FILE_HEAD_TAIL_FORMAT : head_tail_format , gc . PPN_TASK_OS_FILE_LEVELS : levels , gc . PPN_TASK_OS_FILE_SMIL_AUDIO_REF : smil_audio_ref , gc . PPN_TASK_OS_FILE_SMIL_PAGE_REF : smil_page_ref , } self . sync_map . write ( sync_map_format , path , parameters ) self . log ( u"Calling sync_map.write... done" ) return path | Output the sync map file for this task . | 754 | 9 |
226,029 | def _populate_audio_file ( self ) : self . log ( u"Populate audio file..." ) if self . audio_file_path_absolute is not None : self . log ( [ u"audio_file_path_absolute is '%s'" , self . audio_file_path_absolute ] ) self . audio_file = AudioFile ( file_path = self . audio_file_path_absolute , logger = self . logger ) self . audio_file . read_properties ( ) else : self . log ( u"audio_file_path_absolute is None" ) self . log ( u"Populate audio file... done" ) | Create the self . audio_file object by reading the audio file at self . audio_file_path_absolute . | 142 | 24 |
226,030 | def _populate_text_file ( self ) : self . log ( u"Populate text file..." ) if ( ( self . text_file_path_absolute is not None ) and ( self . configuration [ "language" ] is not None ) ) : # the following values might be None parameters = { gc . PPN_TASK_IS_TEXT_FILE_IGNORE_REGEX : self . configuration [ "i_t_ignore_regex" ] , gc . PPN_TASK_IS_TEXT_FILE_TRANSLITERATE_MAP : self . configuration [ "i_t_transliterate_map" ] , gc . PPN_TASK_IS_TEXT_MPLAIN_WORD_SEPARATOR : self . configuration [ "i_t_mplain_word_separator" ] , gc . PPN_TASK_IS_TEXT_MUNPARSED_L1_ID_REGEX : self . configuration [ "i_t_munparsed_l1_id_regex" ] , gc . PPN_TASK_IS_TEXT_MUNPARSED_L2_ID_REGEX : self . configuration [ "i_t_munparsed_l2_id_regex" ] , gc . PPN_TASK_IS_TEXT_MUNPARSED_L3_ID_REGEX : self . configuration [ "i_t_munparsed_l3_id_regex" ] , gc . PPN_TASK_IS_TEXT_UNPARSED_CLASS_REGEX : self . configuration [ "i_t_unparsed_class_regex" ] , gc . PPN_TASK_IS_TEXT_UNPARSED_ID_REGEX : self . configuration [ "i_t_unparsed_id_regex" ] , gc . PPN_TASK_IS_TEXT_UNPARSED_ID_SORT : self . configuration [ "i_t_unparsed_id_sort" ] , gc . PPN_TASK_OS_FILE_ID_REGEX : self . configuration [ "o_id_regex" ] } self . text_file = TextFile ( file_path = self . text_file_path_absolute , file_format = self . configuration [ "i_t_format" ] , parameters = parameters , logger = self . logger ) self . text_file . set_language ( self . configuration [ "language" ] ) else : self . log ( u"text_file_path_absolute and/or language is None" ) self . log ( u"Populate text file... done" ) | Create the self . text_file object by reading the text file at self . text_file_path_absolute . | 619 | 24 |
226,031 | def _tree_to_string ( cls , root_element , xml_declaration = True , pretty_print = True ) : from lxml import etree return gf . safe_unicode ( etree . tostring ( root_element , encoding = "UTF-8" , method = "xml" , xml_declaration = xml_declaration , pretty_print = pretty_print ) ) | Return an lxml tree as a Unicode string . | 87 | 10 |
226,032 | def print_generic ( self , msg , prefix = None ) : if prefix is None : self . _log ( msg , Logger . INFO ) else : self . _log ( msg , prefix ) if self . use_sys : if ( prefix is not None ) and ( prefix in self . PREFIX_TO_PRINT_FUNCTION ) : self . PREFIX_TO_PRINT_FUNCTION [ prefix ] ( msg ) else : gf . safe_print ( msg ) | Print a message and log it . | 105 | 7 |
226,033 | def print_name_version ( self ) : if self . use_sys : self . print_generic ( u"%s v%s" % ( self . NAME , aeneas_version ) ) return self . exit ( self . HELP_EXIT_CODE ) | Print program name and version and exit . | 59 | 8 |
226,034 | def print_rconf_parameters ( self ) : if self . use_sys : self . print_info ( u"Available runtime configuration parameters:" ) self . print_generic ( u"\n" + u"\n" . join ( self . RCONF_PARAMETERS ) + u"\n" ) return self . exit ( self . HELP_EXIT_CODE ) | Print the list of runtime configuration parameters and exit . | 86 | 10 |
226,035 | def has_option ( self , target ) : if isinstance ( target , list ) : target_set = set ( target ) else : target_set = set ( [ target ] ) return len ( target_set & set ( self . actual_arguments ) ) > 0 | Return True if the actual arguments include the specified target option or if target is a list of options at least one of them . | 58 | 25 |
226,036 | def check_c_extensions ( self , name = None ) : if not gf . can_run_c_extension ( name = name ) : if name is None : self . print_warning ( u"Unable to load Python C Extensions" ) else : self . print_warning ( u"Unable to load Python C Extension %s" % ( name ) ) self . print_warning ( u"Running the slower pure Python code" ) self . print_warning ( u"See the documentation for directions to compile the Python C Extensions" ) return False return True | If C extensions cannot be run emit a warning and return False . Otherwise return True . If name is not None check just the C extension with that name . | 122 | 31 |
226,037 | def check_output_file ( self , path ) : if not gf . file_can_be_written ( path ) : self . print_error ( u"Unable to create file '%s'" % ( path ) ) self . print_error ( u"Make sure the file path is written/escaped correctly and that you have write permission on it" ) return False return True | If the given path cannot be written emit an error and return False . Otherwise return True . | 83 | 18 |
226,038 | def check_output_directory ( self , path ) : if not os . path . isdir ( path ) : self . print_error ( u"Directory '%s' does not exist" % ( path ) ) return False test_file = os . path . join ( path , u"file.test" ) if not gf . file_can_be_written ( test_file ) : self . print_error ( u"Unable to write inside directory '%s'" % ( path ) ) self . print_error ( u"Make sure the directory path is written/escaped correctly and that you have write permission on it" ) return False return True | If the given directory cannot be written emit an error and return False . Otherwise return True . | 141 | 18 |
226,039 | def is_safe ( self ) : self . log ( u"Checking if this container is safe" ) for entry in self . entries : if not self . is_entry_safe ( entry ) : self . log ( [ u"This container is not safe: found unsafe entry '%s'" , entry ] ) return False self . log ( u"This container is safe" ) return True | Return True if the container can be safely extracted that is if all its entries are safe False otherwise . | 83 | 20 |
226,040 | def entries ( self ) : self . log ( u"Getting entries" ) if not self . exists ( ) : self . log_exc ( u"This container does not exist. Wrong path?" , None , True , TypeError ) if self . actual_container is None : self . log_exc ( u"The actual container object has not been set" , None , True , TypeError ) return self . actual_container . entries | Return the sorted list of entries in this container each represented by its full path inside the container . | 91 | 19 |
226,041 | def find_entry ( self , entry , exact = True ) : if exact : self . log ( [ u"Finding entry '%s' with exact=True" , entry ] ) if entry in self . entries : self . log ( [ u"Found entry '%s'" , entry ] ) return entry else : self . log ( [ u"Finding entry '%s' with exact=False" , entry ] ) for ent in self . entries : if os . path . basename ( ent ) == entry : self . log ( [ u"Found entry '%s'" , ent ] ) return ent self . log ( [ u"Entry '%s' not found" , entry ] ) return None | Return the full path to the first entry whose file name equals the given entry path . | 149 | 17 |
226,042 | def read_entry ( self , entry ) : if not self . is_entry_safe ( entry ) : self . log ( [ u"Accessing entry '%s' is not safe" , entry ] ) return None if entry not in self . entries : self . log ( [ u"Entry '%s' not found in this container" , entry ] ) return None self . log ( [ u"Reading contents of entry '%s'" , entry ] ) try : return self . actual_container . read_entry ( entry ) except : self . log ( [ u"An error occurred while reading the contents of '%s'" , entry ] ) return None | Read the contents of an entry in this container and return them as a byte string . | 140 | 17 |
226,043 | def decompress ( self , output_path ) : self . log ( [ u"Decompressing the container into '%s'" , output_path ] ) if not self . exists ( ) : self . log_exc ( u"This container does not exist. Wrong path?" , None , True , TypeError ) if self . actual_container is None : self . log_exc ( u"The actual container object has not been set" , None , True , TypeError ) if not gf . directory_exists ( output_path ) : self . log_exc ( u"The output path is not an existing directory" , None , True , ValueError ) if not self . is_safe : self . log_exc ( u"This container contains unsafe entries" , None , True , ValueError ) self . actual_container . decompress ( output_path ) | Decompress the entire container into the given directory . | 184 | 11 |
226,044 | def compress ( self , input_path ) : self . log ( [ u"Compressing '%s' into this container" , input_path ] ) if self . file_path is None : self . log_exc ( u"The container path has not been set" , None , True , TypeError ) if self . actual_container is None : self . log_exc ( u"The actual container object has not been set" , None , True , TypeError ) if not gf . directory_exists ( input_path ) : self . log_exc ( u"The input path is not an existing directory" , None , True , ValueError ) gf . ensure_parent_directory ( input_path ) self . actual_container . compress ( input_path ) | Compress the contents of the given directory . | 165 | 9 |
226,045 | def exists ( self ) : return gf . file_exists ( self . file_path ) or gf . directory_exists ( self . file_path ) | Return True if the container has its path set and it exists False otherwise . | 36 | 15 |
226,046 | def _set_actual_container ( self ) : # infer container format if self . container_format is None : self . log ( u"Inferring actual container format..." ) path_lowercased = self . file_path . lower ( ) self . log ( [ u"Lowercased file path: '%s'" , path_lowercased ] ) self . container_format = ContainerFormat . UNPACKED for fmt in ContainerFormat . ALLOWED_FILE_VALUES : if path_lowercased . endswith ( fmt ) : self . container_format = fmt break self . log ( u"Inferring actual container format... done" ) self . log ( [ u"Inferred format: '%s'" , self . container_format ] ) # set the actual container self . log ( u"Setting actual container..." ) class_map = { ContainerFormat . ZIP : ( _ContainerZIP , None ) , ContainerFormat . EPUB : ( _ContainerZIP , None ) , ContainerFormat . TAR : ( _ContainerTAR , "" ) , ContainerFormat . TAR_GZ : ( _ContainerTAR , ":gz" ) , ContainerFormat . TAR_BZ2 : ( _ContainerTAR , ":bz2" ) , ContainerFormat . UNPACKED : ( _ContainerUnpacked , None ) } actual_class , variant = class_map [ self . container_format ] self . actual_container = actual_class ( file_path = self . file_path , variant = variant , rconf = self . rconf , logger = self . logger ) self . log ( [ u"Actual container format: '%s'" , self . container_format ] ) self . log ( u"Setting actual container... done" ) | Set the actual container based on the specified container format . | 386 | 11 |
226,047 | def _synthesize_single_python_helper ( self , text , voice_code , output_file_path = None , return_audio_data = True ) : # return zero if text is the empty string if len ( text ) == 0 : # # NOTE values of sample_rate, encoding, data # do not matter if the duration is 0.000, # so set them to None instead of the more precise: # return (True, (TimeValue("0.000"), 16000, "pcm_s16le", numpy.array([]))) # self . log ( u"len(text) is zero: returning 0.000" ) return ( True , ( TimeValue ( "0.000" ) , None , None , None ) ) # # NOTE in this example, we assume that the Speect voice data files # are located in the same directory of this .py source file # and that the voice JSON file is called "voice.json" # # NOTE the voice_code value is ignored in this example, # since we have only one TTS voice, # but in general one might select a voice file to load, # depending on voice_code; # in fact, we could have created the ``voice`` object # only once, in the constructor, instead of creating it # each time this function is invoked, # achieving slightly faster synthesis # voice_json_path = gf . safe_str ( gf . absolute_path ( "voice.json" , __file__ ) ) voice = speect . SVoice ( voice_json_path ) utt = voice . synth ( text ) audio = utt . features [ "audio" ] if output_file_path is None : self . log ( u"output_file_path is None => not saving to file" ) else : self . log ( u"output_file_path is not None => saving to file..." ) # NOTE apparently, save_riff needs the path to be a byte string audio . save_riff ( gf . safe_str ( output_file_path ) ) self . log ( u"output_file_path is not None => saving to file... done" ) # return immediately if returning audio data is not needed if not return_audio_data : self . log ( u"return_audio_data is True => return immediately" ) return ( True , None ) # get length and data using speect Python API self . log ( u"return_audio_data is True => read and return audio data" ) waveform = audio . get_audio_waveform ( ) audio_sample_rate = int ( waveform [ "samplerate" ] ) audio_length = TimeValue ( audio . num_samples ( ) / audio_sample_rate ) audio_format = "pcm16" audio_samples = numpy . fromstring ( waveform [ "samples" ] , dtype = numpy . int16 ) . astype ( "float64" ) / 32768 return ( True , ( audio_length , audio_sample_rate , audio_format , audio_samples ) ) | This is an helper function to synthesize a single text fragment via a Python call . | 667 | 17 |
226,048 | def analyze ( self , config_string = None ) : try : if config_string is not None : self . log ( u"Analyzing container with the given config string" ) return self . _analyze_txt_config ( config_string = config_string ) elif self . container . has_config_xml : self . log ( u"Analyzing container with XML config file" ) return self . _analyze_xml_config ( config_contents = None ) elif self . container . has_config_txt : self . log ( u"Analyzing container with TXT config file" ) return self . _analyze_txt_config ( config_string = None ) else : self . log ( u"No configuration file in this container, returning None" ) except ( OSError , KeyError , TypeError ) as exc : self . log_exc ( u"An unexpected error occurred while analyzing" , exc , True , None ) return None | Analyze the given container and return the corresponding job object . | 206 | 12 |
226,049 | def _create_task ( self , task_info , config_string , sync_map_root_directory , job_os_hierarchy_type ) : self . log ( u"Converting config string to config dict" ) parameters = gf . config_string_to_dict ( config_string ) self . log ( u"Creating task" ) task = Task ( config_string , logger = self . logger ) task . configuration [ "description" ] = "Task %s" % task_info [ 0 ] self . log ( [ u"Task description: %s" , task . configuration [ "description" ] ] ) try : task . configuration [ "language" ] = parameters [ gc . PPN_TASK_LANGUAGE ] self . log ( [ u"Set language from task: '%s'" , task . configuration [ "language" ] ] ) except KeyError : task . configuration [ "language" ] = parameters [ gc . PPN_JOB_LANGUAGE ] self . log ( [ u"Set language from job: '%s'" , task . configuration [ "language" ] ] ) custom_id = task_info [ 0 ] task . configuration [ "custom_id" ] = custom_id self . log ( [ u"Task custom_id: %s" , task . configuration [ "custom_id" ] ] ) task . text_file_path = task_info [ 1 ] self . log ( [ u"Task text file path: %s" , task . text_file_path ] ) task . audio_file_path = task_info [ 2 ] self . log ( [ u"Task audio file path: %s" , task . audio_file_path ] ) task . sync_map_file_path = self . _compute_sync_map_file_path ( sync_map_root_directory , job_os_hierarchy_type , custom_id , task . configuration [ "o_name" ] ) self . log ( [ u"Task sync map file path: %s" , task . sync_map_file_path ] ) self . log ( u"Replacing placeholder in os_file_smil_audio_ref" ) task . configuration [ "o_smil_audio_ref" ] = self . _replace_placeholder ( task . configuration [ "o_smil_audio_ref" ] , custom_id ) self . log ( u"Replacing placeholder in os_file_smil_page_ref" ) task . configuration [ "o_smil_page_ref" ] = self . _replace_placeholder ( task . configuration [ "o_smil_page_ref" ] , custom_id ) self . log ( u"Returning task" ) return task | Create a task object from | 607 | 5 |
226,050 | def _compute_sync_map_file_path ( self , root , hierarchy_type , custom_id , file_name ) : prefix = root if hierarchy_type == HierarchyType . PAGED : prefix = gf . norm_join ( prefix , custom_id ) file_name_joined = gf . norm_join ( prefix , file_name ) return self . _replace_placeholder ( file_name_joined , custom_id ) | Compute the sync map file path inside the output container . | 99 | 12 |
226,051 | def _find_files ( self , entries , root , relative_path , file_name_regex ) : self . log ( [ u"Finding files within root: '%s'" , root ] ) target = root if relative_path is not None : self . log ( [ u"Joining relative path: '%s'" , relative_path ] ) target = gf . norm_join ( root , relative_path ) self . log ( [ u"Finding files within target: '%s'" , target ] ) files = [ ] target_len = len ( target ) for entry in entries : if entry . startswith ( target ) : self . log ( [ u"Examining entry: '%s'" , entry ] ) entry_suffix = entry [ target_len + 1 : ] self . log ( [ u"Examining entry suffix: '%s'" , entry_suffix ] ) if re . search ( file_name_regex , entry_suffix ) is not None : self . log ( [ u"Match: '%s'" , entry ] ) files . append ( entry ) else : self . log ( [ u"No match: '%s'" , entry ] ) return sorted ( files ) | Return the elements in entries that | 266 | 6 |
226,052 | def _match_files_flat_hierarchy ( self , text_files , audio_files ) : self . log ( u"Matching files in flat hierarchy" ) self . log ( [ u"Text files: '%s'" , text_files ] ) self . log ( [ u"Audio files: '%s'" , audio_files ] ) d_text = { } d_audio = { } for text_file in text_files : text_file_no_ext = gf . file_name_without_extension ( text_file ) d_text [ text_file_no_ext ] = text_file self . log ( [ u"Added text file '%s' to key '%s'" , text_file , text_file_no_ext ] ) for audio_file in audio_files : audio_file_no_ext = gf . file_name_without_extension ( audio_file ) d_audio [ audio_file_no_ext ] = audio_file self . log ( [ u"Added audio file '%s' to key '%s'" , audio_file , audio_file_no_ext ] ) tasks = [ ] for key in d_text . keys ( ) : self . log ( [ u"Examining text key '%s'" , key ] ) if key in d_audio : self . log ( [ u"Key '%s' is also in audio" , key ] ) tasks . append ( [ key , d_text [ key ] , d_audio [ key ] ] ) self . log ( [ u"Added pair ('%s', '%s')" , d_text [ key ] , d_audio [ key ] ] ) return tasks | Match audio and text files in flat hierarchies . | 376 | 10 |
226,053 | def _match_directories ( self , entries , root , regex_string ) : self . log ( u"Matching directory names in paged hierarchy" ) self . log ( [ u"Matching within '%s'" , root ] ) self . log ( [ u"Matching regex '%s'" , regex_string ] ) regex = re . compile ( r"" + regex_string ) directories = set ( ) root_len = len ( root ) for entry in entries : # look only inside root dir if entry . startswith ( root ) : self . log ( [ u"Examining '%s'" , entry ] ) # remove common prefix root/ entry = entry [ root_len + 1 : ] # split path entry_splitted = entry . split ( os . sep ) # match regex if ( ( len ( entry_splitted ) >= 2 ) and ( re . match ( regex , entry_splitted [ 0 ] ) is not None ) ) : directories . add ( entry_splitted [ 0 ] ) self . log ( [ u"Match: '%s'" , entry_splitted [ 0 ] ] ) else : self . log ( [ u"No match: '%s'" , entry ] ) return sorted ( directories ) | Match directory names in paged hierarchies . | 268 | 9 |
226,054 | def load_task ( self , task ) : if not isinstance ( task , Task ) : self . log_exc ( u"task is not an instance of Task" , None , True , ExecuteTaskInputError ) self . task = task | Load the task from the given Task object . | 52 | 9 |
226,055 | def _step_begin ( self , label , log = True ) : if log : self . step_label = label self . step_begin_time = self . log ( u"STEP %d BEGIN (%s)" % ( self . step_index , label ) ) | Log begin of a step | 58 | 5 |
226,056 | def _step_end ( self , log = True ) : if log : step_end_time = self . log ( u"STEP %d END (%s)" % ( self . step_index , self . step_label ) ) diff = ( step_end_time - self . step_begin_time ) diff = float ( diff . seconds + diff . microseconds / 1000000.0 ) self . step_total += diff self . log ( u"STEP %d DURATION %.3f (%s)" % ( self . step_index , diff , self . step_label ) ) self . step_index += 1 | Log end of a step | 135 | 5 |
226,057 | def _step_failure ( self , exc ) : self . log_crit ( u"STEP %d (%s) FAILURE" % ( self . step_index , self . step_label ) ) self . step_index += 1 self . log_exc ( u"Unexpected error while executing task" , exc , True , ExecuteTaskExecutionError ) | Log failure of a step | 79 | 5 |
226,058 | def execute ( self ) : self . log ( u"Executing task..." ) # check that we have the AudioFile object if self . task . audio_file is None : self . log_exc ( u"The task does not seem to have its audio file set" , None , True , ExecuteTaskInputError ) if ( ( self . task . audio_file . audio_length is None ) or ( self . task . audio_file . audio_length <= 0 ) ) : self . log_exc ( u"The task seems to have an invalid audio file" , None , True , ExecuteTaskInputError ) task_max_audio_length = self . rconf [ RuntimeConfiguration . TASK_MAX_AUDIO_LENGTH ] if ( ( task_max_audio_length > 0 ) and ( self . task . audio_file . audio_length > task_max_audio_length ) ) : self . log_exc ( u"The audio file of the task has length %.3f, more than the maximum allowed (%.3f)." % ( self . task . audio_file . audio_length , task_max_audio_length ) , None , True , ExecuteTaskInputError ) # check that we have the TextFile object if self . task . text_file is None : self . log_exc ( u"The task does not seem to have its text file set" , None , True , ExecuteTaskInputError ) if len ( self . task . text_file ) == 0 : self . log_exc ( u"The task text file seems to have no text fragments" , None , True , ExecuteTaskInputError ) task_max_text_length = self . rconf [ RuntimeConfiguration . TASK_MAX_TEXT_LENGTH ] if ( ( task_max_text_length > 0 ) and ( len ( self . task . text_file ) > task_max_text_length ) ) : self . log_exc ( u"The text file of the task has %d fragments, more than the maximum allowed (%d)." % ( len ( self . task . text_file ) , task_max_text_length ) , None , True , ExecuteTaskInputError ) if self . task . text_file . chars == 0 : self . log_exc ( u"The task text file seems to have empty text" , None , True , ExecuteTaskInputError ) self . log ( u"Both audio and text input file are present" ) # execute self . step_index = 1 self . step_total = 0.000 if self . task . text_file . file_format in TextFileFormat . MULTILEVEL_VALUES : self . _execute_multi_level_task ( ) else : self . _execute_single_level_task ( ) self . log ( u"Executing task... done" ) | Execute the task . The sync map produced will be stored inside the task object . | 618 | 17 |
226,059 | def _execute_single_level_task ( self ) : self . log ( u"Executing single level task..." ) try : # load audio file, extract MFCCs from real wave, clear audio file self . _step_begin ( u"extract MFCC real wave" ) real_wave_mfcc = self . _extract_mfcc ( file_path = self . task . audio_file_path_absolute , file_format = None , ) self . _step_end ( ) # compute head and/or tail and set it self . _step_begin ( u"compute head tail" ) ( head_length , process_length , tail_length ) = self . _compute_head_process_tail ( real_wave_mfcc ) real_wave_mfcc . set_head_middle_tail ( head_length , process_length , tail_length ) self . _step_end ( ) # compute alignment, outputting a tree of time intervals self . _set_synthesizer ( ) sync_root = Tree ( ) self . _execute_inner ( real_wave_mfcc , self . task . text_file , sync_root = sync_root , force_aba_auto = False , log = True , leaf_level = True ) self . _clear_cache_synthesizer ( ) # create syncmap and add it to task self . _step_begin ( u"create sync map" ) self . _create_sync_map ( sync_root = sync_root ) self . _step_end ( ) # log total self . _step_total ( ) self . log ( u"Executing single level task... done" ) except Exception as exc : self . _step_failure ( exc ) | Execute a single - level task | 385 | 7 |
226,060 | def _execute_level ( self , level , audio_file_mfcc , text_files , sync_roots , force_aba_auto = False ) : self . _set_synthesizer ( ) next_level_text_files = [ ] next_level_sync_roots = [ ] for text_file_index , text_file in enumerate ( text_files ) : self . log ( [ u"Text level %d, fragment %d" , level , text_file_index ] ) self . log ( [ u" Len: %d" , len ( text_file ) ] ) sync_root = sync_roots [ text_file_index ] if ( level > 1 ) and ( len ( text_file ) == 1 ) : self . log ( u"Level > 1 and only one text fragment => return trivial tree" ) self . _append_trivial_tree ( text_file , sync_root ) elif ( level > 1 ) and ( sync_root . value . begin == sync_root . value . end ) : self . log ( u"Level > 1 and parent has begin == end => return trivial tree" ) self . _append_trivial_tree ( text_file , sync_root ) else : self . log ( u"Level == 1 or more than one text fragment with non-zero parent => compute tree" ) if not sync_root . is_empty : begin = sync_root . value . begin end = sync_root . value . end self . log ( [ u" Setting begin: %.3f" , begin ] ) self . log ( [ u" Setting end: %.3f" , end ] ) audio_file_mfcc . set_head_middle_tail ( head_length = begin , middle_length = ( end - begin ) ) else : self . log ( u" No begin or end to set" ) self . _execute_inner ( audio_file_mfcc , text_file , sync_root = sync_root , force_aba_auto = force_aba_auto , log = False , leaf_level = ( level == 3 ) ) # store next level roots next_level_text_files . extend ( text_file . children_not_empty ) # we added head and tail, we must not pass them to the next level next_level_sync_roots . extend ( sync_root . children [ 1 : - 1 ] ) self . _clear_cache_synthesizer ( ) return ( next_level_text_files , next_level_sync_roots ) | Compute the alignment for all the nodes in the given level . | 557 | 13 |
226,061 | def _execute_inner ( self , audio_file_mfcc , text_file , sync_root = None , force_aba_auto = False , log = True , leaf_level = False ) : self . _step_begin ( u"synthesize text" , log = log ) synt_handler , synt_path , synt_anchors , synt_format = self . _synthesize ( text_file ) self . _step_end ( log = log ) self . _step_begin ( u"extract MFCC synt wave" , log = log ) synt_wave_mfcc = self . _extract_mfcc ( file_path = synt_path , file_format = synt_format , ) gf . delete_file ( synt_handler , synt_path ) self . _step_end ( log = log ) self . _step_begin ( u"align waves" , log = log ) indices = self . _align_waves ( audio_file_mfcc , synt_wave_mfcc , synt_anchors ) self . _step_end ( log = log ) self . _step_begin ( u"adjust boundaries" , log = log ) self . _adjust_boundaries ( indices , text_file , audio_file_mfcc , sync_root , force_aba_auto , leaf_level ) self . _step_end ( log = log ) | Align a subinterval of the given AudioFileMFCC with the given TextFile . | 309 | 19 |
226,062 | def _load_audio_file ( self ) : self . _step_begin ( u"load audio file" ) # NOTE file_format=None forces conversion to # PCM16 mono WAVE with default sample rate audio_file = AudioFile ( file_path = self . task . audio_file_path_absolute , file_format = None , rconf = self . rconf , logger = self . logger ) audio_file . read_samples_from_file ( ) self . _step_end ( ) return audio_file | Load audio in memory . | 115 | 5 |
226,063 | def _clear_audio_file ( self , audio_file ) : self . _step_begin ( u"clear audio file" ) audio_file . clear_data ( ) audio_file = None self . _step_end ( ) | Clear audio from memory . | 51 | 5 |
226,064 | def _extract_mfcc ( self , file_path = None , file_format = None , audio_file = None ) : audio_file_mfcc = AudioFileMFCC ( file_path = file_path , file_format = file_format , audio_file = audio_file , rconf = self . rconf , logger = self . logger ) if self . rconf . mmn : self . log ( u"Running VAD inside _extract_mfcc..." ) audio_file_mfcc . run_vad ( log_energy_threshold = self . rconf [ RuntimeConfiguration . MFCC_MASK_LOG_ENERGY_THRESHOLD ] , min_nonspeech_length = self . rconf [ RuntimeConfiguration . MFCC_MASK_MIN_NONSPEECH_LENGTH ] , extend_before = self . rconf [ RuntimeConfiguration . MFCC_MASK_EXTEND_SPEECH_INTERVAL_BEFORE ] , extend_after = self . rconf [ RuntimeConfiguration . MFCC_MASK_EXTEND_SPEECH_INTERVAL_AFTER ] ) self . log ( u"Running VAD inside _extract_mfcc... done" ) return audio_file_mfcc | Extract the MFCCs from the given audio file . | 283 | 12 |
226,065 | def _compute_head_process_tail ( self , audio_file_mfcc ) : head_length = self . task . configuration [ "i_a_head" ] process_length = self . task . configuration [ "i_a_process" ] tail_length = self . task . configuration [ "i_a_tail" ] head_max = self . task . configuration [ "i_a_head_max" ] head_min = self . task . configuration [ "i_a_head_min" ] tail_max = self . task . configuration [ "i_a_tail_max" ] tail_min = self . task . configuration [ "i_a_tail_min" ] if ( ( head_length is not None ) or ( process_length is not None ) or ( tail_length is not None ) ) : self . log ( u"Setting explicit head process tail" ) else : self . log ( u"Detecting head tail..." ) sd = SD ( audio_file_mfcc , self . task . text_file , rconf = self . rconf , logger = self . logger ) head_length = TimeValue ( "0.000" ) process_length = None tail_length = TimeValue ( "0.000" ) if ( head_min is not None ) or ( head_max is not None ) : self . log ( u"Detecting HEAD..." ) head_length = sd . detect_head ( head_min , head_max ) self . log ( [ u"Detected HEAD: %.3f" , head_length ] ) self . log ( u"Detecting HEAD... done" ) if ( tail_min is not None ) or ( tail_max is not None ) : self . log ( u"Detecting TAIL..." ) tail_length = sd . detect_tail ( tail_min , tail_max ) self . log ( [ u"Detected TAIL: %.3f" , tail_length ] ) self . log ( u"Detecting TAIL... done" ) self . log ( u"Detecting head tail... done" ) self . log ( [ u"Head: %s" , gf . safe_float ( head_length , None ) ] ) self . log ( [ u"Process: %s" , gf . safe_float ( process_length , None ) ] ) self . log ( [ u"Tail: %s" , gf . safe_float ( tail_length , None ) ] ) return ( head_length , process_length , tail_length ) | Set the audio file head or tail by either reading the explicit values from the Task configuration or using SD to determine them . | 560 | 24 |
226,066 | def _clear_cache_synthesizer ( self ) : self . log ( u"Clearing synthesizer..." ) self . synthesizer . clear_cache ( ) self . log ( u"Clearing synthesizer... done" ) | Clear the cache of the synthesizer | 50 | 7 |
226,067 | def _synthesize ( self , text_file ) : handler , path = gf . tmp_file ( suffix = u".wav" , root = self . rconf [ RuntimeConfiguration . TMP_PATH ] ) result = self . synthesizer . synthesize ( text_file , path ) return ( handler , path , result [ 0 ] , self . synthesizer . output_audio_format ) | Synthesize text into a WAVE file . | 86 | 11 |
226,068 | def _align_waves ( self , real_wave_mfcc , synt_wave_mfcc , synt_anchors ) : self . log ( u"Creating DTWAligner..." ) aligner = DTWAligner ( real_wave_mfcc , synt_wave_mfcc , rconf = self . rconf , logger = self . logger ) self . log ( u"Creating DTWAligner... done" ) self . log ( u"Computing boundary indices..." ) boundary_indices = aligner . compute_boundaries ( synt_anchors ) self . log ( u"Computing boundary indices... done" ) return boundary_indices | Align two AudioFileMFCC objects representing WAVE files . | 148 | 13 |
226,069 | def _adjust_boundaries ( self , boundary_indices , text_file , real_wave_mfcc , sync_root , force_aba_auto = False , leaf_level = False ) : # boundary_indices contains the boundary indices in the all_mfcc of real_wave_mfcc # starting with the (head-1st fragment) and ending with (-1th fragment-tail) aba_parameters = self . task . configuration . aba_parameters ( ) if force_aba_auto : self . log ( u"Forced running algorithm: 'auto'" ) aba_parameters [ "algorithm" ] = ( AdjustBoundaryAlgorithm . AUTO , [ ] ) # note that the other aba settings (nonspeech and nozero) # remain as specified by the user self . log ( [ u"ABA parameters: %s" , aba_parameters ] ) aba = AdjustBoundaryAlgorithm ( rconf = self . rconf , logger = self . logger ) aba . adjust ( aba_parameters = aba_parameters , real_wave_mfcc = real_wave_mfcc , boundary_indices = boundary_indices , text_file = text_file , allow_arbitrary_shift = leaf_level ) aba . append_fragment_list_to_sync_root ( sync_root = sync_root ) | Adjust boundaries as requested by the user . | 313 | 8 |
226,070 | def _append_trivial_tree ( self , text_file , sync_root ) : interval = sync_root . value # # NOTE the following is correct, but it is a bit obscure # time_values = [interval.begin] * (1 + len(text_file)) + [interval.end] * 2 # if len ( text_file ) == 1 : time_values = [ interval . begin , interval . begin , interval . end , interval . end ] else : # interval.begin == interval.end time_values = [ interval . begin ] * ( 3 + len ( text_file ) ) aba = AdjustBoundaryAlgorithm ( rconf = self . rconf , logger = self . logger ) aba . intervals_to_fragment_list ( text_file = text_file , time_values = time_values ) aba . append_fragment_list_to_sync_root ( sync_root = sync_root ) | Append trivial tree made by one HEAD one sync map fragment for each element of text_file and one TAIL . | 211 | 24 |
226,071 | def _create_sync_map ( self , sync_root ) : sync_map = SyncMap ( tree = sync_root , rconf = self . rconf , logger = self . logger ) if self . rconf . safety_checks : self . log ( u"Running sanity check on computed sync map..." ) if not sync_map . leaves_are_consistent : self . _step_failure ( ValueError ( u"The computed sync map contains inconsistent fragments" ) ) self . log ( u"Running sanity check on computed sync map... passed" ) else : self . log ( u"Not running sanity check on computed sync map" ) self . task . sync_map = sync_map | If requested check that the computed sync map is consistent . Then add it to the Task . | 149 | 18 |
226,072 | def detect_interval ( self , min_head_length = None , max_head_length = None , min_tail_length = None , max_tail_length = None ) : head = self . detect_head ( min_head_length , max_head_length ) tail = self . detect_tail ( min_tail_length , max_tail_length ) begin = head end = self . real_wave_mfcc . audio_length - tail self . log ( [ u"Audio length: %.3f" , self . real_wave_mfcc . audio_length ] ) self . log ( [ u"Head length: %.3f" , head ] ) self . log ( [ u"Tail length: %.3f" , tail ] ) self . log ( [ u"Begin: %.3f" , begin ] ) self . log ( [ u"End: %.3f" , end ] ) if ( begin >= TimeValue ( "0.000" ) ) and ( end > begin ) : self . log ( [ u"Returning %.3f %.3f" , begin , end ] ) return ( begin , end ) self . log ( u"Returning (0.000, 0.000)" ) return ( TimeValue ( "0.000" ) , TimeValue ( "0.000" ) ) | Detect the interval of the audio file containing the fragments in the text file . | 298 | 15 |
226,073 | def detect_head ( self , min_head_length = None , max_head_length = None ) : return self . _detect ( min_head_length , max_head_length , tail = False ) | Detect the audio head returning its duration in seconds . | 47 | 10 |
226,074 | def detect_tail ( self , min_tail_length = None , max_tail_length = None ) : return self . _detect ( min_tail_length , max_tail_length , tail = True ) | Detect the audio tail returning its duration in seconds . | 47 | 10 |
226,075 | def _select_tts_engine ( self ) : self . log ( u"Selecting TTS engine..." ) requested_tts_engine = self . rconf [ RuntimeConfiguration . TTS ] if requested_tts_engine == self . CUSTOM : self . log ( u"TTS engine: custom" ) tts_path = self . rconf [ RuntimeConfiguration . TTS_PATH ] if tts_path is None : self . log_exc ( u"You must specify a value for tts_path" , None , True , ValueError ) if not gf . file_can_be_read ( tts_path ) : self . log_exc ( u"Cannot read tts_path" , None , True , OSError ) try : import imp self . log ( [ u"Loading CustomTTSWrapper module from '%s'..." , tts_path ] ) imp . load_source ( "CustomTTSWrapperModule" , tts_path ) self . log ( [ u"Loading CustomTTSWrapper module from '%s'... done" , tts_path ] ) self . log ( u"Importing CustomTTSWrapper..." ) from CustomTTSWrapperModule import CustomTTSWrapper self . log ( u"Importing CustomTTSWrapper... done" ) self . log ( u"Creating CustomTTSWrapper instance..." ) self . tts_engine = CustomTTSWrapper ( rconf = self . rconf , logger = self . logger ) self . log ( u"Creating CustomTTSWrapper instance... done" ) except Exception as exc : self . log_exc ( u"Unable to load custom TTS wrapper" , exc , True , OSError ) elif requested_tts_engine == self . AWS : try : import boto3 except ImportError as exc : self . log_exc ( u"Unable to import boto3 for AWS Polly TTS API wrapper" , exc , True , ImportError ) self . log ( u"TTS engine: AWS Polly TTS API" ) self . tts_engine = AWSTTSWrapper ( rconf = self . rconf , logger = self . logger ) elif requested_tts_engine == self . NUANCE : try : import requests except ImportError as exc : self . log_exc ( u"Unable to import requests for Nuance TTS API wrapper" , exc , True , ImportError ) self . log ( u"TTS engine: Nuance TTS API" ) self . tts_engine = NuanceTTSWrapper ( rconf = self . rconf , logger = self . logger ) elif requested_tts_engine == self . ESPEAKNG : self . log ( u"TTS engine: eSpeak-ng" ) self . tts_engine = ESPEAKNGTTSWrapper ( rconf = self . rconf , logger = self . logger ) elif requested_tts_engine == self . FESTIVAL : self . log ( u"TTS engine: Festival" ) self . tts_engine = FESTIVALTTSWrapper ( rconf = self . rconf , logger = self . logger ) elif requested_tts_engine == self . MACOS : self . log ( u"TTS engine: macOS" ) self . tts_engine = MacOSTTSWrapper ( rconf = self . rconf , logger = self . logger ) else : self . log ( u"TTS engine: eSpeak" ) self . tts_engine = ESPEAKTTSWrapper ( rconf = self . rconf , logger = self . logger ) self . log ( u"Selecting TTS engine... done" ) | Select the TTS engine to be used by looking at the rconf object . | 819 | 16 |
226,076 | def check_shell_encoding ( cls ) : is_in_utf8 = True is_out_utf8 = True if sys . stdin . encoding not in [ "UTF-8" , "UTF8" ] : is_in_utf8 = False if sys . stdout . encoding not in [ "UTF-8" , "UTF8" ] : is_out_utf8 = False if ( is_in_utf8 ) and ( is_out_utf8 ) : gf . print_success ( u"shell encoding OK" ) else : gf . print_warning ( u"shell encoding WARNING" ) if not is_in_utf8 : gf . print_warning ( u" The default input encoding of your shell is not UTF-8" ) if not is_out_utf8 : gf . print_warning ( u" The default output encoding of your shell is not UTF-8" ) gf . print_info ( u" If you plan to use aeneas on the command line," ) if gf . is_posix ( ) : gf . print_info ( u" you might want to 'export PYTHONIOENCODING=UTF-8' in your shell" ) else : gf . print_info ( u" you might want to 'set PYTHONIOENCODING=UTF-8' in your shell" ) return True return False | Check whether sys . stdin and sys . stdout are UTF - 8 encoded . | 307 | 17 |
226,077 | def check_ffprobe ( cls ) : try : from aeneas . ffprobewrapper import FFPROBEWrapper file_path = gf . absolute_path ( u"tools/res/audio.mp3" , __file__ ) prober = FFPROBEWrapper ( ) properties = prober . read_properties ( file_path ) gf . print_success ( u"ffprobe OK" ) return False except : pass gf . print_error ( u"ffprobe ERROR" ) gf . print_info ( u" Please make sure you have ffprobe installed correctly" ) gf . print_info ( u" (usually it is provided by the ffmpeg installer)" ) gf . print_info ( u" and that its path is in your PATH environment variable" ) return True | Check whether ffprobe can be called . | 182 | 9 |
226,078 | def check_ffmpeg ( cls ) : try : from aeneas . ffmpegwrapper import FFMPEGWrapper input_file_path = gf . absolute_path ( u"tools/res/audio.mp3" , __file__ ) handler , output_file_path = gf . tmp_file ( suffix = u".wav" ) converter = FFMPEGWrapper ( ) result = converter . convert ( input_file_path , output_file_path ) gf . delete_file ( handler , output_file_path ) if result : gf . print_success ( u"ffmpeg OK" ) return False except : pass gf . print_error ( u"ffmpeg ERROR" ) gf . print_info ( u" Please make sure you have ffmpeg installed correctly" ) gf . print_info ( u" and that its path is in your PATH environment variable" ) return True | Check whether ffmpeg can be called . | 198 | 8 |
226,079 | def check_espeak ( cls ) : try : from aeneas . textfile import TextFile from aeneas . textfile import TextFragment from aeneas . ttswrappers . espeakttswrapper import ESPEAKTTSWrapper text = u"From fairest creatures we desire increase," text_file = TextFile ( ) text_file . add_fragment ( TextFragment ( language = u"eng" , lines = [ text ] , filtered_lines = [ text ] ) ) handler , output_file_path = gf . tmp_file ( suffix = u".wav" ) ESPEAKTTSWrapper ( ) . synthesize_multiple ( text_file , output_file_path ) gf . delete_file ( handler , output_file_path ) gf . print_success ( u"espeak OK" ) return False except : pass gf . print_error ( u"espeak ERROR" ) gf . print_info ( u" Please make sure you have espeak installed correctly" ) gf . print_info ( u" and that its path is in your PATH environment variable" ) gf . print_info ( u" You might also want to check that the espeak-data directory" ) gf . print_info ( u" is set up correctly, for example, it has the correct permissions" ) return True | Check whether espeak can be called . | 298 | 8 |
226,080 | def check_cdtw ( cls ) : if gf . can_run_c_extension ( "cdtw" ) : gf . print_success ( u"aeneas.cdtw AVAILABLE" ) return False gf . print_warning ( u"aeneas.cdtw NOT AVAILABLE" ) gf . print_info ( u" You can still run aeneas but it will be significantly slower" ) gf . print_info ( u" Please refer to the installation documentation for details" ) return True | Check whether Python C extension cdtw can be imported . | 119 | 11 |
226,081 | def check_cmfcc ( cls ) : if gf . can_run_c_extension ( "cmfcc" ) : gf . print_success ( u"aeneas.cmfcc AVAILABLE" ) return False gf . print_warning ( u"aeneas.cmfcc NOT AVAILABLE" ) gf . print_info ( u" You can still run aeneas but it will be significantly slower" ) gf . print_info ( u" Please refer to the installation documentation for details" ) return True | Check whether Python C extension cmfcc can be imported . | 123 | 12 |
226,082 | def check_cew ( cls ) : if gf . can_run_c_extension ( "cew" ) : gf . print_success ( u"aeneas.cew AVAILABLE" ) return False gf . print_warning ( u"aeneas.cew NOT AVAILABLE" ) gf . print_info ( u" You can still run aeneas but it will be a bit slower" ) gf . print_info ( u" Please refer to the installation documentation for details" ) return True | Check whether Python C extension cew can be imported . | 120 | 11 |
226,083 | def check_all ( cls , tools = True , encoding = True , c_ext = True ) : # errors are fatal if cls . check_ffprobe ( ) : return ( True , False , False ) if cls . check_ffmpeg ( ) : return ( True , False , False ) if cls . check_espeak ( ) : return ( True , False , False ) if ( tools ) and ( cls . check_tools ( ) ) : return ( True , False , False ) # warnings are non-fatal warnings = False c_ext_warnings = False if encoding : warnings = cls . check_shell_encoding ( ) if c_ext : # we do not want lazy evaluation c_ext_warnings = cls . check_cdtw ( ) or c_ext_warnings c_ext_warnings = cls . check_cmfcc ( ) or c_ext_warnings c_ext_warnings = cls . check_cew ( ) or c_ext_warnings # return results return ( False , warnings , c_ext_warnings ) | Perform all checks . | 241 | 5 |
226,084 | def config_string ( self ) : return ( gc . CONFIG_STRING_SEPARATOR_SYMBOL ) . join ( [ u"%s%s%s" % ( fn , gc . CONFIG_STRING_ASSIGNMENT_SYMBOL , self . data [ fn ] ) for fn in sorted ( self . data . keys ( ) ) if self . data [ fn ] is not None ] ) | Build the storable string corresponding to this configuration object . | 91 | 11 |
226,085 | def geq_multiple ( self , other ) : if other == TimeValue ( "0.000" ) : return self return int ( math . ceil ( other / self ) ) * self | Return the next multiple of this time value greater than or equal to other . If other is zero return this time value . | 41 | 24 |
226,086 | def starts_at ( self , time_point ) : if not isinstance ( time_point , TimeValue ) : raise TypeError ( u"time_point is not an instance of TimeValue" ) return self . begin == time_point | Returns True if this interval starts at the given time point . | 51 | 12 |
226,087 | def ends_at ( self , time_point ) : if not isinstance ( time_point , TimeValue ) : raise TypeError ( u"time_point is not an instance of TimeValue" ) return self . end == time_point | Returns True if this interval ends at the given time point . | 51 | 12 |
226,088 | def percent_value ( self , percent ) : if not isinstance ( percent , Decimal ) : raise TypeError ( u"percent is not an instance of Decimal" ) percent = Decimal ( max ( min ( percent , 100 ) , 0 ) / 100 ) return self . begin + self . length * percent | Returns the time value at percent of this interval . | 66 | 10 |
226,089 | def offset ( self , offset , allow_negative = False , min_begin_value = None , max_end_value = None ) : if not isinstance ( offset , TimeValue ) : raise TypeError ( u"offset is not an instance of TimeValue" ) self . begin += offset self . end += offset if not allow_negative : self . begin = max ( self . begin , TimeValue ( "0.000" ) ) self . end = max ( self . end , TimeValue ( "0.000" ) ) if ( min_begin_value is not None ) and ( max_end_value is not None ) : self . begin = min ( max ( self . begin , min_begin_value ) , max_end_value ) self . end = min ( self . end , max_end_value ) return self | Move this interval by the given shift offset . | 179 | 9 |
226,090 | def intersection ( self , other ) : relative_position = self . relative_position_of ( other ) if relative_position in [ self . RELATIVE_POSITION_PP_C , self . RELATIVE_POSITION_PI_LC , self . RELATIVE_POSITION_PI_LG , self . RELATIVE_POSITION_PI_CG , self . RELATIVE_POSITION_IP_B , self . RELATIVE_POSITION_II_LB , ] : return TimeInterval ( begin = self . begin , end = self . begin ) if relative_position in [ self . RELATIVE_POSITION_IP_E , self . RELATIVE_POSITION_II_EG , ] : return TimeInterval ( begin = self . end , end = self . end ) if relative_position in [ self . RELATIVE_POSITION_II_BI , self . RELATIVE_POSITION_II_BE , self . RELATIVE_POSITION_II_II , self . RELATIVE_POSITION_II_IE , ] : return TimeInterval ( begin = other . begin , end = other . end ) if relative_position in [ self . RELATIVE_POSITION_IP_I , self . RELATIVE_POSITION_II_LI , self . RELATIVE_POSITION_II_LE , self . RELATIVE_POSITION_II_LG , self . RELATIVE_POSITION_II_BG , self . RELATIVE_POSITION_II_IG , ] : begin = max ( self . begin , other . begin ) end = min ( self . end , other . end ) return TimeInterval ( begin = begin , end = end ) return None | Return the intersection between this time interval and the given time interval or None if the two intervals do not overlap . | 360 | 22 |
226,091 | def is_non_zero_before_non_zero ( self , other ) : return self . is_adjacent_before ( other ) and ( not self . has_zero_length ) and ( not other . has_zero_length ) | Return True if this time interval ends when the given other time interval begins and both have non zero length . | 52 | 21 |
226,092 | def is_adjacent_before ( self , other ) : if not isinstance ( other , TimeInterval ) : raise TypeError ( u"other is not an instance of TimeInterval" ) return ( self . end == other . begin ) | Return True if this time interval ends when the given other time interval begins . | 52 | 15 |
226,093 | def check_format ( self , sm_format ) : if sm_format not in SyncMapFormat . ALLOWED_VALUES : self . print_error ( u"Sync map format '%s' is not allowed" % ( sm_format ) ) self . print_info ( u"Allowed formats:" ) self . print_generic ( u" " . join ( SyncMapFormat . ALLOWED_VALUES ) ) return False return True | Return True if the given sync map format is allowed and False otherwise . | 96 | 14 |
226,094 | def _add_fragment ( cls , syncmap , identifier , lines , begin , end , language = None ) : syncmap . add_fragment ( SyncMapFragment ( text_fragment = TextFragment ( identifier = identifier , lines = lines , language = language ) , begin = begin , end = end ) ) | Add a new fragment to syncmap . | 73 | 8 |
226,095 | def parse ( self , input_text , syncmap ) : self . log_exc ( u"%s is abstract and cannot be called directly" % ( self . TAG ) , None , True , NotImplementedError ) | Parse the given input_text and append the extracted fragments to syncmap . | 48 | 16 |
226,096 | def format ( self , syncmap ) : self . log_exc ( u"%s is abstract and cannot be called directly" % ( self . TAG ) , None , True , NotImplementedError ) | Format the given syncmap as a Unicode string . | 44 | 10 |
226,097 | def print_examples ( self , full = False ) : msg = [ ] i = 1 for key in sorted ( self . DEMOS . keys ( ) ) : example = self . DEMOS [ key ] if full or example [ "show" ] : msg . append ( u"Example %d (%s)" % ( i , example [ u"description" ] ) ) msg . append ( u" $ %s %s" % ( self . invoke , key ) ) msg . append ( u"" ) i += 1 self . print_generic ( u"\n" + u"\n" . join ( msg ) + u"\n" ) return self . HELP_EXIT_CODE | Print the examples and exit . | 149 | 6 |
226,098 | def print_values ( self , parameter ) : if parameter in self . VALUES : self . print_info ( u"Available values for parameter '%s':" % parameter ) self . print_generic ( u"\n" . join ( self . VALUES [ parameter ] ) ) return self . HELP_EXIT_CODE if parameter not in [ u"?" , u"" ] : self . print_error ( u"Invalid parameter name '%s'" % parameter ) self . print_info ( u"Parameters for which values can be listed:" ) self . print_generic ( u"\n" . join ( sorted ( self . VALUES . keys ( ) ) ) ) return self . HELP_EXIT_CODE | Print the list of values for the given parameter and exit . | 156 | 12 |
226,099 | def check_file_encoding ( self , input_file_path ) : self . log ( [ u"Checking encoding of file '%s'" , input_file_path ] ) self . result = ValidatorResult ( ) if self . _are_safety_checks_disabled ( u"check_file_encoding" ) : return self . result if not gf . file_can_be_read ( input_file_path ) : self . _failed ( u"File '%s' cannot be read." % ( input_file_path ) ) return self . result with io . open ( input_file_path , "rb" ) as file_object : bstring = file_object . read ( ) self . _check_utf8_encoding ( bstring ) return self . result | Check whether the given file is UTF - 8 encoded . | 174 | 11 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.