コード例 #1
0
ファイル: base.py プロジェクト: johnsca/incubator-allura
    def basic_setup(self):
        global log, M
        if self.args[0]:
            # Probably being called from the command line - load the config file
            self.config = conf = appconfig("config:%s" % self.args[0], relative_to=os.getcwd())
            # ... logging does not understand section#subsection syntax
            logging_config = self.args[0].split("#")[0]
            logging.config.fileConfig(logging_config, disable_existing_loggers=False)
            log = logging.getLogger("allura.command")
            log.info("Initialize command with config %r", self.args[0])
            load_environment(conf.global_conf, conf.local_conf)
            self.setup_globals()
            from allura import model

            M = model
            ming.configure(**conf)
            activitystream.configure(**conf)
            pylons.tmpl_context.user = M.User.anonymous()
        else:
            # Probably being called from another script (websetup, perhaps?)
            log = logging.getLogger("allura.command")
            conf = pylons.config
        self.tools = pylons.app_globals.entry_points["tool"].values()
        for ep in iter_entry_points("allura.command_init"):
            log.info("Running command_init for %s", ep.name)
            ep.load()(conf)
        log.info("Loaded tools")
コード例 #2
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", required=True, help="provide name for experiment, to be used as prefix for database collections")
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--dryrun", help="Do the calculations but do not change the database (handiest with --debug 1 to see the results", action="store_true")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)


    if int(args.debug) == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')


    #### main program ####
    log.info("CALCULATING GRAPH SYMMETRY STATS - Experiment: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #3
0
ファイル: test_update_data.py プロジェクト: mmadsen/CTPy
    def setUp(self):
        data.set_database_port("27017")
        data.set_database_hostname("localhost")
        data.set_experiment_name("testupdate")
        config = data.getMingConfiguration()
        ming.configure(**config)

        # clean out the collection
        data.PerGenerationStatsPostclassification.m.remove()

        self.data = dict(
            simulation_time=1000,
            classification_id=ObjectId("52056c3b3f07d50754eec1a3"),
            classification_type="EVEN",
            classification_dim=2,
            classification_coarseness=4,
            replication=0,
            sample_size=50,
            population_size=2000,
            mutation_rate=0.01,
            simulation_run_id="urn:uuid:07f75571-6f6b-4113-84c5-46cb8114cb72",
            mode_richness=[5,3],
            class_richness=2,
            mode_evenness_iqv=[0.5,0.3],
            class_evenness_iqv=0.25,
            design_space_occupation=None,
            class_innovation_interval_times=None
        )
コード例 #4
0
 def basic_setup(self):
     global log, M
     if self.args[0]:
         # Probably being called from the command line - load the config file
         self.config = conf = appconfig('config:%s' % self.args[0],
                                        relative_to=os.getcwd())
         # Configure logging
         try:
             # ... logging does not understand section#subsection syntax
             logging_config = self.args[0].split('#')[0]
             logging.config.fileConfig(logging_config,
                                       disable_existing_loggers=False)
         except Exception:  # pragma no cover
             print >> sys.stderr, (
                 'Could not configure logging with config file %s' %
                 self.args[0])
         log = logging.getLogger('allura.command')
         log.info('Initialize command with config %r', self.args[0])
         load_environment(conf.global_conf, conf.local_conf)
         self.setup_globals()
         from allura import model
         M = model
         ming.configure(**conf)
         pylons.c.user = M.User.anonymous()
     else:
         # Probably being called from another script (websetup, perhaps?)
         log = logging.getLogger('allura.command')
         conf = pylons.config
     self.tools = pylons.g.entry_points['tool'].values()
     for ep in iter_entry_points('allura.command_init'):
         log.info('Running command_init for %s', ep.name)
         ep.load()(conf)
     log.info('Loaded tools')
コード例 #5
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--filename", help="path to file for export", required=True)


    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)

    #### main program ####

    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #6
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", required=True, help="provide name for experiment, to be used as prefix for database collections")
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--finalized", help="Only export runs which finalized after convergence", action="store_true")
    parser.add_argument("--action", choices=["sample", "single", "bulk"])
    parser.add_argument("--ssize", help="Sample size of graphs to export", default="100")
    parser.add_argument("--id", help="Export trait graphs with this object id")
    parser.add_argument("--idfile", help="Export trait graphs for ids in file")
    parser.add_argument("--directory", help="Directory to which DOT files are written")

    args = parser.parse_args()


    if int(args.debug) == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')


    #### main program ####
    log.info("EXPORT TRAIT GRAPHS AS DOT - Experiment: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #7
0
ファイル: base.py プロジェクト: vclisunlang/allura
 def basic_setup(self):
     global log, M
     if self.args[0]:
         # Probably being called from the command line - load the config
         # file
         self.config = conf = appconfig('config:%s' %
                                        self.args[0], relative_to=os.getcwd())
         # ... logging does not understand section#subsection syntax
         logging_config = self.args[0].split('#')[0]
         logging.config.fileConfig(
             logging_config, disable_existing_loggers=False)
         log = logging.getLogger('allura.command')
         log.info('Initialize command with config %r', self.args[0])
         load_environment(conf.global_conf, conf.local_conf)
         self.setup_globals()
         from allura import model
         M = model
         ming.configure(**conf)
         if asbool(conf.get('activitystream.recording.enabled', False)):
             activitystream.configure(**h.convert_bools(conf, prefix='activitystream.'))
         pylons.tmpl_context.user = M.User.anonymous()
     else:
         # Probably being called from another script (websetup, perhaps?)
         log = logging.getLogger('allura.command')
         conf = pylons.config
     self.tools = pylons.app_globals.entry_points['tool'].values()
     for ep in h.iter_entry_points('allura.command_init'):
         log.info('Running command_init for %s', ep.name)
         ep.load()(conf)
     log.info('Loaded tools')
コード例 #8
0
def setup(parser):
    config = parser.parse_args()

    sim_id = uuid.uuid1().urn
    script = __file__

    if config.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    data.set_experiment_name(config.experiment)
    data.set_database_hostname(config.dbhost)
    data.set_database_port(config.dbport)
    dbconfig = data.getMingConfiguration(data.modules)
    ming.configure(**dbconfig)

    # set up parallelism.  At the moment, this doesn't do anything on OSX
    # but should provide parallelism on Linux across the replicates at least

    if config.cores is not None:
        cores = config.cores
    else:
        cores = utils.get_parallel_cores(config.devel)
    log.info("Setting up %s cores for parallel simulation", cores)

    import simuOpt
    if(config.debug == 1):
        simuOpt.setOptions(alleleType='long',optimized=True,quiet=False,numThreads = cores)
    else:
        simuOpt.setOptions(alleleType='long',optimized=True,quiet=False,numThreads = cores)

    return (config,sim_id,script, cores)
コード例 #9
0
def setup():
    global args, simconfig
    permitted_stage_tags = data.get_experiment_stage_tags()

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--collections", choices=['postclassification', 'traits', 'both'], help="Collections to retrofit ", required=True)

    args = parser.parse_args()

    simconfig = utils.CTPyConfiguration(args.configuration)

    if args.debug:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration()
    ming.configure(**config)
コード例 #10
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment, to be used as prefix for database collections")
    parser.add_argument("--simid", help="simulation ID to export from database")
    parser.add_argument("--debug", type=int, help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--outputdirectory", help="path to directory for exported data files", required=True)

    args = parser.parse_args()

    if args.debug == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')


    #### main program ####
    log.info("EXPORT DATA TO CSV - Experiment: %s  SimulationID: %s", args.experiment, args.simid)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #11
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--parallelism", help="Number of concurrent processes to run", default="4")
    parser.add_argument("--diagram", help="Draw a diagram when complete", default=False)

    args = parser.parse_args()

    simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #12
0
ファイル: config.py プロジェクト: joeywen/zarkov
def configure(args=None):
    '''Load the options and configure the system'''
    if args is None: args = sys.argv
    options, args = get_options(args)
    if options.verbose:
        log.info('Settings:')
        for k,v in sorted(options.__dict__.items()):
            log.info('  %s: %r', k, v)
    ming_config = {
        'ming.zarkov.master':options.mongo_uri,
        'ming.zarkov.database':options.mongo_database,
        'ming.zarkov.use_gevent':True}
    for dbinfo in options.extra_dbs:
        dbinfo = dict(dbinfo)
        prefix = 'ming.%s.' % dbinfo.pop('name')
        for k,v in dbinfo.items():
            ming_config[prefix + k] = v
    if options.mongo_username:
        ming_config['ming.zarkov.authenticate.name'] = options.mongo_username
    if options.mongo_username:
        ming_config['ming.zarkov.authenticate.password'] = options.mongo_password
    ming.configure(**ming_config)
    if options.pdb:
        sys.excepthook = postmortem_hook
    return options, args
コード例 #13
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--popsize", help="Population size", required=True)
    parser.add_argument("--numloci", help="Number of loci per individual", required=True)
    parser.add_argument("--maxinittraits", help="Max initial number of traits per locus for initialization", required=True)
    parser.add_argument("--conformismstrength", help="Strength of conformist bias [0.0 - 1.0]", required=True)
    parser.add_argument("--anticonformismstrength", help="Strength of conformist bias [0.0 - 1.0]", required=True)
    parser.add_argument("--innovationrate", help="Theta value rate at which innovations occur in population", required=True)
    parser.add_argument("--periodic", help="Periodic boundary condition", choices=['1','0'], required=True)
    parser.add_argument("--kandlerinterval", help="Interval for Kandler remaining traits sample, taken before maxtime, in generations (will be scaled to timesteps)", default="1000")
    parser.add_argument("--simulationendtime", help="Time at which simulation and sampling end, defaults to 2M steps", default="2000000")

    args = parser.parse_args()

    simconfig = utils.MixtureConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)

    simconfig.num_features = int(args.numloci)
    simconfig.num_traits = int(args.maxinittraits)
    simconfig.popsize = int(args.popsize)
    mut = pg.moran_mutation_rate_from_theta(float(args.popsize), float(args.innovationrate))
    simconfig.innovation_rate = float(args.numloci) * mut
    simconfig.configured_innovation_rate = float(args.innovationrate)
    log.debug("configured theta = %s, using numloci %s * per-locus mutation rate %s = all-loci innovation rate: %s", args.innovationrate, args.numloci, mut, simconfig.innovation_rate)


    simconfig.maxtime = int(args.simulationendtime)
    simconfig.script = __file__
    simconfig.conformism_strength = float(args.conformismstrength)
    simconfig.anticonformism_strength = float(args.anticonformismstrength)
    simconfig.maxtime = int(args.simulationendtime)
    simconfig.model_class_label = simconfig.MODEL_CLASS_LABEL

    log.debug("Equifinality model class: %s", simconfig.model_class_label)


    simconfig.sim_id = uuid.uuid4().urn
    if args.periodic == '1':
        simconfig.periodic = 1
    else:
        simconfig.periodic = 0
コード例 #14
0
 def setUp(self):
     setup_unit_test()
     config = {
         'ming.main.uri': 'mim://host/allura_test',
     }
     ming.configure(**config)
     for i in range(10):
         M.User.upsert('sample-user-%d' % i)
コード例 #15
0
ファイル: test_eventlog.py プロジェクト: joeywen/zarkov
 def setUp(self):
     ming.configure(**{
             'ming.zarkov.master':'mim:///',
             'ming.zarkov.database':'zarkov'})
     self.options = mock.Mock()
     self.options.journal_file_size = 1024
     self.options.journal_min_files = 4
     self.journal_dir = tempfile.mkdtemp('.journal', 'zarkov-test')
     self.j = JournalWriter(self.options, self.journal_dir, start_greenlets=False)
コード例 #16
0
 def test_configure_optional_params(self, Connection):
     ming.configure(**{
             'ming.main.uri':'mongodb://localhost:27017/test_db',
             'ming.main.replicaSet': 'foobar',
             'ming.main.w': 2,
             'ming.main.ssl': True,
             })
     session = Session.by_name('main')
     assert session.bind.conn is not None
     assert session.bind.db is not None
コード例 #17
0
 def test_configure_optional_params(self, Connection):
     ming.configure(**{
             'ming.main.uri':'mongodb://localhost:27017/test_db',
             'ming.main.replicaSet': 'foobar',
             'ming.main.w': 2,
             'ming.main.ssl': True,
             })
     session = Session.by_name('main')
     assert session.bind.conn is not None
     assert session.bind.db is not None
コード例 #18
0
def connection_configure():
    from ming import configure
    from ming.odm import ThreadLocalODMSession

    configure(**{'ming.mysession.uri': 'mongodb://localhost:27017/tutorial'})

    session = ThreadLocalODMSession.by_name('mysession')
    session.db

    ThreadLocalODMSession.by_name('mysession') is session
コード例 #19
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--experiment",
        help=
        "provide name for experiment, to be used as prefix for database collections"
    )
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument("--configuration", help="Path to configuration file")
    parser.add_argument("--model",
                        choices=['axelrod', 'extensible', 'treestructured'],
                        required=True)
    parser.add_argument(
        "--finalized",
        help="Only export runs which finalized after convergence",
        action="store_true")
    parser.add_argument("--filename",
                        help="path to file for export",
                        required=True)

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if args.model == 'axelrod':
        simconfig = utils.AxelrodConfiguration(args.configuration)
    elif args.model == 'extensible':
        simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)
    elif args.model == 'treestructured':
        simconfig = utils.TreeStructuredConfiguration(args.configuration)
    else:
        log.error("This shouldn't happen - args.model = %s", args.model)

    if args.debug == 1:
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    #### main program ####
    log.info("EXPORT DATA TO CSV - Experiment: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #20
0
ファイル: test_datastore.py プロジェクト: dreamhost/Ming
 def test_configure(self, Connection):
     ming.configure(**{
             'ming.main.uri':'mongodb://localhost:27017/test_db',
             'ming.main.connect_retry': 1,
             'ming.main.tz_aware': False,
             })
     session = Session.by_name('main')
     assert session.bind.conn is not None
     assert session.bind.db is not None
     args, kwargs = Connection.call_args
     assert 'database' not in kwargs
コード例 #21
0
ファイル: test_datastore.py プロジェクト: apendleton/Ming
 def test_configure(self):
     ming.configure(**{
             'ming.main.master':'mongodb://localhost:27017/',
             'ming.main.database':'test_db',
             'ming.main.network_timeout':'0.1',
             'ming.main.connect_retry': 1,
             'ming.main.tz_aware': False,
             })
     session = Session.by_name('main')
     assert session.bind.conn is not None
     assert session.bind.db is not None
コード例 #22
0
ファイル: main.py プロジェクト: synappio/pwcred
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    import ming

    update_settings_from_environ(settings)
    ming.configure(**settings)
    config = Configurator(settings=settings)
    add_routes(config)
    config.scan()
    return config.make_wsgi_app()
コード例 #23
0
 def setUp(self):
     class TestDoc(Document):
         class __mongometa__:
             name='test_doc'
             session = Session.by_name('main')
         _id=Field(S.ObjectId, if_missing=None)
         a=Field(S.Int, if_missing=None)
         b=Field(S.Object, dict(a=S.Int(if_missing=None)))
     config = {
         'ming.main.master':'mongo://localhost:27017/test_db' }
     ming.configure(**config)
     self.session = TestDoc.__mongometa__.session
コード例 #24
0
def setup_schema(command, conf, vars):
    """Place any commands to setup allura here"""
    import ming
    import allura

    REGISTRY.prepare()
    REGISTRY.register(pylons.c, EmptyClass())
    REGISTRY.register(pylons.g, config['pylons.app_globals'])
    REGISTRY.register(allura.credentials, allura.lib.security.Credentials())
    ming.configure(**conf)
    # Nothing to do
    log.info('setup_schema called')
コード例 #25
0
ファイル: schema.py プロジェクト: Bitergia/allura
def setup_schema(command, conf, vars):
    """Place any commands to setup allura here"""
    import ming
    import allura

    REGISTRY.prepare()
    REGISTRY.register(pylons.c, EmptyClass())
    REGISTRY.register(pylons.g, config["pylons.app_globals"])
    REGISTRY.register(allura.credentials, allura.lib.security.Credentials())
    ming.configure(**conf)
    # Nothing to do
    log.info("setup_schema called")
コード例 #26
0
 def test_configure(self, Connection):
     ming.configure(**{
             'ming.main.uri':'mongodb://localhost:27017/test_db',
             'ming.main.connect_retry': 1,
             'ming.main.tz_aware': False,
             })
     session = Session.by_name('main')
     assert session.bind.conn is not None
     assert session.bind.db is not None
     assert session.bind.bind._auto_ensure_indexes
     args, kwargs = Connection.call_args
     assert 'database' not in kwargs
コード例 #27
0
ファイル: schema.py プロジェクト: vclisunlang/allura
def setup_schema(command, conf, vars):
    """Place any commands to setup allura here"""
    import ming
    import allura

    REGISTRY.prepare()
    REGISTRY.register(pylons.tmpl_context, EmptyClass())
    REGISTRY.register(pylons.app_globals, config['pylons.app_globals'])
    REGISTRY.register(allura.credentials, allura.lib.security.Credentials())
    ming.configure(**conf)
    if asbool(conf.get('activitystream.recording.enabled', False)):
        activitystream.configure(**h.convert_bools(conf, prefix='activitystream.'))
    # Nothing to do
    log.info('setup_schema called')
コード例 #28
0
def setup_schema(command, conf, vars):
    """Place any commands to setup allura here"""
    import ming
    import allura

    REGISTRY.prepare()
    REGISTRY.register(pylons.tmpl_context, EmptyClass())
    REGISTRY.register(pylons.app_globals, config['pylons.app_globals'])
    REGISTRY.register(allura.credentials, allura.lib.security.Credentials())
    ming.configure(**conf)
    if asbool(conf.get('activitystream.recording.enabled', False)):
        activitystream.configure(**conf)
    # Nothing to do
    log.info('setup_schema called')
コード例 #29
0
def main(global_config, **settings):
    """ This function returns a Pyramid WSGI application.
    """
    config = Configurator(settings=settings)

    # MongoDB connection configuration
    url_str = settings.get('mongo_uri', 'mongodb://localhost:27017/default')
    ming_config = {'ming.default.uri': url_str}
    ming.configure(**ming_config)

    config.add_static_view('static', 'static', cache_max_age=3600)
    config.add_route('home', '/')
    config.scan()
    return config.make_wsgi_app()
コード例 #30
0
ファイル: test_filesystem.py プロジェクト: 99Kies/allura
    def setUp(self):
        config = {
            'ming.main.uri': 'mim://allura',
            'ming.project.uri': 'mim://project-data',
        }
        ming.configure(**config)
        setup_unit_test()
        self.session = session(File)
        self.conn = M.session.main_doc_session.db._connection
        self.db = M.session.main_doc_session.db

        self.db.fs.remove()
        self.db.fs.files.remove()
        self.db.fs.chunks.remove()
コード例 #31
0
ファイル: test_datastore.py プロジェクト: TurboGears/Ming
 def test_configure_with_database(self):
     ming.configure(
         **{
             "ming.main.uri": "mongodb://localhost:27017/test_db",
             "ming.main.database": "another_test_db",
             "ming.main.connect_retry": 1,
             "ming.main.tz_aware": False,
         })
     session = Session.by_name("main")
     assert session.bind.conn is not None
     assert session.bind.db is not None
     assert session.bind.bind._auto_ensure_indexes
     args, kwargs = self.MockConn.call_args
     assert "database" in kwargs
コード例 #32
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--popsize", help="Population size", required=True)
    parser.add_argument("--maxinittraits", help="Max initial number of traits per indiv", required=True)
    parser.add_argument("--additionrate", help="Rate at which traits are added during interactions", required=True)
    parser.add_argument("--maxtraitvalue", help="Maximum integer token for traits in the trait space", required=True)
    parser.add_argument("--periodic", help="Periodic boundary condition", choices=['1','0'], required=True)
    parser.add_argument("--diagram", help="Draw a diagram of the converged model", action="store_true")
    parser.add_argument("--drift_rate", help="Rate of drift")


    args = parser.parse_args()

    simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)

    if args.drift_rate:
        simconfig.drift_rate = float(args.drift_rate)

    simconfig.popsize = int(args.popsize)
    simconfig.maxtraits = int(args.maxinittraits)
    simconfig.add_rate = float(args.additionrate)
    simconfig.max_trait_value = int(args.maxtraitvalue)

    simconfig.sim_id = uuid.uuid4().urn
    if args.periodic == '1':
        simconfig.periodic = 1
    elif args.periodic == '0':
        simconfig.periodic = 0
