예제 #1
0
    def test_col(self):
        params = '--col=timestamp --file={0} --limit=1' \
            .format(self.test_path)

        with StdOut() as output:
            main(*params.split(' '))
        self.assertEqual(output[0], '2015-06-13T07:20:24.110235Z')
예제 #2
0
    def test_offset(self):
        params = "--col=request_processing_time --file={0} --limit=1 --offset=1".format(self.test_path)

        with StdOut() as output:
            main(*params.split(" "))
        self.assertEqual(len(output), 1)
        self.assertEqual(output[0], "0.000075")
예제 #3
0
    def test_order_reverse(self):
        params = '--col=request_processing_time --file={0} --limit=1 --order-reverse=request_processing_time' \
            .format(self.test_path)

        with StdOut() as output:
            main(*params.split(' '))
        self.assertEqual(output[0], '0.000089')
예제 #4
0
    def test_limit_lines(self):
        params = '--col=request_processing_time --file={0} --limit=1' \
            .format(self.test_path)

        with StdOut() as output:
            main(*params.split(' '))
        self.assertEqual(len(output), 1)
예제 #5
0
def main():
    ''' Logging housekeeping '''
    logManager.main(logsPath)
    ''' Load config '''
    loadConfig()
    ''' Set LoggingLevel set in settings.conf '''
    logger.setLevel(LOGGING_LEVEL)
    logger.info('Logger level set to %s', LOGGING_LEVEL)
    ''' Grab credentials '''
    creds = getCredentials()
    service = build('calendar', 'v3', credentials=creds)
    ''' Grab events from calendar '''
    getEvents(service, 100)
    ''' Parse website '''
    parser.main()
    ''' Process results from parsing '''
    for (eventTitle, eventInfo) in savedLocalEvents.items():
        eventDateTime, eventURL = eventInfo
        if eventURL not in savedRemoteEvents:
            ''' We might already know the event, see if we should update '''
            ''' See if we match any of our existing event names '''
            for (remoteURL, remoteInfo) in savedRemoteEvents.items():
                remoteTitle, remoteStart, remoteId = remoteInfo
                ''' we're not support checking matching time yet '''
                if (remoteTitle == eventTitle
                    ):  #or (remoteStart == eventDateTime):
                    print(bcolors.OKGREEN + 'Update the following event:')
                    print(remoteTitle + ', ' + remoteStart + bcolors.ENDC)
                    logger.info('Update the following event:')
                    logger.info(remoteTitle + ', ' + remoteStart)
                    ''' Lets delete the old event before creating new '''
                    print('Deleting old event...')
                    logger.info('Deleting old event...')
                    service.events().delete(calendarId=CALENDAR_ID,
                                            eventId=remoteId).execute()
                    break
            createEvent(service, eventDateTime, eventTitle, eventURL)
        else:
            ''' We have the URL of the event '''
            ''' but we may need to update '''
            if 'T' in eventDateTime:
                ''' Check if there is a time added to the Events Page '''
                remoteTitle, remoteStart, remoteId = savedRemoteEvents[
                    eventURL]
                if 'T' not in remoteStart:
                    print(bcolors.OKGREEN +
                          'Update the time of following event: ')
                    print(remoteTitle + ', ' + remoteStart + bcolors.ENDC)
                    logger.info('Update the time of the following event: ')
                    logger.info(remoteTitle + ', ' + remoteStart)
                    ''' Lets delete the old event before creating new '''
                    print('Deleting old event...')
                    logger.info('Deleting old event...')
                    service.events().delete(calendarId=CALENDAR_ID,
                                            eventId=remoteId).execute()
                    createEvent(service, eventDateTime, eventTitle, eventURL)

    getEvents(service, 100)
    sendEmail()
예제 #6
0
def test_integrate_relation_error(tmp_path, monkeypatch):
    filename = 'a'
    text = 'a :- a a'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main(['--relation', f'{filename}'])
    res = open(f'{filename}.out', 'r').read()
    assert res.split(' ', 1)[0] == 'ERROR'
예제 #7
0
def test_integrate_module(tmp_path, monkeypatch):
    filename = 'a'
    text = 'module a.'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main(['--module', f'{filename}'])
    res = open(f'{filename}.out', 'r').read()
    assert res == 'Module (ID (a))'
