Пример #1
0
    def __judge_special(self, testcase, timeout_command, path,
                        sandbox_submission, judger_path, sandbox_judge):
        testcase_in = str(testcase)
        testcase_out = str(testcase.parents[1] / 'out' / testcase.name)
        # make pipe to communicate
        with pipe() as inpp, pipe() as outp:
            try:
                additional_command = []
                if self.sandbox_enabled:
                    additional_command += timeout_command
                    additional_command.append(
                        str(self.cfg.getint('limit', 'time') + 1))

                # start the judger first
                # disable Ctrl-C for subprocess
                judger = utils.Popen(sandbox_judge,
                                     additional_command +
                                     [judger_path, testcase_in, testcase_out],
                                     stdin=outp.r,
                                     stdout=inpp.w,
                                     stderr=subprocess.PIPE,
                                     start_new_session=True)

                # run submitted one
                starttime = time()
                # disable Ctrl-C for subprocess
                submitted = utils.Popen(
                    sandbox_submission,
                    additional_command +
                    self.lang['exec'].replace('{path}', path).split(),
                    stdin=inpp.r,
                    stdout=outp.w,
                    start_new_session=True)

                # submitted.communicate(timeout=timelimit)
                submitted.wait(timeout=self.cfg.getint('limit', 'time'))
                exectime = int((time() - starttime) * 1000)
                if submitted.returncode != 0:
                    utils.kill_child_processes(judger)
                    return ("RE", None)
            except subprocess.TimeoutExpired:
                res = ("TLE", None)
                if judger.poll() is not None and judger.returncode != 0:
                    res = ("IE", None)
                utils.kill_child_processes(submitted)
                utils.kill_child_processes(judger)
                return res

        try:  # wait for judger for (timelimit) secs
            result = judger.communicate(
                timeout=self.cfg.getint('limit', 'time'))[1]
        except subprocess.TimeoutExpired:
            utils.kill_child_processes(judger)
            return ("IE", None)  # judger TLE

        if judger.returncode != 0:
            return ("IE", None)
        if result.startswith(b"AC"):
            return ("AC", exectime)
        return ("WA", exectime)
Пример #2
0
def main():

    args = parse_args()

    print(args.cc)
    print(args.file)

    pipe.pipe(args.file)
Пример #3
0
 def __init__(self, player):
     self.player = player
     self.platform_list = pygame.sprite.Group()
     self.score_list = pygame.sprite.Group()
     #self.score_list.add(score(0,0))
     l = random.randrange(200, 300)
     pipe_top = pipe(150, l, "up")
     pipe_down = pipe(150, 400 - l, "down")
     self.platform_list.add(pipe_top)
     self.platform_list.add(pipe_down)
Пример #4
0
    def add_pipe(self):
        l = random.randrange(200, 300)
        pipe_top = pipe(self.player.rect.right, l, "up")
        pipe_down = pipe(self.player.rect.right, 400 - l, "down")
        self.platform_list.add(pipe_top)
        self.platform_list.add(pipe_down)

        self.score_list.empty()
        scoreDigits = [int(x) for x in list(str(self.score))]
        for i in range(len(scoreDigits)):
            self.score_list.add(score(scoreDigits[i], i))
Пример #5
0
    def add_pipe(self):
        height = randint(100, 200)
        gap = randint(100, 250)
        top_pipe = pygame.Surface((self.pipew, height))
        top_pipe.fill((0, 255, 0))
        bottom_pipe = pygame.Surface((self.pipew, self.surfaceH - (height + gap)))
        bottom_pipe.fill((0,255,0))

        top = pipe(top_pipe, [self.surfaceW - 100, 0], "top", height)
        bottom = pipe(bottom_pipe, [self.surfaceW - 100, self.surfaceH - (height + gap)], "bottom", height)

        self.pipeList.append(top)
        self.pipeList.append(bottom)
Пример #6
0
 def SpawnPipe(self):
     if self.player.dead == 0:
         self.SpawnTime += 3
         if self.SpawnTime >= self.width:
             Pipe = pipe.pipe(self.screen, self.player, self.width, self.height)
             self.PipeList.append(Pipe)
             self.SpawnTime = 0