コード例 #33
0
ファイル: helpers.py プロジェクト: dastanforever/allura
def ming_config(**conf):
    """Temporarily swap in a new ming configuration, restoring the previous
    one when the contextmanager exits.

    :param \*\*conf: keyword arguments defining the new ming configuration

    """
    import ming
    from ming.session import Session
    datastores = Session._datastores
    try:
        ming.configure(**conf)
        yield
    finally:
        Session._datastores = datastores
        for name, session in Session._registry.iteritems():
            session.bind = datastores.get(name, None)
            session._name = name
コード例 #34
0
ファイル: helpers.py プロジェクト: lym/allura-git
def ming_config(**conf):
    """Temporarily swap in a new ming configuration, restoring the previous
    one when the contextmanager exits.

    :param \*\*conf: keyword arguments defining the new ming configuration

    """
    import ming
    from ming.session import Session
    datastores = Session._datastores
    try:
        ming.configure(**conf)
        yield
    finally:
        Session._datastores = datastores
        for name, session in Session._registry.iteritems():
            session.bind = datastores.get(name, None)
            session._name = name
コード例 #35
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--experiment",
        required=True,
        help=
        "provide name for experiment, to be used as prefix for database collections"
    )
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument(
        "--dryrun",
        help=
        "Do the calculations but do not change the database (handiest with --debug 1 to see the results",
        action="store_true")
    parser.add_argument("--configuration",
                        help="Configuration file for experiment",
                        required=True)

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if int(args.debug) == 1:
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    #### main program ####
    log.info("CALCULATING GRAPH SYMMETRY STATS - Experiment: %s",
             args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #36
0
ファイル: schema.py プロジェクト: apache/allura
def setup_schema(command, conf, vars):
    """Place any commands to setup allura here"""
    import ming
    import allura

    # turbogears has its own special magic wired up for its globals, can't use a regular Registry
    tgl = RequestLocals()
    tgl.tmpl_context = EmptyClass()
    tgl.app_globals = config['tg.app_globals']
    tg.request_local.context._push_object(tgl)

    REGISTRY.prepare()
    REGISTRY.register(allura.credentials, allura.lib.security.Credentials())

    ming.configure(**conf)
    if asbool(conf.get('activitystream.recording.enabled', False)):
        activitystream.configure(**h.convert_bools(conf, prefix='activitystream.'))
    # Nothing to do
    log.info('setup_schema called')
コード例 #37
0
ファイル: http.py プロジェクト: nloadholtes/chapman
def http_main(global_config, **local_settings):
    """ This function returns a (minimal) Pyramid WSGI application.
    """
    settings = dict(global_config)
    settings.update(local_settings)
    config = Configurator(settings=settings)
    config.add_renderer(None, 'pyramid.renderers.json_renderer_factory')
    config.add_route('chapman.1_0.queue', '/1.0/q/{qname}/')
    config.add_route('chapman.1_0.message', '/1.0/m/{message_id}/')
    config.add_subscriber(
        RequireHeader('Authorization', 'chapman %s' % settings['chapman.secret']),
        NewRequest)
    config.scan('chapman.views')
    if not ming.Session._datastores:
        ming.configure(**settings)
    app = config.make_wsgi_app()
    db = ming.Session.by_name('chapman').db
    app = MongoMiddleware(app, db.connection)
    return app
コード例 #38
0
ファイル: initialize_experiment.py プロジェクト: mmadsen/CTPy
def setup():
    global sargs, config, simconfig

    sargs = utils.ScriptArgs()
    if sargs.debug:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    simconfig = utils.CTPyConfiguration(sargs.configuration)

    log.debug("experiment name: %s", sargs.experiment_name)
    data.set_experiment_name(sargs.experiment_name)
    data.set_database_hostname(sargs.database_hostname)
    data.set_database_port(sargs.database_port)
    #### main program ####
    log.info("INITIALIZE_EXPERIMENT - Starting program")
    config = data.getMingConfiguration()
    ming.configure(**config)
コード例 #39
0
def setup():
    global sargs, config, simconfig
    sargs = utils.ScriptArgs()

    if sargs.debug == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    simconfig = utils.CTPyConfiguration(sargs.configuration)

    log.debug("experiment name: %s", sargs.experiment_name)
    data.set_experiment_name(sargs.experiment_name)
    data.set_database_hostname(sargs.database_hostname)
    data.set_database_port(sargs.database_port)

    log.info("CALCULATE_PERSIMRUN_STATISTICS - Starting program")
    config = data.getMingConfiguration()
    ming.configure(**config)
コード例 #40
0
def http_main(global_config, **local_settings):
    """ This function returns a (minimal) Pyramid WSGI application.
    """
    settings = dict(global_config)
    settings.update(local_settings)
    config = Configurator(settings=settings)
    config.add_renderer(None, 'pyramid.renderers.json_renderer_factory')
    config.add_route('chapman.1_0.queue', '/1.0/q/{qname}/')
    config.add_route('chapman.1_0.message', '/1.0/m/{message_id}/')
    config.add_subscriber(
        RequireHeader('Authorization',
                      'chapman %s' % settings['chapman.secret']), NewRequest)
    config.scan('chapman.views')
    if not ming.Session._datastores:
        ming.configure(**settings)
    app = config.make_wsgi_app()
    db = ming.Session.by_name('chapman').db
    app = MongoMiddleware(app, db.connection)
    return app
コード例 #41
0
def setup():
    global sargs, config, simconfig
    sargs = utils.ScriptArgs()
    if sargs.debug:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    simconfig = utils.CTPyConfiguration(sargs.configuration)

    log.debug("experiment name: %s", sargs.experiment_name)
    data.set_experiment_name(sargs.experiment_name)
    data.set_database_hostname(sargs.database_hostname)
    data.set_database_port(sargs.database_port)
    #### main program ####
    log.info("SUBSAMPLE_INDIVIDUAL_SAMPLES - Starting program")
    log.info("Performing subsampling for experiment named: %s", data.experiment_name)
    config = data.getMingConfiguration()
    ming.configure(**config)
コード例 #42
0
def setup(parser):
    config = parser.parse_args()

    sim_id = uuid.uuid1().urn
    script = __file__

    if config.debug == '1':
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    data.set_experiment_name(config.experiment)
    data.set_database_hostname(config.dbhost)
    data.set_database_port(config.dbport)
    dbconfig = data.getMingConfiguration(data.modules)
    ming.configure(**dbconfig)

    # set up parallelism.  At the moment, this doesn't do anything on OSX
    # but should provide parallelism on Linux across the replicates at least

    if config.cores is not None:
        cores = config.cores
    else:
        cores = utils.get_parallel_cores(config.devel)
    log.info("Setting up %s cores for parallel simulation", cores)

    import simuOpt
    if (config.debug == 1):
        simuOpt.setOptions(alleleType='long',
                           optimized=True,
                           quiet=False,
                           numThreads=cores)
    else:
        simuOpt.setOptions(alleleType='long',
                           optimized=True,
                           quiet=False,
                           numThreads=cores)

    return (config, sim_id, script, cores)
コード例 #43
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment",
                        help="provide name for experiment",
                        required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument("--configuration",
                        help="Configuration file for experiment",
                        required=True)
    parser.add_argument("--parallelism",
                        help="Number of concurrent processes to run",
                        default="4")
    parser.add_argument("--diagram",
                        help="Draw a diagram when complete",
                        default=False)

    args = parser.parse_args()

    simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #44
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment, to be used as prefix for database collections")
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Path to configuration file")
    parser.add_argument("--model", choices=['axelrod', 'extensible', 'treestructured'], required=True)
    parser.add_argument("--finalized", help="Only export runs which finalized after convergence", action="store_true")
    parser.add_argument("--filename", help="path to file for export", required=True)

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if args.model == 'axelrod':
        simconfig = utils.AxelrodConfiguration(args.configuration)
    elif args.model == 'extensible':
        simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)
    elif args.model == 'treestructured':
        simconfig = utils.TreeStructuredConfiguration(args.configuration)
    else:
        log.error("This shouldn't happen - args.model = %s", args.model)

    if args.debug == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')


    #### main program ####
    log.info("EXPORT DATA TO CSV - Experiment: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #45
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--experiment",
        help=
        "provide name for experiment, to be used as prefix for database collections"
    )
    parser.add_argument("--simid",
                        help="simulation ID to export from database")
    parser.add_argument("--debug", type=int, help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument("--outputdirectory",
                        help="path to directory for exported data files",
                        required=True)

    args = parser.parse_args()

    if args.debug == 1:
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    #### main program ####
    log.info("EXPORT DATA TO CSV - Experiment: %s  SimulationID: %s",
             args.experiment, args.simid)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #46
0
def setup():
    global args, config, simconfig
    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment, to be used as prefix for database collections")
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Path to configuration file")
    parser.add_argument("--filename", help="path and base filename for exports (DO NOT include *.csv extension)", required=True)

    args = parser.parse_args()

    if int(args.debug) == 1:
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    #### main program ####
    log.info("EXPORT DATA TO CSV - Experiment: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)
コード例 #47
0
ファイル: pipelines.py プロジェクト: dataista0/leninanalysis
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
from scrapy import log
from pymongo.errors import DuplicateKeyError

import config
from information_value.models import Document
from information_value.models import odm_session

import ming
ming_config = {'ming.document_store.uri': config.DATABASE_URL}
ming.configure(**ming_config)


class LeninPipeline(object):
    def process_item(self, item, spider):
        Document(
                name=item['name'],
                url=item['url'],
                text=item['text'],
                month=item['month'],
                year=int(item['year']),
                )
        try:
            odm_session.flush()
        except DuplicateKeyError:
            log.msg('Duplicate found', level=log.WARNING)
            return
        log.msg('Document saved', level=log.INFO)
コード例 #48
0
def _make_core_app(root, global_conf, full_stack=True, **app_conf):
    """
    Set allura up with the settings found in the PasteDeploy configuration
    file used.

    :param root: The controller module containing the TG root
    :param global_conf: The global settings for allura (those
        defined under the ``[DEFAULT]`` section).
    :type global_conf: dict
    :param full_stack: Should the whole TG2 stack be set up?
    :type full_stack: str or bool
    :return: The allura application with all the relevant middleware
        loaded.

    This is the PasteDeploy factory for the allura application.

    ``app_conf`` contains all the application-specific settings (those defined
    under ``[app:main]``.


    """
    # Run all the initialization code here
    mimetypes.init(
        [pkg_resources.resource_filename('allura', 'etc/mime.types')]
        + mimetypes.knownfiles)
    patches.apply()
    try:
        import newrelic
    except ImportError:
        pass
    else:
        patches.newrelic()
    # Configure MongoDB
    ming.configure(**app_conf)

    # Configure ActivityStream
    if asbool(app_conf.get('activitystream.recording.enabled', False)):
        activitystream.configure(**app_conf)

    # Configure EW variable provider
    ew.render.TemplateEngine.register_variable_provider(get_tg_vars)
    
    # Set FormEncode language to english, as we don't support any other locales
    formencode.api.set_stdtranslation(domain='FormEncode', languages=['en'])

    # Create base app
    base_config = ForgeConfig(root)
    load_environment = base_config.make_load_environment()

    # Code adapted from tg.configuration, replacing the following lines:
    #     make_base_app = base_config.setup_tg_wsgi_app(load_environment)
    #     app = make_base_app(global_conf, full_stack=True, **app_conf)

    # Configure the Pylons environment
    load_environment(global_conf, app_conf)

    if config.get('zarkov.host'):
        try:
            import zmq
        except ImportError:
            raise ImportError, "Unable to import the zmq library. Please"\
                               " check that zeromq is installed or comment out"\
                               " the zarkov.host setting in your ini file."

    app = tg.TGApp()
    if asbool(config.get('auth.method', 'local')=='sfx'):
        import sfx.middleware
        d = h.config_with_prefix(config, 'auth.')
        d.update(h.config_with_prefix(config, 'sfx.'))
        app = sfx.middleware.SfxMiddleware(app, d)
    # Required for pylons
    app = RoutesMiddleware(app, config['routes.map'])
    # Required for sessions
    app = SessionMiddleware(app, config)
    # Redirect 401 to the login page
    app = LoginRedirectMiddleware(app)
    # Add instrumentation
    app = AlluraTimerMiddleware(app, app_conf)
    # Clear cookies when the CSRF field isn't posted
    if not app_conf.get('disable_csrf_protection'):
        app = CSRFMiddleware(app, '_session_id')
    # Setup the allura SOPs
    app = allura_globals_middleware(app)
    # Ensure https for logged in users, http for anonymous ones
    if asbool(app_conf.get('auth.method', 'local')=='sfx'):
        app = SSLMiddleware(app, app_conf.get('no_redirect.pattern'))
    # Setup resource manager, widget context SOP
    app = ew.WidgetMiddleware(
        app,
        compress=not asbool(global_conf['debug']),
        # compress=True,
        script_name=app_conf.get('ew.script_name', '/_ew_resources/'),
        url_base=app_conf.get('ew.url_base', '/_ew_resources/'),
        extra_headers=eval(app_conf.get('ew.extra_headers', 'None')))
    # Handle static files (by tool)
    app = StaticFilesMiddleware(app, app_conf.get('static.script_name'))
    # Handle setup and flushing of Ming ORM sessions
    app = MingMiddleware(app)
    # Set up the registry for stacked object proxies (SOPs).
    #    streaming=true ensures they won't be cleaned up till
    #    the WSGI application's iterator is exhausted
    app = RegistryManager(app, streaming=True)
    # Converts exceptions to HTTP errors, shows traceback in debug mode
    tg.error.footer_html = '<!-- %s %s -->'  # don't use TG footer with extra CSS & images that take time to load
    app = tg.error.ErrorHandler(app, global_conf, **config['pylons.errorware'])
    # Make sure that the wsgi.scheme is set appropriately when we
    # have the funky HTTP_X_SFINC_SSL  environ var
    if asbool(app_conf.get('auth.method', 'local')=='sfx'):
        app = set_scheme_middleware(app)
    # Redirect some status codes to /error/document
    if config.get('override_root') != 'task':
        # "task" wsgi would get a 2nd request to /error/document if we used this middleware
        if asbool(config['debug']):
            app = StatusCodeRedirect(app, base_config.handle_status_codes)
        else:
            app = StatusCodeRedirect(app, base_config.handle_status_codes + [500])
    return app
コード例 #49
0
 def setUp(self):
     config = {
         'ming.main.uri': 'mim://allura_test',
     }
     ming.configure(**config)
コード例 #50
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment",
                        help="provide name for experiment",
                        required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument("--configuration",
                        help="Configuration file for experiment",
                        required=True)
    parser.add_argument("--popsize", help="Population size", required=True)
    parser.add_argument("--maxinittraits",
                        help="Max initial number of traits per indiv",
                        required=True)
    parser.add_argument(
        "--additionrate",
        help="Rate at which traits are added during interactions",
        required=True)
    parser.add_argument(
        "--maxtraitvalue",
        help="Maximum integer token for traits in the trait space",
        required=True)
    parser.add_argument("--periodic",
                        help="Periodic boundary condition",
                        choices=['1', '0'],
                        required=True)
    parser.add_argument("--diagram",
                        help="Draw a diagram of the converged model",
                        action="store_true")
    parser.add_argument("--drift_rate", help="Rate of drift")

    args = parser.parse_args()

    simconfig = utils.AxelrodExtensibleConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)

    if args.drift_rate:
        simconfig.drift_rate = float(args.drift_rate)

    simconfig.popsize = int(args.popsize)
    simconfig.maxtraits = int(args.maxinittraits)
    simconfig.add_rate = float(args.additionrate)
    simconfig.max_trait_value = int(args.maxtraitvalue)

    simconfig.sim_id = uuid.uuid4().urn
    if args.periodic == '1':
        simconfig.periodic = 1
    elif args.periodic == '0':
        simconfig.periodic = 0
コード例 #51
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment", help="provide name for experiment", required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost")
    parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017")
    parser.add_argument("--configuration", help="Configuration file for experiment", required=True)
    parser.add_argument("--popsize", help="Population size", required=True)
    parser.add_argument("--maxinittraits", help="Max initial number of traits per indiv", required=True)
    parser.add_argument("--learningrate", help="Rate at which traits are learned during interactions", required=True)
    parser.add_argument("--lossrate", help="Rate at which traits are lost randomly by individuals (0.0 turns this off)", required=True)
    parser.add_argument("--innovrate", help="Rate at which innovations occur in population", required=True)
    parser.add_argument("--periodic", help="Periodic boundary condition", choices=['1','0'], required=True)
    parser.add_argument("--diagram", help="Draw a diagram of the converged model", action="store_true")
    parser.add_argument("--swrewiring", help="Rewiring probability for Watts-Strogatz population graph", required=False)
    parser.add_argument("--numtraittrees", help="Number of trait trees in the design space", required=True)
    parser.add_argument("--branchingfactor", help="Value or mean for tree branching factor", required=True)
    parser.add_argument("--depthfactor", help="Value or mean for tree depth factor", required=True)
    parser.add_argument("--savetraitgraphs", help="Saves a snapshot of trait tree graphs", action="store_true")
    parser.add_argument("--samplinginterval", help="Interval between samples, once sampling begins, defaults to 1M steps", default="1000000")
    parser.add_argument("--samplingstarttime", help="Time at which sampling begins, defaults to 1M steps", default="6000000")
    parser.add_argument("--simulationendtime", help="Time at which simulation and sampling end, defaults to 10000000 steps", default="10000000")

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)

    if args.swrewiring:
        simconfig.ws_rewiring = float(args.swrewiring)

    simconfig.popsize = int(args.popsize)
    simconfig.maxtraits = int(args.maxinittraits)
    simconfig.learning_rate = float(args.learningrate)
    simconfig.num_trees = int(args.numtraittrees)
    simconfig.branching_factor = float(args.branchingfactor)
    simconfig.depth_factor = float(args.depthfactor)
    simconfig.loss_rate = float(args.lossrate)
    simconfig.innov_rate = float(args.innovrate)
    simconfig.maxtime = int(args.simulationendtime)
    simconfig.script = __file__
    simconfig.save_graphs = args.savetraitgraphs

    simconfig.sim_id = uuid.uuid4().urn
    if args.periodic == '1':
        simconfig.periodic = 1
    else:
        simconfig.periodic = 0
