Example #1
0
    def test_export_site_with_subfolders(self):
        from Products.GenericSetup.utils import _getDottedName
        self._setUpAdapters()
        FOLDER_IDS = ('foo', 'bar', 'baz')

        site = _makeFolder('site')
        site.title = 'AAA'
        site._setProperty('description', 'BBB')
        aside = _makeFolder('aside')
        dotted = _getDottedName(aside.__class__)
        for id in FOLDER_IDS:
            folder = _makeFolder(id)
            folder.title = 'Title: %s' % id
            site._setObject(id, folder)

        context = DummyExportContext(site)
        exporter = self._getExporter()
        exporter(context)

        self.assertEqual(len(context._wrote), 2 + (2 *len(FOLDER_IDS)))
        filename, text, content_type = context._wrote[0]
        self.assertEqual(filename, 'structure/.objects')
        self.assertEqual(content_type, 'text/comma-separated-values')

        objects = [x for x in reader(StringIO(text))]
        self.assertEqual(len(objects), 3)

        for index in range(len(FOLDER_IDS)):
            id = FOLDER_IDS[index]
            self.assertEqual(objects[index][0], id)
            self.assertEqual(objects[index][1], dotted)

            filename, text, content_type = context._wrote[2 + (2 * index)]
            self.assertEqual(filename, '/'.join(('structure', id, '.objects')))
            self.assertEqual(content_type, 'text/comma-separated-values')
            subobjects = [x for x in reader(StringIO(text))]
            self.assertEqual(len(subobjects), 0)

            filename, text, content_type = context._wrote[2 + (2 * index) + 1]
            self.assertEqual(filename,
                             '/'.join(('structure', id, '.properties')))
            self.assertEqual(content_type, 'text/plain')
            parser = ConfigParser()
            parser.readfp(StringIO(text))

            defaults = parser.defaults()
            self.assertEqual(len(defaults), 1)
            self.assertEqual(defaults['title'], 'Title: %s' % id)

        filename, text, content_type = context._wrote[1]
        self.assertEqual(filename, 'structure/.properties')
        self.assertEqual(content_type, 'text/plain')

        parser = ConfigParser()
        parser.readfp(StringIO(text))

        defaults = parser.defaults()
        self.assertEqual(len(defaults), 2)
        self.assertEqual(defaults['title'], 'AAA')
        self.assertEqual(defaults['description'], 'BBB')
    def __init__(self):
        if not os.path.exists("BAG.conf"):
            print "*** FOUT *** Kan configuratiebestand 'BAG.conf' niet openen."
            print ""
            raw_input("Druk <enter> om af te sluiten")
            sys.exit()

        configdict = ConfigParser()
        configdict.read("BAG.conf")
        try:
            self.database = configdict.defaults()["database"]
            self.host = configdict.defaults()["host"]
            self.user = configdict.defaults()["user"]
            self.password = configdict.defaults()["password"]
            self.download = configdict.defaults()["download"]
            self.extract = configdict.defaults()["extract"]
            self.logging = configdict.defaults()["logging"]
        except:
            print "*** FOUT *** Inhoud van configuratiebestand 'BAG.conf' is niet volledig."
            print ""
            raw_input("Druk <enter> om af te sluiten")
            sys.exit()
        try:
            self.bestand = configdict.defaults()["bestand"]
        except:
            pass
 def __init__(self):
     if not os.path.exists('BAG.conf'):
         print "*** FOUT *** Kan configuratiebestand 'BAG.conf' niet openen."
         print ""
         #raw_input("Druk <enter> om af te sluiten")
         sys.exit()
         
     configdict = ConfigParser()
     configdict.read('BAG.conf')
     try:
         self.database = configdict.defaults()['database']
         self.host     = configdict.defaults()['host']
         self.user     = configdict.defaults()['user']
         self.password = configdict.defaults()['password']
         self.download = configdict.defaults()['download']
         self.extract  = configdict.defaults()['extract']
         self.logging  = configdict.defaults()['logging']
         # TODO controleer of er commandline parameters zijn meegegeven die de instellingen overrulen
     except:
         print "*** FOUT *** Inhoud van configuratiebestand 'BAG.conf' is niet volledig."
         print ""
         raw_input("Druk <enter> om af te sluiten")
         sys.exit()
     try:               
         self.bestand  = configdict.defaults()['bestand']
     except:
         pass