Пример #7
0
def pipe_update_ics(test=False):
    '''Update the ICS table'''
    if test:
        raise Exception('NYI')
        rows = test_data2
    else:
        rows = gen_rows_ics
    global vals
    vals = []

    def collect(p):
        for v in p:
            vals.append(v)
            yield v

    def cat(p):
        for v in p:
            yield v

    g = pipe.pipe(
        lambda x: rows(),
        compute_active_insulin,
        find_rescue_events,
        # lambda p: pipe.tee(p,prefix='x: ',stringify=lambda r: str(listify_row(r,IOB_KEYS))),
        cat
        # nonzerocarbs
    )
    # pipe.more(g(None))
    db_update(g(None), 'insulin_carb_smoothed', IOB_KEYS)
Пример #8
0
def main():
    global loopCount, scoreCount, touch
    while True:
        gapSize = random.randint(5, 25)
        if loopCount % 90 == 0:
            topPos = random.randint(0, height / 2) - 400
            pipes.add(pipe((width + 100, topPos + gapSize + 800)))
            score.add(gap((width + 100, topPos + gapSize + 800)))
            pipes.add(pipe((width + 100, topPos), True))

        for event in pygame.event.get():
            if event.type == QUIT:
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_SPACE:
                    player.speed[1] = -10

        player.update()
        pipes.update()
        score.update()

        gets_hit = pygame.sprite.spritecollide(player, pipes, False) \
            or player.rect.center[1] > height

        point_get = pygame.sprite.spritecollide(player, score, True)

        screen.blit(background, [0, 0])
        pipes.draw(screen)
        score.draw(screen)
        screen.blit(player.image, player.rect)
        pygame.display.flip()
        loopCount += 1

        if gets_hit:
            lose()

        #print("Touch = "+str(touch)+" Point Get? = "+str(point_get))
        if point_get and touch == False:
            scoreCount += 1
            print("Score: " + str(scoreCount))
            touch = True
        else:
            touch = False
Пример #9
0
 def init_as_game(self, rend):
     if rend is not None:
         self.type = "game"
         self.background = background(rend)
         self.floor = floor(rend)
         self.pipe1_bot = pipe(rend, False)
         self.pipe1_top = pipe(rend, True)
         self.pipe2_bot = pipe(rend, False)
         self.pipe2_top = pipe(rend, True)
         self.pipe1_top.surface.x = 804
         self.pipe1_bot.surface.x = 804
         self.pipe2_top.surface.x = 1130
         self.pipe2_bot.surface.x = 1130
         self.player = bird(rend)
         self.score = score(rend)
         self.entities = [
             self.background, self.pipe1_bot, self.pipe1_top,
             self.pipe2_bot, self.pipe2_top, self.floor, self.player,
             self.score
         ]
         self.index_player = self.entities.index(self.player)
         self.start()
     else:
         self.player.surface.x = 80
         self.player.surface.y = 270
         self.pipe1_top.surface.x = 800
         self.pipe2_top.surface.x = 1130
         self.pipe1_bot.surface.x = 800
         self.pipe2_bot.surface.x = 1130
         self.pipe1_top.surface.y = random.randint(pipeTopLowBound,
                                                   pipeTopHighBound)
         self.pipe1_bot.surface.y = self.pipe1_top.surface.y + pipeOffset
         self.pipe2_top.surface.y = random.randint(pipeTopLowBound,
                                                   pipeTopHighBound)
         self.pipe2_bot.surface.y = self.pipe2_top.surface.y + pipeOffset
         self.background.surface.x = 0
         self.background.surface.y = 0
         self.floor.surface.x = 0
         self.score.count = 0
         self.score.update_textures()
     pass
Пример #10
0
def pipe4(test=False):
    '''Write smoothed data to .csv file'''
    print('Not yet ready for prime time')
    raise Exception
    if test:
        p1 = ic_test_data1
        filename = 'active_insulin_on_test_data.csv'
    else:
        p1 = gen_rows
        filename = 'active_insulin_on_real_data.csv'
    g = pipe.pipe(lambda x: p1(), lambda x: pipe.mapiter(x, coerce_row),
                  gen_insulin_carb_vrows, gen_all_rows_basals)
    csv_output(g(None), filename, IOB_KEYS)
