home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1487 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.7 KB  |  259 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import ConfigParser
  5.  
  6. try:
  7.     set
  8. except NameError:
  9.     from sets import Set as set
  10.  
  11. import sys
  12. import cherrypy
  13. environments = {
  14.     'staging': {
  15.         'engine.autoreload_on': False,
  16.         'checker.on': False,
  17.         'tools.log_headers.on': False,
  18.         'request.show_tracebacks': False },
  19.     'production': {
  20.         'engine.autoreload_on': False,
  21.         'checker.on': False,
  22.         'tools.log_headers.on': False,
  23.         'request.show_tracebacks': False,
  24.         'log.screen': False },
  25.     'embedded': {
  26.         'engine.autoreload_on': False,
  27.         'checker.on': False,
  28.         'tools.log_headers.on': False,
  29.         'request.show_tracebacks': False,
  30.         'log.screen': False,
  31.         'engine.SIGHUP': None,
  32.         'engine.SIGTERM': None },
  33.     'test_suite': {
  34.         'engine.autoreload_on': False,
  35.         'checker.on': False,
  36.         'tools.log_headers.on': False,
  37.         'request.show_tracebacks': True,
  38.         'log.screen': False } }
  39.  
  40. def as_dict(config):
  41.     if isinstance(config, basestring):
  42.         config = _Parser().dict_from_file(config)
  43.     elif hasattr(config, 'read'):
  44.         config = _Parser().dict_from_file(config)
  45.     
  46.     return config
  47.  
  48.  
  49. def merge(base, other):
  50.     if isinstance(other, basestring):
  51.         cherrypy.engine.autoreload.files.add(other)
  52.     
  53.     for section, value_map in as_dict(other).iteritems():
  54.         base.setdefault(section, { }).update(value_map)
  55.     
  56.  
  57.  
  58. class NamespaceSet(dict):
  59.     
  60.     def __call__(self, config):
  61.         ns_confs = { }
  62.         for k in config:
  63.             if '.' in k:
  64.                 (ns, name) = k.split('.', 1)
  65.                 bucket = ns_confs.setdefault(ns, { })
  66.                 bucket[name] = config[k]
  67.                 continue
  68.         
  69.         for ns, handler in self.iteritems():
  70.             exit = getattr(handler, '__exit__', None)
  71.             if exit:
  72.                 callable = handler.__enter__()
  73.                 no_exc = True
  74.                 
  75.                 try:
  76.                     for k, v in ns_confs.get(ns, { }).iteritems():
  77.                         callable(k, v)
  78.                 except:
  79.                     no_exc = False
  80.                     if exit is None:
  81.                         raise 
  82.                     exit is None
  83.                     if not exit(*sys.exc_info()):
  84.                         raise 
  85.                     exit(*sys.exc_info())
  86.                 finally:
  87.                     if no_exc and exit:
  88.                         exit(None, None, None)
  89.                     
  90.  
  91.                 continue
  92.             for k, v in ns_confs.get(ns, { }).iteritems():
  93.                 handler(k, v)
  94.             
  95.         
  96.  
  97.     
  98.     def __repr__(self):
  99.         return '%s.%s(%s)' % (self.__module__, self.__class__.__name__, dict.__repr__(self))
  100.  
  101.     
  102.     def __copy__(self):
  103.         newobj = self.__class__()
  104.         newobj.update(self)
  105.         return newobj
  106.  
  107.     copy = __copy__
  108.  
  109.  
  110. class Config(dict):
  111.     defaults = {
  112.         'tools.log_tracebacks.on': True,
  113.         'tools.log_headers.on': True,
  114.         'tools.trailing_slash.on': True }
  115.     namespaces = NamespaceSet(**{
  116.         'server': (lambda k, v: setattr(cherrypy.server, k, v)),
  117.         'log': (lambda k, v: setattr(cherrypy.log, k, v)),
  118.         'checker': (lambda k, v: setattr(cherrypy.checker, k, v)) })
  119.     
  120.     def __init__(self):
  121.         self.reset()
  122.  
  123.     
  124.     def reset(self):
  125.         self.clear()
  126.         dict.update(self, self.defaults)
  127.  
  128.     
  129.     def update(self, config):
  130.         if isinstance(config, basestring):
  131.             cherrypy.engine.autoreload.files.add(config)
  132.             config = _Parser().dict_from_file(config)
  133.         elif hasattr(config, 'read'):
  134.             config = _Parser().dict_from_file(config)
  135.         else:
  136.             config = config.copy()
  137.         if isinstance(config.get('global', None), dict):
  138.             if len(config) > 1:
  139.                 cherrypy.checker.global_config_contained_paths = True
  140.             
  141.             config = config['global']
  142.         
  143.         which_env = config.get('environment')
  144.         if which_env:
  145.             env = environments[which_env]
  146.             for k in env:
  147.                 if k not in config:
  148.                     config[k] = env[k]
  149.                     continue
  150.             
  151.         
  152.         if 'tools.staticdir.dir' in config:
  153.             config['tools.staticdir.section'] = 'global'
  154.         
  155.         dict.update(self, config)
  156.         self.namespaces(config)
  157.  
  158.     
  159.     def __setitem__(self, k, v):
  160.         dict.__setitem__(self, k, v)
  161.         self.namespaces({
  162.             k: v })
  163.  
  164.  
  165.  
  166. def _engine_namespace_handler(k, v):
  167.     engine = cherrypy.engine
  168.     if k == 'autoreload_on':
  169.         if v:
  170.             engine.autoreload.subscribe()
  171.         else:
  172.             engine.autoreload.unsubscribe()
  173.     elif k == 'autoreload_frequency':
  174.         engine.autoreload.frequency = v
  175.     elif k == 'autoreload_match':
  176.         engine.autoreload.match = v
  177.     elif k == 'reload_files':
  178.         engine.autoreload.files = set(v)
  179.     elif k == 'deadlock_poll_freq':
  180.         engine.timeout_monitor.frequency = v
  181.     elif k == 'SIGHUP':
  182.         engine.listeners['SIGHUP'] = set([
  183.             v])
  184.     elif k == 'SIGTERM':
  185.         engine.listeners['SIGTERM'] = set([
  186.             v])
  187.     elif '.' in k:
  188.         (plugin, attrname) = k.split('.', 1)
  189.         plugin = getattr(engine, plugin)
  190.         setattr(plugin, attrname, v)
  191.     else:
  192.         setattr(engine, k, v)
  193.  
  194. Config.namespaces['engine'] = _engine_namespace_handler
  195.  
  196. def _tree_namespace_handler(k, v):
  197.     cherrypy.tree.graft(v, v.script_name)
  198.     if not v.script_name:
  199.         pass
  200.     cherrypy.engine.log('Mounted: %s on %s' % (v, '/'))
  201.  
  202. Config.namespaces['tree'] = _tree_namespace_handler
  203.  
  204. class _Parser(ConfigParser.ConfigParser):
  205.     
  206.     def optionxform(self, optionstr):
  207.         return optionstr
  208.  
  209.     
  210.     def read(self, filenames):
  211.         if isinstance(filenames, basestring):
  212.             filenames = [
  213.                 filenames]
  214.         
  215.         for filename in filenames:
  216.             fp = open(filename)
  217.             
  218.             try:
  219.                 self._read(fp, filename)
  220.             finally:
  221.                 fp.close()
  222.  
  223.         
  224.  
  225.     
  226.     def as_dict(self, raw = False, vars = None):
  227.         unrepr = unrepr
  228.         import cherrypy.lib
  229.         result = { }
  230.         for section in self.sections():
  231.             if section not in result:
  232.                 result[section] = { }
  233.             
  234.             for option in self.options(section):
  235.                 value = self.get(section, option, raw, vars)
  236.                 
  237.                 try:
  238.                     value = unrepr(value)
  239.                 except Exception:
  240.                     x = None
  241.                     msg = 'Config error in section: %r, option: %r, value: %r. Config values must be valid Python.' % (section, option, value)
  242.                     raise ValueError(msg, x.__class__.__name__, x.args)
  243.  
  244.                 result[section][option] = value
  245.             
  246.         
  247.         return result
  248.  
  249.     
  250.     def dict_from_file(self, file):
  251.         if hasattr(file, 'read'):
  252.             self.readfp(file)
  253.         else:
  254.             self.read(file)
  255.         return self.as_dict()
  256.  
  257.  
  258. del ConfigParser
  259.