frescobaldi / quickly

A LilyPond library for python (slated to become the successor of python-ly)

README for Frescobaldi

Note about maintenance

Frescobaldi is unfortunately close to being unmaintained at present. Releases are extremely difficult to do due to deep packaging issues especially on macOS (issues with the macOS label) and Frescobaldi is still using PyQt5, which is now obsolete (#1407). Help to resolve these issues and continue the development of Frescobaldi is very welcome.

About Frescobaldi

Homepage: http://www.frescobaldi.org/ Main author: Wilbert Berendsen

Frescobaldi is a LilyPond sheet music text editor. It aims to be powerful, yet lightweight and easy to use. Frescobaldi is Free Software, freely available under the General Public License.

Features:

• Powerful text editor with syntax highlighting and automatic completion
• Music view with advanced two-way Point & Click
• Midi player to proof-listen LilyPond-generated MIDI files
• Midi capturing to enter music
• Powerful Score Wizard to quickly setup a music score
• Snippet Manager to store and apply text snippets, templates or scripts
• Use multiple versions of LilyPond, automatically selects the correct version
• Built-in LilyPond documentation browser and built-in help
• Configurable document outline view to navigate large LilyPond scores easily
• Smart layout-control functions like coloring specific objects in the PDF
• Import ABC, Midi and MusicXML using the LilyPond-provided tools
• Experimental export to MusicXML
• Modern user interface with configurable colors, fonts and keyboard shortcuts
• Translated into: Dutch, English, French, German, Italian, Swedish, Czech, Russian, Spanish, Galician, Turkish, Polish, Brazilian, Ukrainian, Traditional Chinese, Simplified Chinese and Japanese.

Music functions:

• Transpose music
• Change music from relative to absolute and vice versa
• Change the language used for note names
• Change the rhythm (double, halve, add/remove dots, copy, paste) etc
• Hyphenate lyrics using word-processor hyphenation dictionaries
• Add spanners, dynamics, articulation easily using the Quick Insert panel
• Update LilyPond syntax using convert-ly, with display of differences

Frescobaldi is designed to run on all major operating systems (Linux, macOS and Windows). It is named after Girolamo Frescobaldi (1583-1643), an Italian composer of keyboard music in the late Renaissance and early Baroque period.

Here is an idea of the basic Frescobaldi workflow:

• Start Frescobaldi
• Open a .ly file or create one using File->New from template or Tools->Setup new Score... and fill in some music
• Press Ctrl+M to run LilyPond
• If the LilyPond output shows errors, press Ctrl+E to jump to the first error
• If you see other mistakes in the music, click the notes to move the text cursor there
• Fix the errors or mistakes in the text
• Press Ctrl+M again to update the music view
• When a piece is finished, press Ctrl+Shift+P once to run LilyPond with point and click turned off (this results in a much smaller PDF file).

Frescobaldi is written in Python and uses PyQt for its user interface.

Installation instructions for the program and MIDI support as well as other information can be found in the Wiki. Other requirements and installation instructions may also be found in the INSTALL.md file.

quickly's Issues

Transposing chords with added bass notes

When transposing a chord which has an added bass note, if the destination pitch is lower than the original one and the bass note moves to a lower octave, the transposition adds one (or more) ',' after the bass note. I think that is not allowed in lilypond or the parser doesn't know how to manage it, because it returns an Unknown token error. It does not happen when the transposition moves one or more octaves up.

import parce
from quickly.registry import find
from quickly.pitch import Pitch
from quickly.transpose import transpose, Transposer

text = r"\relative c' {\chordmode { g:7 | c2/e }}" # Chord with bass note
doc = parce.Document(find("lilypond"), transformer=True)
doc.set_text(text)

print(doc.text()) # \relative c' {\chordmode { g:7 | c2/e }}

pitch1 = Pitch(0, 0, 0)
pitch2 = Pitch(-1, 0, 0) # Transpose exactly one octave down
t = Transposer(pitch1, pitch2)
transpose(doc, t) # Unknown token: <Token ',' at 39:40 (Delimiter)>

print(doc.text()) # \relative c { \chordmode { g':7 | c'2/e, } }

Also, shouldn't chord notes be also transposed down? I mean, ginstead of g'. Without using \relativeyou get the same result.

rel2abs and abs2rel behave abnormally

When following and trying the Features of quickly section from quick-ly.info, I can't get the results that rel2absand abs2relare supposed to return. This is the code:

import parce
from quickly.registry import find
from quickly.relative import rel2abs, abs2rel

text = r"music = \relative c' { c d e f g }"
doc = parce.Document(find("lilypond"), text, transformer=True)

print(doc.text()) # music = \relative c' { c d e f g }
rel2abs(doc)
print(doc.text()) # music = c' { c d, e,, f,,, g,,,, }
abs2rel(doc)
print(doc.text())
# music = c
# 
# \relative c' { c d, e, f, g, }

Maybe some recent change?

Thanks!

sequential durations should provide spacers

If Music(Note('c'), Duration(2), Duration(1)) — there will be written c21

Pitch needs an octave

Sorry, didn't know the best way to make you know. I tried a PR, but I had no permissions.

Pitch can not be created without an octave.

quickly/quickly/key.py

Line 229 in 79fa75a

p = pitch.Pitch(self.note, self.alter)

\language not always parsed correctly

Lilypond accepts language names with or without double quotes around the name.
Quickly does not recognize the language name if it is not quoted.

To reproduce, run the following code:

text = r"""
% Correctly detected
\language "nederlands"
\language "català"
\language "catalan"
\language "deutsch"
\language "english"
\language "español"
\language "espanol"
\language "français"
\language "italiano"
\language "norks"
\language "português"
\language "portugues"
\language "suomi"
\language "svenska"
\language "vlaams"

% Should be detected as well
\language nederlands
\language català
\language catalan
\language deutsch
\language english
\language español
\language espanol
\language français
\language italiano
\language norks
\language português
\language portugues
\language suomi
\language svenska
\language vlaams
"""
doc = parce.Document(LilyPond.root, transformer=True)
doc.set_text(text)
music = doc.get_transform(True)
music.dump()

The second form (without quotes) leads to lily.Language nodes with None as the detected language, followed by a lily.Symbol node containing the unparsed language name.

Export to MusicXML

Hello, are you planning to migrate the MusicXML export functionality from python-ly over here? Thanks!

complex durations support

from quickly.dom import lily

print(lily.Duration(5 / 8).write())  # 2

When I have first seen the example with Duration(3/ 8).write() == "4." I was really excited as It was my first task in own project. But the example with 5/ 8 shows that some durations can be lost. I'm not sure that the best solution would be to make something like Duration(5/ 8).write() == "2~8" as it depends on the bar position. So here is an issue for discussion on the topic.