Example #4
0
    def __init__(self, args):
        # Derive home dir from script location
        self.bagextract_home = os.path.realpath(os.path.dirname(sys.argv[0]) + '/..')

        # Default config file
        config_file = os.path.realpath(self.bagextract_home + '/extract.conf')

        # Option: overrule config file with command line arg pointing to config file
        if args.config:
            config_file = args.config

        Log.log.info("Configuratiebestand is " + str(config_file))
        if not os.path.exists(config_file):
            Log.log.fatal("ik kan het configuratiebestand '" + str(config_file) + "' ech niet vinden.")

        configdict = ConfigParser()
        try:
            configdict.read(config_file)
        except:
            Log.log.fatal("ik kan " + str(config_file) + " wel vinden maar niet inlezen.")

        try:
            # Zet parameters uit config bestand
            self.database = configdict.defaults()['database']
            self.schema   = configdict.defaults()['schema']
            self.host     = configdict.defaults()['host']
            self.user     = configdict.defaults()['user']
            self.password = configdict.defaults()['password']
            self.port = configdict.defaults()['port']

        except:
            Log.log.fatal(" de inhoud van configuratiebestand " + str(config_file) + " is niet volledig.")

        try:
            # Optioneel: overrulen met (commandline) args
            if args.database:
                self.database = args.database
            if args.host:
                self.host = args.host
            if args.schema:
                self.schema = args.schema
            # default to public schema
            if not self.schema:
                self.schema = 'public'
            if args.username:
                self.user = args.username
            if args.port:
                self.port = args.port
            if args.no_password:
                # Gebruik geen wachtwoord voor de database verbinding
                self.password = None
            else:
                if args.password:
                    self.password = args.password

            # Assign Singleton (of heeft Python daar namespaces voor?) (Java achtergrond)
            BAGConfig.config = self
        except:
            Log.log.fatal(" het overrulen van configuratiebestand " + str(config_file) + " via commandline loopt spaak")
Example #5
0
def load_app(filename):
    filename = os.path.abspath(filename)
    parser = ConfigParser()
    parser.read([filename])
    parser.filename = filename
    parser.defaults()['here'] = os.path.dirname(filename)
    parser.defaults()['__file__'] = filename
    return load_app_from_parser(parser)
Example #6
0
def raw_configurator(ini_file, local_conf_key='app:mailcone', here=__file__, zope_conf=''):
    configparser = ConfigParser()
    configparser.read(ini_file)
    configparser.defaults().update(dict(here=here))
    configurator(dict(here=here,
                      __file__=ini_file,
                      zope_conf=zope_conf),
                **dict(configparser.items(local_conf_key)))
Example #7
0
    def test_export_empty_site(self):
        self._setUpAdapters()
        site = _makeFolder('site')
        site.title = 'test_export_empty_site'
        site.description = 'Testing export of an empty site.'
        context = DummyExportContext(site)
        exporter = self._getExporter()
        exporter(context)

        self.assertEqual(len(context._wrote), 2)
        filename, text, content_type = context._wrote[0]
        self.assertEqual(filename, 'structure/.objects')
        self.assertEqual(content_type, 'text/comma-separated-values')

        objects = [x for x in reader(StringIO(text))]
        self.assertEqual(len(objects), 0)

        filename, text, content_type = context._wrote[1]
        self.assertEqual(filename, 'structure/.properties')
        self.assertEqual(content_type, 'text/plain')

        parser = ConfigParser()
        parser.readfp(StringIO(text))

        defaults = parser.defaults()
        self.assertEqual(len(defaults), 1)
        self.assertEqual(defaults['title'], site.title)
Example #8
0
    def options(self):
        # If all fails we will always have default values
        configuration = self.defaults()

        try:
            if self.config == None or isfile(self.config) == False:
                configuration = self.defaults()
                return configuration

        except TypeError:
            # if we are getting a ready-to-go dict then we still try 
            # to do our little translation-and-map thing and if that 
            # comes out as empty, then we assume keys are already 
            # translated
            if type(self.config) is dict:
                configuration = self.key_matcher(self.config, return_empty=True)
                if not configuration:
                    configuration = self.defaults(self.config)
                return configuration

            # we could get an object that is dict-like but type(object)
            # doesn't recognize it as a dict 
            else:
                configuration = self.key_matcher(self.config)
                return configuration
        
        else: # this will get executed *only* if we are seeing a file
            try:
                parser = ConfigParser()
                parser.read(self.config)
                file_options = parser.defaults()
                configuration = self.key_matcher(file_options)
            except Exception, error:
                raise OptionConfigurationError(error)