예제 #8
0
def test_integrate_type(tmp_path, monkeypatch):
    filename = 'a'
    text = 'type a a->a.'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main(['--type', f'{filename}'])
    res = open(f'{filename}.out', 'r').read()
    assert res == 'Typedef (ID (a)) (Arrow (Type (Atom (ID (a)))) (Type (Atom (ID (a)))))'
예제 #9
0
def test_integrate_atom(tmp_path, monkeypatch):
    filename = 'a'
    text = 'a a'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main(['--atom', f'{filename}'])
    res = open(f'{filename}.out', 'r').read()
    assert res == 'Atom (ID (a)) (Atom (ID (a)))'
예제 #10
0
def test_integrate_prog_2(tmp_path, monkeypatch):
    filename = 'a'
    text = 'a a.'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main([f'{filename}'])
    res = open(f'{filename}.out', 'r').read()
    assert res == 'Program (\nRelation (Atom (ID (a)) (Atom (ID (a))))\n)'
예제 #11
0
    def test_order_reverse(self):
        params = "--col=request_processing_time --file={0} --limit=1 --order-reverse=request_processing_time".format(
            self.test_path
        )

        with StdOut() as output:
            main(*params.split(" "))
        self.assertEqual(output[0], "0.000089")
예제 #12
0
def main():
    """This function runs the user interface, prompting the user and calling the necessary functions to resolve their queries"""

    print "Hello, welcome to the recipe transformer!"
    print "To get started, please enter the URL of the recipe you would like to transform. At any point, you may enter \"back\" to return to the previous menu."
    print "You may also enter \"done\" at any point to terminate the program."
    menu = 0
    prompt = ["Enter AllRecipes.com URL:  ", "Enter transformation (enter \"list\" for a list of posible transformations):  ", "Would you like to apply another transformation to this new recipe?  "]
    URL = ""
    again = False

    transformations = ['pescatarian', 'vegetarian', 'east asian', 'italian', 'easy', 'low sodium', 'low carb']


    print "Hello world"

    while(True):
        command = raw_input(prompt[menu]).lower()
        if command == "done":
            return
        if command == "back":
            menu -= 1
            if menu < 0:
                menu = 0
            continue
        if menu == 0:
            if command[:29] == "http://allrecipes.com/recipe/":
                URL = command
                menu += 1
                continue
            print "Invalid URL"
        if menu == 1:
            if command == "list":
                print ", ".join(transformations)
                continue
            if command in transformations:
                if again:
                    transformed_recipe.url = ''
                    transformed_recipe.transformation = command
                    recipes = parser.main(transformed_recipe)
                else:
                    recipe = recipe_classes.Recipe(URL, "recipe", command)
                    recipes = parser.main(recipe)
                original_recipe = recipes[0]
                transformed_recipe = recipes[1]
                menu += 1
                continue
            print "Invalid transformation"
        if menu == 2:
            if command == "yes":
                again = True
                menu = 1
                continue
            if command == "no":
                again = False
                menu = 0
                continue
            print "Invalid response"
예제 #13
0
def test_integrate_arg_error_2(tmp_path, monkeypatch, capsys):
    filename = 'a'
    text = 'kek'
    (tmp_path / filename).write_text(text)
    monkeypatch.chdir(tmp_path)
    parser.main(['kek', f'{filename}'])
    out, err = capsys.readouterr()
    assert err == ''
    assert out == 'Invalid args\n'
예제 #14
0
def index():
	if request.method == 'POST':
		pdf_file = request.files['file']
		if pdf_file and allowed_files(pdf_file.filename):
			filename = secure_filename(pdf_file.filename)
			pdf_file.save(os.path.join(app.config['UPLOAD_FOLDER'],filename))
                        parser.main(pdf=filename)
                        if "@" in filename and filename.count(".") == 2:
                                name_csv = filename.split(".")[0]+"."+filename.split(".")[1]+".csv"
                        else:
                                name_csv = filename.split(".")[0]+".csv"
                        
			return redirect(url_for('download',filename=name_csv))
	return render_template("index.html")
예제 #15
0
 def test_parser(self):
     '''
     Runs the parser on each file in the sentences directory. This is not intended as a true test,
     but rather as a way to review parser performance with each text file quickly.
     '''
     filepath = os.getcwd() + '/sentences/*.txt'
     # Get all filenames and reverse list to run sequentially
     filenames = glob.glob(filepath)[::-1]
     # Loop through filenames and add them to argv sequentially
     for filename in filenames:
         test_argv = ["parser.py", filename]
         with patch.object(sys, 'argv', test_argv):
             # Run main and check output
             main()