Пример #11
0
def start_convert():
    file = request.files['file']
    try:
        blur = bool(request.form['add_blur'])
    except:
        blur = False
    colors_num = int(request.form['colors'])
    max_pieces_size = int(request.form['pieces_size'])

    if file and allowed_file(file.filename):
        filename = secure_filename(file.filename)
        f_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        file.save(f_path)
        try:
            pipe.pipe(f_path,
                      colors_num=colors_num,
                      blur=blur,
                      max_pieces_size=max_pieces_size)
            with open('vot-eto-da-both.svg') as f:
                vector = f.read()
                return {
                    'status': 'OK',
                    'raster': f'../{f_path}',
                    'vector': vector
                }
        except QuantizeError:
            return {
                'status': 'ERROR',
                'error': 'QuantizeError',
                'error_msg': 'Number of colors is higher than img pixels num!'
            }
    else:
        return {
            'status': 'ERROR',
            'error': 'FormatError',
            'error_msg': 'This input file format not supprted!',
        }
    return 'Error'
Пример #12
0
def pipe_write_ics2(test=False, start=None, end=None):
    '''Update the ICS table'''
    if test:
        raise Exception('NYI')
        rows = test_data2
    else:
        rows = lambda: gen_rows_ic(start=start, end=end)

    def cat(p):
        for v in p:
            yield v

    def check_carb_code(p, label):
        n = 0
        keys = 'rtime,carbs,carb_code,dynamic_carbs'.split(',')
        for row in p:
            n += 1
            if row_get(row, 'rtime') == datetime(2017, 1, 1, 0, 35,
                                                 0) or n == 1:
                print(n, label, [str(row_get(row, x)) for x in keys])
            if row_get(row, 'rec_nums') == '87789&87790':
                raise Exception('trouble!')
            if (row_get(row, 'carbs') > 0
                    and row_get(row, 'carb_code') not in [
                        'before6', 'breakfast', 'lunch', 'snack', 'dinner',
                        'after9', 'rescue'
                    ]):
                print row
                raise Exception('bad carb_code in {} check: {}'.format(
                    label, row_get(row, 'carb_code')))
            yield row

    g = pipe.pipe(
        lambda x: rows(),
        basal_amt_12,
        categorize_carbs,
        lambda x: check_carb_code(x, 'one'),
        compute_minutes_since,  # has to be after categorize carbs, since that identifies meals
        compute_cgm_slopes,
        compute_dynamic_insulin,
        lambda x: check_carb_code(x, 'two'),
        compute_dynamic_carbs,
        lambda x: check_carb_code(x, 'three'),
        # lambda p: pipe.tee(p,prefix='x: ',stringify=lambda r: str(listify_row(r,IOB_KEYS))),
        cat
        # nonzerocarbs
    )
    # pipe.more(g(None))
    # I don't recall why I switched to insulin_carb_smoothed_2. Need to figure that out.
    ic_output_list(g(None), 'insulin_carb_smoothed_2', cursor_columns)
Пример #13
0
def create_virtual_rows(test=False, start=None, end=None):
    '''Reads from ICG and writes to ICS, inserting filler rows so that we have a row for every rtime'''
    if test:
        rows = test_data2
    else:
        rows = lambda: gen_rows_ic_dictionaries(
            tablename='insulin_carb_grouped', start=start, end=end)
    keys_from_icg()
    g = pipe.pipe(
        lambda x: rows(),
        lambda p: gen_insulin_carb_vrows(rows=p),  # does the actual smoothing
    )
    # pipe.more(g(None))
    ic_output_dict(g(None), 'insulin_carb_smoothed', IC_KEYS)
Пример #14
0
def pipe_create_ics(test=False):
    '''Compute smoothed data'''
    if test:
        rows = test_data2
    else:
        rows = gen_rows
    g = pipe.pipe(
        lambda x: rows(),
        lambda p: pipe.mapiter(p, coerce_row),
        lambda p: gen_insulin_carb_vrows(rows=p),  # does the actual smoothing
        lambda p: gen_all_rows_basals(rows=p),  # calc basal_amt_12
    )
    # pipe.more(g(None))
    db_output(g(None), 'insulin_carb_smoothed', ICS_KEYS)