Example #9
0
    def test_export_empty_site_with_setup_tool(self):
        self._setUpAdapters()
        site = _makeFolder('site')
        site._setObject('setup_tool', self._makeSetupTool())
        site._updateProperty('title', 'test_export_empty_site_with_setup_tool')
        site._setProperty('description',
                          'Testing export of an empty site with setup tool.')
        context = DummyExportContext(site)
        exporter = self._getExporter()
        exporter(context)

        self.assertEqual(len(context._wrote), 2)
        filename, text, content_type = context._wrote[0]
        self.assertEqual(filename, 'structure/.objects')
        self.assertEqual(content_type, 'text/comma-separated-values')

        objects = [x for x in reader(StringIO(text))]
        self.assertEqual(len(objects), 0)

        filename, text, content_type = context._wrote[1]
        self.assertEqual(filename, 'structure/.properties')
        self.assertEqual(content_type, 'text/plain')

        parser = ConfigParser()
        parser.readfp(StringIO(text))

        defaults = parser.defaults()
        self.assertEqual(len(defaults), 2)
        self.assertEqual(defaults['title'], site.title)
        self.assertEqual(defaults['description'], site.description)
Example #10
0
def load_environment(global_conf, app_conf):
    """Configure the Pylons environment via the ``pylons.config``
    object
    """
    config = PylonsConfig()
    
    # Pylons paths
    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    paths = dict(root=root,
                 controllers=os.path.join(root, 'controllers'),
                 static_files=os.path.join(root, 'public'),
                 templates=[os.path.join(root, 'templates')])

    # import our private.ini that holds keys, etc
    imp = global_conf.get('import')
    if imp:
        cp = ConfigParser()
        cp.read(imp)
        global_conf.update(cp.defaults())
        if cp.has_section('APP'):
            app_conf.update(cp.items('APP'))

    # Initialize config with the basic options
    config.init_app(global_conf, app_conf, package='linkdrop', paths=paths)
    config['routes.map'] = make_map(config)
    config['pylons.app_globals'] = app_globals.Globals(config)

    import linkdrop.lib.helpers as h
    config['pylons.h'] = h
    
    # Setup cache object as early as possible
    import pylons
    pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping
    config['pylons.app_globals'].mako_lookup = TemplateLookup(
        directories=paths['templates'],
        error_handler=handle_mako_error,
        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
        input_encoding='utf-8', default_filters=['escape'],
        imports=['from webhelpers.html import escape'])

    # Setup the SQLAlchemy database engine
    engine = engine_from_config(config, 'sqlalchemy.')
    init_model(engine)

    # sqlalchemy auto migration
    if asbool(config.get('migrate.auto')):
        try:
            # managed upgrades
            cschema = schema.ControlledSchema.create(engine, config['migrate.repository'])
            cschema.update_db_from_model(meta.Base.metadata)
        except exceptions.InvalidRepositoryError, e:
            # unmanaged upgrades
            diff = schemadiff.getDiffOfModelAgainstDatabase(
                meta.Base.metadata, engine, excludeTables=None)
            genmodel.ModelGenerator(diff).applyModel()
Example #11
0
    def parse_config(self):
        """
        Reads the config file (default in /etc/vcscommit/vcscommit.cfg

        :rtype: ConfigParser object
        """
        cfg = ConfigParser()
        cfg.read('/etc/vcscommit/vcscommit.cfg')
        return cfg.defaults()
Example #12
0
    def defaults(self):
        """Return the defaults, with their values interpolated (with the
        defaults dict itself)

        Mainly to support defaults using values such as %(here)s
        """
        defaults = ConfigParser.defaults(self).copy()
        for key, val in iteritems(defaults):
            defaults[key] = self.get('DEFAULT', key) or val
        return defaults
Example #13
0
 def test_as_ini_no_properties(self):
     context = _makePropertied('no_properties')
     context._properties = ()
     adapter = self._getTargetClass()(context)
     text = adapter.as_ini()
     parser = ConfigParser()
     parser.readfp(StringIO(text))
     self.failIf(parser.sections())
     default_options = parser.defaults()
     self.assertEqual(len(default_options), 0)