예제 #16
0
    def test_forbidden(self):
        request = self.read_file("tests/forbidden_1.txt")
        output = parser.main(request)
        self.assertEqual(output,
                         ["HTCPCP-TEA/1.0 403 Forbidden", "\r\n", "\r\n"])

        request = self.read_file("tests/forbidden_2.txt")
        output = parser.main(request)
        self.assertEqual(output,
                         ["HTCPCP-TEA/1.0 403 Forbidden", "\r\n", "\r\n"])

        request = self.read_file("tests/forbidden_3.txt")
        output = parser.main(request)
        self.assertEqual(output,
                         ["HTCPCP-TEA/1.0 403 Forbidden", "\r\n", "\r\n"])
예제 #17
0
def handle_connection(socket):
    """ Handles every connection seen by the server. Converts bytes into parser-expected format,
    then forwards to parser, sending response back over the socket.
    socket - the socket corresponding to the client.
    """
    buffer = b""
    data = socket.recv(2048)
    buffer = data.decode("UTF-8")
    splitStr = ""
    request = []
    # convert bytes read in to request format, splitting on the new line
    # each array has each line of the request, including the /r/n, which
    # is normally stripped by .split().
    while True:
        if buffer == "":
            request.append(bytes(splitStr, "UTF-8"))
            break
        splitStr += buffer[0]
        if buffer[0] == "\n":
            # had to open files as rb in parser, sending splitStr as
            # bytes avoids having to re-write that stuff
            request.append(bytes(splitStr, "UTF-8"))
            splitStr = ""
        buffer = buffer[1:]
    response = parser.main(request)
    for line in response:
        socket.send(bytes(line, "UTF-8"))
    socket.close()
    return
예제 #18
0
 def test_coffee(self):
     request = self.read_file("tests/coffee.txt")
     output = parser.main(request)
     self.assertEqual(output, [
         "HTCPCP-TEA/1.0 200 OK", "\r\n",
         "Content-Type: message/coffee-pot-command\r\n", "\r\n"
     ])
     os.remove("./pot-0")
예제 #19
0
 def test_stop(self):
     request = self.read_file("tests/stop.txt")
     output = parser.main(request)
     self.assertEqual(output, [
         "HTCPCP-TEA/1.0 200 OK", "\r\n",
         "Content-Type: message/teapot\r\n", "\r\n"
     ])
     os.remove("./pot-0/peppermint")
     os.rmdir("./pot-0")
예제 #20
0
def get_func(message):
    if message.text == 'Легковые авто':
        url = 'search/all/'
        main(url)
    if message.text == 'Коммерческие авто':
        main('commercialsearch/all/')
    if message.text == 'Спецтехника':
        main('specsearch/all/')
    if message.text == 'Мотоциклы':
        main('motosearch/all/')
    get_start(message)
예제 #21
0
 def test_index(self):
     request = self.read_file("tests/index.txt")
     output = parser.main(request)
     expectedOutput = [
         "HTCPCP-TEA/1.0 300 Multiple Options\r\n", "Alternates: ",
         "{\"peppermint\" {type message/teapot}}", ",\r\n",
         "{\"black\" {type message/teapot}}", ",\r\n",
         "{\"green\" {type message/teapot}}", ",\r\n",
         "{\"earl-grey\" {type message/teapot}}", "\r\n", "\r\n"
     ]
     self.assertEqual(output, expectedOutput)
예제 #22
0
    def test_php(self):
        request = self.read_file("tests/php_get.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", ")\r\n", "</pre><pre>Array\r\n",
            "(\r\n", ")\r\n", "</pre>\r\n", "\r\n"
        ])

        request = self.read_file("tests/php_get_param.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", "    [testvar] => test\r\n",
            ")\r\n", "</pre><pre>Array\r\n", "(\r\n", ")\r\n", "</pre>\r\n",
            "\r\n"
        ])

        request = self.read_file("tests/php_get_params.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", "    [testvar] => test\r\n",
            "    [testvar2] => test\r\n", ")\r\n", "</pre><pre>Array\r\n",
            "(\r\n", ")\r\n", "</pre>\r\n", "\r\n"
        ])

        request = self.read_file("tests/php_get_404.txt")
        output = parser.main(request)
        self.assertEqual(output,
                         ["HTCPCP-TEA/1.0 404 Not Found", "\r\n", "\r\n"])

        request = self.read_file("tests/php_post.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", ")\r\n", "</pre><pre>Array\r\n",
            "(\r\n", ")\r\n", "</pre>\r\n", "\r\n"
        ])

        request = self.read_file("tests/php_post_param.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", ")\r\n", "</pre><pre>Array\r\n",
            "(\r\n", "    [testvar] => test\r\n", ")\r\n", "</pre>\r\n", "\r\n"
        ])

        request = self.read_file("tests/php_post_params.txt")
        output = parser.main(request)
        self.assertEqual(output, [
            "HTCPCP-TEA/1.0 200 OK", "\r\n", "Content-Type: text/plain",
            "\r\n", "<pre>Array\r\n", "(\r\n", ")\r\n", "</pre><pre>Array\r\n",
            "(\r\n", "    [testvar] => test\r\n", "    [testvar2] => test\r\n",
            ")\r\n", "</pre>\r\n", "\r\n"
        ])
