Python pyconfig.get函数代码示例

def test_watching():
    # Enable watching
    os.environ['PYCONFIG_ETCD_WATCH'] = 'true'

    pyconfig.Config().clear()
    pyconfig.set('pyconfig.etcd.prefix', 'pyconfig_test/watching')
    pyconfig.reload()

    # Wait for 20ms before writing to ensure the watcher thread is ready
    time.sleep(0.020)

    # Write a new value directly to etcd
    pyconfig.etcd().client.write('pyconfig_test/watching/it.works', 
            pytool.json.as_json(True))

    # Try to get the value... this is a bit sloppy but good luck doing
    # something better
    retry = 50
    while retry:
        retry -= 1
        if pyconfig.get('it.works', None) is not None:
            break
        # Wait 20ms more for it to show up
        time.sleep(0.020)

    eq_(pyconfig.get('it.works', False), True)

 def __init__(self):
     self.host = cfg.get('DBHOST')
     self.port = cfg.get('DBPORT')
     self.name = cfg.get('DBNAME')
     self.collection = cfg.get('COLLECTION')
     self.url = self.get_database_url()
     self.client = MongoClient(self.url)
     self.database = self.client[self.name]

def run_tlsanl(pdb_file_path, xyzout, pdb_id, log_out_dir=".",
               verbose_output=False):
    """Run TLSANL.

    A REFMAC file with residual isotropic B-factors and proper TLS descriptions
    is expected. Total isotropic B-factors are written out in the ATOM and
    ANISOU records.

    WARNING: it is assumed that ATOM & HETATM records in the input PDB must
    first be sorted on chain ID and residue number before the TLS ranges
    can be interpreted.

    Detailed documentation for TLSANL can be found at
    http://www.ccp4.ac.uk/html/tlsanl.html.
    """
    _log.info("Preparing TLSANL run...")
    success = False
    keyworded_input = "BINPUT t\nBRESID t\nISOOUT FULL\nNUMERIC\nEND\n"
    p = subprocess.Popen(["tlsanl", "XYZIN", pdb_file_path, "XYZOUT", xyzout],
                         stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                         stderr=subprocess.PIPE)
    (stdout, stderr) = p.communicate(input=keyworded_input)
    try:
        with open(os.path.join(log_out_dir, pyconfig.get("TLSANL_LOG")),
                  "w") as tlsanl_log:
            tlsanl_log.write(stdout)
            if verbose_output:
                print(stdout)
        with open(os.path.join(log_out_dir, pyconfig.get("TLSANL_ERR")),
                  "w") as tlsanl_err:
            tlsanl_err.write(stderr)
            if verbose_output:
                print(stderr)
    except IOError as ex:
        _log.error(ex)
    if p.returncode != 0:
        message = "Problem with TLS group definitions (TLSANL run unsuccessful)"
        write_whynot(pdb_id, message)
        _log.error("{0:s}".format(message))
    elif os.stat(xyzout).st_size <= 2000:
        # from script at http://deposit.rcsb.org/adit/REFMAC.html
        message = "TLSANL problem"
        write_whynot(pdb_id, message)
        _log.error("{0:s}".format(message))
    elif os.stat(os.path.join(log_out_dir,
                              pyconfig.get("TLSANL_ERR"))).st_size > 0:
        message = "Problem with TLS group definitions (TLSANL run unsuccessful)"
        write_whynot(pdb_id, message)
        _log.error("{0:s}".format(message))
    else:
        success = True
        _log.info("TLSANL ran without problems.")
    return success

def test_mongo_uri_with_database():
    if _version._lt('2.6.0'):
        raise SkipTest("Needs version 2.6.0 or later")

    host = pyconfig.get('humbledb.test.db.host', 'localhost')
    port = pyconfig.get('humbledb.test.db.port', 27017)
    uri = 'mongodb://{}:{}/{}'.format(host, port, database_name())

    class DBuri(Mongo):
            config_uri = uri

    with DBuri:
        eq_(DBuri.database.name, database_name())
        eq_(Mongo.context.database.name, database_name())

def main():
    """Create mongo-bdb."""

    parser = argparse.ArgumentParser(
        description='Create a MongoDB document store from bdb json files.')
    parser.add_argument(
        '-q', '--quiet',
        help='show less verbose output',
        action='store_true')
    mode = parser.add_mutually_exclusive_group()
    mode.add_argument('-i', '--insall', help='Insert all documents without ' +
                      'checking if they already exist in the store.',
                      action='store_true')
    mode.add_argument('-u', '--upsert', help='Update all documents. If the ' +
                      'document does not yet exist, it is created.',
                      action='store_true')
    args = parser.parse_args()

    # Set the log level depending on verbosity
    if args.quiet:
        LOG.setLevel(logging.INFO)
        LOG.debug('Configured less verbose logging.')

    crawler = DocumentFinder(cfg.get('DOCUMENT_WILDCARD'))
    LOG.info('Preparing to store {0:d} bdb documents...'.format(
        len(crawler.document_paths)))
    database = Database()

    if args.insall:
        insert_all(database, crawler)
    elif args.upsert:
        upsert_all(database, crawler)

    LOG.info('Finished creating mongo-bdb.')

