示例#1
0
 def get_context_data(self, **kwargs):
     context = super().get_context_data(**kwargs)
     CURRENT_THEME = get_theme()
     context['form'] = ConfigUpdateForm(initial={'theme': CURRENT_THEME})
     context['themes'] = get_themes()
     context['title'] = get_key("ctf_name")
     context['start_time'] = get_key('start_time')
     context['end_time'] = get_key('end_time')
     return context
示例#2
0
    def getBasicInfo(self):
        url = get_urls('url_view')
        timestamp_ms = get_timestamp()
        appkey = get_key()
        UAS = get_user_agents()
        params = {'type': 'json', 'appkey': appkey, 'id': str(
            self.aid), '_': '{}'.format(timestamp_ms)}
        # print(params)
        headers = {'User-Agent': random.choice(UAS)}
        # print(headers)

        try:
            res = requests.get(url, params=params, headers=headers)
            res.raise_for_status()
        except Exception as e:
            # print(e)
            msg = 'aid({}) get error'.format(self.aid)
            bilivideolog.error(msg)
            return None
        data = json.loads(res.text)
        # print(data)
        if 'mid' in data:
            # ('added','mid','aid','tid','cid','typename','arctype','title','pic','pages','created')
            related_info = (get_timestamp_s(), data['mid'], self.aid, data['tid'],
                            data['cid'], data['typename'], data['arctype'],
                            data['title'], data['pic'],
                            data['pages'], data['created'])
            return related_info

        else:
            msg = 'aid({}) basic info request  return error'.format(self.aid)
            bilivideolog.info(msg)
            return None
示例#3
0
def arrivals(naptan, app_id=None, app_key=None):

	if app_id == None or app_key == None:
		app_id, app_key = config.get_key()

	payload = {'app_id': app_id, 'app_key': app_key}
	r = requests.get('https://api.tfl.gov.uk/StopPoint/{0}/Arrivals'.format(naptan), params=payload)

	json_result = r.json()
	timestamp = ""

	to_zone = dateutil.tz.tzlocal()

	now = datetime.datetime.now(to_zone)
	for arrival in json_result:
		eta = dateutil.parser.parse(arrival['expectedArrival'])
		local = eta.astimezone(to_zone)
		rd = relativedelta(local, now)
		#expectedArrival=datetime.datetime.strptime( arrival['expectedArrival'], "%Y-%m-%dT%H:%M:%SZ" )
		#eta = expectedArrival.strftime('%H:%M:%S %Z')
		#utc = eta.replace(tzinfo=from_zone)
		#local = utc.astimezone(to_zone)

		print("Stop {1}: {2} towards {0}: {3}, {4} minutes".format(arrival['destinationName'], arrival['platformName'], arrival['lineName'], local.strftime('%H:%M'), rd.minutes))
		timestamp = arrival['timestamp']
	print("ts/now: {0}/{1}".format(timestamp, datetime.datetime.now().time()))
def get_previous_session():
    sess = None
    token_key, token_secret = config.get_access_token()

    if token_key and token_secret:
        sess = session.DropboxSession(config.get_key(), config.get_secret(), ACCESS_TYPE)
        sess.set_token(token_key, token_secret)

    return sess
示例#5
0
    def __call__(self, request):
        if request.path.startswith(reverse('installer')):
            return self.get_response(request)

        install_status = get_key("installed")
        if install_status:
            response = self.get_response(request)
            return response
        else:
            return redirect(reverse("installer"))
示例#6
0
def get_theme():
    theme = cache.get("theme")
    if theme is not None:
        return theme
    else:
        theme = get_key("theme")
        if theme:
            cache.set("theme", theme)
            return theme
        else:
            cache.set("theme", "core")
            return "core"
def check_input(character):
    if global_var.lives <= 0:
        global_var.quit_flag = 1  
        return
    event = config.get_key(config.get_input())
    if event == config.LEFT:
        character.check_left()
    elif event == config.RIGHT:
        character.check_right()
    elif event == config.QUIT:
        global_var.quit_flag = 1  
        return
    reset_scenery()
def create_new_session():
    sess = session.DropboxSession(config.get_key(), config.get_secret(), ACCESS_TYPE)
    request_token = sess.obtain_request_token()

    print((sess.build_authorize_url(request_token)))
    print("Visit this website and press the 'Allow' button, then hit 'Enter' here: ")

    raw_input()

    access_token = sess.obtain_access_token(request_token)
    config.save_access_token(access_token.key, access_token.secret)

    return sess