コード例 #52
0
ファイル: middleware.py プロジェクト: 00mjk/allura
def _make_core_app(root, global_conf, full_stack=True, **app_conf):
    """
    Set allura up with the settings found in the PasteDeploy configuration
    file used.

    :param root: The controller module containing the TG root
    :param global_conf: The global settings for allura (those
        defined under the ``[DEFAULT]`` section).
    :type global_conf: dict
    :param full_stack: Should the whole TG2 stack be set up?
    :type full_stack: str or bool
    :return: The allura application with all the relevant middleware
        loaded.

    This is the PasteDeploy factory for the allura application.

    ``app_conf`` contains all the application-specific settings (those defined
    under ``[app:main]``.


    """
    # Run all the initialization code here
    mimetypes.init([pkg_resources.resource_filename('allura', 'etc/mime.types')] + mimetypes.knownfiles)

    # Configure MongoDB
    ming.configure(**app_conf)

    # Configure ActivityStream
    if asbool(app_conf.get('activitystream.recording.enabled', False)):
        activitystream.configure(**h.convert_bools(app_conf, prefix='activitystream.'))

    # Configure EW variable provider
    ew.render.TemplateEngine.register_variable_provider(get_tg_vars)

    # Set FormEncode language to english, as we don't support any other locales
    formencode.api.set_stdtranslation(domain='FormEncode', languages=['en'])

    # Create base app
    base_config = ForgeConfig(root)
    load_environment = base_config.make_load_environment()

    # Code adapted from tg.configuration, replacing the following lines:
    #     make_base_app = base_config.setup_tg_wsgi_app(load_environment)
    #     app = make_base_app(global_conf, full_stack=True, **app_conf)

    # Configure the TG environment
    load_environment(global_conf, app_conf)

    app = tg.TGApp()

    for mw_ep in h.iter_entry_points('allura.middleware'):
        Middleware = mw_ep.load()
        if getattr(Middleware, 'when', 'inner') == 'inner':
            app = Middleware(app, config)

    # Required for sessions
    app = SessionMiddleware(app, config, data_serializer=BeakerPickleSerializerWithLatin1())
    # Handle "Remember me" functionality
    app = RememberLoginMiddleware(app, config)
    # Redirect 401 to the login page
    app = LoginRedirectMiddleware(app)
    # Add instrumentation
    app = AlluraTimerMiddleware(app, app_conf)
    # Clear cookies when the CSRF field isn't posted
    if not app_conf.get('disable_csrf_protection'):
        app = CSRFMiddleware(app, '_session_id')
    if asbool(config.get('cors.enabled', False)):
        # Handle CORS requests
        allowed_methods = aslist(config.get('cors.methods'))
        allowed_headers = aslist(config.get('cors.headers'))
        cache_duration = asint(config.get('cors.cache_duration', 0))
        app = CORSMiddleware(app, allowed_methods, allowed_headers, cache_duration)
    # Setup the allura SOPs
    app = allura_globals_middleware(app)
    # Ensure http and https used per config
    if config.get('override_root') != 'task':
        app = SSLMiddleware(app, app_conf.get('no_redirect.pattern'),
                            app_conf.get('force_ssl.pattern'),
                            app_conf.get('force_ssl.logged_in'))
    # Setup resource manager, widget context SOP
    app = ew.WidgetMiddleware(
        app,
        compress=True,
        use_cache=not asbool(global_conf['debug']),
        script_name=app_conf.get('ew.script_name', '/_ew_resources/'),
        url_base=app_conf.get('ew.url_base', '/_ew_resources/'),
        extra_headers=ast.literal_eval(app_conf.get('ew.extra_headers', '[]')),
        cache_max_age=asint(app_conf.get('ew.cache_header_seconds', 60*60*24*365)),

        # settings to pass through to jinja Environment for EW core widgets
        # these are for the easywidgets' own [easy_widgets.engines] entry point
        # (the Allura [easy_widgets.engines] entry point is named "jinja" (not jinja2) but it doesn't need
        #  any settings since it is a class that uses the same jinja env as the rest of allura)
        **{
            'jinja2.auto_reload': asbool(config['auto_reload_templates']),
            'jinja2.bytecode_cache': AlluraJinjaRenderer._setup_bytecode_cache(),
            'jinja2.cache_size': asint(config.get('jinja_cache_size', -1)),
        }
    )
    # Handle static files (by tool)
    app = StaticFilesMiddleware(app, app_conf.get('static.script_name'))
    # Handle setup and flushing of Ming ORM sessions
    app = MingMiddleware(app)
    # Set up the registry for stacked object proxies (SOPs).
    #    streaming=true ensures they won't be cleaned up till
    #    the WSGI application's iterator is exhausted
    app = RegistryManager(app, streaming=True)

    # "task" wsgi would get a 2nd request to /error/document if we used this middleware
    if config.get('override_root') not in ('task', 'basetest_project_root'):
        if asbool(config['debug']):
            # Converts exceptions to HTTP errors, shows traceback in debug mode
            # don't use TG footer with extra CSS & images that take time to load
            tg.error.footer_html = '<!-- %s %s -->'
            app = tg.error.ErrorHandler(app, global_conf, **config['tg.errorware'])
        else:
            app = ErrorMiddleware(app, config, **config['tg.errorware'])

        app = SetRequestHostFromConfig(app, config)

        # Redirect some status codes to /error/document
        if asbool(config['debug']):
            app = StatusCodeRedirect(app, base_config.handle_status_codes)
        else:
            app = StatusCodeRedirect(
                app, base_config.handle_status_codes + [500])

    for mw_ep in h.iter_entry_points('allura.middleware'):
        Middleware = mw_ep.load()
        if getattr(Middleware, 'when', 'inner') == 'outer':
            app = Middleware(app, config)

    return app
