Python utils.read_config函数代码示例

def main(params_file):
    params = {}
    params_file = os.path.realpath(params_file)
    # Figure out the paths
    script_path = os.path.realpath(__file__)
    script_dir = os.path.dirname(script_path)
    app_dir = os.path.dirname(script_dir)
    params['app_dir'] = app_dir

    # Current timestamp
    curr_timestamp = time.strftime("%d_%b_%Y_%H_%M_%S_GMT", time.gmtime())

    # read configuration file and check
    utils.read_config(params_file, params)
    process_country_gender(params)

def main(argv):
    """
    Entry point for etl module.
    """
    option_parser = optparse.OptionParser(usage=DEFAULT_USAGE_TEXT)
    option_parser.add_option("-c", "--config", dest="config",
                             default="config.cfg", help="Configuration file")
    option_parser.add_option("-v", "--verbose", dest="verbose",
                             action="store_true", default=False,
                             help="Show verbose output")
    options, _ = option_parser.parse_args(argv)

    if not os.path.exists(options.config):
        sys.stderr.write("ERROR: {} does not exist\n".format(options.config))
        option_parser.print_help()
        return 1
    config = read_config(options.config)

    log_dir = config['general']['log_dir']
    if not os.path.exists(log_dir):
        os.mkdir(log_dir)
    filename = os.path.join(log_dir, __file__.replace(".py", ".log"))
    setup_logger(filename, options.verbose)
    logging.debug("config={}".format(json.dumps(config, indent=2)))

    retcode = run_etl(config)
    return retcode

def play_sound(fname):
    global cfg_dict
    cfg_dict = utils.read_config()

    audio = pyaudio.PyAudio()
    stream_audio = audio.open(format=pyaudio.paInt16,
                              channels=2,
                              rate=cfg_dict['rate'],
                              output=True,
                              frames_per_buffer=cfg_dict['rate'])

    f = open(fname)
    data = list(utils.chunks(f.read(), cfg_dict['rate']))
    f.close()

    print ' * play'
    start = time.time()

    for i in range(len(data)):
        stream_audio.write(data[i])

    print ' * play end |',

    stream_audio.stop_stream()
    stream_audio.close()
    audio.terminate()

    print 'elapsed time =', time.time() - start

 def __init__(self, path):
     """
     :param path: path to theme file
     :type path: str
     :raises: :class:`~alot.settings.errors.ConfigError`
     """
     self._spec = os.path.join(DEFAULTSPATH, 'theme.spec')
     self._config = read_config(path, self._spec,
                                checks={'align': align_mode,
                                        'widthtuple': width_tuple,
                                        'force_list': force_list,
                                        'attrtriple': attr_triple})
     self._colours = [1, 16, 256]
     # make sure every entry in 'order' lists have their own subsections
     threadline = self._config['search']['threadline']
     for sec in self._config['search']:
         if sec.startswith('threadline'):
             tline = self._config['search'][sec]
             if tline['parts'] is not None:
                 listed = set(tline['parts'])
                 here = set(tline.sections)
                 indefault = set(threadline.sections)
                 diff = listed.difference(here.union(indefault))
                 if diff:
                     msg = 'missing threadline parts: %s' % ', '.join(diff)
                     raise ConfigError(msg)

def XST(env, target, source):
    """
    A pseudo-Builder wrapper for the XST synthesizer

    Reads the config file
    Creates the XST Project file (containing all the verilog)
    Creates the XST Script file (containing all of the commands)
    Executes the build

    Args:
        env (SCons Environment)
        target (list of strings)
        source (list of strings) 

    Returns:
        The output file list

    Raises:
        XSTBuilderWarning
        XSTBuilderError
    """
    #OKAY MAYBE I DIDN'T NEED A PSUEDO-BUILDER
    config = utils.read_config(env)
    _xst_builder.__call__(env, env["XST_NGC_FILE"], config["verilog"])
    return [xst_utils.get_ngc_filename(config)]

def upload(env, target, source):
    """
    A Pseudo-builder wrapper for the upload program
    """
    config = utils.read_config(env)

    _upload_builder.__call__(env, target, source)
    return "upload_img"

 def test_create_build_directory(self):
     cfg = utils.read_config(self.env)
     build_dir = "temp"
     cfg["build_dir"] = build_dir
     utils.create_build_directory(cfg)
     build_dir = os.path.join(utils.get_project_base(), build_dir)
     self.assertTrue(os.path.exists(build_dir))
     os.rmdir(build_dir)