示例#9
0
def hash():

    #    url = "https://api.heroku.com/apps/frozen-garden-83591/config-vars"
    #    r = requests.get(url)
    #    values = r.json()

    key = config.get_key()
    secret = config.get_secret()
    clientID = config.get_clientID()

    nonce = int(time.time() * 1000000) + 374491605044

    message = str(nonce) + clientID + key
    message = bytes(message, 'utf-8')
    byte_key = bytes(secret, 'utf-8')

    signature = hmac.new(byte_key, message, hashlib.sha256).hexdigest()

    return ({"key": key, "signature": str.lower(signature), "nonce": nonce})
示例#10
0
def addObjectList(bd, level_name, *names):

    for name in names:

        bd.at = 0

        completeName = os.path.join(dir_path + level_name, name + ".txt")
        file = open(completeName, "w")

        ob = makeObject(name)
        mk = objects.Marker(ob, ob.width, ob.height, 60, 30)

        bd.add(mk, mk.x, mk.y)
        while True:
            bd.clear(config.show_width)

            addobjects(bd, brick, enemy, goomba, spikey, stalker,
                       spring, coin, cloud, specialbrick, boss, castle)

            bd.add(mk, mk.x, mk.y)

            os.system('clear')
            bd.show(config.show_width, config.show_height)
            event = config.get_key(config.get_input())
            if event == config.QUIT:
                break
            elif event == config.SHOOT:
                bd.add(mk, mk.x, mk.y)
                file.write(str(mk.x) + ',' + str(mk.y) + '\n')
                lists[name].append(makeObject(name, mk.x, mk.y))
            else:
                mk.move(event)
                bd.move(event, mk.width)
                bd.add(mk, mk.x, mk.y)
        bd.remove(mk, mk.x, mk.y)
        bd.at = 0
示例#11
0
文件: main.py 项目: shivam14300/Mario
import board
import objects
import datetime
import config
from board import *
from config import *
''' Main file for running the code '''
bd = board.Board()
p_input = -1
while (True):

    global lives
    p_input = config.get_key(config.get_input())
    if p_input == config.QUIT:  # if input is q, quit the game
        break
    # Calling collision function
    bd.CollisionMarioPipe()
    bd.process_input(p_input)
    bd.insert()
    bd.printIt()
    flag1 = bd.CollisionMarioBrick()
    flag = bd.CollisionMarioEnemy()
    flag2 = bd.CollisionMarioSmartEnemy()
    bd.CollisionMarioCoin()
    bd.CollisionMarioSpring()

    if bd.youWin():
        break

    if board.t == 0:
        bd.gameOver()
示例#12
0
import darksky
from twilio.rest import Client
import config

twilio_acct = config.get_key('twilio_acct')
twilio_token = config.get_key('twilio_token')
twilio_tn = config.get_key('twilio_tn')
darksky_key = config.get_key('darksky')
tn = config.get_key('cell_phone_tn')


def send_text(forecast, tn, twilio_acct, twilio_token):
    text_body = f"Forecast: {forecast['summary'].lower()} High today of {forecast['apparentTemperatureHigh']}, " \
                f"low of {forecast['apparentTemperatureLow']}."

    client = Client(twilio_acct, twilio_token)
    message = client.messages.create(to=tn, from_=twilio_tn, body=text_body)


def main():
    forecast = darksky.get_today_weather(darksky_key, config.location)
    send_text(forecast, tn, twilio_acct, twilio_token)


if __name__ == '__main__':
    main()
示例#13
0
            common.restart_all()
            config.LIVES = 10

        # if mario goes below the floor LEVEL
        if config.M != "" and config.M.y_pos > common.MIDS_R:
            raise config.DeadMario

        # create the scene depending on the LEVEL
        create_scenery.create_scene()
        if config.M != "":
            if Char != config.JUMP:
                create_scenery.check_floor()
        common.print_all()

        # get input from user
        Char = config.get_key(config.get_input())

        if Char == config.QUIT:
            # shut down all [q]
            config.STAGE = "quit"
            common.game_over()

        if Char == config.START:
            # create a Person [m]
            sound.play_sound("mb_new.wav")
            create_scenery.create_mario()

        elif Char == config.BREAK:
            # break the loop [s]
            os.system("tput reset")
            break
示例#14
0
 def keypress(self, size: Tuple[int, int], key: str) -> str:
     if self.controller.editor_mode:
         return self.controller.editor.keypress((20, ), key)
     else:
         return super(View, self).keypress(size, get_key(key))
