def load(self):
     _path = os.path.join(self.root_dir, 'database', 'master_scol')
     with open(_path, 'rb') as _f:
         buf = Reader(_f)
         I, S = buf.read_int, buf.read_str
         def assert_int(i):
             if I() != i:
                 buf.error("Not valid scenario data")
         count = I()     # 剧情章节总计
         for chapter in range(count):
             chapter_id = I()
             chapter = self.scenario[chapter_id] = Chapter()
             assert_int(0)
             chapter.id = chapter_id
             chapter.i = I()
             chapter.title = S()
             chapter.sections = []
             for i in range(I()):
                 section = Section()
                 section.prefix = I()
                 section.title = S()
                 section.battle_num = I()
                 section.talks = []
                 for j in range(I()):
                     section.talks.append(I())
                 chapter.sections.append(section)
             if chapter_id < 400:
                 assert_int(0xc8)
             else:
                 assert_int(0xa1)
         buf.end()

def evaluate(expr):
    reader = Reader(expr)
    try:
        exprs = reader.read()
    except Exception, e:
        print e
        return

def message_affiche_choix(message, rcenter):
    texte = Reader(message, pos=(rcenter[0] - 290, rcenter[1] + 210), width=cote_fenetre - 20, fontsize=16, height=80,
                   bg=(150, 150, 150), fgcolor=(20, 20, 20))
    # texte.TEXT = message
    continuer_2 = 1
    choix = "n"  # valeur par défaut
    while continuer_2:
        for event in pygame.event.get():
            texte.show()
            if event.type == JOYBUTTONUP:
                if event.button == 0:
                    choix = "o"
                    continuer_2 = 0
                elif event.button == 1:
                    choix = "n"
                    continuer_2 = 0
            elif event.type == KEYDOWN:
                if event.key == K_n:
                    choix = "n"
                    continuer_2 = 0
                elif event.key == K_o:
                    choix = "o"
                    continuer_2 = 0
            elif event.type != KEYDOWN and event.type != MOUSEBUTTONDOWN and event.type != JOYBUTTONUP:
                continue
            elif event.type == QUIT:
                sys.exit()
    return choix

def main(unused_args):
    reader = Reader(split = 0.9)
    x_train, y_train, x_test, y_test = reader.get_data(glob('../../WSJ-2-12/*/*.POS'))
    print('len(reader.word_to_id)',len(reader.word_to_id),
          'len(reader.tag_to_id)', len(reader.tag_to_id))
    print('len(x_train)',len(x_train),
          'len(x_test)', len(x_test))
    best_misclass = 1.0

    with tf.Graph().as_default(), tf.Session() as session:
        initializer = tf.random_uniform_initializer(-FLAGS.init_scale, FLAGS.init_scale)
        with tf.variable_scope("model", reuse=None, initializer=initializer):
            m = RNNTagger(True, len(reader.word_to_id), len(reader.tag_to_id))
        with tf.variable_scope("model", reuse=True, initializer=initializer):
            mtest = RNNTagger(False, len(reader.word_to_id), len(reader.tag_to_id))

        tf.initialize_all_variables().run()

        saver = tf.train.Saver()
        for i in range(FLAGS.max_max_epoch):
            lr_decay = FLAGS.lr_decay ** max(i - FLAGS.max_epoch, 0.0)
            m.assign_lr(session, FLAGS.learning_rate * lr_decay)

            print("Epoch: %d Learning rate: %.3f" % (i + 1, session.run(m.lr)))
            train_perplexity, _ = run_epoch(session, m, x_train, y_train, m.train_op,
                                         verbose=True)
            _, misclass = run_epoch(session, mtest, x_test, y_test, tf.no_op(), verbose=True)
            if misclass < best_misclass:
                best_misclass = misclass
                fname = 'dropout_double_rnn_tagger_' + str(best_misclass)
                saver.save(session, fname, global_step=i)
                print('saving', fname)

