def main(): usage = "%prog [options] <results-file> [<result-number>=0]" parser = OptionParser(usage=usage) parser.add_option( "-q", "--quiet", dest="quiet", action="store_true", help="only output the requested information, no meta-info.") parser.add_option("-p", "--print", dest="printout", action="store_true", help="output the result to stdout.") parser.add_option("--path", dest="path", action="store_true", help="display the fully-specified tonal space path.") parser.add_option( "--play", dest="play", action="store_true", help= "use the harmonical to play the root sequence of the result's semantics." ) parser.add_option( "--audio", dest="audio", action="store", help= "use the harmonical to render the root sequence, as with --play, and store the result to a wave file." ) options, arguments = parser.parse_args() # Just get the default formalism formalism = get_default_formalism() def _print(string=""): if not options.quiet: print >> sys.stderr, string if len(arguments) == 0: print >> sys.stderr, "Specify a file to read the results from" sys.exit(1) results = ParseResults.from_file(arguments[0]) if len(arguments) > 1: res_num = int(arguments[1]) else: res_num = 0 prob, result = results.sorted_results[res_num] if options.printout: _print("Result:") # Just display the resulting category print result _print() if options.path: _print("Tonal space path:") # Compute the tonal path (coordinates) from the result path = formalism.semantics_to_coordinates(result.semantics) points, timings = zip(*path) print ", ".join(coordinates_to_roman_names(points)) _print() if options.play or options.audio is not None: _print("Building pitch structure from result...") # Convert the semantics into a list of TS points path = formalism.semantics_to_coordinates(result.semantics) # Decide on chord types # For now, since we don't know the original chords, use dom7 # for dom chords, maj for subdoms, and M7 for tonics fun_chords = { 'T': 'M7', 'D': '7', 'S': '', } functions = formalism.semantics_to_functions(result.semantics) chord_types = [(fun_chords[f], t) for (f, t) in functions] tones = path_to_tones(path, chord_types=chord_types, double_root=True) _print("Rendering audio samples...") samples = tones.render() if options.audio is not None: filename = os.path.abspath(options.audio) _print("Writing wave data to %s" % filename) save_wave_data(samples, filename) if options.play: _print("Playing...") play_audio(samples, wait_for_end=True) _print()
def main(): usage = "%prog [options] <results-file> [<result-number>=0]" parser = OptionParser(usage=usage) parser.add_option("-q", "--quiet", dest="quiet", action="store_true", help="only output the requested information, no meta-info.") parser.add_option("-p", "--print", dest="printout", action="store_true", help="output the result to stdout.") parser.add_option("--path", dest="path", action="store_true", help="display the fully-specified tonal space path.") parser.add_option("--play", dest="play", action="store_true", help="use the harmonical to play the root sequence of the result's semantics.") parser.add_option("--audio", dest="audio", action="store", help="use the harmonical to render the root sequence, as with --play, and store the result to a wave file.") options, arguments = parser.parse_args() # Just get the default formalism formalism = get_default_formalism() def _print(string=""): if not options.quiet: print >>sys.stderr, string if len(arguments) == 0: print >>sys.stderr, "Specify a file to read the results from" sys.exit(1) results = ParseResults.from_file(arguments[0]) if len(arguments) > 1: res_num = int(arguments[1]) else: res_num = 0 prob,result = results.sorted_results[res_num] if options.printout: _print("Result:") # Just display the resulting category print result _print() if options.path: _print("Tonal space path:") # Compute the tonal path (coordinates) from the result path = formalism.semantics_to_coordinates(result.semantics) points,timings = zip(*path) print ", ".join(coordinates_to_roman_names(points)) _print() if options.play or options.audio is not None: _print("Building pitch structure from result...") # Convert the semantics into a list of TS points path = formalism.semantics_to_coordinates(result.semantics) # Decide on chord types # For now, since we don't know the original chords, use dom7 # for dom chords, maj for subdoms, and M7 for tonics fun_chords = { 'T' : 'M7', 'D' : '7', 'S' : '', } functions = formalism.semantics_to_functions(result.semantics) chord_types = [(fun_chords[f],t) for (f,t) in functions] tones = path_to_tones(path, chord_types=chord_types, double_root=True) _print("Rendering audio samples...") samples = tones.render() if options.audio is not None: filename = os.path.abspath(options.audio) _print("Writing wave data to %s" % filename) save_wave_data(samples, filename) if options.play: _print("Playing...") play_audio(samples, wait_for_end=True) _print()
def _result_callback(response): if response is None: # Empty input, or the subprocess doesn't want us to do anything return else: # Mark this input as completed global completed_parses completed_parses[response['identifier']] = True if response['results'] is None: # There was some error: check what it was error = response['error'] print >> sys.stderr, "Error parsing %s" % str(response['input']) print >> sys.stderr, "The error was:" print >>sys.stderr, error[2] global parse_exit_status parse_exit_status = 1 else: # Keep this together with all the other processes' responses all_results.append(response) print "Parsed: %s" % response['input'] # Run any cleanup routines that the formalism defines grammar.formalism.clean_results(response['results']) # Remove complex results if atomic-only option has been set if options.atoms_only: response['results'] = remove_complex_categories(response['results'], grammar.formalism) if not options.no_results: print "Results:" list_results(response['results']) if output_dir is not None: # Try getting a gold standard analysis if one has been # associated with the input gold = response['input'].get_gold_analysis() # Get the results with their probabilities top_results = [(getattr(res, 'probability', None), res) \ for res in response['results']] if options.topn is not None: # Limit the results that get stored top_results = list(reversed(sorted( top_results)))[:options.topn] # Output the results to a file presults = ParseResults( top_results, signs=True, gold_parse=gold, timed_out=response['timed_out'], cpu_time=response['time']) filename = get_output_filename(response['identifier']) presults.save(filename) print "Parse results output to %s" % filename if time_parse: print "Parse took %f seconds" % response['time'] if options.lh_analysis: print >>sys.stderr, "\nLonguet-Higgins tonal space analysis for each result:" # Output the tonal space path for each result for i,result in enumerate(response['results']): path = grammar.formalism.sign_to_coordinates(result) coords,times = zip(*path) print "%d> %s" % (i, ", ".join( ["%s@%s" % (crd,time) for (crd,time) in zip(coordinates_to_roman_names(coords),times)])) if options.lh_coord: print >>sys.stderr, "\nLonguet-Higgins tonal space coordinates for each result:" # Output the tonal space path for each result for i,result in enumerate(response['results']): path = grammar.formalism.sign_to_coordinates(result) print "%d> %s" % (i, ", ".join(["(%d,%d)@%s" % (x,y,t) for ((x,y),t) in path])) # Print out any messages the parse routine sent to us for message in response['messages']: print message # Print as summary of what we've completed num_completed = len(filter(lambda x:x[1], completed_parses.items())) if not stdinput: if not options.no_progress: print format_table([ [str(ident), "Complete" if completed_parses[ident] else ""] for ident in sorted(completed_parses.keys())]) if num_inputs is None: print "\nCompleted %d parses" % num_completed else: print "\nCompleted %d/%d parses" % (num_completed, num_inputs) # Enter interactive mode now if requested in options # Don't do this is we're in a process pool if not multiprocessing and options.interactive: print from jazzparser.shell import interactive_shell env = {} env.update(globals()) env.update(locals()) interactive_shell(response['results'], options, response['tagger'], response['parser'], grammar.formalism, env, input_data=response['input']) print # Flush the output to make sure everything gets out before we start the next one sys.stderr.flush() sys.stdout.flush()