示例#15
0
def main():
    lives = 3
    reply = input('Do want to make your own level?(y/n)		')
    if reply == "y":
        level_name = input('What do you want to name your cutom level?		')
        levelGenerator.makeLevel(level_name)

    level_name = input('Please enter level name:	')

    while lives:
        tme = 360 + int(time.time())

        clearLists(specialbrick, brick, enemy, spring, coin, cloud, castle,
                   boss)

        bd = board.Board(config.board_width, config.board_width)
        try:
            loadLevel(level_name, "brick", "spring", "goomba", "stalker",
                      "spikey", "boss", "castle", "cloud", "coin",
                      "specialbrick")
        except:
            print("No such level exists")
            exit()

        mario = objects.Player(2, 2, 54, 15)
        bd.at = 0

        while True:

            bd.clear(config.show_width)

            levelGenerator.addobjects(bd, brick, enemy, spring, coin, cloud,
                                      specialbrick, boss, castle)
            bd.add(mario, mario.x, mario.y)

            collisionCheck.bossFight(enemy, boss, bd, mario)

            collisionCheck.enemyCollision(enemy, enemy, mario, bd)
            collisionCheck.enemyCollision(boss, boss, mario, bd)

            collisionCheck.updateEnemy(boss, bd, mario.x, brick, spring)
            collisionCheck.updateEnemy(enemy, bd, mario.x, brick, spring)

            collisionCheck.brickCollision(brick, mario, bd)
            collisionCheck.specialbrickCollision(specialbrick, mario, bd)

            collisionCheck.springCollision(spring, mario, bd)
            collisionCheck.coinCollision(coin, mario, bd)

            if mario.hp <= 0 or mario.y > config.show_height or int(
                    tme - time.time()) <= 0:
                lives -= 1
                break

            if mario.x >= castle[0].x:
                print("YOU WIN \t TOTAL SCORE:",
                      mario.score + int(tme - time.time()))
                lives = 0
                break

            os.system('tput reset')
            bd.show(config.show_width, config.show_height)
            print("LIVES:", lives, "\t", "HEALTH:", mario.hp, "\t", "SCORE:",
                  mario.score, "\t", "TIME LEFT:", int(tme - time.time()))

            event = config.get_key(config.get_input())

            if event == config.QUIT:
                lives = 0
                break

            if mario.move(event) == "move":
                bd.move(event, 1)

    print("GAME OVER")
示例#16
0
def init_key(inputKey):
    script, id = config.get_key(inputKey)
    global sg
    sg = Shotgun(server, script, id)
 def __init__(self):
     self.key = config.get_key()
     self.test_user = config.get_test_user_id()
     self.base_api_url = "http://api.steampowered.com/"
     self.base_store_api_url = "http://store.steampowered.com/"
示例#18
0
def main():
    try:
        height, width = tuple(map(int, rd[1:3]))
    except BaseException:
        height, width = (34, 76)

    a = 'r'

    while a == 'r':

        try:
            level = int(input("Choose level [[1], 2, 3] :"))
            if level not in [0, 1, 2, 3]:
                raise Exception
        except BaseException:
            level = 1

        # make the board and player
        bd = board.Board(height, width, level)

        player = people.Bomber(
            5,
            3,
            config.lives[level],
            config.bombs[level])  # always spawns at top left
        # spawning the player on the board
        bd.spawn(player)

        print("Initializing enemies, bricks ...")
        if not (spawn(config._enemy, config.enemies[level], bd) and
                spawn(config._bricks, config.bricks[level], bd)):
            print("Object Spawn Error")
            return False

        print("Objects spawned successfully", "Rendering board", sep="\n")
        sleep(1)

        bd.render()

        is_clean = False
        p_input = -1
        # main loop which renders the game
        st_time = datetime.datetime.now()
        prev_round = datetime.datetime.now()
        while (datetime.datetime.now() - st_time) <= \
                datetime.timedelta(seconds=config.timelimit[level]):

            print(config.printcc("'q' : quit | 'b' : drop bomb || Lives ", 'Gray') +
                  config.printcc('%s' % (player.lives * '♥ '), 'Red') +
                  config.printcc('| Bombs ', 'Gray') +
                  config.printcc('%s' % (player.bombs * '💣 '), 'Dark Gray') +
                  config.printcc("| T : %d " % (config.timelimit[level] - (datetime.datetime.now() -
                                                                           st_time).seconds), 'Gray'))

            try:
                bd.is_over(player)
            except Exception as exc:
                print(config.printcc(exc.args[0], 'Gray'))
                is_clean = True
                break

            p_input = config.get_key(config.get_input())

            if p_input == config.QUIT:
                break

            cur_round = datetime.datetime.now()
            bd.process_input(player, p_input)
            if (cur_round - prev_round) >= datetime.timedelta(seconds=1):
                bd.update_frame()
                prev_round = cur_round

            bd.render()

        if not is_clean:
            print(config.printcc("TIME UP!", 'Gray'))

        bd.clear_storage()
        for c, player in enumerate(bd.players):
            print(
                config.printcc(
                    "Player %d score : %d" %
                    (c, player.score), 'White'))

        sleep(3)
        print(
            config.printcc(
                "Press ANY KEY to exit | Press 'r' to restart",
                'Gray'))
        a = config._getch()
        system('reset')
