Speedup sysconfig startup

Lib/sysconfig.py

 """Access to Python's configuration information."""
 import os
 import re
 import sys
 from os.path import pardir, realpath
-
-import itertools
-
-class SectionProxy:
-    def __init__(self, parser, name):
-        self._parser = parser
-        self._name = name
-
-    def __getitem__(self, key):
-        if not self._parser.has_option(self._name, key):
-            raise KeyError(key)
-        return self._parser.get(self._name, key)
-
-    def __contains__(self, key):
-        return self._parser.has_option(self._name, key)
-
-    def __iter__(self):
-        return iter(self._parser.options(self._name))
-
-    def get(self, option):
-        return self._parser.get(self._name, option)
-
-class _ConfigParser:
-    """Specialized copy of configparser.RawConfigParser: read-only using dict."""
-
-    def __init__(self):
-        self._sections = dict()
-        self._proxies = dict()
-
-    def sections(self):
-        return list(self._sections.keys())
-
-    def add_section(self, section):
-        if section in self._sections:
-            raise DuplicateSectionError(section)
-        self._sections[section] = dict()
-        self._proxies[section] = SectionProxy(self, section)
-
-    def has_section(self, section):
-        return section in self._sections
-
-    def options(self, section):
-        try:
-            opts = self._sections[section].copy()
-        except KeyError:
-            raise NoSectionError(section)
-        return list(opts.keys())
-
-    def read(self, filename):
-        with open(filename) as fp:
-            self._read(fp, filename)
-
-    def items(self, section):
-        d = dict()
-        try:
-            d.update(self._sections[section])
-        except KeyError:
-            raise NoSectionError(section)
-        return [(option, d[option]) for option in d.keys()]
-
-    def has_option(self, section, option):
-        if section not in self._sections:
-            return False
-        else:
-            option = option
-            return option in self._sections[section]
-
-    def set(self, section, option, value=None):
-        try:
-            sectdict = self._sections[section]
-        except KeyError:
-            raise NoSectionError(section)
-        sectdict[option] = value
-
-    def remove_section(self, section):
-        existed = section in self._sections
-        if existed:
-            del self._sections[section]
-            del self._proxies[section]
-        return existed
-
-    def __getitem__(self, key):
-        if not self.has_section(key):
-            raise KeyError(key)
-        return self._proxies[key]
-
-    def __setitem__(self, section, keys):
-        self.remove_section(section)
-        elements_added = set()
-        section = str(section)
-        try:
-            self.add_section(section)
-        except (DuplicateSectionError, ValueError):
-            if section in elements_added:
-                raise
-        elements_added.add(section)
-        for key, value in keys.items():
-            key = str(key)
-            if value is not None:
-                value = str(value)
-            if (section, key) in elements_added:
-                raise DuplicateOptionError(section, key, '<dict>')
-            elements_added.add((section, key))
-            self.set(section, key, value)
-
-    def __contains__(self, key):
-        return self.has_section(key)
-
-    def __iter__(self):
-        return iter(self._sections.keys())
-
-    def _read(self, fp, fpname):
-        elements_added = set()
-        cursect = None                        # None, or a dictionary
-        sectname = None
-        optname = None
-        lineno = 0
-        indent_level = 0
-        optcre = re.compile(r"(?P<option>.*?)\s*(?P<vi>[=:])\s*(?P<value>.*)$")
-        nonspacecre = re.compile(r"\S")
-        e = None                              # None, or an exception
-        for lineno, line in enumerate(fp, start=1):
-            comment_start = None
-            # strip full line comments
-            for prefix in ('#', ';'):
-                if line.strip().startswith(prefix):
-                    comment_start = 0
-                    break
-            value = line[:comment_start].strip()
-            if not value:
-                # add empty line to the value, but only if there was no
-                # comment on the line
-                if (comment_start is None and
-                    cursect is not None and
-                    optname and
-                    cursect[optname] is not None):
-                    cursect[optname].append('') # newlines added at join
-                continue
-            # continuation line?
-            first_nonspace = nonspacecre.search(line)
-            cur_indent_level = first_nonspace.start() if first_nonspace else 0
-            if (cursect is not None and optname and
-                cur_indent_level > indent_level):
-                cursect[optname].append(value)
-            # a section header or option header?
-            else:
-                indent_level = cur_indent_level
-                # is it a section header?
-                if value.startswith('[') and value.endswith(']'):
-                    sectname = value[1:-1]
-                    if sectname in self._sections:
-                        if sectname in elements_added:
-                            raise DuplicateSectionError(sectname, fpname,
-                                                        lineno)
-                        cursect = self._sections[sectname]
-                        elements_added.add(sectname)
-                    else:
-                        cursect = dict()
-                        self._sections[sectname] = cursect
-                        self._proxies[sectname] = SectionProxy(self, sectname)
-                        elements_added.add(sectname)
-                    # So sections can't start with a continuation line
-                    optname = None
-                # no section header in the file?
-                elif cursect is None:
-                    raise MissingSectionHeaderError(fpname, lineno, line)
-                # an option line?
-                else:
-                    mo = optcre.match(value)
-                    if mo:
-                        optname, vi, optval = mo.group('option', 'vi', 'value')
-                        if not optname:
-                            e = self._handle_error(e, fpname, lineno, line)
-                        optname = optname.rstrip()
-                        if (sectname, optname) in elements_added:
-                            raise DuplicateOptionError(sectname, optname,
-                                                       fpname, lineno)
-                        elements_added.add((sectname, optname))
-                        # This check is fine because the OPTCRE cannot
-                        # match if it would set optval to None
-                        if optval is not None:
-                            optval = optval.strip()
-                            cursect[optname] = [optval]
-                        else:
-                            # valueless option handling
-                            cursect[optname] = None
-                    else:
-                        # a non-fatal parsing error occurred. set up the
-                        # exception but keep going. the exception will be
-                        # raised at the end of the file and will contain a
-                        # list of all bogus lines
-                        e = self._handle_error(e, fpname, lineno, line)
-        # if any parsing errors occurred, raise an exception
-        if e:
-            raise e
-        self._join_multiline_values()
-
-    def _join_multiline_values(self):
-        for section, options in self._sections.items():
-            for name, val in options.items():
-                if isinstance(val, list):
-                    val = '\n'.join(val).rstrip()
-                options[name] = val
-
-    def _handle_error(self, exc, fpname, lineno, line):
-        if not exc:
-            exc = ParsingError(fpname)
-        exc.append(lineno, repr(line))
-        return exc
 
 __all__ = [
     'get_config_h_filename',
     'get_config_var',
     'get_config_vars',
     'get_makefile_filename',
     'get_path',
     'get_path_names',
     'get_paths',
     'get_platform',
     'get_python_version',
     'get_scheme_names',
     'parse_config_h',
 ]