Example #14
0
 def put_ini(self, text):
     """
     """
     context = self.context
     parser = ConfigParser()
     parser.readfp(StringIO(text))
     for option, value in parser.defaults().items():
         prop_type = context.getPropertyType(option)
         if prop_type is None:
             context._setProperty(option, value, 'string')
         else:
             context._updateProperty(option, value)
Example #15
0
class Config(object):

    def __init__(self):
        self._parser = ConfigParser()
        self._parser._defaults = IncludeDict(self._parser)

        # Copy attributes from the parser to avoid one additional
        # function call on each access.
        for attr in ["has_section", "remove_section"]:
            setattr(self, attr, getattr(self._parser, attr))

    def read_configs(self, configs):
        for config in configs:
            match = re.match("(.*)/([^/]+)=(.*)", config)
            if not match:
                raise Exception, "Invalid config string: %s" % config

            (name, option, value) = match.groups()
            if not self._parser.has_section(name):
                self._parser.add_section(name)

            self._parser.set(name, option, value)

    def read_file(self, file, filename="<stream>"):
        logging.info("Reading configurations from: %s", filename)

        self._parser.readfp(file, filename)

    def read_filename(self, filename):
        if not posixpath.exists(filename):
            raise Exception, "No such configuration file: %s" % filename

        file = open(filename, "r")
        return self.read_file(file, filename)

    def get_defaults(self):
        attributes = self._parser.defaults()
        return ConfigDefaults(self, 'DEFAULT', attributes)

    def get_section(self, name):
        if self._parser.has_section(name):
            attributes = dict(self._parser.items(name))
            return ConfigSection(self, name, attributes)

        return None

    def get_section_names(self):
        return self._parser.sections()

    def add_section(self, name):
        self._parser.add_section(name)
        return self.get_section(name)
Example #16
0
def handle_config_option(option, opt, value, parser, *args, **kwargs):
    fp = open(value, 'r')
    del fp
    parser.values.config_file = value
    config = ConfigParser()
    parser.values.config = config
    config.read(value)
    for k, v in config.defaults().iteritems():
        try:
            v = config.getboolean('DEFAULT', k)
        except ValueError:
            pass
        setattr(parser.values, k, v)
Example #17
0
    def test_export_site_with_csvaware(self):
        from Products.GenericSetup.utils import _getDottedName
        self._setUpAdapters()

        site = _makeFolder('site')
        site.title = 'test_export_site_with_csvaware'
        site._setProperty('description',
                          'Testing export of an site with CSV-aware content.')

        aware = _makeCSVAware('aware')
        site._setObject('aware', aware)

        context = DummyExportContext(site)
        exporter = self._getExporter()
        exporter(context)

        self.assertEqual(len(context._wrote), 3)
        filename, text, content_type = context._wrote[0]
        self.assertEqual(filename, 'structure/.objects')
        self.assertEqual(content_type, 'text/comma-separated-values')

        objects = [x for x in reader(StringIO(text))]
        self.assertEqual(len(objects), 1)
        self.assertEqual(objects[0][0], 'aware')
        self.assertEqual(objects[0][1], _getDottedName(aware.__class__))

        filename, text, content_type = context._wrote[1]
        self.assertEqual(filename, 'structure/.properties')
        self.assertEqual(content_type, 'text/plain')

        parser = ConfigParser()
        parser.readfp(StringIO(text))

        defaults = parser.defaults()
        self.assertEqual(len(defaults), 2)
        self.assertEqual(defaults['title'], site.title)
        self.assertEqual(defaults['description'], site.description)

        filename, text, content_type = context._wrote[2]
        self.assertEqual(filename, 'structure/aware.csv')
        self.assertEqual(content_type, 'text/comma-separated-values')
        rows = [x for x in reader(StringIO(text))]
        self.assertEqual(len(rows), 2)
        self.assertEqual(rows[0][0], 'one')
        self.assertEqual(rows[0][1], 'two')
        self.assertEqual(rows[0][2], 'three')
        self.assertEqual(rows[1][0], 'four')
        self.assertEqual(rows[1][1], 'five')
        self.assertEqual(rows[1][2], 'six')