示例#19
0
def main():
    height, width = (24, 76)
    quit = False
    won = False
    print("Waking up Mario ...")
    sleep(2)
    print("Yay, he woke up!")
    print("Now, waking up your enemies ...")
    a = 'r'
    while a == 'r':
        bd = board.Board(24, 400)
        player = person.Mario(3, height - 3, 3)
        # while (player.lives > 0):
        bd.spawn(player)

        ls = spawn(config._enemy, bd)
        # ck = spawn_coins(config._coin, bd)

        if ls == False:  # or ck == False:
            print("Object Spawn Error")
            return False

        print("Objects spawned, your enemies have been born\n")
        print("Rendering Board ...")

        sleep(3)
        bd.render(0, 76)
        x = 0
        p_input = -1

        st_time = datetime.datetime.now()
        prev_round = datetime.datetime.now()
        while (datetime.datetime.now() -
               st_time) <= datetime.timedelta(seconds=100):
            # while a=='r':
            sys.stdout.write(Fore.BLUE + "'q' : quit || Lives " + Fore.RED +
                             '%s' % (player.lives * '♥ '))
            sys.stdout.write(' || ' + Fore.BLUE + "Time : %d" %
                             (100 -
                              (datetime.datetime.now() - st_time).seconds))

            try:
                bd.gameover(player)
            except Exception as exc:
                print(exc.args[0])
                break
            print(Style.RESET_ALL)
            p_input = config.get_key(config.get_input())

            if p_input == config.QUIT:
                print(Fore.BLUE +
                      "Quitting game because you're a sore loser ...")
                print("Resetting your clock ...")
                print(Style.RESET_ALL)
                quit = True
                break
            cur_round = datetime.datetime.now()
            if (cur_round - prev_round) >= datetime.timedelta(seconds=1):
                bd.update_frame()
                prev_round = cur_round

            if p_input == config.UP:
                i = 3
                while i > 0:
                    bd.process_input(player, config.UP)
                    bd.render(x, x + 76)
                    inter_input = config.get_key(config.get_input())
                    if inter_input == config.LEFT or inter_input == config.RIGHT or inter_input == config.UP:
                        bd.process_input(player, inter_input)

                    # sleep(0.1)
                    i = i - 1
                '''while i > 0:
                    if i == 2:
                        sleep(0.2)
                    bd.process_input(player, config.DOWN)
                    bd.render()
                    # inter_input = config.get_key(config.get_input())
                    # bd.process_input(player, inter_input)
                    # bd.render()
                    sleep(0.1)
                    i = i - 1'''
                '''while player.get_ycoords()+2 != 23:
                    # print(player.get_ycoords())
                    bd.process_input(player, config.DOWN)
                    bd.render()
                    sleep(0.1)
                '''

            # cur_round = datetime.datetime.now()
            if p_input == config.LEFT or p_input == config.RIGHT:
                bd.process_input(player, p_input)

            try:
                bd.gameover(player)
            except Exception as exc:
                sys.stdout.write(exc.args[0])
                break

            for _ in bd._storage[config.types[config._enemy]]:
                while _.get_ycoords() + 2 != 23:
                    res = bd.process_input(_, config.DOWN)
                    if res == False:
                        break

            while player.get_ycoords() != 23:
                # print(player.get_ycoords())
                res = bd.process_input(player, config.DOWN)
                if res == False:
                    break
                bd.render(x, x + 76)
                res = bd.process_input(player, config.DOWN)
                sleep(0.1)

            if player.get_ycoords() == 23:
                player.lives -= 1
            try:
                bd.gameover(player)
            except Exception as exc:
                sys.stdout.write(exc.args[0])
                break

            if player.get_xcoords() >= 360:
                won = True
                sys.stdout.write(Fore.RED + Style.BRIGHT + Back.BLACK +
                                 "YOU BEAT THE GAME")
                print(Style.RESET_ALL)
                break

                # sleep(0.1)
                # bd.render()
            """ if (cur_round - prev_round) >= datetime.timedelta(seconds=1):
                # bd.update_frame()
                # prev_round = cur_round"""
            bd.render(x, x + 76)
            if player.get_xcoords() > (x + 38):
                x = x + 6
                bd.render(x, x + 76)

        if player.lives > 0 and won == False:
            sys.stdout.write(Fore.BLUE + "TIME'S UP\n")
        sleep(2)
        bd.clear_storage()

        player.score = (
            100 - (datetime.datetime.now() - st_time).total_seconds()) * 384

        for player in bd.players:
            if quit:
                sys.stdout.write(Fore.RED + "PLAYER SCORE: 0")
            else:
                sys.stdout.write(Fore.RED + "PLAYER SCORE: %d" % player.score)
        print(Style.RESET_ALL)

        print("Press 'r' to RESTART")
        a = config._getch()
        system('reset')