예제 #23
0
def main():
    number_of_cores = int(sys.argv[1])
    number_of_tasks = int(sys.argv[2])
    for utilisation in [90, 80, 70, 60, 50, 40, 30, 20, 10]:
        path = "TaskSets/" + str(number_of_cores) + "Cores" + str(
            number_of_tasks) + "Tasks" + str(utilisation) + ".csv"
        resultPath = "MILPresults" + str(number_of_cores) + "Cores" + str(
            number_of_tasks) + "Tasks"

        for jobs, releaseTimes, deadlines, executionTimes, processors, M in parser.main(
                number_of_cores, path):
            status = milpForm.runExperiment(jobs, releaseTimes, deadlines,
                                            executionTimes, processors, M)
            lg.log_results(resultPath, [utilisation, status])
예제 #24
0
def start(input_file, output_file, version):
    output_file
    with open(output_file, "w") as output:
        output.write("zaragoza\n")
        output.write("t2ri0va94ush0tdu9gpuusq64r\n")
    counter = 1
    for problem in parser.main(input_file):
        try:
            start_time = time.time()
            print("Problem {}".format(counter), end="\r")
            sys.stdout.flush()
            with open(output_file, "a") as output:
                resulting_string = algorithm.solve_problem(
                    counter, version, problem)
                if not resulting_string.replace(" ", ""):
                    print("Problem {} not completed due to no result found".
                          format(counter))
                    counter += 1
                    continue
                output.write("{}: {}\n".format(counter, resulting_string))
            problem_coverage_results = coverage_calculator.go(
                input_file, output_file, counter)
            if problem_coverage_results:
                result = "32mPASSED" if problem_coverage_results[
                    0] >= 30 else "31mFAILED"
                print(
                    "\033[{}\033[0m Problem {}: Coverage: {}%, Score: {} - {} seconds"
                    .format(result, counter, problem_coverage_results[0],
                            problem_coverage_results[1],
                            round(time.time() - start_time, 2)))
            else:
                print("\033[91mERROR\033[0m Problem {} - {} seconds".format(
                    counter, round(time.time() - start_time, 2)))
            counter += 1
        except KeyboardInterrupt:
            print("Problem {} not completed due to Keyboard Interrupt".format(
                counter))
            sys.stdout.flush()
            counter += 1
예제 #25
0
 def render(self):
     input_string = self.input_text.get(1.0,tk.END)
     from parser import main
     main(input_string)
     image = tk.PhotoImage(file = "output.png")
     self.output_image_label.config(image = image)
예제 #26
0
파일: prod.py 프로젝트: xch91/foodnemo
import parser


if __name__ == '__main__':
    parser.main(
        '/opt/proj/foodnemo/raw/order.json',
        '/opt/proj/foodnemo/raw/order.loc',
        '/opt/proj/foodnemo/raw/order.pid',
    )
예제 #27
0
    def test_col(self):
        params = "--col=timestamp --file={0} --limit=1".format(self.test_path)

        with StdOut() as output:
            main(*params.split(" "))
        self.assertEqual(output[0], "2015-06-13T07:20:24.110235Z")
예제 #28
0
def update_parser():
    print("Parsing Last Week's Data...")
    main()
    return 'Update Success!'
예제 #29
0
def main():
    official_pdf_analyzer.main()
    parser.main()
    merger.main()