def load_lisp_core(filename="core.lisp"):
    # Load up and evaluate core.lisp
    f = open(filename)
    reader = Reader(f.read(), filename)
    f.close()
    for expr in reader.read():
        expr.evaluate(core.scope)

    def __init__(self, file_path, tree_name):
        """
        Constructor
        """

        ## Execute the base class constructor
        Reader.__init__(self, file_path, tree_name)

 def loadData(self):
     reader = Reader()
     print('loading data')
     self.X_train, self.y_train, self.meta_train=self.prepareData(reader.getData(TRAIN))
     print('train data has been loaded!')
     self.X_valid, self.y_valid, self.meta_valid=self.prepareData(reader.getData(DEV))
     print('valid data has been loaded!')
     self.X_test, self.y_test, self.meta_test=self.prepareData(reader.getData(TEST))
     print('test data has been loaded!')

    def __switch(self, xiinArgDict):
        """
        Traffic director.
        """
        from reader import Reader
        reader = Reader()
        # Write output
        if xiinArgDict.filename is not None:
            print('Starting xiin...')
            print('')
            with open(xiinArgDict.filename, 'w') as xiinArgDict.outputFile:
                reader.info(xiinArgDict)

        #Displays output.
        elif xiinArgDict.display:
            print('Starting xiin...')
            print('')
            reader.info(xiinArgDict)

        elif xiinArgDict.grep is not None:
            print('Starting xiin...')
            print('')
            print('Searching files...')
            print('')
            self.grepXiinInfo(xiinArgDict.grep)

        elif xiinArgDict.upload is not None:
    #        xiin.ftp = {'source': '', 'destination': '', 'uname': '', 'password': ''}
            from uploader import Uploader

            xiinArgDict.ftpSource      = None
            xiinArgDict.ftpDestination = None
            xiinArgDict.ftpUname       = None
            xiinArgDict.ftpPwd         = None

            if len(xiinArgDict.upload ) > 0:
                xiinArgDict.ftpSource      = xiinArgDict.upload[0]
                xiinArgDict.ftpDestination = xiinArgDict.upload[1]

            if len(xiinArgDict.upload ) > 2:
                # Legacy support
                if xiinArgDict.ftpUname is 'anon' or xiinArgDict.ftpUname is 'anonymous':
                    pass
                else:
                    xiinArgDict.ftpUname       = xiinArgDict.upload[2]
                    xiinArgDict.ftpPwd         = xiinArgDict.upload[3]

            print('Starting xiin uploader...')
            print('')
            print('Uploading debugging information...')
            print('')

            uploader = Uploader()
            uploader.upload(xiinArgDict.ftpSource, xiinArgDict.ftpDestination, xiinArgDict.ftpUname, xiinArgDict.ftpPwd)
        else:
            print('ERROR: Unknown')
            exit(7)

 def get_nuclide_from_file(self, file_name):
     try:
         reader = Reader(file_name)
         reader.read_z_a(self.z, self.a)
         nuclide = Nuclide(name=reader.nuclide_data.name, z=int(reader.nuclide_data.z),
                           a=int(reader.nuclide_data.a))
         return nuclide
     except Exception, e:
         raise e

def main(size, path):
    checker = Checker(size)
    reader = Reader(checker, size)
    data = reader.read("data\\" + path)
    solver = Solver(checker, size)

    try:
        return solver.solve(data)
    except Exception as e:
        return str(e)