def modify_results(results_filename, exam_config_filename,
                   output_filename, invalidate, set_correct):
    config = utils.read_config()
    results = utils.read_results(results_filename)
    exam_data = utils.ExamConfig(exam_config_filename)
    for result in results:
        modify(result, exam_data, invalidate, set_correct)
    utils.write_results(results, output_filename, config['csv-dialect'])

def BITGEN(env, target, source):
    """
    A pseudo-builder wrapper for Xilinx Bitgen
    """
    config = utils.read_config(env)
    env["BITGEN_SOURCES"] = source
    env["BITGEN_TARGETS"] = target
    _bitgen_builder.__call__(env, target, source)
    return bitgen_utils.get_bitgen_filename(config)

 def __init__(self, path):
     """
     :param path: path to theme file
     :type path: str
     :raises: :class:`~alot.settings.errors.ConfigError`
     """
     self._spec = os.path.join(DEFAULTSPATH, 'theme.spec')
     self._config = read_config(path, self._spec)
     self.attributes = self._parse_attributes(self._config)

def main(params_file):
    params = {}
    params_file = os.path.realpath(params_file)
    # Figure out the paths
    script_path = os.path.realpath(__file__)
    script_dir = os.path.dirname(script_path)
    app_dir = os.path.dirname(script_dir)
    params['app_dir'] = app_dir

    # Current timestamp
    curr_timestamp = time.strftime("%d_%b_%Y_%H_%M_%S_GMT", time.gmtime())

    # read configuration file and check
    utils.read_config(params_file, params)
    gen_class = GenderClassifier()
    #gen_class.loadData(params['process_country_gender_output_file_gender'], params['process_country_gender_output_file_gender_zh'], params['gender_classifier_model_file_zh'])
    gen_class.loadModel(params['gender_classifier_model_file_zh'])
    t1 = time.time()
    for c in ascii_lowercase:
        print gen_class.predict(c)
    print gen_class.predict('Diyi Yang')
    t2 = time.time()
    print("Predict Time: %f ms" % ((t2 - t1) * 1000))
    print gen_class.predict('Yuntian Deng')
    print gen_class.predict('Hanyue Liang')
    print gen_class.predict('Lidan Mu')
    print gen_class.predict('Lanxiao Xu')
    print gen_class.predict('Zhiruo Zhou')
    print gen_class.predict('Charlotte Riley')
    print gen_class.predict('Qi Guo')
    print gen_class.predict('Eric Xing')
    print gen_class.predict('Yiming Yang')
    print gen_class.predict('Xiaoping Deng')
    print gen_class.predict('Yidi Zhao')
    print gen_class.predict('Yuanchi Ning')
    print gen_class.predict('Jinping Xi')
    print gen_class.predict('Liyuan Peng')
    print gen_class.predict('Wei-chiu Ma')
    print gen_class.predict('Zhiting Hu')
    print gen_class.predict('Hao Zhang')
    print gen_class.predict('Li Zhou')
    print gen_class.predict('Shayan Doroudi')
    print gen_class.predict('Daniel Guo')
    print gen_class.predict('Christoph Dann')

def TRACE(env, target, source):
    """
    A pseudo-builder wrapper for Xilinx trace
    """
    config = utils.read_config(env)
    env["TRACE_SOURCES"] = source
    env["TRACE_TARGETS"] = target

    _trace_builder.__call__(env, target, source)
    return trace_utils.get_trace_filename(config)

def generate(env):
    env["UPLOAD_COMMAND"] = _detect(env)
    config = utils.read_config(env)
    upload_flags = config["upload_flags"]
    
    env.SetDefault(
            UPLOAD_FLAGS = upload_flags,
            UPLOAD_COMSTR = "$UPLOAD_COMMAND $UPLOAD_FLAGS $SOURCES"
            )
    env.AddMethod(_upload_builder, "upload")
    return None

def PAR(env, target, source):
    """
    A pseudo-builder wrapper for the Xilinx par
    """
    config = utils.read_config(env)
    env["PAR_SOURCES"] = source
    env["PAR_TARGETS"] = target

    _par_builder.__call__(env, target, source)

    return par_utils.get_par_filename(config)

    def __init__(self, pid, role, config_path):
        self.__config = utils.read_config(config_path)
        for r in self.__config:
            if r in ('acceptors', 'proposers', 'clients', 'learners'):
                self.__config[r][1] = int(self.__config[r][1])
        self.__role = role
        self.__multicast_group = tuple(self.__config[self.__role])

        self._id = pid
        self.__recv_socket = self.__init_socket(self.__multicast_group[0])
        self.__recv_socket.bind(self.__multicast_group)