jazzparser.formalisms

57 """ 58 Superclass of all Formalism structures. These tie together all the 59 components of a formalism in an easily accessible way: rules, 60 syntax, semantics, etc. 61 """ 62 literal_functions = {} 63 shell_tools = [] 64

65 - class __metaclass__(type):

66 - def __init__(cls, name, bases, dict):

67 # Skip all this when the base class if created 68 if name != "FormalismBase": 69 # Initialize all the output options 70 # If they're never set by whatever script is running, this 71 # ensures that their default values are available 72 formalism = cls.get_name() 73 opts = ModuleOption.process_option_dict({}, cls.output_options) 74 # Store this so it's globally available to the formalism 75 settings.OPTIONS.OUTPUT[formalism] = opts

76 77 output_options = [] 78 """ 79 ModuleOptions that can be used to set global settings that will 80 affect the formatting of output. 81 82 Don't use any required options. All options must be able to be initialized 83 to a default. 84 85 The values of the options will be set to their default when the formalism 86 class is first encountered. Call L{process_output_options} to customize 87 the options. 88 89 Although the options are globally available for simplicity of access, 90 you should only ever access them from within formalism-specific code in 91 practice. 92 93 """ 94 95 @classmethod

96 - def process_output_options(cls, optdict):

97 """ 98 Makes output options globally available, based on a dictionary. 99 100 @see: L{output_options}. 101 102 """ 103 formalism = cls.get_name() 104 opts = ModuleOption.process_option_dict(optdict, cls.output_options) 105 settings.OPTIONS.OUTPUT[formalism] = opts

106 107 @classmethod

108 - def cl_output_options(cls, string):

109 """ 110 Convenience method so you don't have to do this lots of times over. 111 112 Take a string of output options from the command line and set the 113 output options from it. 114 115 Should only be used in command-line scripts. 116 117 """ 118 if string is not None and string.lower() == "help": 119 print "Available output options" 120 print "========================" 121 print options_help_text(cls.output_options) 122 sys.exit(0) 123 optdict = ModuleOption.process_option_string(string) 124 cls.process_output_options(optdict)

125 126 semantics_to_coordinates = None 127 """Function to generate a list of coordinates from a parse result (semantic part).""" 128 129 @classmethod

130 - def sign_to_coordinates(cls, sign):

131 """ 132 Function to generate a list of coordinates from a parse result. 133 By default, uses C{semantics_to_coordinates} applied to the semantic 134 part of the sign. 135 136 """ 137 return cls.semantics_to_coordinates(sign.semantics)

138 139 semantics_distance_metrics = [] 140 """ 141 List of distance metrics available in the formalism. Each item is a 142 subclass of L{jazzparser.formalisms.base.semantics.distance.DistanceMetric}. 143 144 """ 145 PcfgModel = None 146 """ 147 Pcfg model class appropriate for the formalism. 148 149 """ 150 151 @classmethod

152 - def get_name(cls):

153 return cls.__module__.rpartition(".")[2]

154

155 - class Syntax:

156 """ 157 Formalisms should define override this nested class with their 158 own, which will specify values for these attributes. 159 """ 160 Sign = None 161 ComplexCategory = None 162 AtomicCategory = None 163 DummyCategory = None 164 165 @classmethod

166 - def is_category(cls, obj):

167 return isinstance(obj, cls.Category)

168 169 @classmethod

170 - def is_complex_category(cls, obj):

171 return isinstance(obj, cls.ComplexCategory)

172 173 @classmethod

174 - def is_atomic_category(cls, obj):

175 return isinstance(obj, cls.AtomicCategory)

176 177 @staticmethod

178 - def merge_equal_signs(existing_sign, new_sign):

179 pass

180

181 - class Semantics:

182 """ 183 Formalisms should define override this nested class with their 184 own, which will specify values for these attributes. 185 """ 186 Semantics = None 187 apply = None 188 compose = None

189

190 - class Evaluation:

191 """ 192 Functions for evaluating tonal space paths and parse results. 193 194 """ 195 tonal_space_alignment_costs = None 196 """ 197 Performs an alignment of two tonal space paths and returns a dictionary 198 of costs incurred in the optimal alignment. 199 The values must include 'deletions', 'substitutions' and 'insertions' 200 and may also include more fine-grained information, like 'root_subs' 201 and 'function_subs'. 202 203 """ 204 tonal_space_distance = None 205 """ 206 Performs an alignment of two tonal space paths and computes a distance 207 metric between them. The metric is assumed to be based on edit distance, 208 so to have a minimum value of 0 (identity) and maximum the length of 209 the longer sequence. 210 211 """

Source Code for Package jazzparser.formalisms