+
+class SectionProxy:
+    def __init__(self, parser, name):
+        self._parser = parser
+        self._name = name
+
+    def __iter__(self):
+        return iter(self._parser.options(self._name))
+
+class _ConfigParser:
+    """
+    configparser.RawConfigParser copy specialized for sysconfig:
+     - read-only
+     - use dict
+     - only support "#" prefix for comments
+     - only support "=" option name/value separator
+     - don't use custom exceptions
+    """
+
+    def __init__(self):
+        self._sections = dict()
+        self._proxies = dict()
+
+    def sections(self):
+        return list(self._sections.keys())
+
+    def add_section(self, section):
+        if section in self._sections:
+            raise Exception("Section %s already exists" % section)
+        self._sections[section] = dict()
+        self._proxies[section] = SectionProxy(self, section)
+
+    def has_section(self, section):
+        return section in self._sections
+
+    def options(self, section):
+        return list(self._sections[section].keys())
+
+    def items(self, section):
+        return self._sections[section].items()
+
+    def has_option(self, section, option):
+        if section not in self._sections:
+            return False
+        else:
+            option = option
+            return option in self._sections[section]
+
+    def set(self, section, option, value=None):
+        self._sections[section][option] = value
+
+    def remove_section(self, section):
+        existed = section in self._sections
+        if existed:
+            del self._sections[section]
+            del self._proxies[section]
+        return existed
+
+    def __getitem__(self, key):
+        return self._proxies[key]
+
+    def __iter__(self):
+        return iter(self._sections.keys())
+
+    def read(self, filename):
+        with open(filename, encoding="ASCII") as fp:
+            self._read(fp, filename)
+
+    def _read(self, fp, fpname):
+        cursect = None                        # None, or a dictionary
+        sectname = None
+        optname = None
+        lineno = 0
+        for lineno, line in enumerate(fp, start=1):
+            value = line.strip()
+            if value.startswith('#'):
+                continue
+            if not value:
+                continue
+
+            # is it a section header?
+            if value.startswith('[') and value.endswith(']'):
+                sectname = value[1:-1]
+                if sectname in self._sections:
+                    raise Exception("%s:%s: Section %s already exists"
+                                    % (fpname, lineno, sectname))
+                else:
+                    cursect = dict()
+                    self._sections[sectname] = cursect
+                    self._proxies[sectname] = SectionProxy(self, sectname)
+                # So sections can't start with a continuation line
+                optname = None
+            # no section header in the file?
+            elif cursect is None:
+                raise Exception('%s:%s: File contains no section headers'
+                                % (fpname, lineno))
+            # an option line?
+            else:
+                optname, optval = value.split('=', 1)
+                optname = optname.rstrip()
+                optval = optval.lstrip()

[gregory.p.smith, 2012/03/20 05:13:35]

do we need to preserve trailing spaces on a value?  if not, optval.strip().

[haypo, 2012/03/20 10:22:22]

line.strip() is supposed to have already removed trailing spaces. Am I wrong?

+                if not optname:
+                    raise ValueError("%s:%s: Empty option name"
+                                     % (fpname, lineno))
+                optname = optname.rstrip()

[gregory.p.smith, 2012/03/20 05:13:35]

you already did this above.

[haypo, 2012/03/20 10:22:22]

Ah yes, I forgot it in the cleanup.

+                if optname in cursect:
+                    raise DuplicateOptionError(sectname, optname,
+                                               fpname, lineno)
+                cursect[optname] = optval
 
 # let's read the configuration file
 # XXX _CONFIG_DIR will be set by the Makefile later
 _CONFIG_DIR = os.path.normpath(os.path.dirname(__file__))
 _CONFIG_FILE = os.path.join(_CONFIG_DIR, 'sysconfig.cfg')
 _SCHEMES = _ConfigParser()
 _SCHEMES.read(_CONFIG_FILE)
 _VAR_REPL = re.compile(r'\{([^{]*?)\}')
 
 
@@ skipping 746 matching lines @@
     print('Current installation scheme: "%s"' % _get_default_scheme())
     print()
     _print_dict('Paths', get_paths())
     print()
     _print_dict('Variables', get_config_vars())
 
 
 if __name__ == '__main__':
     _main()