コード例 #53
0
config_file = None
simconfig = utils.CTPyConfiguration(config_file)

log.basicConfig(level=log.DEBUG,
                format='%(asctime)s %(levelname)s: %(message)s')

log.debug("experiment name: %s", args.experiment_name)
log.debug(
    "NOTE:  This interactive simulation always sends data to MongoDB instance on localhost"
)

data.set_experiment_name(args.experiment_name)
data.set_database_hostname("localhost")
data.set_database_port("27017")
config = data.getMingConfiguration()
ming.configure(**config)

sim_id = uuid.uuid4().urn

log.info("Beginning simulation run: %s", sim_id)

beginCollectingData = cpm.expectedIAQuasiStationarityTimeHaploid(
    args.popsize, args.mutationrate)
log.info("Starting data collection at generation: %s", beginCollectingData)

totalSimulationLength = beginCollectingData + args.length
log.info("Simulation will sample %s generations after stationarity",
         args.length)

data.storeSimulationData(args.popsize, args.mutationrate, sim_id,
                         args.samplesize, args.replications, args.numloci,
コード例 #54
0
def setup():
    global args, simconfig

    parser = argparse.ArgumentParser()
    parser.add_argument("--experiment",
                        help="provide name for experiment",
                        required=True)
    parser.add_argument("--debug", help="turn on debugging output")
    parser.add_argument("--dbhost",
                        help="database hostname, defaults to localhost",
                        default="localhost")
    parser.add_argument("--dbport",
                        help="database port, defaults to 27017",
                        default="27017")
    parser.add_argument("--configuration",
                        help="Configuration file for experiment",
                        required=True)
    parser.add_argument("--popsize", help="Population size", required=True)
    parser.add_argument("--maxinittraits",
                        help="Max initial number of traits per indiv",
                        required=True)
    parser.add_argument(
        "--learningrate",
        help="Rate at which traits are learned during interactions",
        required=True)
    parser.add_argument(
        "--lossrate",
        help=
        "Rate at which traits are lost randomly by individuals (0.0 turns this off)",
        required=True)
    parser.add_argument("--innovrate",
                        help="Rate at which innovations occur in population",
                        required=True)
    parser.add_argument("--periodic",
                        help="Periodic boundary condition",
                        choices=['1', '0'],
                        required=True)
    parser.add_argument("--diagram",
                        help="Draw a diagram of the converged model",
                        action="store_true")
    parser.add_argument(
        "--swrewiring",
        help="Rewiring probability for Watts-Strogatz population graph",
        required=False)
    parser.add_argument("--numtraittrees",
                        help="Number of trait trees in the design space",
                        required=True)
    parser.add_argument("--branchingfactor",
                        help="Value or mean for tree branching factor",
                        required=True)
    parser.add_argument("--depthfactor",
                        help="Value or mean for tree depth factor",
                        required=True)
    parser.add_argument("--savetraitgraphs",
                        help="Saves a snapshot of trait tree graphs",
                        action="store_true")
    parser.add_argument(
        "--samplinginterval",
        help=
        "Interval between samples, once sampling begins, defaults to 250K steps",
        default="250000")
    parser.add_argument(
        "--samplingstarttime",
        help="Time at which sampling begins, defaults to 1000000 steps",
        default="1000000")

    args = parser.parse_args()

    simconfig = utils.TreeStructuredConfiguration(args.configuration)

    if args.debug == '1':
        log.basicConfig(level=log.DEBUG,
                        format='%(asctime)s %(levelname)s: %(message)s')
    else:
        log.basicConfig(level=log.INFO,
                        format='%(asctime)s %(levelname)s: %(message)s')

    log.debug("experiment name: %s", args.experiment)
    data.set_experiment_name(args.experiment)
    data.set_database_hostname(args.dbhost)
    data.set_database_port(args.dbport)
    config = data.getMingConfiguration(data.modules)
    ming.configure(**config)

    if args.swrewiring:
        simconfig.ws_rewiring = float(args.swrewiring)

    simconfig.popsize = int(args.popsize)
    simconfig.maxtraits = int(args.maxinittraits)
    simconfig.learning_rate = float(args.learningrate)
    simconfig.num_trees = int(args.numtraittrees)
    simconfig.branching_factor = float(args.branchingfactor)
    simconfig.depth_factor = float(args.depthfactor)
    simconfig.loss_rate = float(args.lossrate)
    simconfig.innov_rate = float(args.innovrate)
    simconfig.maxtime = simconfig.SIMULATION_CUTOFF_TIME
    simconfig.script = __file__
    simconfig.save_graphs = args.savetraitgraphs

    simconfig.sim_id = uuid.uuid4().urn
    if args.periodic == '1':
        simconfig.periodic = 1
    else:
        simconfig.periodic = 0