Example #18
0
def ini2keys(fp):
    cp = ConfigParser()
    cp.optionxform = str
    cp.readfp(fp)

    default_keys = [x for x in cp.defaults()]
    keys = {'DEFAULT': default_keys}

    for section in cp.sections():
        keys[section] = [
            o for o in cp.options(section)
            if o not in default_keys
        ]
    del cp
    return keys
Example #19
0
 def test_as_ini_string_property(self):
     TITLE = 'String Property'
     DESCR = 'Another property'
     context = _makePropertied('string_property')
     context.title = TITLE
     context._setProperty('description', DESCR)
     adapter = self._getTargetClass()(context)
     text = adapter.as_ini()
     parser = ConfigParser()
     parser.readfp(StringIO(text))
     self.failIf(parser.sections())
     default_options = parser.defaults()
     self.assertEqual(len(default_options), 2)
     self.assertEqual(default_options['title'].strip(), TITLE)
     self.assertEqual(default_options['description'].strip(), DESCR)
Example #20
0
def configurator(global_conf, **local_conf):
    config.here = global_conf.get('here')
    config.ini_file = global_conf.get('__file__')
    config.zope_conf = global_conf.get('zope_conf')
    
    configparser = ConfigParser()
    configparser.read(config.ini_file)
    
    # building 2D dicts
    parsed = dict()
    for key, value in local_conf.iteritems():
        if configparser.has_section(value):
            parsed[key] = dict([(o, configparser.get(value, o),) for o in configparser.options(value)
                                if not o in configparser.defaults().keys()])
    config.local_configuration = local_conf
    config.local_configuration.update(parsed)
 def parse_config(self):
     """
     Parses the config file
     """
     cfg = ConfigParser()
     cfg.read('/etc/vcs-post-receive/post-receive.cfg')
     defaults = cfg.defaults()
     self.bugzilla_url = defaults['bugzilla_url']
     self.rest_uri = defaults['rest_uri']
     self.netrc = defaults['netrc']
     self.vcsopts.proxy = defaults['proxy']
     self.vcs_conf = {}
     for vcs in self.supported_vcs:
        self.__dict__[vcs] = {}
        self.__dict__[vcs]['vcsurl'] = cfg.get(vcs, 'vcsurl')
        self.__dict__[vcs]['rootdir'] = cfg.get(vcs, 'rootdir')
Example #22
0
def load_environment(global_conf, app_conf):
    """Configure the Pylons environment via the ``pylons.config``
    object
    """
    config = PylonsConfig()
    
    # Pylons paths
    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
    paths = dict(root=root,
                 controllers=os.path.join(root, 'controllers'),
                 static_files=os.path.join(root, 'public'),
                 templates=[os.path.join(root, 'templates')])

    # import our private.ini that holds keys, etc
    imp = global_conf.get('import')
    if imp:
        cp = ConfigParser()
        cp.read(imp)
        global_conf.update(cp.defaults())
        if cp.has_section('APP'):
            app_conf.update(cp.items('APP'))

    # Initialize config with the basic options
    config.init_app(global_conf, app_conf, package='linkdrop', paths=paths)
    config['routes.map'] = make_map(config)
    config['pylons.app_globals'] = app_globals.Globals(config)

    import linkdrop.lib.helpers as h
    config['pylons.h'] = h
    
    # Setup cache object as early as possible
    import pylons
    pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping
    config['pylons.app_globals'].mako_lookup = TemplateLookup(
        directories=paths['templates'],
        error_handler=handle_mako_error,
        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),
        input_encoding='utf-8', default_filters=['escape'],
        imports=['from webhelpers.html import escape'])

    # CONFIGURATION OPTIONS HERE (note: all config options will override
    # any Pylons config options)
    
    return config
