def get_plate_data_from_file_with_multiple_plates(path, c): return thread_first( path, open, file.read, (str.replace, '\r', ''), (str.split, c['plate_delimiter']), tail, map(StringIO), map(pd.read_csv(delimiter=c['delimiter'], skiprows=c['skiprows'])), pd.concat, df.dropna(axis=1, how='all'), (drop_matching_columns, c['dropcols']), df.rename(columns=c['colrename']), (add_normalized_columns, c['normcols']))
def main(): print("Calculating MAP for exercise 1") predictedSum = getPredictedSummariesEx1() relevantSum = getRelevantSummaries() MAP = map(predictedSum, relevantSum) print('Mean Average Precision:', MAP) print("Calculating MAP for exercise 2") predictedSum = getPredictedSummariesEx2() relevantSum = getRelevantSummaries() MAP = map(predictedSum, relevantSum) print('Mean Average Precision:', MAP)
def get_plate_data_from_file_with_multiple_plates(path,c): return thread_first(path, open, file.read, (str.replace,'\r',''), (str.split,c['plate_delimiter']), tail, map(StringIO), map(pd.read_csv(delimiter=c['delimiter'], skiprows=c['skiprows'])), pd.concat, df.dropna(axis=1,how='all'), (drop_matching_columns,c['dropcols']), df.rename(columns=c['colrename']), (add_normalized_columns,c['normcols']))
def normalizePrices(self): highs = self.get('highs') lows = self.get('lows') closes = self.get('closes') opens = self.get('opens') new_highs = utils.map(highs, self.__flattenNonesPrice) new_lows = utils.map(lows, self.__flattenNonesPrice) new_opens = utils.map(opens, self.__flattenNonesPrice) new_closes = utils.map(closes, self.__flattenNonesPrice) self.set('highs', new_highs) self.set('lows', new_lows) self.set('opens', new_opens) self.set('closes', new_closes)
def setAvgVolume(self): volumes = self.get('volumes') new_vols = utils.map(volumes, self.__zeroNonesVol) self.set('volumes', new_vols) avg = utils.average(new_vols) self.set('avg_volume', avg) return avg
def getIntensity(self, lampValues): """produce the values needed for each lamp""" returnList = [] for value in lampValues: for propN, prop in enumerate(self.lightIntensityOn): returnList.append(utils.map(value, 0, 255, self.lightIntensityOff[propN], prop)) return returnList
def getCategoryList (q=None, shouldUpdateDb=True): "Query traditionally for multiple categorys."; q = q or {}; assert type(q) is dict; adaptWrapper = lambda category: ( # A wrapper around `adapt`, aware of `shouldUpdateDb`. categoryAdp.adapt(category, shouldUpdateDb)#, # NO COMMA ); return utils.map(adaptWrapper, db.categoryBox.find(q));
def getDojoList(q=None, shouldUpdateDb=True): "Query traditionally for multiple dojos." q = q or {} assert type(q) is dict adaptWrapper = lambda dojo: ( # A wrapper around `adapt`, aware of `shouldUpdateDb`. dojoAdp.adapt(dojo, shouldUpdateDb) #, # NO COMMA ) return utils.map(adaptWrapper, db.dojoBox.find(q))
def getUserList(q=None, shouldUpdateDb=True): "Query traditionally. No special treatment for emails." q = q or {} assert type(q) is dict adaptWrapper = lambda user: ( # A wrapper around `adapt`, aware of `shouldUpdateDb`. userAdp.adapt(user, shouldUpdateDb) #, # NO COMMA ) return utils.map(adaptWrapper, db.userBox.find(q))
def getArticleList(q=None, shouldUpdateDb=True): "Query traditionally for multiple articles." q = q or {} assert type(q) is dict adaptWrapper = lambda article: ( # A wrapper around `adapt`, aware of `shouldUpdateDb`. articleAdp.adapt(article, shouldUpdateDb) #, # NO COMMA ) return utils.map(adaptWrapper, db.articleBox.find(q))
def post_userCon_fetchUserList(): sesh = auth.getSesh() userList = userMod.getUserList() #print("userList = ", userList); snippedUserList = utils.map(userList, userMod.snipUser) #print("snippedUserList = ", snippedUserList); return { "userList": snippedUserList }
def main(): classifier = trainPerceptron() weightsList = [] for weight in classifier.coef_[0]: weightsList.append(weight) predictedSum = getPredictedSummariesEx3(weightsList) relevantSum = getRelevantSummaries() MAP = map(predictedSum, relevantSum) print('Mean Average Precision:', MAP)
def generateOpenSimplex(self): self.generatePlain() for i in range(0, utils.chunk_size): for k in range(0, utils.chunk_size): value = utils.map( utils.simplex2d( (self.position.x * utils.chunk_size + i) * 0.025, (self.position.z * utils.chunk_size + k) * 0.025), -1, 1, 0, utils.chunk_size) for j in range(0, int(value)): self.placeBlockAt(i, j, k, BlockType.GRASS)
def get_article_urls(query='', page=0): yielded = [] url = 'https://www.hmetro.com.my/search?s={}{}'.format( query, '' if page == 0 or not isinstance(page, int) else '&page={}'.format(page)) for url in filter( map(filter(open_soup(url).find_all('a'), has_key('href')), get_key('href')), text_match(r'^/.+?/\d{4}/\d{2}/\d{6}/.+$')): url = 'https://www.hmetro.com.my{}'.format(url) if url in yielded: continue yielded.append(url) yield page, url, get_article(open_soup(url))
def home(): request.headers.environ["X_FORWARDED_FOR"] = "54.39.138.153" proxies = utils.map(request.headers.environ, http_headers) print(request.headers.environ.get("HTTP_USER_AGENT")) print("Are proxies enabled - " + str(proxies)) print(request.headers) opened_ports = portscan.scan(request.headers.environ.get("REMOTE_ADDR")) return render_template( 'index.html', using_proxies=proxies, user_agent=request.headers.environ.get("HTTP_USER_AGENT"), language=request.headers.environ.get("HTTP_ACCEPT_LANGUAGE"), opened_ports=opened_ports, title='Home Page', year=datetime.now().year, )
def step(self, tick): # if self.target == self.master.ball.location: # self.master.ball.step(tick) # self.target = self.master.ball.location # if self.agent.team == 0: print(utils.steer(self.target, self.car), utils.angle2D(self.target, self.car), self.target.tuple, self.car.location.tuple) # self.controls.yaw = utils.steer(self.target, self.car) self.controls.throttle, self.controls.boost = utils.throttle( self.car, self.speed) turn_radius = utils.turn_radius(self.car, self.target) angle_to_target = utils.angle2D(self.target, self.car) point = utils.point_on_circle(self.car, utils.sign(angle_to_target) * math.pi / 2, turn_radius) #, self.car.rotation) circle = [] for i in range(0, 366, 6): n = utils.point_on_circle(point, math.radians(i), turn_radius) #, point.rotation) circle.append(n.tuple) self.agent.renderer.draw_polyline_3d(circle, self.agent.renderer.red()) # ball_prediction = self.agent.get_ball_prediction_struct() # if ball_prediction is not None: # # for i in range(0, ball_prediction.num_slices): # if self.target == self.master.ball.location: # self.target = structs.Vector3(ball_prediction.slices[10].physics.location) # turn_radius = utils.turn_radius(self.car, self.target) # goal_to_ball_uv = (self.agent.game_info.their_goal.location - self.agent.game_info.ball.location).normalize() # yaw = math.atan2(goal_to_ball_uv.x, goal_to_ball_uv.z) #math.atan((goal_to_ball_uv.x/(-goal_to_ball_uv.y)))# # pitch = 0#math.atan(math.hypot(goal_to_ball_uv.x, goal_to_ball_uv.y)/goal_to_ball_uv.z) # target_ang = structs.Rotator(pitch, yaw, 0) # circle_point = utils.point_on_circle(self.target, math.pi/2, turn_radius, target_ang) # circle = [] # for i in range(0, 366, 6): # n = utils.point_on_circle(circle_point, math.radians(i), turn_radius) # circle.append(n.tuple) # self.agent.renderer.draw_polyline_3d(circle, self.agent.renderer.black()) # x1 = point.x # y1 = point.y # x2 = circle_point.x # y2 = circle_point.y # gamma = -math.atan((y2-y1)/(x2-x1)) # beta = math.asin((turn_radius-turn_radius)/math.sqrt((x2-x1)**2 + (y2-y1)**2)) # alpha = gamma-beta # x3 = x1 - turn_radius*math.cos((math.pi/2)-alpha) # y3 = y1 - turn_radius*math.sin((math.pi/2)-alpha) # x4 = x2 + turn_radius*math.cos((math.pi/2)-alpha) # y4 = y2 + turn_radius*math.sin((math.pi/2)-alpha) # tang1 = structs.Vector3(x3, y3, 100) # tang2 = structs.Vector3(x4, y4, 100) # if self.last_target_ang != target_ang: # print('ye') # self.cur_hit = 0 # self.last_target_ang = target_ang # self.to_hit = [tang1, tang2, self.agent.game_info.ball.location] # self.agent.renderer.draw_rect_3d(self.to_hit[0].tuple, 20, 20, True, self.agent.renderer.black()) # self.agent.renderer.draw_rect_3d(self.to_hit[1].tuple, 20, 20, True, self.agent.renderer.black()) # point_to_target = utils.distance2D(self.target, point) # if point_to_target < turn_radius: # #inside circle # if abs(utils.angle2D(self.target, self.car)) < math.pi/2: # to_target = utils.localize(self.target, self.car).normalize(turn_radius) # self.target = self.car.location - to_target # self.controls.boost = 0 # self.controls.throttle = 0 # else: # to_target = utils.localize(self.target, self.car).normalize(turn_radius) # self.target = self.car.location - to_target # self.controls.boost = 0 # self.controls.handbrake = 1 # point2 = structs.Vector3(x,y,z) # self.agent.renderer.draw_rect_3d(point.tuple, 10, 10, True, self.agent.renderer.blue()) if isinstance(self.master, states.quickShoot): if self.path: if not self.path.on_path(self.car.location): # self.path = None print('yes') else: curvetarget = self.path.evaluate(0.1) curvetarget = structs.Vector3(curvetarget[0], curvetarget[1], 0) self.controls.steer = utils.steer(curvetarget, self.car) self.agent.renderer.draw_rect_3d( curvetarget.tuple, 10, 10, True, self.agent.renderer.blue()) if not self.path: b_prediction = self.agent.get_ball_prediction_struct() target = utils.find_point_on_line( self.agent.game_info.their_goal.location, self.target, -.05) self.path = structs.Path(self.agent, [ self.car.location, utils.point_on_circle(self.car, 0, 500), 'TP', target, self.target ], utils.sign(angle_to_target), self.car.rotation, self.car) angletotarget = utils.map( abs(utils.angle2D(self.target, self.car)), 0, math.pi, 0, math.pi) curvetarget = self.path.evaluate(0.1) curvetarget = structs.Vector3(curvetarget[0], curvetarget[1], 0) self.agent.renderer.draw_rect_3d(curvetarget.tuple, 10, 10, True, self.agent.renderer.blue()) self.controls.steer = utils.steer(curvetarget, self.car) elif utils.distance2D(point, self.target) < turn_radius: to_target = utils.localize(self.target, self.car).normalize(turn_radius) self.target = self.car.location - to_target self.controls.boost = False self.controls.steer = utils.steer(self.target, self.car) else: self.controls.steer = utils.steer(self.target, self.car) if self.path: # print(self.path.on_path(self.car.location)) self.agent.renderer.draw_polyline_3d( self.path.get_path_points(np.linspace(0, 1.0, 100)), self.agent.renderer.green()) self.agent.renderer.draw_rect_3d(self.target.tuple, 10, 10, True, self.agent.renderer.red()) self.agent.renderer.draw_line_3d(self.car.location.flatten().tuple, self.target.flatten().tuple, self.agent.renderer.green()) self.expired = True return self.controls
import json # PIP: import bottle # LOC: import bu from appDef import app from constants import K import utils import emailer # Install required netloc: utils.map(app.install, [ bu.mkPlugin_enforeSchemeAndNetloc(K.APP_SCHEME, K.APP_NETLOC), bu.plugin_frameDeny, bu.plugin_timer, ]) # Static routing (front/) & templating (views/): for dirPath in K.STATIC_DIR_PATHS: bu.addStaticFolder(app, dirPath) for dirPath in K.VIEW_DIR_PATHS: bu.addTemplateFolder(dirPath) # General, not app-specific. # Add shortcuts: bu.addShortcuts(app, K.SHORTCUT_MAP) # Configure bottle-related: bu.setMemfileMax(K.MEMFILE_MAX)
def get_article(soup): attribs = {'class': 'field-item even', 'property': 'content:encoded'} return '\n\n'.join( filter(map(soup.find('div', attribs).find_all('p'), lambda x: x.text), is_part_of_article))
try: with open('latest_page.log', 'r') as file: latest_page = int(file.read()) except: latest_page = 0 # 23 with open('dbconfig.json', 'r') as file: config = json.loads(file.read()) conn = mysql_connect(**config) for page, url, article in scrap(page=latest_page): # utama/2019/10/505232/datuk-red-enggan-cerai-adira match = find_matches( r'^https://www\.hmetro\.com\.my/(.+?)/(\d{4})/(\d{2})/(\d+?)/(.+)$', url) c, y, m, id, title = map(range(1, 6), lambda x: try_cast(match.group(x), int)) cid = get_id_by_category(c) with open('article.txt', 'a', encoding='utf-8') as file: file.write('{}\n\n'.format(article)) print('Got article from page {}: {}'.format(page, url)) # ID, category_id, year, month, title, content # insert_into( # conn, # 'INSERT INTO article (ID,category_id,year,month,title,content) VALUES (%s, %s, %s, %s, %s, %s)', # id, cid, y, m, title, article # ) last_page = page
def map(message): if message.chat.id != config.group_id: config.the_bot.forward_message(config.group_id, message.chat.id, message.message_id) utils.map(message.chat.id)
print Arduino.cue() while True: sender = [] output = Arduino.readSequence() print output for i in output: sender.append(int(i) * 83) EntTec.sendLights(pins,sender) elif mode == "boulez": IRCAM = IRCAM() IRCAM.connect('0.0.0.0',7007) while True: message = IRCAM.getMessage() if message != None: print "in" + str(message) message = map(message, 0, 90, 0, 63) #messages = [0] * 64 for cN,channel in enumerate(messages): if channel != 0: messages[cN] -= 2 message = clamp(message, 0, 63) messages[message] = 20 #EntTec.senddmx(range(1,65),messages) EntTec.senddmx(range(1,65),messages) elif mode == "test": while True: IRCAM = IRCAM() IRCAM.connect('0.0.0.0',7007) elif mode == "test2": while True:
def engine_game(screen, get_data, decrease_lives): """ This function handles the 'wheelie' minigame. - screen: pygame.display to draw to. - get_data: get_data function to retrieve data from the microbit. """ global angle global angle_opponent global X global Y global car global background blow_points = 0 old_blow_points = 0 stage = 0 # Load car sprite car = pygame.image.load("engine_files" + utils.sep + "car.png").convert_alpha() # Car sprite's coordinates X = 600 Y = utils.height - 20 - 320 # 320 is the sprite's height # Init engine temperature sprite temp_indicator = engine_files.engine_temp.EngineTemp() indicator_sprites = pygame.sprite.Group() indicator_sprites.add(temp_indicator) # Init smoke sprite smoke = engine_files.smoke.Smoke() smoke_sprites = pygame.sprite.Group() smoke_sprites.add(smoke) # Load backgound image background = pygame.image.load("engine_files" + utils.sep + "background.png").convert_alpha() # Game pygame.mixer.music.load("engine_files" + utils.sep + "music.ogg") pygame.mixer.music.play(1) # Do not loop the song, play it once seconds_counter = time.time() utils.text_colour = (190, 150, 200) while True: old_blow_points = blow_points if stage == 5: pygame.mixer.music.stop() end_anim(screen, True) utils.time_remaining = 0 # Make sure the game stops if time.time() - seconds_counter > 1: utils.time_remaining -= 1 seconds_counter = time.time() if utils.time_remaining > 0: utils.run_in_thread(get_data) utils.check_data_integrity(screen) for event in pygame.event.get(): if event.type == pygame.QUIT: pygame.quit() sys.exit() screen.fill((0, 0, 0)) # Map the data coming from the microbit to a # scale of 0 to 100. # If the engine is not spinning, the pin is floating # due to the diode protection. Might need adjustement. blow = utils.map(utils.data[3], 80, 560, 0, 100) if blow > 70: blow_points += 0.02 if int(blow_points) > int(old_blow_points): stage += 1 utils.points += 1 temp_indicator.change_temp(stage) smoke.animate() screen.blit(background, (0, 0)) indicator_sprites.draw(screen) screen.blit(car, (X, Y)) smoke_sprites.draw(screen) smoke_sprites.update() indicator_sprites.update() # Info utils.draw_text(screen, "Blow on the fan!", utils.width / 2, 322) utils.draw_points(screen) utils.draw_time(screen, utils.time_remaining) utils.run_in_thread(utils.draw_volume(screen)) pygame.display.flip() utils.clock.tick(60) else: pygame.mixer.music.stop() if stage < 5: decrease_lives() end_anim(screen, False) utils.minigame_end(screen, get_data) break return
def action(self): """Runs a loop within a thread, different action depending on input_device""" sys.stdout.write("%s thread initiated\n" % self.input_device) while True: if self.playThread: # Arduino Mode if self.mode == 'Arduino': #print "Start Arduino" ArduinoLights = [57, 49, 41, 33, 25, 17, 9, 1] # Mapping of the 8 arduono lights #ArduinoLights = [1, 2, 3, 4, 5, 6, 7, 8] ArduinoLights.reverse() step = 0 self.input_device.cue() # Send a start command to the Arduino over serial # This loop waits for each step from the arduino then it passes the values to the DMX device # It only ends when the user presses the button to set playThread False while True: if self.input_device.isConnected() == False: print "Arduino Not connected" self.playThread = False else: ArduinoStep = [] # New empty list for the DMX send output = self.input_device.readSequence() # this blocks until it can return a value step += 1 #app.cueNumber.set(step) # string to list > this could be done more efficiently using list()? for i in output: ArduinoStep.append(self.rangeMapper(int(i), 0, 3, 0, 255)) # Send list to DMX output if step >= 0: # <=466 self.output_device.sendLights(ArduinoLights,ArduinoStep) elif step == 465: self.output_device.all(0) else: self.output_device.all(255) # Stop playing if end of sequence if step >= 2131: self.playThread = False # Terminate when button sets playThread False, closes port if not self.playThread: # print "Stopping Arduino" self.input_device.stop() self.output_device.all(0) #app.cueNumber.set('0') break # IRCAM Mode elif self.mode == "IRCAM": self.cue = 0 print "Listening for IRCAM" messages = [0] * 65 lastMessages = [] lastspat = None lastpitch = None self.output_device.sendLights(all64Lights,messages) while True: message = self.input_device.getMessage() print message if message.get('cue', None) != None: #app.cueNumber.set(message['cue']) self.cue = message['cue'] elif self.cue >= 22 and self.cue <= 31: fade = 51 if message.get('spat', None) != None: message = message['spat'] message = map(message, 0, 360, 0, 64) message = clamp(message, 1, 64) messages[message] = 255 elif self.cue >= 209: fade = 15 if message.get('pitch', None) != None: message = message['pitch'] message = clamp(message, 50, 100) message = map(message, 50, 100, 4, 64) #message = clamp(message, 1, 64) messages[message] = 255 #print "pitch %d " % message else: self.output_device.all(0) for cN,channel in enumerate(messages): if channel != 0: messages[cN] -= fade if messages != lastMessages: lastMessages = messages[:] self.output_device.sendLights(all64Lights,messages) if not self.playThread: print "Stopping IRCAM" self.output_device.all(0) # self.input_device.disconnect() #app.cueNumber.set('0') break # testCircle Mode elif self.mode == "testCircle": while True: output = self.input_device.circle() if output == 1: last_output = 64 else: last_output = output - 1 self.output_device.sendLights([last_output, output],[0, 255]) #app.cueNumber.set(str(output)) if not self.playThread: print "Stopping Circle test" #app.cueNumber.set('0') self.input_device.reset() self.output_device.all(0) break # testAll Mode elif self.mode == "testAll": while True: if self.playThread: self.output_device.sendLights(all64Lights, [255]*64) elif not self.playThread: print 'stop' self.output_device.sendLights(all64Lights, [0]*64) break sleep(0.1) # fadeAll Mode elif self.mode == "fadeAll": while True: output = self.input_device.fade() #app.cueNumber.set(str(output)) self.output_device.sendLights(all64Lights,[output]*64) if not self.playThread: print "Stopping fade test" #app.cueNumber.set('0') self.input_device.reset() self.output_device.all(0) break sleep(0.1)