def main():
  SUCCESS = 0
  #arguments declaration
  parser = argparse.ArgumentParser()
  parser.add_argument('--omitheader','-m', help='Do not show the header about pizza and kittens',  action='store_true', default=False)
  parser.add_argument('--hublist', help='Shows all available hubs',  action='store_true', default=False)
  parser.add_argument('--similar','-s', help='Displays similar hubs as a histogram', nargs=1, metavar=("hub_name"))
  parser.add_argument('--alsoread','-a', help='Displays what else people read from this hub as a histogram', nargs=1, metavar=("hub_name"))
  parser.add_argument('--max', help='Print several hubs that maximize the score function e.g. --similar or --alsoread', nargs=1, metavar=("number_of_hubs"), type=int) 
  parser.add_argument('--min', help='Print several hubs that minimize the score function e.g. --similar or --alsoread', nargs=1, metavar=("number_of_hubs"), type=int)
  parser.add_argument('--company', help='If a name is ambiguous, like yandex: it is a hub and a company, then enforce company interpretation', action="store_true", default=False)

  args = vars(parser.parse_args())

  #check flags and delegate functions to src/reader.py and src/hubs_wrapper.py
  if len(sys.argv)==1:
    print_header_hubs()
    parser.print_help()
    return SUCCESS

  if args['omitheader']:
    pass
  else:
    print_header_hubs()

  if args['hublist']:
    Reader.print_hubs()
    return SUCCESS

  isCompany = False
  if args['company']:
    isCompany = True

  flag = None
  flagopts = None
  if args['max']:
    flag = "max"
    flagopts = args['max'][0]

  if args['min']:
    flag = "min"
    flagopts = args['min'][0]

  if args['similar']:
    hub_name = args['similar'][0]
    display_preferences(hub_name, isCompany, "similarity", flag, flagopts)
    return SUCCESS

  if args['alsoread']:
    hub_name = args['alsoread'][0]
    display_preferences(hub_name, isCompany, "inclusion", flag, flagopts)
    return SUCCESS

class Wayterm(object):
    def __init__(self):
        self.app_key = '1746312660'
        self.app_secret = 'a113b12f49266b12125f6df1f9808045'
        self.callback_url = 'http://wayterm.nerocrux.org/done'
        self.template = Template()
        self.url = Url()
        self.reader = Reader()
        self.token = {}

        if self._read_access_token():
            self.client = Client(self.app_key, self.app_secret, self.callback_url, self.token)
        else:
            self.client = Client(self.app_key, self.app_secret, self.callback_url)
            self.auth_url = self.url.shorten(self.client.authorize_url)
            print '[1] Open this url in your browser: ' + self.auth_url
            self.auth_code = raw_input('[2] Enter authorization code: ')
            self.client.set_code(self.auth_code)
            token = {
                'access_token':self.client.token['access_token'],
                'expires_at':self.client.token['expires_at'],
                'uid':self.client.token['uid'],
            }
            self._write_access_token(token)
            print 'Authorization done. Enjoy!'


    def _read_access_token(self):
        try:
            self.token = yaml.load(open(os.path.join(os.getenv('HOME'), '.wayterm.yaml')).read())
        except:
            return False
        return True


    def _write_access_token(self, token):
        stream = file(os.path.join(os.getenv('HOME'), '.wayterm.yaml'), 'w')
        yaml.dump(token, stream)


    def _init_print(self):
        self.reader.printfile('logo')


    def call(self, command):
        if command[0].lower() == 'exit':
            exit()
        if command[0].lower() == 'help':
            self.reader.printfile('help')
            return
        api = Api(self.client)
        api.call(command)

class Generator:
    def __init__(self, filename):
        self.reader = Reader(filename)

    def execute(self):
        self.reader.execute()
        datas=self.reader.getData()

        tps=[InterfaceTemplate(datas), ImplementTemplate(datas), \
             TestTemplate(datas)]

        for tp in tps:
            print tp.execute()

 def load(self):
     _path = path.join(self.root_dir, 'database', 'master_card')
     with open(_path, 'rb') as _f:
         buf = Reader(_f)
         count = buf.read_int()  # 卡牌数量
         offsets = [0] * count
         self.cards = cards = [None] * count
         for i in range(count):
             cards[i] = MACard()
             offsets[i] = buf.read_int()
         for i, card in enumerate(cards):
             buf.seek(offsets[i])
             card.load(buf)