Example #23
0
    def test_export_site_with_exportable_simple_items(self):
        from Products.GenericSetup.utils import _getDottedName
        self._setUpAdapters()
        ITEM_IDS = ('foo', 'bar', 'baz')

        site = _makeFolder('site')
        site.title = 'AAA'
        site._setProperty('description', 'BBB')
        aware = _makeINIAware('aside')
        dotted = _getDottedName(aware.__class__)
        for id in ITEM_IDS:
            site._setObject(id, _makeINIAware(id))

        context = DummyExportContext(site)
        exporter = self._getExporter()
        exporter(context)

        self.assertEqual(len(context._wrote), 2 + len(ITEM_IDS))
        filename, text, content_type = context._wrote[0]
        self.assertEqual(filename, 'structure/.objects')
        self.assertEqual(content_type, 'text/comma-separated-values')

        objects = [x for x in reader(StringIO(text))]
        self.assertEqual(len(objects), 3)
        for index in range(len(ITEM_IDS)):
            self.assertEqual(objects[index][0], ITEM_IDS[index])
            self.assertEqual(objects[index][1], dotted)

            filename, text, content_type = context._wrote[index+2]
            self.assertEqual(filename, 'structure/%s.ini' % ITEM_IDS[index])
            object = site._getOb(ITEM_IDS[index])
            self.assertEqual(text.strip(),
                             object.as_ini().strip())
            self.assertEqual(content_type, 'text/plain')

        filename, text, content_type = context._wrote[1]
        self.assertEqual(filename, 'structure/.properties')
        self.assertEqual(content_type, 'text/plain')
        parser = ConfigParser()
        parser.readfp(StringIO(text))

        defaults = parser.defaults()
        self.assertEqual(len(defaults), 2)
        self.assertEqual(defaults['title'], 'AAA')
        self.assertEqual(defaults['description'], 'BBB')
Example #24
0
File: cte.py Project: fgansevl/cte
def parse(parser, args = None):
  parser.add_option("-o", "--output", action = "store",
		    help="write output to file")
  parser.add_option("-i", "--ini", action = "store",
		    help="load settings from INI file")
  parser.add_option("-j", "--json", action = "store",
		    help="load settings from JSON file")
  parser.add_option("-y", "--yaml", action = "store",
		    help="load settings from YAML file")

  (options, args) = parser.parse_args(args)
  d = {}
  if options.ini:
    from ConfigParser import ConfigParser
    conf = ConfigParser()
    if options.ini == '-':
      cfg = sys.stdin
    else:
      cfg = file(options.ini)
    conf.readfp(cfg)
    d.update(conf.defaults())
    for sect in conf.sections():
      d[sect] = dict(conf.items(sect))
  if options.json:
    import json
    if options.json == '-':
      cfg = sys.stdin
    else:
      cfg = file(options.json)
    d.update(json.load(cfg))
  if options.yaml:
    import yaml
    if options.yaml == '-':
      cfg = sys.stdin
    else:
      cfg = file(options.yaml)
    d.update(yaml.load(cfg))
  for arg in args:
    key, val = [s.strip() for s in arg.split('=', 1)]
    d[key] = val
  options.data = d
  return options
Example #25
0
 def test_as_ini_other_properties(self):
     from DateTime.DateTime import DateTime
     INTPROP = 42
     FLOATPROP = 3.1415926
     DATESTR = '2005-11-07T12:00:00.000Z'
     context = _makePropertied('string_property')
     context._properties = ()
     context._setProperty('int_prop', INTPROP, 'int')
     context._setProperty('float_prop', FLOATPROP, 'float')
     context._setProperty('date_prop', DateTime(DATESTR), 'date')
     adapter = self._getTargetClass()(context)
     text = adapter.as_ini()
     parser = ConfigParser()
     parser.readfp(StringIO(text))
     self.failIf(parser.sections())
     default_options = parser.defaults()
     self.assertEqual(len(default_options), 3)
     self.assertEqual(default_options['int_prop'], str(INTPROP))
     self.assertEqual(default_options['float_prop'], str(FLOATPROP))
     self.assertEqual(default_options['date_prop'], str(DateTime(DATESTR)))
Example #26
0
def from_file(file_name):
    conf = ConfigParser(defaults=DEFAULT_CONF)
    try:
        conf.read(file_name)
    except Error:
        stderr.write("Error reading config file. Please ensure that the file exists, has correct permissions,"
                     "and is a valid python config file")
        stderr.flush()
        raise
    conf_dict = conf.defaults()
    typed_config_list = []
    # The ugly try-catch is required due to a quirk in literal_eval of plain strings
    for k,v in conf_dict.items():
        try:
            typed_val = literal_eval(v)
        except ValueError:
            typed_val = "'" + v + "'"
        typed_config_list.append((k,typed_val))
    merged_dict = OrderedDict(dict(DEFAULT_CONF.items() + typed_config_list))
    return namedtuple_from_dict(merged_dict)
