pyx/config.py

   1 # -*- encoding: utf-8 -*-
   2 #
   3 #
   4 # Copyright (C) 2003-2011 Jörg Lehmann <joergl@users.sourceforge.net>
   5 # Copyright (C) 2003-2011 André Wobst <wobsta@users.sourceforge.net>
   6 #
   7 # This file is part of PyX (http://pyx.sourceforge.net/).
   8 #
   9 # PyX is free software; you can redistribute it and/or modify
  10 # it under the terms of the GNU General Public License as published by
  11 # the Free Software Foundation; either version 2 of the License, or
  12 # (at your option) any later version.
  13 #
  14 # PyX is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 # GNU General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU General Public License
  20 # along with PyX; if not, write to the Free Software
  21 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  22
  23 import configparser, io, logging, os, pkgutil, subprocess, shutil
  24
  25 logger = logging.getLogger("pyx")
  26 logger_execute = logging.getLogger("pyx.execute")
  27 logger_filelocator = logging.getLogger("pyx.filelocator")
  28
  29 builtinopen = open
  30
  31 try:
  32     import pykpathsea as pykpathsea_module
  33     has_pykpathsea = True
  34 except ImportError:
  35     has_pykpathsea = False
  36
  37
  38 # Locators implement an open method which returns a list of functions
  39 # by searching for a file according to a specific rule. Each of the functions
  40 # returned can be called (multiple times) and return an open file. The
  41 # opening of the file might fail with a IOError which indicates, that the
  42 # file could not be found at the given location.
  43 # names is a list of kpsewhich format names to be used for searching where as
  44 # extensions is a list of file extensions to be tried (including the dot). Note
  45 # that the list of file extenions should include an empty string to not add
  46 # an extension at all.
  47
  48 locator_classes = {}
  49
  50 class local:
  51     """locates files in the current directory"""
  52
  53     def openers(self, filename, names, extensions):
  54         return [lambda extension=extension: builtinopen(filename+extension, "rb") for extension in extensions]
  55
  56 locator_classes["local"] = local
  57
  58
  59 class internal:
  60     """locates files within the PyX data tree"""
  61
  62     def openers(self, filename, names, extensions):
  63         for extension in extensions:
  64             full_filename = filename+extension
  65             dir = os.path.splitext(full_filename)[1][1:]
  66             try:
  67                 data = pkgutil.get_data("pyx", "data/%s/%s" % (dir, full_filename))
  68             except IOError:
  69                 pass
  70             else:
  71                 if data:
  72                     return [lambda: io.BytesIO(data)]
  73         return []
  74
  75 locator_classes["internal"] = internal
  76
  77
  78 class recursivedir:
  79     """locates files by searching recursively in a list of directories"""
  80
  81     def __init__(self):
  82         self.dirs = getlist("filelocator", "recursivedir")
  83         self.full_filenames = {}
  84
  85     def openers(self, filename, names, extensions):
  86         for extension in extensions:
  87             if filename+extension in self.full_filenames:
  88                 return [lambda: builtinopen(self.full_filenames[filename], "rb")]
  89         while self.dirs:
  90             dir = self.dirs.pop(0)
  91             for item in os.listdir(dir):
  92                 full_item = os.path.join(dir, item)
  93                 if os.path.isdir(full_item):
  94                     self.dirs.insert(0, full_item)
  95                 else:
  96                     self.full_filenames[item] = full_item
  97             for extension in extensions:
  98                 if filename+extension in self.full_filenames:
  99                     return [lambda: builtinopen(self.full_filenames[filename], "rb")]
 100         return []
 101
 102 locator_classes["recursivedir"] = recursivedir
 103
 104
 105 class ls_R:
 106     """locates files by searching a list of ls-R files"""
 107
 108     def __init__(self):
 109         self.ls_Rs = getlist("filelocator", "ls-R")
 110         self.full_filenames = {}
 111
 112     def openers(self, filename, names, extensions):
 113         while self.ls_Rs and not any([filename+extension in self.full_filenames for extension in extensions]):
 114             lsr = self.ls_Rs.pop(0)
 115             base_dir = os.path.dirname(lsr)
 116             dir = None
 117             first = True
 118             with builtinopen(lsr, "r", encoding="ascii", errors="surrogateescape") as lsrfile:
 119                 for line in lsrfile:
 120                     line = line.rstrip()
 121                     if first and line.startswith("%"):
 122                         continue
 123                     first = False
 124                     if line.endswith(":"):
 125                         dir = os.path.join(base_dir, line[:-1])
 126                     elif line:
 127                         self.full_filenames[line] = os.path.join(dir, line)
 128         for extension in extensions:
 129             if filename+extension in self.full_filenames:
 130                 def _opener():
 131                     try:
 132                         return builtinopen(self.full_filenames[filename+extension], "rb")
 133                     except IOError:
 134                         logger.warning("'%s' should be available at '%s' according to the ls-R file, "
 135                                     "but the file is not available at this location; "
 136                                     "update your ls-R file" % (filename, self.full_filenames[filename]))
 137                 return [_opener]
 138         return []
 139
 140 locator_classes["ls-R"] = ls_R
 141
 142
 143 class pykpathsea:
 144     """locate files by pykpathsea (a C extension module wrapping libkpathsea)"""
 145
 146     def openers(self, filename, names, extensions):
 147         if not has_pykpathsea:
 148             return []
 149         for name in names:
 150             full_filename = pykpathsea_module.find_file(filename, name)
 151             if full_filename:
 152                 break
 153         else:
 154             return []
 155         def _opener():
 156             try:
 157                 return builtinopen(full_filename, "rb")
 158             except IOError:
 159                 logger.warning("'%s' should be available at '%s' according to libkpathsea, "
 160                             "but the file is not available at this location; "
 161                             "update your kpsewhich database" % (filename, full_filename))
 162         return [_opener]
 163
 164 locator_classes["pykpathsea"] = pykpathsea
 165
 166
 167 # class libkpathsea:
 168 #     """locate files by libkpathsea using ctypes"""
 169 #
 170 #     def openers(self, filename, names, extensions):
 171 #         raise NotImplemented
 172 #
 173 # locator_classes["libpathsea"] = libkpathsea
 174
 175 def Popen(cmd, *args, **kwargs):
 176     try:
 177         cmd + ""
 178     except:
 179         pass
 180     else:
 181         raise ValueError("pyx.config.Popen must not be used with a string cmd")
 182     info = "PyX executes {} with args {}".format(cmd[0], cmd[1:])
 183     try:
 184         shutil.which
 185     except:
 186         pass
 187     else:
 188         info += " located at {}".format(shutil.which(cmd[0]))
 189     logger_execute.info(info)
 190     return subprocess.Popen(cmd, *args, **kwargs)
 191
 192 PIPE = subprocess.PIPE
 193 STDOUT = subprocess.STDOUT
 194
 195
 196 def fix_cygwin(full_filename):
 197     # detect cygwin result on windows python
 198     if os.name == "nt" and full_filename.startswith("/"):
 199         with Popen(['cygpath', '-w', full_filename], stdout=subprocess.PIPE).stdout as output:
 200             return io.TextIOWrapper(output, encoding="ascii", errors="surrogateescape").readline().rstrip()
 201     return full_filename
 202
 203
 204 class kpsewhich:
 205     """locate files using the kpsewhich executable"""
 206
 207     def __init__(self):
 208         self.kpsewhich = get("filelocator", "kpsewhich", "kpsewhich")
 209
 210     def openers(self, filename, names, extensions):
 211         full_filename = None
 212         for name in names:
 213             try:
 214                 with Popen([self.kpsewhich, '--format', name, filename], stdout=subprocess.PIPE).stdout as output:
 215                     full_filename = io.TextIOWrapper(output, encoding="ascii", errors="surrogateescape").readline().rstrip()
 216             except OSError:
 217                 return []
 218             if full_filename:
 219                 break
 220         else:
 221             return []
 222
 223         full_filename = fix_cygwin(full_filename)
 224
 225         def _opener():
 226             try:
 227                 return builtinopen(full_filename, "rb")
 228             except IOError:
 229                 logger.warning("'%s' should be available at '%s' according to kpsewhich, "
 230                             "but the file is not available at this location; "
 231                             "update your kpsewhich database" % (filename, full_filename))
 232         return [_opener]
 233
 234 locator_classes["kpsewhich"] = kpsewhich
 235
 236
 237 class locate:
 238     """locate files using a locate executable"""
 239
 240     def __init__(self):
 241         self.locate = get("filelocator", "locate", "locate")
 242
 243     def openers(self, filename, names, extensions):
 244         full_filename = None
 245         for extension in extensions:
 246             with Popen([self.locate, filename+extension], stdout=subprocess.PIPE).stdout as output:
 247                 for line in io.TextIOWrapper(output, encoding="ascii", errors="surrogateescape"):
 248                     line = line.rstrip()
 249                     if os.path.basename(line) == filename+extension:
 250                         full_filename = line
 251                         break
 252             if full_filename:
 253                 break
 254         else:
 255             return []
 256
 257         full_filename = fix_cygwin(full_filename)
 258
 259         def _opener():
 260             try:
 261                 return builtinopen(full_filename, "rb")
 262             except IOError:
 263                 logger.warning("'%s' should be available at '%s' according to the locate, "
 264                             "but the file is not available at this location; "
 265                             "update your locate database" % (filename+extension, full_filename))
 266         return [_opener]
 267
 268 locator_classes["locate"] = locate
 269
 270
 271
 272 class _marker: pass
 273
 274 config = configparser.ConfigParser()
 275 config.read_string(locator_classes["internal"]().openers("pyxrc", [], [""])[0]().read().decode("utf-8"), source="(internal pyxrc)")
 276 if os.name == "nt":
 277     user_pyxrc = os.path.join(os.environ['APPDATA'], "pyxrc")
 278 else:
 279     user_pyxrc = os.path.expanduser("~/.pyxrc")
 280 config.read(user_pyxrc, encoding="utf-8")
 281
 282 def get(section, option, default=_marker):
 283     if default is _marker:
 284         return config.get(section, option)
 285     else:
 286         try:
 287             return config.get(section, option)
 288         except configparser.Error:
 289             return default
 290
 291 def getint(section, option, default=_marker):
 292     if default is _marker:
 293         return config.getint(section, option)
 294     else:
 295         try:
 296             return config.getint(section, option)
 297         except configparser.Error:
 298             return default
 299
 300 def getfloat(section, option, default=_marker):
 301     if default is _marker:
 302         return config.getfloat(section, option)
 303     else:
 304         try:
 305             return config.getfloat(section, option)
 306         except configparser.Error:
 307             return default
 308
 309 def getboolean(section, option, default=_marker):
 310     if default is _marker:
 311         return config.getboolean(section, option)
 312     else:
 313         try:
 314             return config.getboolean(section, option)
 315         except configparser.Error:
 316             return default
 317
 318 def getlist(section, option, default=_marker):
 319     if default is _marker:
 320         l = config.get(section, option).split()
 321     else:
 322         try:
 323             l = config.get(section, option).split()
 324         except configparser.Error:
 325             return default
 326     if space:
 327         l = [item.replace(space, " ") for item in l]
 328     return l
 329
 330
 331 space = get("general", "space", "SPACE")
 332 methods = [locator_classes[method]()
 333            for method in getlist("filelocator", "methods", ["local", "internal", "pykpathsea", "kpsewhich"])]
 334 opener_cache = {}
 335
 336
 337 def open(filename, formats, ascii=False):
 338     """returns an open file searched according the list of formats"""
 339
 340     # When using an empty list of formats, the names list is empty
 341     # and the extensions list contains an empty string only. For that
 342     # case some locators (notably local and internal) return an open
 343     # function for the requested file whereas other locators might not
 344     # return anything (like pykpathsea and kpsewhich).
 345     # This is useful for files not to be searched in the latex
 346     # installation at all (like lfs files).
 347     extensions = set([""])
 348     for format in formats:
 349         for extension in format.extensions:
 350             extensions.add(extension)
 351     names = tuple([format.name for format in formats])
 352     if (filename, names) in opener_cache:
 353         file = opener_cache[(filename, names)]()
 354     else:
 355         for method in methods:
 356             openers = method.openers(filename, names, extensions)
 357             for opener in openers:
 358                 try:
 359                     file = opener()
 360                 except EnvironmentError:
 361                     file = None
 362                 if file:
 363                     info = "PyX filelocator found {} by method {}".format(filename, method.__class__.__name__)
 364                     if hasattr(file, "name"):
 365                         info += " at {}".format(file.name)
 366                     logger_filelocator.info(info)
 367                     opener_cache[(filename, names)] = opener
 368                     break
 369             # break two loops here
 370             else:
 371                 continue
 372             break
 373         else:
 374             logger_filelocator.info("PyX filelocator failed to find {} of type {} and extensions {}".format(filename, names, extensions))
 375             raise IOError("Could not locate the file '%s'." % filename)
 376     if ascii:
 377         return io.TextIOWrapper(file, encoding="ascii", errors="surrogateescape")
 378     else:
 379         return file
 380
 381
 382 class format:
 383     def __init__(self, name, extensions):
 384         self.name = name
 385         self.extensions = extensions
 386
 387 format.tfm = format("tfm", [".tfm"])
 388 format.afm = format("afm", [".afm"])
 389 format.fontmap = format("map", [])
 390 format.pict = format("graphic/figure", [".eps", ".epsi"])
 391 format.tex_ps_header = format("PostScript header", [".pro"])                    # contains also: enc files
 392 format.type1 = format("type1 fonts", [".pfa", ".pfb"])
 393 format.vf = format("vf", [".vf"])
 394 format.dvips_config = format("dvips config", [])
 395