def create_strava_authorization():
        id = idgen.getId()
        redirect_url = request.args.get('redirect_uri')

        if redirect_url is None:
            abort(400, 'no redirect_uri parameter provided')

        params = {
                  'client_id': pyconfig.get('strava.client_id'),
                  'redirect_uri': redirect_url,
                  'response_type': 'code',
                  'scope': 'public',
                  'approval_prompt': 'force',
                  'state': id
        }

        auth = {
                'id': id,
                'url': 'https://www.strava.com/oauth/authorize?{params}'.format(params=urllib.urlencode(params)),
                'createdTs': datetime.datetime.utcnow()
        }
        con.authorizations.insert(auth)

        return Response(dumps({
            'id': auth['id'],
            'url': auth['url'],
            'createdTs': str(auth['createdTs'])
        }), mimetype='application/json')

def test_get_default_with_various_values():
    eq_(pyconfig.get('default_num', 1), 1)
    eq_(pyconfig.get('default_num', 1.0), 1.0)
    eq_(pyconfig.get('default_none', None), None)
    eq_(pyconfig.get('default_true', True), True)
    eq_(pyconfig.get('default_false', False), False)
    eq_(pyconfig.get('default_unicode', 'Test'), 'Test')
    eq_(pyconfig.get('default_expr', 60*24), 60*24)
    eq_(pyconfig.get('ns.test_namespace', 'pyconfig'), 'pyconfig')

def test_mongo_uri_database_with_conflict_raises_error():
    if _version._lt('2.6.0'):
        raise SkipTest("Needs version 2.6.0 or later")

    host = pyconfig.get('humbledb.test.db.host', 'localhost')
    port = pyconfig.get('humbledb.test.db.port', 27017)
    uri = 'mongodb://{}:{}/{}'.format(host, port, database_name())

    class DBuri(Mongo):
            config_uri = uri

    from humbledb import Document
    class TestDoc(Document):
        config_database = database_name() + '_is_different'
        config_collection = 'test'

    with DBuri:
        TestDoc.find()

 def start(cls):
     """ Public function for manually starting a session/context. Use
         carefully!
     """
     if cls in Mongo.contexts:
         raise NestedConnection("Do not nest a connection within itself, it "
                 "may cause undefined behavior.")
     if pyconfig.get('humbledb.allow_explicit_request', True):
         pass#cls.connection.start_request()
     Mongo.contexts.append(cls)

 def end(cls):
     """ Public function for manually closing a session/context. Should be
         idempotent. This must always be called after :meth:`Mongo.start`
         to ensure the socket is returned to the connection pool.
     """
     if pyconfig.get('humbledb.allow_explicit_request', True):
         pass#cls.connection.end_request()
     try:
         Mongo.contexts.pop()
     except (IndexError, AttributeError):
         pass

    def reload(self):
        self.client = MongoClient(pyconfig.get('mongodb.host', 'strava-mongodb'), int(pyconfig.get('mongodb.port', '27017')))
        self.db = self.client.stravasocial
        self.comparisons = self.db.comparisons
        self.authorizations = self.db.authorizations
        self.roles = self.db.roles

        self.gearman_connections = [
            'strava-gearmand:4730'
        ]
        self.gearmanClient = GearmanClient(self.gearman_connections)
        self.ff = FeatureFlags()

def test_auto_increment_errors_with_wrong_db():
    if _version._lt('2.6.0'):
        raise SkipTest

    host = pyconfig.get('humbledb.test.db.host', 'localhost')
    port = pyconfig.get('humbledb.test.db.port', 27017)
    uri = 'mongodb://{}:{}/{}'.format(host, port, database_name())

    class DBuri(Mongo):
        config_uri = uri

    class MyDoc2(Document):
        config_database = database_name()
        config_collection = 'test'

        auto = 'a', auto_increment(database_name() + '_is_different', SIDECAR,
                'MyDoc2')


    doc = MyDoc2()
    with DBuri:
        doc.auto

    def as_live(self):
        """
        Return this call as if it were being assigned in a pyconfig namespace,
        but load the actual value currently available in pyconfig.

        """
        key = self.get_key()
        default = pyconfig.get(key)
        if default:
            default = repr(default)
        else:
            default = self._default() or NotSet()
        return "%s = %s" % (key, default)

    def ensure(self, cls):
        """ Does an ensure_index call for this index with the given `cls`.

            :param cls: A Document subclass

        """
        # Allow disabling of index creation
        if not pyconfig.get('humbledb.ensure_indexes', True):
            return

        # Map the attribute name to its key name, or just let it ride
        index = self._resolve_index(cls)

        # Make the ensure index call
        cls.collection.ensure_index(index, **self.kwargs)

def write_whynot(pdb_id, reason):
    """Create a WHY NOT file.

    Return a Boolean.
    """
    directory = pyconfig.get("BDB_FILE_DIR_PATH")
    filename = pdb_id + ".whynot"
    _log.warn("Writing WHY NOT entry.")
    try:
        with open(os.path.join(directory, filename), "w") as whynot:
            whynot.write("COMMENT: " + reason + "\n" +
                         "BDB," + pdb_id + "\n")
            return True
    except IOError as ex:
        _log.error(ex)
        return False