Example #27
0
    def makeone(self, xtra=None, index_name='test-func-index', count=None):
        from cheeseprism.wsgiapp import main
        cp = ConfigParser(dict(here=self.base))

        with open(resource_spec(self.devini)) as fp:
            cp.readfp(fp)

        defaults = dict((x, cp.get('DEFAULT', x)) for x in cp.defaults())

        count = count is None and self.count or count
        self.idxpath = index_path = self.base / ("%s-%s" %(count, index_name))

        settings = {
            'cheeseprism.file_root': index_path,
            'cheeseprism.data_json': 'data.json'
            }

        settings = xtra and dict(settings, **xtra) or settings
        app = main(defaults, **settings)
        self.executor = app.registry['cp.executor']
        from webtest import TestApp
        return TestApp(app)
Example #28
0
class ConfigDict:
    """Singleton style/static initialisation wrapper thing"""
    def __init__(self):
        self.configdict = ConfigParser()
        foundini = False
        paths = (os.path.expanduser('~/.uploadr.ini'), os.path.abspath('uploadr.ini'))
        for filename in paths:
            if os.path.exists(filename):
                print 'using uploadr.ini file "%s"' % os.path.abspath(filename)
                self.configdict.read(filename)
                foundini = True
                break
        if not foundini:
            raise IOError('Missing configuration file: ' + ' '.join(paths))


    def get(self, configparam, default=None):
        """get the value from the ini file's default section."""
        defaults = self.configdict.defaults()
        if configparam in defaults:
            return defaults[configparam]
        if default:
            return default
        raise KeyError(configparam)
Example #29
0
import logging
import logging.config
import os
from ConfigParser import ConfigParser

DEBUG = True
log_conf_path = os.path.dirname(os.path.abspath(__file__))
logging.config.fileConfig(log_conf_path + "/logging.cfg")

logger = logging.getLogger("root") if DEBUG else logging.getLogger("Test")

conf = ConfigParser()
conf.read(log_conf_path + "/project.cfg")


if __name__ == "__main__":
    print conf.get("DEFAULT", "test")
    print conf.defaults()
    print conf.sections()
Example #30
0
def main(conffile, logs, legends, outdir, verbose):
    """ Produce plots from given """

    dataset = [d for f, d in logs]

    config = ConfigParser()
    config.read(conffile)

    for s in config.sections():
        p = Plot(name = s, outdir = outdir)

        # defaults
        for d, v in config.defaults().items():
            if d != 'encoding':
                p.__dict__[d] = v
            else:
                encoding = v

        # stats
        # conf:   200.count, 400.count
        # result: [["200", "count"], ["400", "count"]]
        try:
            stats = [x.strip().rsplit('.', 1)
                     for x in config.get(s, 'stats').split(' ')]
        except:
            print 'error: unable to read plot "%s" stats' % s
            continue

        if config.has_option(s, 'styles'):
            p.styles = [x.strip() for x in config.get(s, 'styles').split(' ')]

        if config.has_option(s, 'legend'):
            # this is the legend prefix$
            l = []
            count    = 0
            clegends = config.get(s, 'legend').decode(encoding).split(',')

            for f in logs:
                l     += ['%s %s' % (x.strip(), legends[count]) \
                          for x in clegends]
                count += 1
        p.legends = l
        
        if config.has_option(s, 'position'):
            # legend position according to matplotlib standard values (1-10)
            val = config.get(s, 'position').decode(encoding)
            if val.isdigit():
                p.position = int(val)
            else:
                p.position = val
            

        if config.has_option(s, 'yfactor'):
            try:
                p.__dict__['yfactor'] = map(float,config.get(s, 'yfactor').decode(encoding).split(','))
            except ValueError:
                print 'warning: %s yfactor not a number: %s' \
                    % (p.name, config.get(s, yfactor))
        # Text parameters - to decode into specified encoding
        for attr in ['title', 'xlabel', 'ylabel', 'plottype', 'yscale']:
            if config.has_option(s, attr):
                cstring = config.get(s, attr).decode(encoding)
                p.__dict__[attr] = cstring

        # Numerical parameters
        for attr in ['xfactor', 'dpi', 'tn_dpi']:
            if config.has_option(s, attr):
                try:
                    p.__dict__[attr] = config.getfloat(s, attr)
                except ValueError:
                    print 'warning: %s %s not a number: %s' \
                          % (p.name, attr, config.get(s, attr))

        outfile = p.plot(stats, dataset)

        if verbose:
            print 'Generated plot %s' % outfile