Пример #15
0
    def setup_plant(self):
        ## River water cooling circuit:

        # Water intake from river
        river_intake1 = self.add(river("River water intake 1"))
        river_intake2 = self.add(river("River water intake 2"))

        # River pumps
        river_pump1 = self.add(pump("River Pump 1", physics.large_pump_pressure_Pa, base_height_m=-4.0))
        river_pump2 = self.add(pump("River Pump 2", physics.large_pump_pressure_Pa, base_height_m=-4.0))
        river_pump1.in_port.connect(river_intake1.port)
        river_pump2.in_port.connect(river_intake2.port)

        # Backflow valves for pumps
        river_valve1 = self.add(valve("River Backflow Valve 1", height_m=-4.0))
        river_valve2 = self.add(valve("River Backflow Valve 2", height_m=-4.0))
        river_valve1.in_port.connect(river_pump1.out_port)
        river_valve2.in_port.connect(river_pump2.out_port)

        # Tank that combines inflows from river pumps
        river_in_tank = self.add(tank("River intake tank", 10.0, 2.0, 1.0))
        river_in_tank.add_port("in1").connect(river_valve1.out_port)
        river_in_tank.add_port("in2").connect(river_valve2.out_port)
        river_tank_out_port = river_in_tank.add_port("out")
        river_in_pipe = self.add(pipe("River tank to steam condenser pipe", 30.0, area_m2=physics.large_pipe_size_m2))
        river_in_pipe.in_port.connect(river_tank_out_port)

        # Steam condenser
        steam_condenser = self.add(heat_exchanger("Steam condenser"))
        steam_condenser.a_in.connect(river_in_pipe.out_port)

        # River waste-water pipe
        river_out = self.add(river("River cooling water outlet"))
        river_out_pipe = self.add(pipe("Steam condenser to river pipe", 40.0, area_m2=physics.large_pipe_size_m2))
        river_out_pipe.in_port.connect(steam_condenser.a_out)
        river_out_pipe.out_port.connect(river_out.port)
Пример #16
0
    def end_statement():
        end_token()

        # Remove comments
        try:
            comment_index = statement.index(COMMENT_TOKEN)
        except ValueError:
            pass
        else:
            del statement[comment_index:]

        if statement:
            # TODO: make `lex` into a class to avoid hacks like [:]
            statement[:] = pipe(statement, on=PIPE_TOKEN)
            program.append(tuple(statement))
            statement.clear()
Пример #17
0
    def end_statement():
        end_token()

        # Remove comments
        try:
            comment_index = statement.index(COMMENT_TOKEN)
        except ValueError:
            pass
        else:
            del statement[comment_index:]

        if statement:
            # TODO: make `lex` into a class to avoid hacks like [:]
            statement[:] = pipe(statement, on=PIPE_TOKEN)
            program.append(tuple(statement))
            statement.clear()
Пример #18
0
def pipe_count_carbs():
    carb_count = [0]

    def count_carbs(seq):
        for s in seq:
            if s['carbs'] > 0:
                carb_count[0] += 1
            yield s

    g = pipe.pipe(
        lambda x: gen_rows(),
        lambda p: pipe.mapiter(p, coerce_row),
        lambda p: gen_insulin_carb_vrows(rows=p),  # does the actual smoothing
        lambda p: gen_all_rows_basals(rows=p),  # calc basal_amt_12
        count_carbs)
    # pipe.more(g(None))
    pipe.exhaust(g(None), progress=1000)
    print 'carb_count', carb_count
Пример #19
0
  def updateScore(dt):
    global last_pipe
    global pipes

    # remove offscreen pipes
    pipes_off_screen = [index for index,value in enumerate(pipes) if value.x < (-1 * PIPE_WIDTH)]

    for p in pipes_off_screen:
      pipes[p].delete()
      pipes.pop(p)

    # add a new pipe if it is due
    if last_pipe % PIPE_FREQUENCY == 0:
      rand_height = random.randint(0, window.height - PIPE_GAP)
      new_pipe = pipe(window.width, rand_height, PIPE_WIDTH, PIPE_GAP, PIPE_VELOCITY, window.height, main_batch)
      pipes.append(new_pipe)
      last_pipe = 0

    last_pipe += 1

    # move agent
    agent.update()

    # update score
    scoreboard.set_score(agent.score)

    # check for game over
    if agent.y > 0:
      agent.set_score(agent.score + 1)
    else:
      game_over()

    for p in pipes:
      p.update()
      if ((agent.x + agent.size) > p.x) and (agent.x < (p.x + PIPE_WIDTH)):
        if ((agent.y < p.y) or ((agent.y + agent.size) > (p.y + PIPE_GAP))):
          game_over()