예제 #30
0
파일: views.py 프로젝트: qxbug/ojbk_jiexi
def api():
    url = request.form.get('url')
    hash_ = request.form.get('hash')
    captcha_code = request.form.get('captcha_code')
    if captcha_code is not None:
        print 'input code is :', captcha_code
        print 'session code is :', session.get('CAPTCHA')
        if captcha_code.upper() == session.get('CAPTCHA'):
            return jsonify({'captcha': 'pass'})
    if hash_ != session.get('hash'):
        return jsonify({'captcha': 'ok'})
    if hash_ is None:
        return jsonify({'captcha': 'ok'})
    if request.headers['User-Agent'] is None or 'python' in request.headers[
            'User-Agent'].lower():
        return jsonify({'captcha': 'ok'})
    else:
        retdata = {}
        # tumblr单个视频解析
        if 'tumblr.com/post' in url:
            try:
                video = ''
                cont = requests.get(url).content
                pictures = IMAGEREGEX.findall(cont)
                vid = VIDEOREGEX.findall(cont)
                poster = POSTERREGEX.findall(cont)
                isvideo = 0
                if vid:
                    video = vhead % vid[0]
                    poster = poster[0]
                    isvideo = 1
                    # flash('解析成功')
                    retdata['status'] = 'ok'
                    retdata['total'] = 1
                    retdata['pages'] = 1
                    retdata['video'] = [{
                        'url': video,
                        'desc': '',
                        'thumb': poster
                    }]
                    return jsonify(retdata)
                else:
                    # flash('解析失败')
                    retdata['status'] = 'fail'
                    retdata['message'] = '解析失败,请联系站长解决'
                    return jsonify(retdata)
            except Exception, e:
                print e
                # flash('解析失败')
                retdata['status'] = 'fail'
                retdata['message'] = '解析失败,请联系站长解决'
                return jsonify(retdata)
        # tumblr批量解析
        if 'tumblr.com' in url:
            id = re.findall('://(.*?)\.', url)[0]
            if check(id):
                is_exists = ID.query.filter_by(id=id).first()
                if is_exists is None:
                    now = datetime.now()
                    inserttime = now.strftime('%Y%m%d %H:%M:%S')
                    a = ID(id=id, updateTime=inserttime, parseTimes=1)
                    db.session.add(a)
                    db.session.commit()
                    retdata['status'] = 'fail'
                    retdata['message'] = '正在解析,请稍等15s再试!'
                    subprocess.Popen('python {clawer} {id}'.format(
                        clawer=clawer, id=id),
                                     shell=True)
                    return jsonify(retdata)
                else:
                    now = datetime.now()
                    is_exists.updateTime = now.strftime('%Y%m%d %H:%M:%S')
                    is_exists.parseTimes += 1
                    db.session.add(is_exists)
                    db.session.commit()
                    subprocess.Popen('python {clawer} {id}'.format(
                        clawer=clawer, id=id),
                                     shell=True)
                    retdata['status'] = 'ok'
                    retdata['total'] = 50
                    retdata['pages'] = 2
                    retdata[
                        'html'] = '<a href="/download?id={}&type=video" class="btn btn-primary" role="button" title="导出视频">导出视频 <span class="glyphicon glyphicon-film"></span></a>'.format(
                            id)
                    retdata[
                        'html'] += ' | <a href="/download?id={}&type=picture" class="btn btn-primary" role="button" title="导出图片">导出图片 <span class="glyphicon glyphicon-picture"></span></a>'.format(
                            id)
                    videos = Context.query.filter_by(
                        id=id, isvideo=1).order_by(
                            Context.posttime.desc()).limit(50).all()
                    for video in videos:
                        retdata.setdefault('video', []).append({
                            'url':
                            video.urls,
                            'desc':
                            video.description,
                            'thumb':
                            video.poster
                        })
                    return jsonify(retdata)
            else:
                # flash('解析失败')
                retdata['status'] = 'fail'
                retdata['message'] = '解析失败,请联系站长解决'
                return jsonify(retdata)
        # 2mm
        else:
            try:
                video, title, picture = parser.main(url)
                retdata['status'] = 'ok'
                retdata['total'] = 1
                retdata['pages'] = 1
                retdata['video'] = [{
                    'url': video,
                    'desc': title,
                    'thumb': picture
                }]
                return jsonify(retdata)
            except Exception, e:
                print e
                retdata['status'] = 'fail'
                retdata['message'] = '解析网站不存在'
                return jsonify(retdata)
