Untitled
unknown
python
3 years ago
28 kB
3
Indexable
Never
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# This file is part of LilyPond, the GNU music typesetter.
#
# Copyright (C) 1998--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
# Jan Nieuwenhuizen <janneke@gnu.org>
#
# LilyPond is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# LilyPond is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
r'''
Example usage:
test:
lilypond-book --filter="tr '[a-z]' '[A-Z]'" BOOK
convert-ly on book:
lilypond-book --filter="convert-ly --no-version --from=1.6.11 -" BOOK
classic lilypond-book:
lilypond-book --process="lilypond" BOOK.tely
TODO:
* ly-options: intertext?
* --line-width?
* eps in latex / eps by lilypond -b ps?
* check latex parameters, twocolumn, multicolumn?
* use --png --ps --pdf for making images?
* Converting from lilypond-book source, substitute:
@mbinclude foo.itely -> @include foo.itely
\mbinput -> \input
'''
# TODO: Better solve the global_options copying to the snippets...
import codecs
import gettext
import glob
import hashlib
from optparse import OptionGroup
import os
import pipes
import re
import stat
import subprocess
import sys
import tempfile
import typing
# See lock_path and unlock_path; this module is not available at all on Windows.
if os.name == 'posix':
import fcntl
"""
# relocate-preamble.py.in
#
# This file is part of LilyPond, the GNU music typesetter.
#
# Copyright (C) 2007--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
#
# LilyPond is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# LilyPond is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
#
This is generic code, used for all python scripts.
The quotes are to ensure that the source .py file can still be
run as a python script, but does not include any sys.path handling.
Otherwise, the lilypond-book calls inside the build
might modify installed .pyc files.
"""
# This is needed for installations with a non-default layout, ie where share/
# is not next to bin/.
sys.path.insert (0, os.path.join ('/usr/share/lilypond/2.22.1', 'python'))
# Dynamic relocation, for installations with a default layout including GUB,
# but also for execution from the build directory.
bindir = os.path.abspath (os.path.dirname (sys.argv[0]))
topdir = os.path.dirname (bindir)
if bindir.endswith (r'/scripts/out'):
topdir = os.path.join (os.path.dirname (topdir), 'out')
datadir = os.path.abspath (os.path.join (topdir, 'share', 'lilypond'))
for v in [ 'current', '2.22.1' ]:
sys.path.insert (0, os.path.join (datadir, v, 'python'))
"""
"""
import book_base
import book_docbook
import book_html
import book_latex
import book_texinfo
import book_snippets
import fontextract
# Load translation and install _() into Python's builtins namespace.
gettext.install('lilypond', '/usr/share/locale')
import lilylib as ly
original_dir = os.getcwd()
backend = 'ps'
help_summary = (
_("Process LilyPond snippets in hybrid HTML, LaTeX, texinfo or DocBook document.")
+ '\n\n'
+ _("Examples:")
+ '''
$ lilypond-book --filter="tr '[a-z]' '[A-Z]'" %(BOOK)s
$ lilypond-book -F "convert-ly --no-version --from=2.0.0 -" %(BOOK)s
$ lilypond-book --process='lilypond -I include' %(BOOK)s
''' % {'BOOK': _("BOOK")})
authors = ('Jan Nieuwenhuizen <janneke@gnu.org>',
'Han-Wen Nienhuys <hanwen@xs4all.nl>')
################################################################
def exit(i):
if ly.is_verbose():
raise Exception(_('Exiting (%d)...') % i)
else:
sys.exit(i)
progress = ly.progress
warning = ly.warning
error = ly.error
program_version = '2.22.1'
if program_version.startswith("@"):
# '@' in lilypond-book output confuses texinfo
program_version = "dev"
def identify():
progress('%s (GNU LilyPond) %s' % (ly.program_name, program_version))
def warranty():
identify()
sys.stdout.write('''
%s
%s
%s
%s
''' % (_('Copyright (c) %s by') % '2001--2021',
'\n '.join(authors),
_("Distributed under terms of the GNU General Public License."),
_("It comes with NO WARRANTY.")))
def get_option_parser():
p = ly.get_option_parser(usage=_("%s [OPTION]... FILE") % 'lilypond-book',
description=help_summary,
conflict_handler="resolve",
add_help_option=False)
p.add_option('-F', '--filter', metavar=_("FILTER"),
action="store",
dest="filter_cmd",
help=_(
"pipe snippets through FILTER [default: `convert-ly -n -']"),
default=None)
p.add_option('-f', '--format',
help=_(
"use output format FORMAT (texi [default], texi-html, latex, html, docbook)"),
metavar=_("FORMAT"),
action='store')
p.add_option("-h", "--help",
action="help",
help=_("show this help and exit"))
p.add_option("-I", '--include', help=_("add DIR to include path"),
metavar=_("DIR"),
action='append', dest='include_path',
default=[])
p.add_option('--info-images-dir',
help=_("format Texinfo output so that Info will "
"look for images of music in DIR"),
metavar=_("DIR"),
action='store', dest='info_images_dir',
default='')
p.add_option('--left-padding',
metavar=_("PAD"),
dest="padding_mm",
help=_(
"pad left side of music to align music in spite of uneven bar numbers (in mm)"),
type="float",
default=3.0)
p.add_option('--lily-loglevel',
help=_("Print lilypond log messages according to LOGLEVEL"),
metavar=_("LOGLEVEL"),
action='store', dest='lily_loglevel',
default=os.environ.get("LILYPOND_LOGLEVEL", None))
p.add_option('--lily-output-dir',
help=_("write lily-XXX files to DIR, link into --output dir"),
metavar=_("DIR"),
action='store', dest='lily_output_dir',
default=None)
p.add_option("-l", "--loglevel",
help=_("Print log messages according to LOGLEVEL "
"(NONE, ERROR, WARNING, PROGRESS (default), DEBUG)"),
metavar=_("LOGLEVEL"),
action='callback',
callback=ly.handle_loglevel_option,
type='string')
p.add_option("-o", '--output', help=_("write output to DIR"),
metavar=_("DIR"),
action='store', dest='output_dir',
default='')
p.add_option('-P', '--process', metavar=_("COMMAND"),
help=_("process ly_files using COMMAND FILE..."),
action='store',
dest='process_cmd', default='')
p.add_option('--redirect-lilypond-output',
help=_("Redirect the lilypond output"),
action='store_true',
dest='redirect_output', default=False)
p.add_option('-s', '--safe', help=_("Compile snippets in safe mode"),
action="store_true",
default=False,
dest="safe_mode")
p.add_option('--skip-lily-check',
help=_("do not fail if no lilypond output is found"),
metavar=_("DIR"),
action='store_true', dest='skip_lilypond_run',
default=False)
p.add_option('--skip-png-check',
help=_("do not fail if no PNG images are found for EPS files"),
metavar=_("DIR"),
action='store_true', dest='skip_png_check',
default=False)
p.add_option('--use-source-file-names',
help=_(
"write snippet output files with the same base name as their source file"),
action='store_true', dest='use_source_file_names',
default=False)
p.add_option('-V', '--verbose', help=_("be verbose"),
action="callback",
callback=ly.handle_loglevel_option,
callback_args=("DEBUG",))
p.version = "2.22.1"
p.add_option("--version",
action="version",
help=_("show version number and exit"))
p.add_option('-w', '--warranty',
help=_("show warranty and copyright"),
action='store_true')
group = OptionGroup(p, "Options only for the latex and texinfo backends")
group.add_option('--latex-program',
help=_("run executable PROG instead of latex, or in\n\
case --pdf option is set instead of pdflatex"),
metavar=_("PROG"),
action='store', dest='latex_program',
default='latex')
group.add_option('--texinfo-program',
help=_("run executable PROG instead of texi2pdf"),
metavar=_("PROG"),
action='store', dest='texinfo_program',
default='texi2pdf')
group.add_option('--pdf',
action="store_true",
dest="create_pdf",
help=_("create PDF files for use with PDFTeX"),
default=False)
p.add_option_group(group)
p.add_option_group('',
description=(
_("Report bugs via %s")
% 'bug-lilypond@gnu.org') + '\n')
for formatter in book_base.all_formats:
formatter.add_options(p)
return p
lilypond_binary = os.path.join('/usr/bin', 'lilypond')
# If we are called with full path, try to use lilypond binary
# installed in the same path; this is needed in GUB binaries, where
# @bindir is always different from the installed binary path.
if 'bindir' in globals() and bindir:
lilypond_binary = os.path.join(bindir, 'lilypond')
# Only use installed binary when we are installed too.
if '/usr/bin' == ('@' + 'bindir@') or not os.path.exists(lilypond_binary):
lilypond_binary = 'lilypond'
# Need to shell-quote, issue 3468
lilypond_binary = pipes.quote(lilypond_binary)
global_options = None
def command_name(cmd):
# Strip all stuf after command,
# deal with "((latex ) >& 1 ) .." too
cmd = re.match(r'([\(\)]*)([^\\ ]*)', cmd).group(2)
return os.path.basename(cmd)
def system_in_directory(cmd_str, directory, log_file):
"""Execute a command in a different directory."""
if global_options.redirect_output:
ly.progress(_("Processing %s.ly") % log_file)
else:
if ly.is_verbose():
ly.progress(_("Invoking `%s\'") % cmd_str)
else:
name = command_name(cmd_str)
ly.progress(_("Running %s...") % name)
output_location = None
if global_options.redirect_output:
output_location = open(log_file + '.log', 'w', encoding='utf8')
try:
subprocess.run(cmd_str, stdout=output_location,
stderr=output_location, cwd=directory,
shell=True, check=True)
except subprocess.CalledProcessError as e:
sys.stderr.write("%s\n" % e)
sys.exit(1)
def process_snippets(cmd, outdated_dict,
formatter, lily_output_dir):
"""Run cmd on all of the .ly files from snippets."""
basenames = sorted(outdated_dict.keys())
# No need for a secure hash function, just need a digest.
checksum = hashlib.md5()
for name in basenames:
checksum.update(name.encode('ascii'))
checksum = checksum.hexdigest()
lily_output_dir = global_options.lily_output_dir
snippet_map_file = 'snippet-map-%s.ly' % checksum
snippet_map_path = os.path.join(lily_output_dir, snippet_map_file)
# Write snippet map.
with open(snippet_map_path, 'w', encoding='utf8') as snippet_map:
snippet_map.write("""
#(define version-seen #t)
#(define output-empty-score-list #f)
""")
snippet_map.write("#(ly:add-file-name-alist '(\n")
for name in basenames:
snippet_map.write('("%s.ly" . "%s")\n' % (
name.replace('\\', '/'), outdated_dict[name].input_fullpath()))
snippet_map.write('))\n')
# Write list of snippet names.
snippet_names_file = 'snippet-names-%s.ly' % checksum
snippet_names_path = os.path.join(lily_output_dir, snippet_names_file)
with open(snippet_names_path, 'w', encoding='utf8') as snippet_names:
snippet_names.write('\n'.join(
[snippet_map_file] + [name + '.ly' for name in basenames]))
# Run command.
cmd = formatter.adjust_snippet_command(cmd)
# Remove .ly ending.
logfile = os.path.splitext(snippet_names_path)[0]
snippet_names_arg = mkarg(snippet_names_path.replace(os.path.sep, '/'))
system_in_directory(' '.join([cmd, snippet_names_arg]),
lily_output_dir,
logfile)
os.unlink(snippet_map_path)
os.unlink(snippet_names_path)
def lock_path(name):
if os.name != 'posix':
return None
fp = open(name, 'w', encoding='utf8')
fcntl.lockf(fp, fcntl.LOCK_EX)
return fp
def unlock_path(lock):
if os.name != 'posix':
return None
fcntl.lockf(lock, fcntl.LOCK_UN)
lock.close()
def do_process_cmd(chunks, options):
"""Wrap do_process_cmd_locked in a filesystem lock"""
snippets = [c for c in chunks if isinstance(
c, book_snippets.LilypondSnippet)]
# calculate checksums eagerly
for s in snippets:
s.get_checksum()
os.makedirs(options.lily_output_dir, exist_ok=True)
lock_file = os.path.join(options.lily_output_dir, "lock")
lock = None
try:
lock = lock_path(lock_file)
do_process_cmd_locked(snippets, options)
finally:
if lock:
unlock_path(lock)
def do_process_cmd_locked(snippets, options):
"""Look at all snippets, write the outdated ones, and compile them."""
outdated = [c for c in snippets if c.is_outdated(options.lily_output_dir)]
if outdated:
# First unique the list based on the basename, by using them as keys
# in a dict.
outdated_dict = dict()
for snippet in outdated:
outdated_dict[snippet.basename()] = snippet
# Next call write_ly() for each snippet once.
progress(_("Writing snippets..."))
for snippet in outdated_dict.values():
snippet.write_ly()
progress(_("Processing..."))
process_snippets(options.process_cmd, outdated_dict,
options.formatter, options.lily_output_dir)
else:
progress(_("All snippets are up to date..."))
progress(_("Linking files..."))
abs_lily_output_dir = os.path.join(
options.original_dir, options.lily_output_dir)
abs_output_dir = os.path.join(options.original_dir, options.output_dir)
if abs_lily_output_dir != abs_output_dir:
for snippet in snippets:
snippet.link_all_output_files(abs_lily_output_dir,
abs_output_dir)
###
# Format guessing data
def guess_format(input_filename):
format = None
e = os.path.splitext(input_filename)[1]
for formatter in book_base.all_formats:
if formatter.can_handle_extension(e):
return formatter
error(_("cannot determine format for: %s" % input_filename))
exit(1)
def write_if_updated(file_name, lines):
try:
with open(file_name, encoding='utf-8') as file:
old_str = file.read()
except FileNotFoundError:
pass
else:
new_str = ''.join(lines)
if old_str == new_str:
progress(_("%s is up to date.") % file_name)
# this prevents make from always rerunning lilypond-book:
# output file must be touched in order to be up to date
os.utime(file_name, None)
return
output_dir = os.path.dirname(file_name)
os.makedirs(output_dir, exist_ok=True)
progress(_("Writing `%s'...") % file_name)
codecs.open(file_name, 'w', 'utf-8').writelines(lines)
def note_input_file(name, inputs=[]):
# hack: inputs is mutable!
inputs.append(name)
return inputs
def samefile(f1, f2):
try:
return os.path.samefile(f1, f2)
except AttributeError: # Windoze
f1 = re.sub("//*", "/", f1)
f2 = re.sub("//*", "/", f2)
return f1 == f2
def do_file(input_filename, included=False):
# Ugh.
input_absname = input_filename
if not input_filename or input_filename == '-':
in_handle = sys.stdin
input_fullname = '<stdin>'
else:
if os.path.exists(input_filename):
input_fullname = input_filename
else:
input_fullname = global_options.formatter.input_fullname(
input_filename)
# Normalize path to absolute path, since we will change cwd to the output dir!
# Otherwise, "lilypond-book -o out test.tex" will complain that it is
# overwriting the input file (which it is actually not), since the
# input filename is relative to the CWD...
input_absname = os.path.abspath(input_fullname)
note_input_file(input_fullname)
in_handle = codecs.open(input_fullname, 'r', 'utf-8')
if input_filename == '-':
global_options.input_dir = os.getcwd()
input_base = 'stdin'
elif included:
input_base = os.path.splitext(input_filename)[0]
else:
global_options.input_dir = os.path.split(input_absname)[0]
input_base = os.path.basename(
os.path.splitext(input_filename)[0])
# don't complain when global_options.output_dir is existing
if not global_options.output_dir:
global_options.output_dir = os.getcwd()
else:
global_options.output_dir = os.path.abspath(global_options.output_dir)
os.makedirs(global_options.output_dir, 0o777, exist_ok=True)
output_filename = os.path.join(global_options.output_dir,
input_base + global_options.formatter.default_extension)
if (os.path.exists(input_filename)
and os.path.exists(output_filename)
and samefile(output_filename, input_absname)):
error(
_("Output would overwrite input file; use --output."))
exit(2)
try:
progress(_("Reading `%s'") % input_absname)
source = in_handle.read()
if not included:
global_options.formatter.init_default_snippet_options(source)
progress(_("Dissecting..."))
chunks = book_base.find_toplevel_snippets(
source, global_options.formatter, global_options)
for c in chunks:
c.set_document_fullpaths(input_fullname, output_filename)
# Let the formatter modify the chunks before further processing
chunks = global_options.formatter.process_chunks(chunks)
def process_include(snippet):
name = snippet.substring('filename')
progress(_("Processing include `%s'") % name)
return do_file(name, included=True)
include_chunks = []
for x in chunks:
if isinstance(x, book_snippets.IncludeSnippet):
include_chunks += process_include(x)
return chunks + include_chunks
except book_snippets.CompileError:
progress(_("Removing `%s'") % output_filename)
raise book_snippets.CompileError
def adjust_include_path(path, outpath):
"""Rewrite an include path relative to the dir where lilypond is launched.
Always use forward slashes since this is what lilypond expects."""
path = os.path.expanduser(path)
path = os.path.expandvars(path)
path = os.path.normpath(path)
if os.path.isabs(outpath):
return os.path.abspath(path).replace(os.path.sep, '/')
if os.path.isabs(path):
return path.replace(os.path.sep, '/')
return os.path.join(inverse_relpath(original_dir, outpath), path).replace(os.path.sep, '/')
def inverse_relpath(path, relpath):
"""Given two paths, the second relative to the first,
return the first path relative to the second.
Always use forward slashes since this is what lilypond expects."""
if os.path.isabs(relpath):
return os.path.abspath(path).replace(os.path.sep, '/')
relparts = ['']
parts = os.path.normpath(path).split(os.path.sep)
for part in os.path.normpath(relpath).split(os.path.sep):
if part == '..':
relparts.append(parts[-1])
parts.pop()
else:
relparts.append('..')
parts.append(part)
return '/'.join(relparts[::-1])
def do_options():
global global_options
opt_parser = get_option_parser()
(global_options, args) = opt_parser.parse_args()
global_options.information = {
'program_version': program_version, 'program_name': ly.program_name}
global_options.original_dir = original_dir
if global_options.lily_output_dir:
global_options.lily_output_dir = os.path.expanduser(
global_options.lily_output_dir)
for i, path in enumerate(global_options.include_path):
global_options.include_path[i] = adjust_include_path(
path, global_options.lily_output_dir)
global_options.include_path.insert(0, inverse_relpath(
original_dir, global_options.lily_output_dir))
elif global_options.output_dir:
global_options.output_dir = os.path.expanduser(
global_options.output_dir)
for i, path in enumerate(global_options.include_path):
global_options.include_path[i] = adjust_include_path(
path, global_options.output_dir)
global_options.include_path.insert(
0, inverse_relpath(original_dir, global_options.output_dir))
global_options.include_path.insert(0, "./")
if global_options.warranty:
warranty()
exit(0)
if not args or len(args) > 1:
opt_parser.print_help()
exit(2)
return args
def mkarg(x):
r"""
A modified version of the commands.mkarg(x)
Uses double quotes (since Windows can't handle the single quotes)
and escapes the characters \, $, ", and ` for unix shells.
"""
if os.name == 'nt':
return ' "%s"' % x
s = ' "'
for c in x:
if c in '\\$"`':
s = s + '\\'
s = s + c
s = s + '"'
return s
def write_output_documents(chunks: typing.List[book_snippets.Chunk], is_filter: bool):
text_by_path = {}
for ch in chunks:
path = ch.output_fullpath()
if path not in text_by_path:
text_by_path[path] = []
if is_filter:
s = ch.filter_text()
else:
s = ch.replacement_text()
text_by_path[path].append(s)
for path in text_by_path:
write_if_updated(path, text_by_path[path])
def main():
if "LILYPOND_BOOK_LOGLEVEL" in os.environ:
ly.set_loglevel(os.environ["LILYPOND_BOOK_LOGLEVEL"])
files = do_options()
basename = os.path.splitext(files[0])[0]
basename = os.path.split(basename)[1]
if global_options.format:
# Retrieve the formatter for the given format
for formatter in book_base.all_formats:
if formatter.can_handle_format(global_options.format):
global_options.formatter = formatter
else:
global_options.formatter = guess_format(files[0])
global_options.format = global_options.formatter.format
# make the global options available to the formatters:
global_options.formatter.global_options = global_options
formats = global_options.formatter.image_formats
if global_options.process_cmd == '':
global_options.process_cmd = (lilypond_binary
+ ' --formats=%s -dbackend=eps ' % formats)
if global_options.process_cmd:
includes = global_options.include_path
global_options.process_cmd += ' '.join([' -I %s' % mkarg(p)
for p in includes])
global_options.formatter.process_options(global_options)
if global_options.lily_loglevel:
ly.debug_output(_("Setting LilyPond's loglevel to %s") %
global_options.lily_loglevel, True)
global_options.process_cmd += " --loglevel=%s" % global_options.lily_loglevel
elif ly.is_verbose():
if os.environ.get("LILYPOND_LOGLEVEL", None):
ly.debug_output(_("Setting LilyPond's loglevel to %s (from environment variable LILYPOND_LOGLEVEL)") %
os.environ.get("LILYPOND_LOGLEVEL", None), True)
global_options.process_cmd += " --loglevel=%s" % os.environ.get(
"LILYPOND_LOGLEVEL", None)
else:
ly.debug_output(
_("Setting LilyPond's output to --verbose, implied by lilypond-book's setting"), True)
global_options.process_cmd += " --verbose"
if global_options.padding_mm:
global_options.process_cmd += " -deps-box-padding=%f " % global_options.padding_mm
global_options.process_cmd += " -dread-file-list -dno-strip-output-dir"
if global_options.lily_output_dir:
global_options.lily_output_dir = os.path.abspath(
global_options.lily_output_dir)
else:
global_options.lily_output_dir = os.path.abspath(
global_options.output_dir)
relative_output_dir = global_options.output_dir
identify()
try:
chunks = do_file(files[0])
if global_options.filter_cmd:
write_output_documents(chunks, is_filter=True)
elif global_options.process_cmd:
do_process_cmd(chunks, global_options)
progress(_("Compiling `%s'...") % files[0])
write_output_documents(chunks, is_filter=False)
except book_snippets.CompileError:
exit(1)
inputs = note_input_file('')
inputs.pop()
base_file_name = os.path.splitext(os.path.basename(files[0]))[0]
dep_file = os.path.join(global_options.output_dir, base_file_name + '.dep')
final_output_file = os.path.join(relative_output_dir,
base_file_name + global_options.formatter.default_extension)
open(dep_file, 'w', encoding='utf8').write('%s: %s\n'
% (final_output_file, ' '.join(inputs)))
if __name__ == '__main__':
main()