Пример #20
0
        continue

    rc = os.fork()
    
    wait = True
    if '&' in args:
        wait = False
        args.remove('&')

    if rc < 0:
        os.write(2, "fork failed, exiting...".encode())
        sys.exit(0)

    elif rc == 0:  # child
        if '|' in args:
            pipe(args)
            continue

        if '<' in args:
            redirect(args, '<')

        if '>' in args:
            redirect(args, '>')

        try:
            os.execve(args[0], args, os.environ)
        except FileNotFoundError:
            pass

        for dir in re.split(":", os.environ['PATH']):  # try each directory in the path
            program = "%s/%s" % (dir, args[0])
Пример #21
0
# import dash
# import dash_html_components as html
import dash_core_components as dcc
from pipe import pipe

df2 = pipe()
data = df2.groupby('Country_ARR').count()
grafica1 = [{'x': [x], 'y': [y], 'type': 'bar', 'name': name} for x, y, name in zip(range(1, data.shape[0]), data.Id, data.index)]

data = df2[df2['Country_DEP']=='SPAIN'].groupby('Country_ARR').count()
grafica2 = [{'x': [x], 'y': [y], 'type': 'bar', 'name': name} for x, y, name in zip(range(1, data.shape[0]), data.Id, data.index)]


data = df2[df2['Country_ARR']=='SPAIN'].groupby('Country_DEP').count()
grafica3 = [{'x': [x], 'y': [y], 'type': 'bar', 'name': name} for x, y, name in zip(range(1, data.shape[0]), data.Id, data.index)]

df2['date_DEP_TIME'] = df2['DEP_TIME'].dt.date
data = df2.groupby('date_DEP_TIME').count()
grafica4 = [{'x': list(data.index), 'y': list(data.Id), 'type': 'line', 'name': list(data.index)}]


g1 = grafica1
g2 = grafica2
g3 = grafica3
g4 = grafica4


# grafica 1
graphic1 = dcc.Graph(
        id='example-graph-1',
        figure={
Пример #22
0
    def step(self, action):
        if action == 1:
            self.bird.jump()

        reward = 1

        # remove offscreen pipes
        pipes_off_screen = [
            index for index, value in enumerate(self.pipes)
            if value.x < (-1 * self.pipe_width)
        ]

        for p in pipes_off_screen:
            self.pipes[p].delete()
            self.pipes.pop(p)
            reward += 150

        # add a new pipe if it is due
        if self.last_pipe % self.pipe_frequency == 0:
            rand_height = random.randint(0, self.window_y - self.pipe_gap)
            new_pipe = pipe(self.window_x, rand_height, self.pipe_width,
                            self.pipe_gap, self.pipe_velocity, self.window_y,
                            self.batch)
            self.pipes.append(new_pipe)
            self.last_pipe = 0

        self.last_pipe += 1

        # move agent
        self.bird.update()

        # update score
        if not self.batch == False:
            self.scoreboard.set_score(self.bird.score)

        # check for game over
        done = False

        if self.bird.y <= 0:
            done = True

        if self.bird.y + self.bird.size >= self.bird.max_y:
            done = True

        for p in self.pipes:
            p.update()
            if ((self.bird.x + self.bird.size) >
                    p.x) and (self.bird.x < (p.x + self.pipe_width)):
                if ((self.bird.y < p.y) or ((self.bird.y + self.bird.size) >
                                            (p.y + self.pipe_gap))):
                    done = True

        if not done:
            self.bird.set_score(self.bird.score + reward)

        else:
            reward = -100
            self.reset()

        observation = self.observation()

        return (observation, reward, done, '')
Пример #23
0
 def __init__(self):
     self.pipe = pipe()