예제 #31
0
                retdata['status'] = 'ok'
                retdata['total'] = 50
                retdata['pages'] = 2
                retdata['html'] = '<a href="/download?id={}&type=video" class="btn btn-primary" role="button" title="导出视频">导出视频 <span class="glyphicon glyphicon-film"></span></a>'.format(
                    id)
                retdata['html'] += ' | <a href="/download?id={}&type=picture" class="btn btn-primary" role="button" title="导出图片">导出图片 <span class="glyphicon glyphicon-picture"></span></a>'.format(
                    id)
                videos = Context.query.filter_by(
                    uid=id, isvideo=1).order_by(Context.posttime.desc()).limit(50).all()
                for video in videos:
                    retdata.setdefault('video', []).append(
                        {'url': video.urls, 'desc': video.description, 'thumb': video.poster})
                return jsonify(retdata)
        else:
            try:
                video, title, picture = parser.main(url)
                retdata['status'] = 'ok'
                retdata['total'] = 1
                retdata['pages'] = 1
                retdata['video'] = [
                    {'url': video, 'desc': title, 'thumb': picture}]
                return jsonify(retdata)
            except Exception, e:
                print e
                retdata['status'] = 'fail'
                retdata['message'] = '解析网站不存在'
                return jsonify(retdata)


@app.route('/download')
def download():
예제 #32
0
def main():
    """This function runs the user interface, prompting the user and calling the necessary functions to resolve their queries"""

    print "Hello, welcome to the recipe transformer!"
    print "To get started, please enter the URL of the recipe you would like to transform. At any point, you may enter \"back\" to return to the previous menu."
    print "You may also enter \"done\" at any point to terminate the program."
    menu = 0
    prompt = [
        "Enter AllRecipes.com URL:  ",
        "Enter transformation (enter \"list\" for a list of posible transformations):  ",
        "Would you like to apply another transformation to this new recipe?  "
    ]
    URL = ""
    again = False

    transformations = [
        'pescatarian', 'vegetarian', 'east asian', 'italian', 'easy',
        'low sodium', 'low carb'
    ]

    print "Hello world"

    while (True):
        command = raw_input(prompt[menu]).lower()
        if command == "done":
            return
        if command == "back":
            menu -= 1
            if menu < 0:
                menu = 0
            continue
        if menu == 0:
            if command[:29] == "http://allrecipes.com/recipe/":
                URL = command
                menu += 1
                continue
            print "Invalid URL"
        if menu == 1:
            if command == "list":
                print ", ".join(transformations)
                continue
            if command in transformations:
                if again:
                    transformed_recipe.url = ''
                    transformed_recipe.transformation = command
                    recipes = parser.main(transformed_recipe)
                else:
                    recipe = recipe_classes.Recipe(URL, "recipe", command)
                    recipes = parser.main(recipe)
                original_recipe = recipes[0]
                transformed_recipe = recipes[1]
                menu += 1
                continue
            print "Invalid transformation"
        if menu == 2:
            if command == "yes":
                again = True
                menu = 1
                continue
            if command == "no":
                again = False
                menu = 0
                continue
            print "Invalid response"
def main(argv):
    parser.main(argv)
    pass
def main():
    et.main()
    p.main()
예제 #35
0
# Christoph Burschka, 2012

from converters import *
from parser import main

sig_graph = {'E':('relation',2)}
sig_ord = {'≤':('relation',2)}

print(main('((.fa. x E(x,x) && .fa. x .fa. y (E(x,y) <-> E(y,x)) ) && .fa. x .fa. y .fa. z ((E(x,y) && E(y,z))->E(x,z)))', sig_graph))

formula=main('(((.fa. x ≤(x,x) && .fa. x .fa. y ((≤(x,y) && ≤(y,x)) -> x=y) ) && .fa. x .fa. y .fa. z ((≤(x,y) && ≤(y,z))->≤(x,z))) && .fa. x .fa. y (≤(x,y) || ≤(y,x)))', sig_ord)
print(formula)
print(prenex(formula))
예제 #36
0
# Christoph Burschka, 2012

from converters import *
from parser import main

sig_graph = {'E': ('relation', 2)}
sig_ord = {'≤': ('relation', 2)}

print(
    main(
        '((.fa. x E(x,x) && .fa. x .fa. y (E(x,y) <-> E(y,x)) ) && .fa. x .fa. y .fa. z ((E(x,y) && E(y,z))->E(x,z)))',
        sig_graph))

formula = main(
    '(((.fa. x ≤(x,x) && .fa. x .fa. y ((≤(x,y) && ≤(y,x)) -> x=y) ) && .fa. x .fa. y .fa. z ((≤(x,y) && ≤(y,z))->≤(x,z))) && .fa. x .fa. y (≤(x,y) || ≤(y,x)))',
    sig_ord)
