Class Hierarchy

• jazzparser.settings.CANDC
• jazzparser.formalisms.FormalismBase.Evaluation: Functions for evaluating tonal space paths and parse results.
  • jazzparser.formalisms.music_halfspan.Formalism.Evaluation: Functions for evaluating tonal space paths and parse results.
• jazzparser.settings.OPTIONS
• jazzparser.settings.PCFG_PARSER
• jazzparser.formalisms.FormalismBase.Semantics: Formalisms should define override this nested class with their own, which will specify values for these attributes.
  • jazzparser.formalisms.music_halfspan.Formalism.Semantics: Formalisms should define override this nested class with their own, which will specify values for these attributes.
• jazzparser.formalisms.FormalismBase.Syntax: Formalisms should define override this nested class with their own, which will specify values for these attributes.
  • jazzparser.formalisms.music_halfspan.Formalism.Syntax: Formalisms should define override this nested class with their own, which will specify values for these attributes.
• jazzparser.settings.TEST: Settings and common constants for unit tests (see jptests).
• object: The most base type
  • jazzparser.backoff.base.BackoffBuilder: Defines the interface and common functions for models that assign a semantics directly to an input sequence.
    • jazzparser.backoff.ngram.midi.MidiHmmPathBuilder: Use an HP chord labeler to get a chord lattice and HmmPath on the lattice.
    • jazzparser.backoff.base.ModelBackoffBuilder: Subclass of BackoffBuilder that handles model loading.
      • jazzparser.backoff.ngram.hmmpath.HmmPathBuilder: Builds a semantics using an ngram model.
  • jazzparser.misc.tree.balancedseq.BalancedSequence: Elements should be just 0s and 1s.
  • exceptions.BaseException: Common base class for all exceptions
    • exceptions.Exception: Common base class for all non-exit exceptions.
      • jazzparser.backoff.loader.BackoffLoadError
      • jazzparser.utils.nltk.ngram.baumwelch.BaumWelchTrainingError
      • jazzparser.taggers.candc.tagger.CandcConfigurationError
      • jazzparser.taggers.candc.tagger.CandcTaggingError
      • jazzparser.taggers.candc.training.CandcTrainingError
      • jazzparser.formalisms.base.syntax.Category.CategoryParseError
      • jazzparser.parsers.cky.chart.ChartError: Raised if something goes wrong while building or processing a chart.
      • jazzparser.utils.chords.ChordError: Raised when there's a problem recognising or processing a chord.
      • jazzparser.utils.web.ChordSequenceParseError
      • jazzparser.harmonical.midi.chords.ChordSequenceRealizationError
      • jazzparser.utils.config.ConfigFileReadError
      • jazzparser.data.corpora.CorpusError
      • jazzparser.parsers.cky.parser.DirectedParseError
      • jazzparser.misc.tree.balancedseq.EmptySequenceError
      • jazzparser.formalisms.loader.FormalismLoadError
      • jazzparser.grammar.GrammarLookupError: Raised if there are problems consulting the grammar.
      • jazzparser.grammar.GrammarReadError: Thrown if there's a problem while reading the grammar description from the XML file.
      • jazzparser.harmonical.input.HarmonicalInputFileReadError
      • jazzparser.data.assignments.EquivalenceAssignment.IncompatibleAssignmentError
      • jazzparser.formalisms.base.syntax.VariableSubstitutor.InconsistencyError
      • jazzparser.data.corpora.temperley.InputError
      • jazzparser.data.input.InputReadError
      • jazzparser.data.input.InputTypeError
      • jazzparser.formalisms.base.syntax.VariableSubstitution.InvalidVariableTypeError
      • jazzparser.formalisms.music_halfspan.semantics.KeyInferenceError
      • jazzparser.data.parsing.ParseResults.LoadError
      • jazzparser.data.dependencies.MaltTabReadError
      • jazzparser.data.midi.MidiAlignmentError
      • midi.MidiReadError: Usually raised on encountering invalid MIDI data while parsing.
      • midi.MidiWriteError
      • jazzparser.parsers.pcfg.model.ModelError
      • jazzparser.parsers.pcfg.model.ModelLoadError
      • jazzparser.misc.chordlabel.ModelLoadError
      • jazzparser.taggers.models.ModelLoadError
      • jazzparser.parsers.pcfg.model.ModelSaveError
      • jazzparser.taggers.models.ModelSaveError
      • jazzparser.misc.chordlabel.ModelTrainError
      • jazzparser.parsers.pcfg.model.ModelTrainingError
      • jazzparser.utils.options.ModuleOptionError
      • jazzparser.utils.nltk.ngram.model.NgramError
      • jazzparser.utils.nltk.storage.ObjectStorerError
      • jazzparser.utils.base.OptionalImportError
      • jazzparser.parsers.ParseError: Thrown if it's not possible to carry out a parse, for some reason.
      • jazzparser.parsers.ParserInitializationError: Thrown when initializing the parser if something in the configuration prevents correct initialization.
      • jazzparser.parsers.loader.ParserLoadError
      • jazzparser.parsers.cky.parser.ParserTimeout
      • jazzparser.utils.probabilities.ProbabilityError
      • jazzparser.misc.raphsto.RaphstoHmmError
      • jazzparser.misc.raphsto.RaphstoHmmParameterError
      • jazzparser.misc.raphsto.RaphstoModelLoadError
      • jazzparser.misc.raphsto.RaphstoModelSaveError
      • jazzparser.parsers.RuleApplicationError: Thrown if there's an error during application of a rule to categories.
      • jazzparser.formalisms.music_halfspan.semantics.SemanticsPostProcessError
      • jazzparser.formalisms.music_halfspan.semantics.SemanticsStringBuildError
      • jazzparser.formalisms.music_halfspan.harmstruct.SemanticsToDependenciesError
      • jazzparser.formalisms.music_halfspan.harmstruct.SemanticsToTreesError
      • midi.sequencer_portmidi.SequencerInitializationError
      • jazzparser.shell.shell.ShellError
      • jazzparser.shell.shell.ShellRestoreError
      • jazzparser.formalisms.music_halfspan.syntax.SignStringBuildError
      • jazzparser.data.db_mirrors.semantics.SimpleSemanticsBuildError
      • exceptions.StandardError: Base class for all standard Python exceptions that do not represent interpreter exiting.
        • exceptions.AssertionError: Assertion failed.
      • jazzparser.formalisms.base.syntax.VariableSubstitutor.SubstitutionError
      • jazzparser.formalisms.music_halfspan.syntax.SyntaxStringBuildError
      • jazzparser.taggers.loader.TaggerLoadError
      • jazzparser.taggers.TaggerTrainingError: For any problems encountered while training a tagging model.
      • jazzparser.taggers.models.TaggingModelError: For errors encountered while tagging using a model.
      • jazzparser.formalisms.base.semantics.temporal.TempralError
      • jazzparser.data.tonalspace.TonalSpaceAnalysisSetLoadError
      • jazzparser.data.trees.TreeBuildError
      • jazzparser.misc.tree.balancedseq.UnbalancedSequenceError
      • jazzparser.data.Fraction.ValueError
      • jazzparser.formalisms.base.syntax.VariableSubstitution.VariableSubstitutionError
      • jazzparser.utils.domxml.XmlReadError
  • jazzparser.harmonical.tones.BaseToneEvent: A single event in the tone matrix.
    • jazzparser.harmonical.tones.MultiSineToneEvent: Generates a tone by summing several sine waves (simple additive synthesis).
      • jazzparser.harmonical.tones.SineClusterEvent: Generates a tone by summing the notes of a tonal space cluster.
        • jazzparser.harmonical.tones.SineChordEvent: Generates a tone by summing the notes of a chord of a standard type.
    • jazzparser.harmonical.tones.SineToneEvent: A single event in the tone matrix.
  • jazzparser.misc.tree.datastructs.BaseTree: Base class for representing trees.
    • jazzparser.misc.tree.datastructs.ImmutableTree: Tree data structure.
    • jazzparser.misc.tree.datastructs.MutableTree: Normal mutable tree data structure.
  • jazzparser.utils.nltk.ngram.baumwelch.BaumWelchTrainer: Class with methods to retrain an HMM using the Baum-Welch EM algorithm.
    • jazzparser.misc.chordlabel.baumwelch.HPBaumWelchTrainer: Baum-Welch training for jazzparser.misc.chordlabel.HPChordLabeler models.
  • jazzparser.formalisms.base.syntax.Category: Parent class of categories (i.e.
    • jazzparser.formalisms.base.syntax.AtomicCategoryBase: Much of the implementation of an atomic category is left to subclasses, since this is where the most formalism-dependence is.
      • jazzparser.formalisms.music_halfspan.syntax.AtomicCategory: An atomic category is of the form A-B, where A and B are half categories.
    • jazzparser.formalisms.base.syntax.ComplexCategoryBase
      • jazzparser.formalisms.music_halfspan.syntax.ComplexCategory: In the halfspan formalism, complex categories are made up of an argument half category, a slash and a result half category.
    • jazzparser.formalisms.base.syntax.DummyCategoryBase: A category type with no combinatorial power at all.
      • jazzparser.formalisms.music_halfspan.syntax.DummyCategory: hash(x)
  • jazzparser.taggers.segmidi.chordclass.tagutils.CategoryProcessChart: CKY chart for the mini-parsing task we need to do to prepare the categories.
  • jazzparser.parsers.cky.chart.Chart: Represents a chart for use in CKY chart parsing.
    • jazzparser.parsers.pcfg.chart.PcfgChart: Overrides the CKY chart to add probabilistic stuff.
    • jazzparser.parsers.tagrank.chart.TagRankChart: Overrides the CKY chart to add probabilistic stuff.
  • jazzparser.data.db_mirrors.Chord: A single instance of a chord in a sequence.
  • jazzparser.data.Chord: A Chord object represents a single chord in an input sequence to the parser.
  • jazzparser.grammar.ChordClass: Representation of a chord class.
  • jazzparser.taggers.segmidi.chordclass.train.ChordClassBaumWelchTrainer: Class with methods to retrain a chordclass model using the Baum-Welch EM algorithm.
  • jazzparser.misc.chordlabel.data.ChordLabel: Representation of a chord label.
  • jazzparser.data.db_mirrors.ChordSequence: A chord sequence in the corpus.
  • jazzparser.misc.chordlabel.realize.ChordSequenceRealizer: Factory to take the output from the labeler and realize the chord sequence as a midi file.
  • jazzparser.harmonical.midi.chords.ChordSequenceRealizer: A factory class to produce a MIDI file (represented using the midi library package's EventStream)) from a sequence of tonal space roots and chord types.
  • jazzparser.misc.raphsto.midi.ChordSequenceRealizer: Factory to take the output from the labeller and realize the chord sequence as a midi file.
  • nltk.probability.ConditionalFreqDist: A collection of frequency distributions for a single experiment run under different conditions.
    • jazzparser.utils.nltk.probability.CutoffConditionalFreqDist: A version of ConditionalFreqDist that uses a CutoffFreqDist for each distribution instead of FreqDist.
  • nltk.probability.ConditionalProbDistI: A collection of probability distributions for a single experiment run under different conditions.
    • nltk.probability.ConditionalProbDist: A conditional probability distribution modelling the experiments that were used to generate a conditional frequency distribution.
    • nltk.probability.DictionaryConditionalProbDist: An alternative ConditionalProbDist that simply wraps a dictionary of ProbDists rather than creating these from FreqDists.
  • jazzparser.utils.config.ConfigFile: A really simple interface to options stored in config files.
  • jazzparser.data.db_mirrors.consistency.ConsistencyData: Data structure to store multiple annotations of the same chord sequences to evaluate annotator consistency.
  • jazzparser.data.corpora.temperley.DataSequence: Data structure to store a list of events read in from a corpus file.
  • jazzparser.data.dependencies.DependencyGraph: Data structure to represent dependency graphs.
  • jazzparser.data.DerivationTrace: Stores a trace of the derivation of a particular CCGCategory node and is associated with that category.
  • jazzparser.formalisms.base.semantics.distance.DistanceMetric: Base class for semantic distance metrics.
    • jazzparser.formalisms.music_halfspan.semantics.distance.DependencyGraphSize: This is a baseline metric that does nothing clever.
    • jazzparser.formalisms.base.semantics.distance.FScoreMetric: Metrics that compute their distance by f-score share a lot of processing.
      • jazzparser.formalisms.music_halfspan.semantics.distance.DependencyRecovery: Exact dependency recovery metric.
      • jazzparser.formalisms.music_halfspan.semantics.distance.LargestCommonEmbeddedSubtrees: Tonal space distance metric computed as the size of the largest subtree that can be embedded in the dependency graphs of two logical forms.
      • jazzparser.formalisms.music_halfspan.semantics.distance.OptimizedDependencyRecovery: Aligns the two dependency graphs in the way that optimizes their dependency recovery and reports that dependency recovery.
      • jazzparser.formalisms.music_halfspan.semantics.distance.TonalSpaceEditDistance: Original tonal space distance metric computed as the edit distance of the step vectors and functions of the path through the tonal space implied by the semantics.
    • jazzparser.formalisms.music_halfspan.semantics.distance.RandomDistance: Returns a distance by picking a random number.
  • jazzparser.grammar.EntriesItem
  • jazzparser.grammar.EquivalenceEntry: Like a MorphItem.
  • jazzparser.data.corpora.temperley.Event: Superclass of all events that occur in the data.
    • jazzparser.data.corpora.temperley.BeatEvent: A beat identifier, giving a time of occurrence and a beat level.
    • jazzparser.data.corpora.temperley.ChordEvent: A chord, identified just by its start time, end time and root.
    • jazzparser.data.corpora.temperley.TPCNoteEvent: Tonal pitch-class note, found in TPC files and chord files.
  • midi.Event: Base class for all MIDI events.
    • midi.AfterTouchEvent: Changes the pressure of aftertouch on a note.
    • midi.ChannelAfterTouchEvent: Channel pressure (after-touch).
    • midi.ControlChangeEvent: Sets the value of one of the 128 controllers available to a device.
    • midi.MetaEvent: MetaEvent is a special subclass of Event that is not meant to be used as a concrete class.
      • midi.BeatMarkerEvent
      • midi.ChannelPrefixEvent: Associates a MIDI channel with following meta events.
      • midi.CopyrightEvent: Defines copyright information including the copyright symbol (0xA9), year and author.
      • midi.CuePointEvent: Marks the start of some type of new sound or action.
      • midi.EndOfTrackEvent: Appears and the end of each track to mark the end.
      • midi.InstrumentNameEvent: Defines the name of an instrument being used in the current track chunk.
      • midi.KeySignatureEvent: Sets the key signature, made up of a number of sharps/flats and either major or minor.
      • midi.LyricsEvent: Defines the lyrics in a song and usually used to define a syllable or group of works per quarter note.
      • midi.MarkerEvent: Marks a significant point in time for the sequence.
      • midi.PortEvent: Specifies which MIDI port should be used to output all subsequent events.
      • midi.SequenceNumberEvent: Defines the pattern number of a Type 2 MIDI file or the number of a sequence in a Type 0 or Type 1 MIDI file.
      • midi.SequencerSpecificEvent: Specifies information specific to a hardware or software sequencer.
      • midi.SetTempoEvent: Change the tempo of events played after this point.
      • midi.SmpteOffsetEvent: Designates the SMPTE start time (hours, minutes, secs, frames, subframes) of the track.
      • midi.TextEvent: Defines some text which can be used for any reason including track notes, comments.
      • midi.TimeSignatureEvent: Expressed as 4 numbers: <numerator> <denominator> <metronome> <thirtyseconds>.
      • midi.TrackLoopEvent
      • midi.TrackNameEvent: Defines the name of a sequence when in a Type 0 or Type 2 MIDI file or in the first track of a Type 1 MIDI file.
      • midi.UnknownEvent
    • midi.NoteEvent: Abstract base class for NoteOnEvent and NoteOffEvent.
      • midi.NoteOffEvent: Note-off event.
      • midi.NoteOnEvent: Note-on event.
    • midi.PitchWheelEvent: Change the pitch-bend wheel value.
    • midi.ProgramChangeEvent: Changes the patch (voice) number of the instrument.
    • midi.SysExEvent: System exclusive MIDI event.
  • midi.EventFactory: EventFactory is a factory for getting MIDI events out of a data stream.
  • midi.EventStream: Class used to describe a collection of MIDI events, organized into tracks.
  • midi.EventStreamIterator
  • midi.EventStreamReader: Reads MIDI data in from an input stream, probably a file, and produces an EventStream to represent it internally.
  • midi.slice.EventStreamSlice: Represents a portion of a midi stream (an EventStream).
  • midi.EventStreamWriter: Takes care of writing MIDI data from an EventStream to an output stream, such as a file.
  • jazzparser.utils.base.ExecutionTimer: Very simple class to wrap up a common method for measuring the execution time of some code.
  • jazzparser.grammar.Family: A lexical family.
  • logging.Filterer: A base class for loggers and handlers which allows them to share common code.
    • logging.Handler: Handler instances dispatch logging events to specific destinations.
      • jazzparser.utils.loggers.NullHandler: A handler that drops all the logs.
  • jazzparser.formalisms.FormalismBase: Superclass of all Formalism structures.
    • jazzparser.formalisms.music_halfspan.Formalism
  • jazzparser.data.Fraction: Stores a rational fraction as a numerator and denominator.
  • gobject.GInterface: Interface GInterface
    • gtk.Buildable
      • gtk.Widget: Object GtkWidget
        • gtk.Container: Object GtkContainer
          • gtk.Bin: Object GtkBin
            • gtk.EventBox: Object GtkEventBox
              • jazzparser.harmonical.tsgui.TonalSpaceCell: Widget to draw a single point in the tonal space.
            • gtk.Window: Object GtkWindow
              • jazzparser.parsers.cky.inspector.CellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.pcfg.inspector.PcfgCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.tagrank.inspector.TagRankCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
              • jazzparser.parsers.cky.inspector.ChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.pcfg.inspector.PcfgChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.tagrank.inspector.TagRankChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
              • jazzparser.parsers.cky.inspector.DerivationTraceWindow: Simple window to spew out a derivation trace for a sign in the chart.
              • jazzparser.gui.windows.GraphicalJazzParserWindow: Main top-level interface window.
              • jazzparser.gui.windows.ModuleOptionsWindow: Generic editing window for module options.
              • jazzparser.harmonical.tsgui.TonalSpaceWindow: A window that displays an interactive tonal space.
                • jazzparser.harmonical.tstuner.TonalSpaceRetunerWindow
    • atk.ImplementorIface
      • gtk.Widget: Object GtkWidget
        • gtk.Container: Object GtkContainer
          • gtk.Bin: Object GtkBin
            • gtk.EventBox: Object GtkEventBox
              • jazzparser.harmonical.tsgui.TonalSpaceCell: Widget to draw a single point in the tonal space.
            • gtk.Window: Object GtkWindow
              • jazzparser.parsers.cky.inspector.CellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.pcfg.inspector.PcfgCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.tagrank.inspector.TagRankCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
              • jazzparser.parsers.cky.inspector.ChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.pcfg.inspector.PcfgChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.tagrank.inspector.TagRankChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
              • jazzparser.parsers.cky.inspector.DerivationTraceWindow: Simple window to spew out a derivation trace for a sign in the chart.
              • jazzparser.gui.windows.GraphicalJazzParserWindow: Main top-level interface window.
              • jazzparser.gui.windows.ModuleOptionsWindow: Generic editing window for module options.
              • jazzparser.harmonical.tsgui.TonalSpaceWindow: A window that displays an interactive tonal space.
                • jazzparser.harmonical.tstuner.TonalSpaceRetunerWindow
  • unreachable.GObject: Object GObject
    • gtk.Object: Object GtkObject
      • gtk.Widget: Object GtkWidget
        • gtk.Container: Object GtkContainer
          • gtk.Bin: Object GtkBin
            • gtk.EventBox: Object GtkEventBox
              • jazzparser.harmonical.tsgui.TonalSpaceCell: Widget to draw a single point in the tonal space.
            • gtk.Window: Object GtkWindow
              • jazzparser.parsers.cky.inspector.CellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.pcfg.inspector.PcfgCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
                • jazzparser.parsers.tagrank.inspector.TagRankCellInspectorWindow: A small window that gives more information about a particular cell in the chart.
              • jazzparser.parsers.cky.inspector.ChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.pcfg.inspector.PcfgChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
                • jazzparser.parsers.tagrank.inspector.TagRankChartInspectorWindow: A window that displays a summary of the chart and allows inspection of it in greater detail.
              • jazzparser.parsers.cky.inspector.DerivationTraceWindow: Simple window to spew out a derivation trace for a sign in the chart.
              • jazzparser.gui.windows.GraphicalJazzParserWindow: Main top-level interface window.
              • jazzparser.gui.windows.ModuleOptionsWindow: Generic editing window for module options.
              • jazzparser.harmonical.tsgui.TonalSpaceWindow: A window that displays an interactive tonal space.
                • jazzparser.harmonical.tstuner.TonalSpaceRetunerWindow
  • jazzparser.data.trees.GeneralizedCategory: Partially represents a CCG category in a simple way.
    • jazzparser.data.trees.AtomicCategory
    • jazzparser.data.trees.SlashCategory
    • jazzparser.data.trees.UnknownCategory: The categories of some chords are unknown and not specified in the annotation.
  • jazzparser.grammar.Grammar: Represents a grammar read in from an XML grammar file.
  • jazzparser.formalisms.music_halfspan.syntax.HalfCategory: One half of an atomic category, or the argument or result of a complex category.
  • jazzparser.harmonical.input.HarmonicalInputFile: Base class for input files to the harmonical.
    • jazzparser.harmonical.input.ChordDictionaryFile: Rather like the ChordInputFile format, but specifies a list of chords with names.
    • jazzparser.harmonical.input.ChordInputFile: Type of harmonical input file that simply specifies a list of chords, with durations, defined by a list of tonal space points.
  • jazzparser.data.HashSet: A simple implementation of a hash table using a dictionary.
    • jazzparser.parsers.cky.chart.SignHashSet: Based on the basic hash set implementation.
      • jazzparser.parsers.pcfg.chart.ProbabilisticSignHashSet: For this chart's internal data structure, we use a modified implementation of the HashSet which adds handling of probabilities.
      • jazzparser.parsers.tagrank.chart.TagProbabilitySignHashSet: For this chart's internal data structure, we use a modified implementation of the HashSet which adds some basic handling of the tag probabilities that came from the tagger's model.
  • nltk.tag.hmm.HiddenMarkovModelTrainer: Algorithms for learning HMM parameters from training data.
    • jazzparser.utils.nltk.hmm.PicklableHmmTrainer: We override HiddenMarkovModelTrainer to overcome the fact that it produces HMMs that can't be pickled.
  • jazzparser.data.input.InputReader: Superclass for all sorts of input.
    • jazzparser.data.input.BulkInput: Ways of accepting multiple inputs at once.
      • jazzparser.data.input.ChordBulkInput: A file containing a list of textual chord sequences.
      • jazzparser.data.input.DbBulkInput: A file containing a list of chord sequences.
        • jazzparser.data.input.AnnotatedDbBulkInput: Like DbBulkInput, but for AnnotatedDbInput.
      • jazzparser.data.input.SegmentedMidiBulkInput: A CSV file containing midi file paths and the parameters for segmenting each one.
        • jazzparser.data.input.MidiTaggerTrainingBulkInput: Subclass of SegmentedMidiBulkInput for taking training input for midi supertaggers.
    • jazzparser.data.input.Input: Superclass for different types of input wrapper.
      • jazzparser.data.input.ChordInput: Input wrapper for textual chord input.
      • jazzparser.data.input.DbInput: Wrapper for input from the database, rather than the command line.
        • jazzparser.data.input.AnnotatedDbInput: Like DbInput, but stores category annotations along with the chords.
      • jazzparser.data.input.SegmentedMidiInput: Input wrapper for MIDI files with extra information about segmentation, in the form it's needed for the Raphael and Stoddard model and midi supertagging models: that is, offset (start of first bar) and bar length.
      • jazzparser.data.input.WeightedChordLabelInput: Input wrapper for a lattice of chord labels, including a set of chord labels for each timestep, each with a probability.
  • jazzparser.misc.raphsto.midi.InputSourceFile: File reader to get midi input files listed in a single file format.
  • jazzparser.formalisms.base.semantics.lambdacalc.LogicalForm: A semantic element, used to build the semantic interpretations returned by the parser.
    • jazzparser.formalisms.music_halfspan.semantics.CoordinateList: Just a list of enharmonic coordinates, forming a tonal space path.
    • jazzparser.formalisms.music_halfspan.semantics.Coordination: Special operator to represent coordination.
    • jazzparser.formalisms.base.semantics.lambdacalc.DummyLogicalForm: A logical form that doesn't really represent anything, but implements the full interface of LogicalForm.
      • jazzparser.formalisms.music_halfspan.semantics.DummyLogicalForm
    • jazzparser.formalisms.base.semantics.lambdacalc.FunctionApplication: A function application in a semantic expression.
      • jazzparser.formalisms.music_halfspan.semantics.FunctionApplication: Standard application implementation overridden to add time processing.
    • jazzparser.formalisms.base.semantics.lambdacalc.LambdaAbstraction: A type of complex logical form element corresponding to a lambda abstraction.
      • jazzparser.formalisms.music_halfspan.semantics.LambdaAbstraction: Standard abstraction implementation overridden to add time processing.
    • jazzparser.formalisms.music_halfspan.semantics.List: The Path or List data structure.
    • jazzparser.formalisms.music_halfspan.semantics.ListCat: Represents the concatenation of multiple Lists.
    • jazzparser.formalisms.base.semantics.lambdacalc.Terminal: Base class for any logical forms that are atomic: have no children.
      • jazzparser.formalisms.music_halfspan.semantics.EnharmonicCoordinate: A four-dimensional coordinate.
        • jazzparser.formalisms.music_halfspan.semantics.PathCoordinate: Simple subclass of EnharmonicCoordinate to store points on a path directly.
      • jazzparser.formalisms.music_halfspan.semantics.GhostCoordinate: Wrapper that stores an EnharmonicCoordinate.
      • jazzparser.formalisms.music_halfspan.semantics.LexicalCoordinate: When a logical form is read in from the lexicon, coordinates must be specified relative to the root of the chord.
      • jazzparser.formalisms.base.semantics.lambdacalc.Literal: Represents any literal that is used in a semantic expression.
        • jazzparser.formalisms.music_halfspan.semantics.Predicate: Superclass of literal predicates (such as leftonto).
          • jazzparser.formalisms.music_halfspan.semantics.Leftonto: A leftonto predicate literal.
          • jazzparser.formalisms.music_halfspan.semantics.Now: A special predicate that doesn't change its argument at all, except to set its start time to be no later than the start time associated with the predicate.
          • jazzparser.formalisms.music_halfspan.semantics.Rightonto: A rightonto predicate literal, analagous to Leftonto.
    • jazzparser.formalisms.base.semantics.lambdacalc.Variable: A variable in a semantic expression.
      • jazzparser.formalisms.music_halfspan.semantics.Variable: Standard variable implementation overridden to add time processing.
  • jazzparser.grammar.MacroItem: Not yet implemented.
  • jazzparser.misc.raphsto.midi.MidiHandler: Class to encapsulate all the midi processing needed for getting input to a Raphsto model.
  • jazzparser.formalisms.base.modalities.ModalAtomicCategory
    • jazzparser.formalisms.music_halfspan.syntax.AtomicCategory: An atomic category is of the form A-B, where A and B are half categories.
  • jazzparser.formalisms.base.modalities.ModalComplexCategory
    • jazzparser.formalisms.music_halfspan.syntax.ComplexCategory: In the halfspan formalism, complex categories are made up of an argument half category, a slash and a result half category.
  • jazzparser.formalisms.base.modalities.ModalSlash: A CCG slash class that wants modalities should inherit (first) from the base Slash (or some subclass) and also from this, to add the modality functionality.
    • jazzparser.formalisms.music_halfspan.syntax.Slash
  • jazzparser.formalisms.base.modalities.ModalityTree: The tree is a DAG which defines a hierarchy of categories.
  • jazzparser.formalisms.base.modalities.ModalityTreeNode: A node in the modality tree.
  • jazzparser.utils.options.ModuleOption: An option that can be specified on the command line and that is specific to a certain modular component (e.g.
  • jazzparser.grammar.MorphItem: A morphological item - a word.
  • jazzparser.utils.nltk.ngram.model.NgramModel: A general n-gram model, trained on some labelled data.
    • jazzparser.taggers.segmidi.chordclass.hmm.ChordClassHmm: Hidden Markov Model based on the model described in the paper.
    • jazzparser.utils.nltk.ngram.dictionary.DictionaryHmmModel: Like an NgramModel, but (a) restricted to be an HMM (order 2 and no backoff) and (b) uses dictionary distributions, rather than distributions generated from counts.
      • jazzparser.misc.chordlabel.hmm.HPChordLabeler: HMM based on that of Harmony Progression Analyzer for MIREX 2011, by Ni, Mcvicar, Santos-Rodriguez, De Bie.
    • jazzparser.backoff.ngram.hmmpath.HmmPathNgram: An ngram model that takes multiple chords (weighted by probability) as input to its decoding.
    • jazzparser.taggers.ngram_multi.model.MultiChordNgramModel: An ngram model that takes multiple chords (weighted by probability) as input to its decoding.
    • jazzparser.utils.nltk.ngram.model.PrecomputedNgramModel: Overrides parts of NgramModel to provide exactly the same interface, but stores the precomputed transition matrix and uses this to provide transition probabilities.
    • jazzparser.misc.raphsto.RaphstoHmm: Hidden Markov Model that implements the model described in the paper.
      • jazzparser.misc.raphsto.RaphstoHmmFourChord: Like RaphstoHmmThreeChord, but also allows a minor secondary dominant chord (II).
      • jazzparser.misc.raphsto.RaphstoHmmThreeChord: Modification of the Raphsto algorithm that allows it only to assign one of three chords: I, IV and V.
      • jazzparser.misc.raphsto.RaphstoHmmUnigram: Like RaphstoHmm, but always gives all state transitions equal probability, so that it is effectively a unigram model.
  • jazzparser.misc.tree.datastructs.Node: Node of a tree.
  • jazzparser.utils.nltk.storage.ObjectStorer: Interface for various storers that take certain types of objects and produce a dictionary with the essential data needed to recreate them.
    • jazzparser.utils.nltk.storage.ConditionalFreqDistStorer
    • jazzparser.utils.nltk.storage.ConditionalProbDistStorer
    • jazzparser.utils.nltk.probability.CutoffConditionalFreqDistStorer
    • jazzparser.utils.nltk.probability.CutoffFreqDistStorer
    • jazzparser.utils.nltk.storage.DictionaryConditionalProbDistStorer
    • jazzparser.utils.nltk.storage.DictionaryProbDistStorer
      • jazzparser.utils.nltk.storage.MutableProbDistStorer
    • jazzparser.utils.nltk.storage.FreqDistStorer
    • jazzparser.utils.nltk.storage.GoodTuringProbDistStorer
    • jazzparser.utils.nltk.hmm.HiddenMarkovModelTaggerStorer
    • jazzparser.utils.nltk.storage.LaplaceProbDistStorer
    • jazzparser.utils.nltk.storage.MLEProbDistStorer
    • jazzparser.utils.nltk.storage.WittenBellProbDistStorer
  • jazzparser.data.parsing.ParseResults: A simple wrapper object to store the results of a parse, plus the gold standard result, so that they can easily be dumped out to a file using pickle.
  • jazzparser.parsers.base.parser.Parser: Base class for all parsers.
    • jazzparser.parsers.cky.parser.CkyParser: CkyParser is the central class for the jazz chord sequence recogniser parsing mechanism.
      • jazzparser.parsers.fail.parser.FailParser: A dummy parser that never does any actual parsing.
      • jazzparser.parsers.pcfg.parser.PcfgParser
      • jazzparser.parsers.tagrank.parser.TagRankParser
    • jazzparser.parsers.cky.parser.DirectedCkyParser: DirectedCkyParser is a special version of the CKY parser that tries to produce a parse according to a pre-built derivation tree.
  • jazzparser.parsers.pcfg.model.PcfgModel: A trainable model used by a pcfg parser.
    • jazzparser.formalisms.music_halfspan.pcfg.HalfspanPcfgModel: A simple implementation of the PcfgModel interface.
  • jazzparser.formalisms.music_halfspan.Formalism.PcfgParser: Formalism interface for the PcfgParser parser module.
  • nltk.probability.ProbDistI: A probability distribution for the outcomes of an experiment.
    • nltk.probability.DictionaryProbDist: A probability distribution whose probabilities are directly specified by a given dictionary.
    • nltk.probability.GoodTuringProbDist: The Good-Turing estimate of a probability distribution.
    • nltk.probability.LidstoneProbDist: The Lidstone estimate for the probability distribution of the experiment used to generate a frequency distribution.
      • nltk.probability.LaplaceProbDist: The Laplace estimate for the probability distribution of the experiment used to generate a frequency distribution.
    • nltk.probability.MLEProbDist: The maximum likelihood estimate for the probability distribution of the experiment used to generate a frequency distribution.
    • nltk.probability.MutableProbDist: An mutable probdist where the probabilities may be easily modified.
    • nltk.probability.WittenBellProbDist: The Witten-Bell estimate of a probability distribution.
      • jazzparser.utils.nltk.probability.WittenBellProbDistFix: There's a nasty bug in WittenBellProbDist, but the fix is very simple.
  • jazzparser.misc.raphsto.train.RaphstoBaumWelchTrainer: Class with methods to retrain a Raphsto model using the Baum-Welch EM algorithm.
    • jazzparser.misc.raphsto.train.RaphstoBaumWelchUnigramTrainer: Class with methods to retrain a Raphsto model using the Baum-Welch EM algorithm.
  • midi.sequencer_pygame.RealtimeSequencer: Sends realtime midi events to midi devices through Pygame.
  • jazzparser.utils.multiproc.Result
  • jazzparser.formalisms.base.rules.Rule
    • jazzparser.formalisms.base.rules.ApplicationRuleBase: Rule for standard CCG application.
      • jazzparser.formalisms.music_halfspan.rules.ApplicationRule
    • jazzparser.formalisms.music_halfspan.rules.CadenceRepetitionRule: A special unary rule for expanding the lexicon to add dominant or subdominant repetition categories for all the substitutions, generated from the cadential categories already in the lexicon.
    • jazzparser.formalisms.base.rules.CompositionRuleBase: Rule for standard CCG composition.
      • jazzparser.formalisms.music_halfspan.rules.CompositionRule
    • jazzparser.formalisms.music_halfspan.rules.CoordinationRule: The coordination rule allows partial cadences to combine and share a resolution.
    • jazzparser.formalisms.music_halfspan.rules.DevelopmentRule: The development rule strings together sequences of resolved cadences.
    • jazzparser.formalisms.music_halfspan.rules.TonicRepetitionRule: A special unary rule for expanding the lexicon to add tonic repetition categories, generated from the tonic categories already in the lexicon.
  • jazzparser.formalisms.base.semantics.lambdacalc.Semantics: This acts as the root node in the LF's tree structure.
    • jazzparser.formalisms.music_halfspan.semantics.Semantics: hash(x)
  • jazzparser.data.db_mirrors.SequenceIndex: Stores indexes and provides quick access to mirrored sequences.
  • jazzparser.data.midi.SequenceMidiAlignment: Specification of parameters to align a chord sequence with a MIDI file.
  • midi.sequencer_portmidi.Sequencer: Midi sequencer that sends midi events to system midi devices using PyGame's interface to Portmidi.
  • midi.sequencer_pygame.Sequencer: Midi sequencer that outputs midi to a temporary file and plays it using PyGame's interface to the SDL mixer.
  • jazzparser.shell.shell.ShellState: Class to wrap up the various bits of state that need to be stored in the shell and that may be manipulated by tools.
  • jazzparser.formalisms.base.syntax.SignBase: A CCG category and its associated semantics: a CCG sign.
    • jazzparser.formalisms.music_halfspan.syntax.Sign: A CCG category and its associated semantics: a CCG sign.
  • jazzparser.data.db_mirrors.semantics.SimpleSemantics: A simple logical form that allows no lambda calculus or functional operations at all.
  • jazzparser.formalisms.base.syntax.SlashBase
    • jazzparser.formalisms.music_halfspan.syntax.Slash
  • jazzparser.harmonical.files.SoundFile: A wave file to store uncompressed audio signal data.
  • jazzparser.parsers.base.utils.SpanCombiner: For various purposes, we want to combine adjacent identical spanning edges into one before adding them to the chart.
  • jazzparser.data.trees.StackMarker: Special type to place markers among the categories in the stack.
    • jazzparser.data.trees.CoordinationMiddleMarker: Marks the end of the first part of a coordination.
  • jazzparser.data.trees.SyntacticTreeNode: Superclass of nodes in syntactic trees.
    • jazzparser.data.trees.SyntacticNonTerminal: An internal node in a syntactic tree.
    • jazzparser.data.trees.SyntacticTerminal: A terminal node (leaf) in a syntactic tree.
  • jazzparser.data.trees.SyntacticTreeRoot: The root of a syntactic tree.
  • jazzparser.taggers.tagger.Tagger: The superclass of all taggers.
    • jazzparser.taggers.segmidi.chordlabel.tagger.ChordLabelNgramTagger: Tagger that loads a chord labeling model to assign chord labels to MIDI data, then hands over to a chord supertagger to process the output of the labeler.
    • jazzparser.taggers.fail.tagger.FailTagger: The input doesn't matter.
    • jazzparser.taggers.full.tagger.FullTagger: The input to this should just be a string.
    • jazzparser.taggers.models.ModelTagger: Base class for corpus-trained supertagging models.
      • jazzparser.taggers.baseline1.tagger.Baseline1Tagger: The first of the simple baseline tagger models.
      • jazzparser.taggers.baseline2.tagger.Baseline2Tagger: The second of the simple baseline tagger models.
      • jazzparser.taggers.baseline3.tagger.Baseline3Tagger: The second of the simple baseline tagger models.
      • jazzparser.taggers.candc.tagger.CandcTagger: Superclass of both kinds of C&C tagger.
        • jazzparser.taggers.candc.tagger.CandcBestTagger: Uses the C&C supertagger component to get the best tag for each word.
        • jazzparser.taggers.candc.tagger.CandcMultiTagger: Uses the C&C supertagger component to get multiple tags for each word.
      • jazzparser.taggers.ngram_multi.tagger.MultiChordNgramTagger
      • jazzparser.taggers.ngram.tagger.NgramTagger
      • jazzparser.taggers.segmidi.base.SegmidiTagger: Base class for segmented MIDI taggers.
        • jazzparser.taggers.segmidi.chordclass.ChordClassMidiTagger
    • jazzparser.taggers.pretagged.tagger.PretaggedTagger: The input doesn't matter.
  • nltk.tag.api.TaggerI: A processing interface for assigning a tag to each token in a list.
    • nltk.tag.hmm.HiddenMarkovModelTagger: Hidden Markov model class, a generative model for labelling sequence data.
  • jazzparser.taggers.models.TaggerModel: A trainable model used by a ModelTagger.
    • jazzparser.backoff.base.BackoffModel: A model to be used by a BackoffBuilder.
      • jazzparser.backoff.ngram.hmmpath.HmmPathModel: Model type that uses an ngram model to assign a tonal space path to a sequence.
    • jazzparser.taggers.baseline1.tagger.Baseline1Model: A class to encapsulate the model data for the tagger.
    • jazzparser.taggers.baseline2.tagger.Baseline2Model: A class to encapsulate the model data for the tagger.
    • jazzparser.taggers.baseline3.tagger.Baseline3Model: A class to encapsulate the model data for the tagger.
    • jazzparser.taggers.candc.tagger.CandcTaggerModel: This is really a fake: it doesn't actually save models itself, since we hand over to the C&C tagger to do that.
    • jazzparser.taggers.segmidi.chordclass.ChordClassTaggerModel: Model class to go with ChordClassMidiTagger.
    • jazzparser.taggers.ngram_multi.tagger.MultiChordNgramTaggerModel: hash(x)
    • jazzparser.taggers.ngram.tagger.NgramTaggerModel: hash(x)
  • jazzparser.taggers.pretagged.tagger.TagsFile: A file format for storing a list of tags, potentially multiple tag lists.
  • jazzparser.formalisms.base.semantics.temporal.Temporal: Adds temporal information to a logical form.
    • jazzparser.formalisms.music_halfspan.semantics.CoordinateList: Just a list of enharmonic coordinates, forming a tonal space path.
    • jazzparser.formalisms.music_halfspan.semantics.Coordination: Special operator to represent coordination.
    • jazzparser.formalisms.music_halfspan.semantics.DummyLogicalForm
    • jazzparser.formalisms.music_halfspan.semantics.EnharmonicCoordinate: A four-dimensional coordinate.
      • jazzparser.formalisms.music_halfspan.semantics.PathCoordinate: Simple subclass of EnharmonicCoordinate to store points on a path directly.
    • jazzparser.formalisms.music_halfspan.semantics.FunctionApplication: Standard application implementation overridden to add time processing.
    • jazzparser.formalisms.music_halfspan.semantics.GhostCoordinate: Wrapper that stores an EnharmonicCoordinate.
    • jazzparser.formalisms.music_halfspan.semantics.LambdaAbstraction: Standard abstraction implementation overridden to add time processing.
    • jazzparser.formalisms.music_halfspan.semantics.LexicalCoordinate: When a logical form is read in from the lexicon, coordinates must be specified relative to the root of the chord.
    • jazzparser.formalisms.music_halfspan.semantics.List: The Path or List data structure.
    • jazzparser.formalisms.music_halfspan.semantics.ListCat: Represents the concatenation of multiple Lists.
    • jazzparser.formalisms.music_halfspan.semantics.Predicate: Superclass of literal predicates (such as leftonto).
      • jazzparser.formalisms.music_halfspan.semantics.Leftonto: A leftonto predicate literal.
      • jazzparser.formalisms.music_halfspan.semantics.Now: A special predicate that doesn't change its argument at all, except to set its start time to be no later than the start time associated with the predicate.
      • jazzparser.formalisms.music_halfspan.semantics.Rightonto: A rightonto predicate literal, analagous to Leftonto.
    • jazzparser.formalisms.music_halfspan.semantics.Variable: Standard variable implementation overridden to add time processing.
  • jazzparser.formalisms.base.semantics.temporal.TemporalSemantics: Adds temporal semantics to the Semantics root class.
    • jazzparser.formalisms.music_halfspan.semantics.Semantics: hash(x)
  • unittest.case.TestCase: A class whose instances are single test cases.
    • jptests.formalisms.music_halfspan.rules.TestApplication: Tests for the application rule.
    • jptests.data.init.TestChord: Tests for the various ways of creating instances of Chord.
    • jptests.data.input.TestChordBulkInput: Tests for loading a ChordBulkInput (text chord sequences).
    • jptests.data.input.TestChordInput: Test for loading a ChordInput.
    • jptests.formalisms.music_halfspan.rules.TestComposition: Tests for the composition rule.
    • jptests.formalisms.music_halfspan.semantics.TestCoordination: Tests for use of semantic coordination.
    • jptests.formalisms.music_halfspan.rules.TestCoordination: Tests for the coordination rule.
    • jptests.data.input.TestDbBulkInput: Test for loading a DbBulkInput.
    • jptests.data.input.TestDbInput: Tests for loading a DbInput.
    • jptests.data.init.TestDerivationTraceHalfspan: A derivation trace is quite a simple data structure.
    • jptests.formalisms.music_halfspan.rules.TestDevelopment: Tests for the development rule.
    • jptests.formalisms.music_halfspan.semantics.TestEnharmonicCoordinate: Tests for certain bits of jazzparser.formalisms.music_halfspan.semantics.EnharmonicCoordinate.
    • jptests.data.init.TestFraction: Tests for jazzparser.data.Fraction.
    • jptests.grammar.TestGrammar
    • jptests.formalisms.music_halfspan.semantics.TestLfToCoordinates: Tests for producing a tonal space path from a logical form.
    • jptests.formalisms.music_halfspan.backoff.TestLfToStates: Tests for building LFs from a list of state labels and vice versa.
    • jptests.misc.tree.datastructs.TestMutableTree
    • jptests.misc.tree.datastructs.TestNode
    • jptests.formalisms.music_halfspan.semantics.TestPredicates: Tests for creating and reducing the predicates.
    • jptests.data.input.TestSegmentedMidiBulkInput: Tests for loading a list of MIDI files from a CSV.
    • jptests.data.input.TestSegmentedMidiInput: Test for loading a SegmentedMidiInput from a MIDI file.
    • jptests.formalisms.music_halfspan.semantics.TestSemantics: General tests for the semantics module.
    • jptests.formalisms.music_halfspan.semantics.TestStringBuilder: Tests for building LFs using semantics_from_string.
    • jptests.formalisms.music_halfspan.syntax.TestStringBuilder: Tests for building categories using syntax_from_string.
    • jptests.utils.nltk.ngram.baumwelch.TestTrain
    • jptests.formalisms.music_halfspan.harmstruct.TestTreeBuilder: Tests for building trees from semantics using semantics_to_dependency_trees.
    • jptests.data.input.TestTypeLists: Some sanity checks on the type lists.
    • jptests.data.input.TestUtilities: Tests the utility functions.
  • jazzparser.data.tonalspace.TonalSpaceAnalysisSet: Data structure to hold and store a set of tonal space analyses.
  • jazzparser.harmonical.tones.ToneMatrix: A timesheet of tones, with pitches, onset times and durations, designed for specifying input to the tone generator.
  • jazzparser.shell.tools.Tool: Base class for interactive shell tools.
    • jazzparser.shell.tools.AtomsOnlyTool: Removes all complex categories from the results list.
    • jazzparser.parsers.cky.tools.ChartTool: Tool for examining the chart's contents.
    • jazzparser.taggers.segmidi.chordlabel.tools.ChordLabelTool
    • jazzparser.shell.tools.DerivationTraceExplorerTool: Shell tool for exploring large derivation traces in more detail.
    • jazzparser.shell.tools.DerivationTraceTool: Shell tool for outputing derivation traces.
    • jazzparser.shell.tools.HelpTool: Display shell help.
    • jazzparser.data.input.tools.InputTool
    • jazzparser.parsers.cky.tools.InteractiveChartTool: Tool for examining the chart's contents.
    • jazzparser.formalisms.music_halfspan.songtools.ListSongsTool
    • jazzparser.formalisms.music_halfspan.songtools.LoadCorpusTool: Tool to load a corpus of tonal space analyses of songs.
    • jazzparser.shell.gstools.LoadGoldStandardTool: Load an annotated chord sequence file.
    • jazzparser.shell.tools.LoadResultsTool
    • jazzparser.shell.tools.LogLevelTool: Change the log level from the shell.
    • jazzparser.shell.gstools.MarkCorrectTool
    • jazzparser.data.input.tools.PlayBulkMidiChunksTool
    • jazzparser.data.input.tools.PlayMidiChunksTool
    • jazzparser.formalisms.music_halfspan.songtools.PrintAnalysisTool
    • jazzparser.data.input.tools.PrintMidiChunksTool
    • jazzparser.parsers.pcfg.tools.ProbabilisticChartTool: Outputs an arc from the chart, ranked by probability
    • jazzparser.parsers.pcfg.tools.ProbabilisticDerivationTraceTool: Outputs an arc from the chart, ranked by probability
    • jazzparser.parsers.pcfg.tools.ProbabilisticResultListTool: Prints out a particular range of results, or the whole list.
    • jazzparser.parsers.pcfg.tools.ProbabilityTool: Outputs the probability of a sign.
    • jazzparser.shell.tools.PythonTool: Excecutes arbitrary python commands.
    • jazzparser.formalisms.music_halfspan.songtools.RecogniseSongTool
    • jazzparser.shell.tools.ResultListTool: Prints out a particular range of results, or the whole list.
    • jazzparser.formalisms.music_halfspan.songtools.ResultSongDependencyRecoveryTool
    • jazzparser.formalisms.music_halfspan.songtools.ResultSongTSEditDistanceTool
    • jazzparser.shell.tools.RuleApplicationTool: Manually applies a named rule to signs in the chart.
    • jazzparser.shell.tools.SaveStateTool
    • jazzparser.formalisms.music_halfspan.songtools.SongDependencyGraphTool: Converts a song's semantics to a tree.
    • jazzparser.formalisms.music_halfspan.songtools.SongSelfSimilarityTool: For fooling around with comparing songs to themselves to see what happens.
    • jazzparser.formalisms.music_halfspan.songtools.SongTreeTool: Converts a song's semantics to a tree.
    • jazzparser.taggers.segmidi.chordclass.tools.StateGridTool
    • jazzparser.formalisms.base.semantics.timetools.TimeOutputTool: Toggles full time output.
    • jazzparser.shell.tools.TonalSpaceCoordinatesTool
  • jazzparser.data.db_mirrors.TreeInfo: Additional information about a chord that allows an unambiguous derivation tree to be built.
  • jazzparser.utils.csv.UTF8Recoder: Iterator that reads an encoded stream and reencodes the input to UTF-8.
  • jazzparser.utils.csv.UnicodeCsvReader: A CSV reader which will iterate over lines in the CSV file "f", which is encoded in the given encoding.
  • jazzparser.utils.csv.UnicodeCsvWriter: A CSV writer which will write rows to CSV file "f", which is encoded in the given encoding.
  • jazzparser.formalisms.base.syntax.UnificationResultBase: Class for the object returned as the result of unification.
    • jazzparser.formalisms.music_halfspan.syntax.UnificationResult: Dummy unification results which allows us to use the unification formalism without actually unifying any variables.
  • jazzparser.utils.options.UnprocessedOptionValue: Simple wrapper for strings to mark that they haven't yet been processed as option values.
  • jazzparser.formalisms.base.syntax.VariableSubstitutor: An instance of VariableSubstitutor defines a type of variable forming a component of categories.
  • threading._Verbose
    • threading.Thread
      • jazzparser.parsers.cky.inspector.ChartInspectorThread: A thread to display a window at the same time as parsing is going on.
        • jazzparser.parsers.pcfg.inspector.PcfgChartInspectorThread
        • jazzparser.parsers.tagrank.inspector.TagRankChartInspectorThread
      • midi.sequencer_pygame.MusicEndWaiter: Sets an endevent on the PyGame mixer so that it gets notified when the music comes to an end.
      • midi.sequencer_portmidi.SequencerThread
  • dict: dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list.
    • jazzparser.data.assignments.EquivalenceAssignment: A special kind of dict that stores not only a mapping from keys to values, but also equivalence classes of keys.
    • jazzparser.grammar.EquivalenceMap: A mapping from some of the morph entries to others via a root change.
    • nltk.probability.FreqDist: A frequency distribution for the outcomes of an experiment.
      • jazzparser.utils.nltk.probability.CutoffFreqDist: Like FreqDist, but returns zero counts for everything with a count less than a given cutoff.
    • jazzparser.taggers.chordmap.NamedMapping: Just a dictionary with a name.
    • jazzparser.formalisms.base.syntax.VariableSubstitution: A mapping from some sort of variable subject to unification that appears in categories.
  • list: list() -> new empty list list(iterable) -> new list initialized from iterable's items
    • midi.TempoMap
  • type: type(object) -> the object's type type(name, bases, dict) -> a new type
    • jazzparser.formalisms.FormalismBase.__metaclass__
    • jazzparser.data.corpora.temperley.Event.__metaclass__
    • midi.Event.__metaclass__