def evaluate_file(filename):
    try:
        f = open(filename)
    except IOError:
        print "Cannot open file %s" % repr(filename)
        return
    reader = Reader(f.read())
    f.close()
    try:
        exprs = reader.read()
    except Exception, e:
        print e
        return

def main_test():
    reader = Reader()
    retainer = Retainer()
    params = reader.read()
    api_targets = []
    for name, param in params.items():
        parser = Parser(name, param)
        api_targets.append(parser)
    for target in api_targets:
        creater = Creater(target)
        api_parameters = creater.create()
        retainer.insert(target.name, api_parameters)
    retainer.close()

 def __init__(self):
     reader = Reader()
     print('loading data')
     self.X_train=reader.getData(TRAIN)
     print('train data has been loaded!')
     self.X_valid=reader.getData(DEV)
     print('valid data has been loaded!')
     self.X_test=reader.getData(TEST)
     print('test data has been loaded!')
     self.c_title=[]
     self.c_body=[]
     self.bigram=Phrases.load('./data/bigram.dat')
     self.trigram=Phrases.load('./data/trigram.dat')

class Notifier(wx.App):
    """main notifier app"""

    def __init__(self):

        wx.App.__init__(self, redirect=0)

        # menu handlers
        menu = [
            ("Show again", self.again),
            ("Settings", self.settings),
            ("Exit", self.exit),
        ]

        # main objects
        self.icon = Icon(menu)
        self.popup = Popup()
        self.reader = Reader(feeds=["http://digg.com/rss/index.xml"])

        # main timer routine
        timer = wx.Timer(self, -1)
        self.Bind(wx.EVT_TIMER, self.main, timer)
        timer.Start(500)
        self.MainLoop()

    def main(self, event):

        if not self.popup.opened():
            # show popup for next new item
            for item in self.reader.items():
                self.popup.show("%(feed)s\n%(title)s%(title)s%(title)s%(title)s%(title)s%(title)s%(title)s%(title)s" % item)
                status = "on"
                break
            else:
                status = "off"
            # set icon status
            self.icon.setStatus(status)

    def again(self):
        print "again"

    def settings(self):
        print "settings"

    def exit(self):

        # close objects and end
        self.reader.close()
        self.icon.close()
        self.Exit()

def main(opts):
    if not opts.demo:
        from reader import Reader

    global q
    delay = 0.001
    lights = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}

    print opts
    if not opts.demo:
        reader = Reader(lights)

    sounder = Sounder()
    player = Player(sounder)
    songs = os.listdir("./songs/")
    songs = filter(lambda x: x.endswith(".js"), songs)

    numpy.random.shuffle(songs)
    print ("Loaded songs:")
    print (songs)

    for song in cycle(songs):
        # time.sleep(.5)
        q = player.song(song)

        while True:
            debug_str = ""
            time.sleep(delay)

            if not opts.demo:
                reader.fetch()

            if not q["play"].empty():
                player.chord(q["play"].get_nowait())

            for ch in lights:
                debug_str += "{}:{} ".format(ch, lights[ch])
                if lights[ch] < 650 or opts.demo:
                    sounder.start(get_str(ch))
                else:
                    sounder.stop(get_str(ch))

            # print(debug_str)
            time.sleep(delay)

            if q["sig"] == "stopped":
                print "caught sig... stopping song"
                sounder.mute()
                break

    def test_extractLinks(self):
        print ">>> test_extractLinks"
        app    = LinkCrawler()
        reader = Reader(app)
        configIsLoaded = app.loadConfigurationSite("unittest")

        if configIsLoaded is False:
            self.fail("load configuration failed")
        else:
            response     = reader.getResponse('http://www.scandio.de')
            responseData = response[3]
            links = reader.extractLinks(responseData, 'http://www.scandio.de')

        print "<<< test_extractLinks [links: %s]\n" % links
        self.failUnless(links)