print(formula)
print(prenex(formula))
예제 #37
0
        return self.objects[address]
    
    def interpret(self, trace):
        for call in trace.calls:
            self.interpret_call(call)

    def handle_call(self, call):
        sys.stderr.write("%s\n" % call)
        
        args = [self.interpret_arg(arg) for name, arg in call.args] 
        
        if call.klass:
            obj = args[0]
            args = args[1:]
        else:
            obj = self.globl
            
        method = getattr(obj, call.method)
        ret = method(*args)
        
        if call.ret and isinstance(call.ret, model.Pointer):
            self.register_object(call.ret.address, ret)

    def interpret_arg(self, node):
        translator = Translator(self)
        return translator.visit(node)
    

if __name__ == '__main__':
    parser.main(Interpreter)
예제 #38
0
import sys
import parser

in_filename = sys.argv[1]
out_filename = sys.argv[1].rpartition('.')[0] + '.hack'

in_file = open(in_filename)
out_file = open(out_filename, 'w')

compiled = parser.main(in_file)
out_file.writelines(compiled)
예제 #39
0
파일: run.py 프로젝트: ihptru/aamms
def main():
    # SETTINGS ##############################################
    userdatadir="./server/data"
    userconfigdir="./server/config"
    # COMMAND LINE OPTIONS ##################################
    oparser=OptionParser()
    #parser.add_option("-v", "--vardir", dest="vardir", default=None, help="Path to the var directory (server)")
    oparser.add_option("-d", "--datadir", dest="datadir", default=None, help="Path to the data directory (server)")
    oparser.add_option("-c", "--configdir", dest="configdir", default=None, help="Path to the config directory (server)")
    oparser.add_option("-e", "--executable", dest="server", default=None, help="Path of the server executable", metavar="EXECUTABLE")
    oparser.add_option("-p", "--prefix", dest="prefix", default=None, help="The prefix the server was installed to.")
    oparser.add_option("-n", "--name", dest="servername", default=None, help="The name of the server", metavar="SERVERNAME")
    oparser.add_option("--debug",dest="debug", default=False, action="store_true", help="Run in debug mode")
    oparser.add_option("--disable", dest="disabledCommands", action="append", help="Disable COMMAND.", metavar="COMMAND", default=[])
    oparser.add_option("--default", dest="save", action="store_true", default=False, help="Set this configuration as default")
    oparser.add_option("-D","--disableExt", dest="disabledExtensions", default=[], action="append", help="Dsiable the extension with the name EXTENSION.", metavar="EXTENSION")
    oparser.add_option("--list-extensions", dest="list_extensions", default=False, action="store_true", help="List all available extensions.")
    options=oparser.parse_args()[0]
    options.vardir="server/var"
    optionsdict=dict()
    save_options=["vardir","configdir","server","datadir", "servername", "prefix"]

    # START #################################################
    # Get available extensions
    if options.list_extensions:
        print("Extensions:")
        print("\n".join(extensions.getExtensions()))
    os.chdir(os.path.dirname(sys.argv[0]) )
    if not os.path.exists("run"):
        os.mkdir("run")
    os.chdir("run")
    asked=False
    # Read prefix
    def read_prefix():
        global asked
        default=""
        test_prefixes=["/usr","/usr/local"]
        for test_prefix in test_prefixes:
            if os.path.exists(os.path.join(test_prefix,"bin/armagetronad-dedicated")):
                default="["+test_prefix+"]"
                break
        while options.prefix==None or not os.path.exists(options.prefix):
            options.prefix=input("Prefix the server was installed to "+default+": ")
            if options.prefix.strip()=="":
                options.prefix=default[1:-1]
            if not os.path.exists(options.prefix):
                print("Error: Prefix doesn't exist.")
    # Read config files ++++++++++++++++++++++++++++++++
    if os.path.exists("config.yaml"):
        optionsdict2=yaml.load(open("config.yaml","r") )
        for key,value in optionsdict2.items():
            try:
                if getattr(options, key)==None:
                    setattr(options, key, value)
            except:
                pass
    else:
        read_prefix()
        asked=True
    if ( not options.prefix or not os.path.exists(options.prefix)) and not all((not os.path.exists(i) for i in (options.datadir, options.configdir, options.server))):
        read_prefix()
        asked=True
        options.server=None
        options.datadir=None
        options.configdir=None     
    if not options.server: options.server=os.path.join(options.prefix, "bin/armagetronad-dedicated")    
    if not options.datadir: options.datadir=os.path.join(options.prefix, "share/armagetronad-dedicated")
    if not options.configdir: options.configdir=os.path.join(options.prefix, "etc/armagetronad-dedicated")
    if not os.path.exists(options.server): options.server=os.path.join(options.prefix,"games/armagetronad-dedicated")
    if not os.path.exists(options.configdir): options.configdir=os.path.join(options.prefix, "etc/games/armagetronad-dedicated")
    if not os.path.exists(options.configdir): options.configir="/etc/armagetronad-dedicated"
    if not os.path.exists(options.datadir): options.datadir=os.path.join(options.prefix, "share/games/armagetronad-dedicated")
    
    Global.datadir=options.datadir
    Global.configdir=options.configdir
    Global.debug=options.debug
    
    if options.servername==None:
        options.servername=input("Please enter a name for your server: ")
        asked=True
    # Write config files +++++++++++++++++++++++++++++++
    for save_option in save_options:
        optionsdict[save_option]=getattr(options, save_option)
    if options.save or not os.path.exists("config.yaml") or asked:
        yaml.dump(optionsdict, open("config.yaml","w"), default_flow_style=False )
    
    if not os.path.exists(userconfigdir):
        os.makedirs(userconfigdir)
    if not os.path.exists(userdatadir):
        os.makedirs(userdatadir)
    if not os.path.exists(options.vardir):
        os.makedirs(options.vardir)
    open(os.path.join(options.vardir,"ladderlog.txt"),"w" ).close()
    print("[START] Starting server. Serverlog can be found in run/server.log")
    args=["--vardir",options.vardir, "--datadir",options.datadir, "--configdir",options.configdir,
          "--userdatadir",userdatadir, "--userconfigdir",userconfigdir]
    print("[START] Executable: "+options.server)
    t=Thread(None, target=runServerForever,args=([options.server]+args,options.debug) )
    t.daemon=True
    t.start()
    while(p==None):
        time.sleep(1) # Give the the server some time to start up
    atexit.register(exit)
    sys.stdout=OutputToProcess()
    if os.path.exists("debug.log"):
        os.remove("debug.log")
    sys.stdin=WatchFile(open(os.path.join(options.vardir,"ladderlog.txt"), encoding="latin-1" ) )
    sys.stdin.skipUnreadLines()
    sys.stderr=FlushFile(sys.__stdout__)
    t2=Thread(None, read_stdin)
    t2.daemon=True
    t2.start()
    sys.stderr.write("Reading commands from stdin.\n")
    Global.server_name=options.servername
    extensions.loadExtensions()
    sys.stderr.write("[START] Starting script.\n")
    sys.stderr.write("[START] Press ctrl+c or type /quit to exit.\n")
    sys.stderr.write("\n")
    sys.stderr.flush()    
    reloaded=False
    while True:
        try:
            parser.main(debug=options.debug, disabledCommands=options.disabledCommands, reloaded=reloaded)
        except KeyboardInterrupt:
            break
        except SystemExit:
            break
        except Global.ReloadException:
            import tools
            tools.reload_script_modules()
            reloaded=True
            continue
        except Exception:
            sys.stderr.write("#####################################################################\n")
            sys.stderr.write("################## SCRIPT CRASHED ###################################\n")
            sys.stderr.write("#####################################################################\n")
            traceback.print_exc(file=sys.stderr)
            sys.stderr.write("#####################################################################\n")
            sys.stderr.flush()
            parser.exit(False, quiet=True)        
            try:
                sys.stderr.write("Restarting in 3 seconds ... \n")        
                sys.stderr.write("\n")
                time.sleep(3)
                reloaded=True
            except KeyboardInterrupt:
                break
            except:
                continue
            continue
        break
    exit()
from datetime import date
from dateutil.rrule import rrule, DAILY
import scraper
import parser

a = date(2013, 3, 4)
b = date(2013, 3, 5)

if __name__ == '__main__':
	for dt in rrule(DAILY, dtstart=a, until=b):
    		current_date = dt.strftime("%Y/%m/%d")
		print 'Scraping ' + current_date
		scraper.main(dt.strftime("%d/%m/%Y"))
		print 'Parsing ' + current_date
		parser.main(dt.strftime("%Y/%m/%d"))