0:\n bufL = [buf]\n def bufferPoly(feature):\n return feature.buffer(bufL[0])\n\n ptsB = pts1.map(bufferPoly)\n def table_m(image):\n table = (image\n .select('VI')\n .reduceRegions(collection = ptsB.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_ptsB',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n \n #print ('buffered pts by:' + str(buf) + ' for Landsat: ' + sen + '_' + met)\n\n elif poly > 0:\n \n def table_m(image):\n table = (image\n .select('VI')\n .reduceRegions(collection = pts1.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_poly1',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n \n #print ('spatial mean in poly: no buffer for Landsat: ' + sen + '_' + met)\n\n else:\n def table_m(image):\n table = (image\n .select('VI')\n .reduceRegions(collection = pts1.select([ID_field]),\n reducer = ee.Reducer.mean(),\n scale = scalePix))\n \n def table_add_date(f):\n return f.set('startDate', ee.Date(image.get('system:time_start')))\n\n return table.map(table_add_date)\n\n triplets = img_col.map(table_m).flatten()\n\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\n .filter(ee.Filter.neq('mean', None))\n .select(['.*'],None,False),\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_pts1',\n folder = folderOut,\n fileFormat = 'CSV')\n task_tc.start()\n \n #print('value at point: no buffer for Landsat: ' + sen + '_' + met)","def extract_dl(driving_log_path):\r\n entries = []\r\n with open(driving_log_path) as csv_file:\r\n reader = csv.reader(csv_file)\r\n for entry in reader:\r\n entries.append(entry)\r\n empty_lists = [[] for i in range(7)]\r\n center_images, left_images, right_images, steerings, throttles, brakes, speeds = empty_lists\r\n for entry in entries:\r\n center_image_path, left_image_path, right_image_path = (entry[0], entry[1], entry[2])\r\n steering = float(entry[3])\r\n throttle = float(entry[4])\r\n brake = float(entry[5])\r\n speed = float(entry[6])\r\n center_image = cv2.imread(center_image_path)\r\n left_image = cv2.imread(left_image_path)\r\n right_image = cv2.imread(right_image_path)\r\n center_images.append(center_image)\r\n left_images.append(left_image)\r\n right_images.append(right_image)\r\n steerings.append(steering)\r\n throttles.append(throttle)\r\n brakes.append(brake)\r\n speeds.append(speed)\r\n return center_images, left_images, right_images, steerings, throttles, brakes, speeds"],"string":"[\n \"def process_traffic_lights(self):\\n light = None\\n\\n #some plausability checks before starting the processing\\n if None is self.waypoints:\\n return -1, TrafficLight.UNKNOWN\\n if None is self.pose:\\n return -1, TrafficLight.UNKNOWN\\n if len( self.stopLineIndex) == 0:\\n return -1, TrafficLight.UNKNOWN\\n \\n car_wp_idx = self.get_closest_waypoint(self.pose)\\n closestStopLineIdx = self.find_next_stoplineIndex(car_wp_idx)\\n totalNoWP = len(self.waypoints.waypoints)\\n \\n \\n \\n #we assume that we can see traffic lights up to a distance of 40 m\\n distance = 0.\\n #resulting list of stoplights in sight\\n tl_index_in_distance = []\\n if car_wp_idx == self.stopLineIndex[closestStopLineIdx][0]:\\n tl_index_in_distance.append(closestStopLineIdx)\\n closestStopLineIdx = (closestStopLineIdx + 1) % len(self.stopLineIndex)\\n \\n noWPScanned = 0 \\n while distance < 40.:\\n next_car_wp_idx = (car_wp_idx + 1) % totalNoWP\\n distance += self.get_waypoint_distance(car_wp_idx, next_car_wp_idx)\\n car_wp_idx = next_car_wp_idx\\n #if there is another stoplight in distance, append it to the array \\n #of stoplight indices\\n if car_wp_idx == self.stopLineIndex[closestStopLineIdx][0]:\\n tl_index_in_distance.append(closestStopLineIdx)\\n closestStopLineIdx = (closestStopLineIdx + 1) % len(self.stopLineIndex)\\n noWPScanned += 1\\n for idx in tl_index_in_distance:\\n trafficLightIndex = self.stopLineIndex[idx][1]\\n trafficLightWaypoint = self.stopLineIndex[idx][0]\\n if TrafficLight.RED == self.get_light_status(trafficLightIndex):\\n return trafficLightWaypoint, TrafficLight.RED\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n closest_light = None\\n line_wp_index = None\\n\\n # We want to find the smallest \\\"diff\\\". Initialize to the maximum possible value: total number of waypoints\\n diff = len(self.base_waypoints.waypoints)\\n\\n # List of positions that correspond to the line to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n\\n if(self.pose):\\n car_wp_index = self.get_closest_waypoint(self.pose.pose.position.x, self.pose.pose.position.y)\\n\\n #TODO find the closest visible traffic light (if one exists)\\n\\n # Now go over each light position in the known map (total of 8)\\n for i, light in enumerate(self.lights):\\n line = stop_line_positions[i] # position of the stop line\\n\\n # Extract the closest waypoint associated to traffic light (index = i) and in front of the ego\\n temp_wp_idx = self.get_closest_waypoint(line[0], line[1])\\n\\n # Find the number of waypoints between the ego and the temp_wp_idx\\n d = temp_wp_idx - car_wp_index\\n\\n # If this the smallest so far?\\n if (d >= 0) and (d < diff):\\n diff = d\\n closest_light = light\\n line_wp_index = temp_wp_idx\\n\\n # If we did find a closest light:\\n if (closest_light):\\n # Read the state of the closest light and update the state (i.e., the color of the light)\\n # Red: 0, Yellow: 1, Green: 2, Unknown: 4\\n state = self.get_light_state(closest_light)\\n is_close = (diff < 5) # CLOSE_THRESH\\n \\n '''\\n color_dict = { TrafficLight.RED: 'Red', \\\\\\n TrafficLight.YELLOW: 'Yellow', \\\\\\n TrafficLight.GREEN: 'Green', \\\\\\n TrafficLight.UNKNOWN: 'Unknown'}\\n \\n rospy.logwarn(\\\"Closest Traffic Light: ({0}, {1})\\\".format( color_dict[state], line_wp_index) )\\n '''\\n return line_wp_index, state, is_close\\n else:\\n # rospy.logwarn(\\\"No traffic light found.\\\")\\n return -1, TrafficLight.UNKNOWN, False\",\n \"def process_traffic_lights(self):\\n\\n # Our closest visible traffic light starts off as none\\n t1 = time()\\n\\n\\n closest_traffic_light_waypoint = -1\\n\\n # Get the list of 'stop line' positions\\n stop_line_positions = self.config['stop_line_positions']\\n\\n # Find which waypoint the car is closest to\\n closest_stop_line_waypoint = -1\\n traffic_light_state = TrafficLight.UNKNOWN\\n if(self.pose):\\n car_position_waypoint = self.get_closest_waypoint(self.pose.pose)\\n\\n # Find the closest traffic light based on stop positions\\n index, closest_stop_line_waypoint = self.get_closest_stop_line_waypoint(self.waypoints, car_position_waypoint, stop_line_positions)\\n\\n # Get traffic light state ground truth from simulator provided lights list\\n traffic_light_state_truth = TrafficLight.UNKNOWN\\n if len(self.lights) > 0 and index >= 0 and index < len(self.lights):\\n # Use matching index from stop_line_positions and hope that they align\\n traffic_light_state_truth = self.lights[index].state\\n\\n # Get traffic light state from camera image\\n traffic_light_state = self.get_light_state(traffic_light_state_truth)\\n\\n text = \\\"\\\"\\n if traffic_light_state == 0: text = \\\"Red.\\\"\\n if traffic_light_state == 1: text = \\\"Yellow.\\\"\\n if traffic_light_state == 2: text = \\\"Green.\\\"\\n if traffic_light_state == 3: text = \\\"Unknown.\\\"\\n real = \\\"\\\"\\n if traffic_light_state_truth == 0: real = \\\"Red.\\\"\\n if traffic_light_state_truth == 1: real = \\\"Yellow.\\\"\\n if traffic_light_state_truth == 2: real = \\\"Green.\\\"\\n if traffic_light_state_truth == 3: real = \\\"Unknown.\\\"\\n\\n return closest_stop_line_waypoint, traffic_light_state\",\n \"def process_traffic_lights(self):\\n closest_light = None\\n\\tline_wp_idx = None\\n\\n # List of positions that correspond to the line to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n if(self.pose):\\n\\n \\tcar_wp_idx = self.get_closest_waypoint(self.pose.pose, self.lights)\\n\\t\\ttl = self.lights[car_wp_idx]\\n\\n \\t#TODO find the closest visible traffic light (if one exists)\\n\\t\\tdiff = len(self.waypoints)\\n\\t\\tfor i, light in enumerate(self.lights):\\n\\t\\t\\tline = stop_line_positions[i]\\n\\n\\t\\t\\tline_pose = Pose()\\n\\t\\t\\tline_pose.position.x = line[0]\\n\\t\\t\\tline_pose.position.y = line[1]\\n\\n\\t\\t\\ttemp_wp_idx = self.get_closest_waypoint(line_pose, self.waypoints)\\n\\n\\t\\t\\td = temp_wp_idx - car_wp_idx\\n\\t\\t\\tif d >= 0 and d < diff:\\n\\t\\t\\t\\tdiff = d\\n\\t\\t\\t\\tclosest_light = light\\n\\t\\t\\t\\tline_wp_idx = temp_wp_idx\\n\\n\\tcar_dist = self.dist_to_point(self.pose.pose, tl.pose.pose)\\n\\n#\\trospy.logwarn(\\\"DISTANCE: {}, LAST_DISTANCE: {}\\\".format(car_dist, self.last_dist))\\n\\n if closest_light and car_dist<self.distance_threshold_max and car_dist>self.distance_threshold_min and self.last_dist>=car_dist:\\n\\t\\tcv_img = self.bridge.imgmsg_to_cv2(self.camera_image, 'rgb8')\\n\\t\\ttl_image = self.detect_traffic_light(cv_img)\\n\\t\\tif tl_image is not None:\\n\\t\\t\\tstate = self.light_classifier.get_classification(tl_image)\\n\\t\\t\\tstate = state if(state != self.invalid_state_number) else TrafficLight.UNKNOWN\\t\\n\\t\\t\\t\\n\\t\\t\\trospy.logwarn(\\\"[TL_DETECTOR] State of traffic light is {}\\\".format(state))\\n\\t\\telse:\\n\\t\\t\\trospy.logwarn(\\\"[TL_DETECTOR] No TL is detected\\\")\\t\\n\\t\\tself.last_dist = car_dist\\n return line_wp_idx, state\\n \\n\\tself.last_dist = car_dist\\n return -1, TrafficLight.UNKNOWN\",\n \"def __process_traffic_lights(self):\\n rospy.logdebug(\\\"TLDetector.__process_traffic_lights\\\")\\n\\n closest_light, line_index = self.__get_closest_light()\\n\\n if closest_light:\\n if self.__mode == CLSFY_MODE:\\n state = self.__get_light_state(closest_light)\\n elif self.__mode == LABEL_MODE:\\n if line_index - self.__get_car_index() <= 100:\\n state = closest_light.state\\n else:\\n state = 4\\n rospy.loginfo(\\n \\\"TLDetector: Publishing index: \\\"\\n + str(line_index)\\n + \\\" and state: \\\"\\n + str(state)\\n )\\n return line_index, state\\n rospy.logdebug(\\\"TLDetector: Publishing default\\\")\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n\\n # Clear closest light\\n closest_light = None\\n\\n # Clear closest line index\\n line_wp_idx = None\\n \\n # Load stop line positions from config\\n stop_line_positions = self.config['stop_line_positions']\\n\\n # If we've received valid pose information...\\n if self.pose:\\n\\n # Find index of waypoint closest to current car position\\n car_wp_idx = self.waypoint_tree.query([self.pose.pose.position.x, self.pose.pose.position.y],1)[-1]\\n\\n # Largest possible offset from car to light\\n diff = len(self.waypoints.waypoints)\\n\\n # For each light in the list of traffic lights...\\n for i, light in enumerate(self.lights):\\n\\n # Get stop line position i\\n line = stop_line_positions[i]\\n\\n # Find index of waypoint closest to the light\\n wp_idx = self.waypoint_tree.query(line,1)[-1]\\n\\n # How many waypoints ahead to light? \\n wps = wp_idx - car_wp_idx\\n\\n # If light is ahead of or abreast of car\\n # and we haven't encuntered a closer one...\\n if wps>=0 and wps<diff:\\n\\n # Keep track of least positive waypoint count\\n diff = wps\\n\\n # Save this light\\n closest_light = light\\n\\n # Save the waypoint index for this light\\n line_wp_idx = wp_idx\\n\\n # If there is a traffic light in front of us...\\n if closest_light:\\n\\n # Get its state\\n state = self.get_light_state(closest_light)\\n\\n # Return its line index and state\\n return line_wp_idx, state\\n\\n # Otherwise return sentinel indicating no light\\n return -1, TrafficLight.UNKNOWN\",\n \"def find_tfl_lights(image: np.ndarray):\\n kernel = np.array(\\n [[0, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [1, 3, 1],\\n [0, 1, 0]])\\n\\n kernel = kernel - kernel.mean()\\n\\n red_image = image.copy()\\n red_image = red_image[:, :, 0]\\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(red_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n red_points = np.where(mask)\\n positions = []\\n final_red_points = []\\n for point1 in range(len(red_points[0])):\\n point = (red_points[0][point1], red_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\\n final_red_points.append(point)\\n final_red_points = filter_points(final_red_points)\\n positions += final_red_points\\n auxilary = ['r'] * len(positions)\\n red_x = [val[1] for val in final_red_points]\\n red_y = [val[0] for val in final_red_points]\\n green_image = image.copy()\\n green_image = green_image[:, :, 1]\\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(green_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n green_points = np.where(mask)\\n final_green_points = []\\n for point1 in range(len(green_points[0])):\\n point = (green_points[0][point1], green_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\\n final_green_points.append(point)\\n\\n final_green_points = filter_points(final_green_points)\\n positions += final_green_points\\n auxilary += ['g'] * len(final_green_points)\\n green_x = [val[1] for val in final_green_points]\\n green_y = [val[0] for val in final_green_points]\\n print(f\\\"There are {len(green_x) + len(red_x)} points\\\")\\n return positions, auxilary\",\n \"def process_traffic_lights(self):\\n stopping_waypoint_index = int(self.stopping_waypoint_index)\\n nearest_light = self.stopping_waypoint_distance\\n # the result of the image_cb function is in the equation below\\n traffic_light_value = self.last_state\\n #obtain the minimum stopping distance possible given the acceleration, and jerk limits, and slow stop point\\n acceleration_limit = 10.0 - 1.0\\n slow_stop_point = 0\\n min_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\\n #obtain the maximum stopping distance by changing the acceleration limit to 6\\n acceleration_limit -= 3.0\\n max_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\\n #add on the current_velocity*rate to make sure it does not overlook the time gap\\n max_stop_distance += self.current_velocity*1.0/self.loop_rate\\n #if the previous light was red and the car began to stop, continue stopping\\n if (traffic_light_value==self.Red_Light and self.prev_traffic_light_value==self.Red_Light and self.prev_stopping_waypoint_index>=0):\\n None\\n #else if the traffic light is green, ignore it.\\n elif traffic_light_value==self.Green_Light:\\n stopping_waypoint_index = -1\\n #If the velocity is less than 2*slow_stop_point and the distance to the light is less than 2*(0.5*slow_stop_point**2) and the light is red\\n elif (self.current_velocity<=5 and nearest_light<=5 and traffic_light_value==self.Red_Light):\\n None\\n #if the distance to the nearest_light is more than the max_stop_distance, ignore it\\n elif nearest_light > max(max_stop_distance,10):\\n stopping_waypoint_index = -1\\n # else if the traffic light is Yellow or Red and the distance to the nearest light is more than the min_stop_distance\\n elif ((traffic_light_value==self.Red_Light or traffic_light_value==self.Yellow_Light) and nearest_light>min_stop_distance):\\n None\\n #else if the traffic light is unknown, stopping waypoint will be -2, telling whatever previous action to keep proceeding\\n elif traffic_light_value==self.Unknown_Light:\\n stopping_waypoint_index = -2\\n # #else if the traffic light is green, ignore it.\\n # elif traffic_light_value==self.Green_Light:\\n # stopping_waypoint_index = -1\\n #publish the stopping waypoint index\\n # self.upcoming_red_light_pub.publish(stopping_waypoint_index)\\n self.prev_traffic_light_value = traffic_light_value\\n self.prev_stopping_waypoint_index = stopping_waypoint_index\\n return stopping_waypoint_index\",\n \"def process_traffic_lights(self):\\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\\n if self.init:\\n state = self.get_light_state(0)\\n return -1, TrafficLight.UNKNOWN\\n elif self.ntlwp:\\n state = self.get_light_state(self.ntlwp)\\n # state = TrafficLight.RED\\n return self.ntlwp, state\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n light = None\\n\\n car_position = None\\n\\n light_wp = None\\n\\n # List of positions that correspond to the line\\n # to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n if(self.pose):\\n car_position = self.get_closest_waypoint(self.pose.pose)\\n\\n # TODO find the closest visible traffic light (if one exists)\\n\\n # rospy.logerr(self.waypoints_list[5000:6000])\\n\\n closest_upcoming_tl = None\\n\\n if car_position:\\n\\n car_index = car_position[2]\\n next_car_index = car_index + 1\\n next_car_position = self.waypoints_list[next_car_index]\\n\\n for stop_line_position in stop_line_positions:\\n # Add None to the last element to not block\\n stop_line_index = kdtree_closest_point(\\n self.kdtree, stop_line_position)[2]\\n if stop_line_index > car_index:\\n light_wp = stop_line_index\\n light = True\\n break\\n\\n # time.sleep(1000)\\n\\n # rospy.logerr(car_position)\\n # rospy.logerr(upcoming_stop_line_positions)\\n\\n # tl_kdtree = build_kdtree(stop_line_positions)\\n # closest_upcoming_tl = kdtree_closest_point(tl_kdtree, car_position)\\n#\\n #if closest_upcoming_tl:\\n # light = True\\n # light_wp = kdtree_closest_point(\\n # self.kdtree, closest_upcoming_tl)[2]\\n\\n # rospy.logerr(light_wp)\\n\\n if light:\\n state = 1\\n state = self.get_light_state(light)\\n # rospy.logerr(\\\"state\\\")\\n # rospy.logerr(state)\\n return light_wp, state\\n self.waypoints = None\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n light = None\\n\\n if self.waypoints and self.pose:\\n self.car_wpidx = self.waypoints.find_closest_waypoint([self.pose.pose.position.x, self.pose.pose.position.y])\\n for traffic_light_wp in self.traffic_light_waypoints:\\n # rospy.loginfo(\\\"Traffic Waypoiny: %d\\\", traffic_light_wp[1])\\n # rospy.loginfo(\\\"Car position: %d\\\", self.car_wpidx)\\n if traffic_light_wp[1] > self.car_wpidx:\\n light = True\\n light_id = traffic_light_wp[0]\\n light_wp = traffic_light_wp[1]\\n break\\n\\n if light and light_wp - self.car_wpidx < self.traffic_light_lookahead_wps:\\n state, max_output_score, _ = self.get_light_state(self.lights[light_id])\\n if self.loglevel >= 4:\\n rospy.loginfo(\\\"Traffic state: %d, score: %f\\\", state, max_output_score)\\n return light_wp, state\\n if light:\\n return light_wp, TrafficLight.UNKNOWN\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n light = None\\n light_wp = -1\\n\\n if not self.waypoints:\\n return -1, TrafficLight.UNKNOWN\\n if not self.lights:\\n return -1, TrafficLight.UNKNOWN\\n\\n stop_line_positions = self.config['stop_line_positions']\\n car_position_idx = 0\\n if (self.pose):\\n car_position_idx = self.get_closest_waypoint_idx(self.pose.pose)\\n car_position = self.waypoints[car_position_idx]\\n #rospy.loginfo(\\\"tl_detector - pose %s %s\\\", self.pose.pose.position, car_position.pose.pose.position)\\n\\n #TODO find the closest visible traffic light (if one exists)\\n # Fined the closet visible traffic light based on current position\\n dist_min = float('inf')\\n closest_stop_line_idx = -1\\n for i, stop_line_pose in enumerate(stop_line_positions):\\n if self.is_ahead_of(car_position.pose.pose, stop_line_pose[0],\\n stop_line_pose[1]):\\n dist = self.calculate_distance(\\n car_position.pose.pose.position.x, stop_line_pose[0],\\n car_position.pose.pose.position.y, stop_line_pose[1])\\n if dist < dist_min:\\n dist_min = dist\\n closest_stop_line_idx = i\\n\\n if dist_min < self.max_tl_dist and closest_stop_line_idx >= 0:\\n # Find wp index in waypoints which is closest to the traffic light\\n light = self.lights[closest_stop_line_idx]\\n dist_min = float('inf')\\n wp = self.get_closest_waypoint_xy(\\n stop_line_positions[closest_stop_line_idx])\\n\\n if wp > car_position_idx:\\n light_wp = wp\\n\\n state = self.get_light_state(light)\\n return light_wp, state\\n return -1, TrafficLight.UNKNOWN\",\n \"def _process_traffic_lights(self):\\n #\\n # handle bad data just in case\\n #\\n if self.waypoints is None or self.waypoints_tree is None:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: No waypoints available\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if self.pose is None:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: car pose is None\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if not self.use_ground_truth and not self.has_image:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: no image available for detection\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if not self.lights:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: no lights found\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n ############################################\\n # no errors, so real processing begins here\\n ############################################\\n #\\n # find the nearest traffic light ahead\\n #\\n light = None\\n light_idx = self._get_closest_light_ahead(self.pose)\\n #\\n # handle case where there is no light ahead at any distance\\n #\\n if light_idx < 0:\\n return -1, TrafficLight.UNKNOWN\\n\\n light = self.lights[light_idx]\\n light_pos = light.pose.pose.position\\n\\n #\\n # don't worry about the light if it is too far away\\n #\\n dist_to_light = self._find_distance(self.pose.position.x,\\n self.pose.position.y,\\n light.pose.pose.position.x,\\n light.pose.pose.position.y)\\n\\n if dist_to_light > MAX_TRAFFIC_LIGHT_DETECTION_DISTANCE:\\n return -1, TrafficLight.UNKNOWN\\n\\n \\n #\\n # get stop line for light\\n #\\n stop_line_for_light = self.stop_line_positions[light_idx]\\n\\n #\\n # get closest waypoints to the stop line for this light\\n #\\n stop_line_pose = Pose()\\n stop_line_pose.position.x = stop_line_for_light[0]\\n stop_line_pose.position.y = stop_line_for_light[1]\\n stop_line_waypoint_idx = self._get_closest_waypoint(stop_line_pose)\\n\\n #\\n # get closest waypoint to the car\\n #\\n car_waypoint_idx = self._get_closest_waypoint(self.pose)\\n\\n #\\n # get light state\\n #\\n state = TrafficLight.UNKNOWN \\n if self.use_ground_truth:\\n #rospy.logwarn(\\\"GROUND TRUTH\\\")\\n state = light.state\\n else:\\n #rospy.logwarn(\\\"CLASSIFYING IMAGE\\\")\\n state = self._get_light_state(light) \\n\\n #\\n # test against gt_state in sim\\n #\\n if not self.is_site:\\n gt_state = light.state\\n pred_state = state\\n if gt_state == pred_state:\\n self.num_correct_predictions += 1\\n else:\\n self.num_incorrect_predictions += 1\\n self.num_predictions += 1\\n\\n if self.num_predictions > 0 and self.num_predictions % 10 == 0:\\n pred_acc = 100.0*float(self.num_correct_predictions)/float(self.num_predictions) \\n rospy.logwarn('[TL_DETECTOR] prediction accuracy is %f percent' % pred_acc)\\n\\n #\\n # return waypoint index of stopline and the light state\\n #\\n return stop_line_waypoint_idx, state\",\n \"def traffic_waypoint_cb(self, msg):\\n\\n # Save waypoint index for detected traffic light\\n self.stopline_waypoint_idx = msg.data\",\n \"def image_cb(self, msg):\\n if self.waypoints is None:\\n return\\n if self.state_count >= self.state_count_threshold and time.time() - self.last_detection_time < self.traffic_light_detection_interval:\\n return\\n if time.time() - self.last_tl_off_time < self.traffic_light_off_idle_interval:\\n if self.loglevel >= 5:\\n rospy.logdebug(\\\"No detection %f %f %f\\\", time.time(), self.last_tl_off_time, self.traffic_light_off_idle_interval)\\n return\\n\\n self.last_detection_time = time.time()\\n self.has_image = True\\n self.camera_image = msg\\n light_wp, state = self.process_traffic_lights()\\n\\n '''\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n '''\\n if self.state != state:\\n self.state_count = 1\\n self.state = state\\n else:\\n self.state_count += 1\\n if self.state_count >= self.state_count_threshold:\\n if state == TrafficLight.GREEN and self.last_state in (TrafficLight.RED, TrafficLight.YELLOW):\\n self.last_tl_off_time = time.time()\\n self.last_state = self.state\\n self.last_wp = light_wp\\n self.last_msg = state_msg = TrafficLightStatus()\\n state_msg.tlwpidx = light_wp\\n state_msg.state = state\\n self.upcoming_red_light_pub.publish(state_msg)\\n elif self.last_msg: # have not reached the threshold\\n if self.car_wpidx < self.last_msg.tlwpidx + self.traffic_light_over_waypoints: \\n # keep sending previous message when we are still close to the current traffic light\\n self.upcoming_red_light_pub.publish(self.last_msg)\\n else: # for other locations, clear traffic light status\\n self.last_msg.tlwpidx = -1\\n self.last_msg.state = TrafficLight.UNKNOWN\\n self.upcoming_red_light_pub.publish(self.last_msg)\\n self.last_msg = None\\n if self.loglevel >= 4:\\n rospy.loginfo(\\\"Curr Light_wp: %d, state: %d, global state: %d, last Light_wp: %d, state count: %d\\\", light_wp, state, self.state, self.last_wp, self.state_count)\",\n \"def image_cb(self, msg):\\n self.has_image = True\\n self.camera_image = msg\\n light_wp, state = self.process_traffic_lights()\\n #print(light_wp)\\n #print(state)\\n #print()\\n\\n '''\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n '''\\n our_msg = TL_State()\\n our_light = TrafficLight()\\n our_light.header = Header()\\n our_light.header.stamp = rospy.Time.now()\\n our_light.header.frame_id = '/world'\\n if self.state != state:\\n self.state_count = 0\\n self.state = state\\n elif self.state_count >= STATE_COUNT_THRESHOLD:\\n self.last_state = self.state\\n light_wp = light_wp if (state == TrafficLight.RED or state == TrafficLight.YELLOW) else -1\\n self.last_wp = light_wp\\n self.upcoming_red_light_pub.publish(Int32(light_wp))\\n\\n our_msg.waypoint = light_wp\\n our_light.state = state\\n our_msg.light = our_light\\n self.custom_state_pub.publish(our_msg)\\n else:\\n self.upcoming_red_light_pub.publish(Int32(self.last_wp))\\n\\n our_msg.waypoint = self.last_wp\\n our_light.state = self.last_state\\n our_msg.light = our_light\\n self.custom_state_pub.publish(our_msg)\\n self.state_count += 1\",\n \"def find_tfl_lights(c_image: np.ndarray):\\n red_img = c_image[:, :, 0]\\n green_img = c_image[:, :, 1]\\n new_red = convolution(red_img)\\n new_green = convolution(green_img)\\n x_red, y_red = get_max_candidate(new_red)\\n x_green, y_green = get_max_candidate(new_green)\\n return x_red, y_red, x_green, y_green\",\n \"def image_cb(self, msg):\\n self.has_image = True\\n self.camera_image = msg\\n light_wp, state = self.process_traffic_lights()\\n\\n # rospy.logerr(\\\"light_wp\\\")\\n # rospy.logerr(light_wp)\\n\\n # self.upcoming_red_light_pub.publish(Int32(light_wp))\\n\\n '''\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n '''\\n if self.state != state:\\n self.state_count = 0\\n self.state = state\\n elif self.state_count >= STATE_COUNT_THRESHOLD:\\n self.last_state = self.state\\n light_wp = light_wp if state == TrafficLight.RED else -1\\n self.last_wp = light_wp\\n self.upcoming_red_light_pub.publish(Int32(light_wp))\\n else:\\n self.upcoming_red_light_pub.publish(Int32(self.last_wp))\\n self.state_count += 1\",\n \"def image_cb(self, msg):\\n\\n # Save the camera image\\n self.camera_image = msg\\n\\n # I sufficient information is available...\\n if not None in (self.camera_image, self.waypoint_tree, self.lights):\\n\\n # Find index and color state of next light\\n light_wp, state = self.process_traffic_lights()\\n\\n # If the light is green...\\n if state == TrafficLight.GREEN:\\n\\n # Publish sentinel indicatig no red light\\n self.upcoming_red_light_pub.publish(Int32(-1))\\n\\n else:\\n\\n # Publish the traffic light index\\n self.upcoming_red_light_pub.publish(Int32(light_wp))\",\n \"def traffic_cb(self, msg):\\n prev_red_light_waypoint = self.red_light_waypoint\\n self.red_light_waypoint = msg.data if msg.data >= 0 else None\\n if prev_red_light_waypoint != self.red_light_waypoint:\\n if debugging:\\n rospy.loginfo(\\\"TrafficLight changed: %s\\\", str(self.red_light_waypoint))\\n if publish_on_light_change:\\n self.update_and_publish() # Refresh if next traffic light has changed\",\n \"def traffic_light_cb(self, msg):\\n\\n # Save the traffic light array\\n self.lights = msg.lights\",\n \"def nextLight():\\n global light\\n pin.setAllOutPinsLow()\\n light += 1\\n light %= len(traffic_lights)\\n print traffic_colors[light]\\n pin.setOutPinHigh(traffic_lights[light])\",\n \"def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\\n image = np.array(Image.open(image_path))\\n if json_path is None:\\n objects = None\\n else:\\n gt_data = json.load(open(json_path))\\n what = ['traffic light']\\n objects = [o for o in gt_data['objects'] if o['label'] in what]\\n\\n show_image_and_gt(image, objects, fig_num)\\n\\n red_x, red_y, green_x, green_y = find_tfl_lights(image)\\n plt.plot(red_x, red_y, 'ro', color='r', markersize=3)\\n plt.plot(green_x, green_y, 'ro', color='g', markersize=3)\",\n \"def traffic_light_detection(img_in, radii_range):\\n\\n thresh1 = 110\\n thresh2 = 60\\n cannyEdges = cv2.Canny(img_in, thresh1, thresh2)\\n\\n circles = cv2.HoughCircles(cannyEdges,cv2.HOUGH_GRADIENT, 1, 20, param1=50,param2=30,minRadius=0,maxRadius=0)\\n circles_selected = select_three(circles)\\n\\n for circle in circles_selected:\\n column = circle[0]\\n row = circle[1]\\n coordinates = (column, row)\\n state_pixels = img_in[int(row), int(column), :]\\n # print(state_pixels)\\n if state_pixels[1] == 255 and state_pixels[2] != 255 :\\n state = 'green'\\n if state_pixels[1] != 255 and state_pixels[2] == 255 :\\n state = 'red'\\n if state_pixels[1] == 255 and state_pixels[2] == 255 :\\n state = 'yellow'\\n\\n column_2 = circles_selected[1][0]\\n row_2 = circles_selected[1][1]\\n coordinates_2 = (column_2, row_2)\\n state_pixels_2 = img_in[int(row_2), int(column_2), :]\\n\\n return coordinates_2, state\\n raise NotImplementedError\",\n \"def identify_dbs(image):\\n locations = {\\\"red\\\": Point(), \\\"green\\\": Point(), \\\"blue\\\": Point()}\\n masks = {\\\"red\\\": [], \\\"green\\\": [], \\\"blue\\\": []}\\n\\n bridge = cv_bridge.CvBridge()\\n image = bridge.imgmsg_to_cv2(image, \\\"bgr8\\\")\\n hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)\\n\\n # upper and lower bounds for red\\n # using python 3 bgr [0,0,188] = hsv [0, 255, 188]\\n lower_red = numpy.array([0, 100, 100]) \\n upper_red = numpy.array([10, 255, 255])\\n masks[\\\"red\\\"] = cv2.inRange(hsv, lower_red, upper_red)\\n\\n # upper and lower bounds for green\\n # using python 3 bgr [0,175,0] = hsv [60, 255, 175]\\n lower_green = numpy.array([50, 100, 100]) \\n upper_green = numpy.array([70, 255, 255])\\n masks[\\\"green\\\"] = cv2.inRange(hsv, lower_green, upper_green)\\n\\n # upper and lower bounds for blue\\n # using python 3 bgr [176, 0, 17] = hsv [123, 255, 176]\\n lower_blue = numpy.array([113, 100, 100])\\n upper_blue = numpy.array([133, 255, 255])\\n masks[\\\"blue\\\"] = cv2.inRange(hsv, lower_blue, upper_blue)\\n\\n x, y, w, h = 0, 0, image.shape[1]//3, image.shape[0]\\n\\n for color, mask in masks.items():\\n pixels = {\\\"left\\\": 0, \\\"middle\\\": 0, \\\"right\\\": 0}\\n \\n # define section of image to use for left, middle and right\\n left = mask[y:y+h, x:x+w]\\n middle = mask[y:y+h, x+w:x+w+w]\\n right = mask[y:y+h, x+w+w:x+3*w]\\n\\n # count the number of pixels in each section\\n pixels[\\\"left\\\"] = cv2.countNonZero(left)\\n pixels[\\\"middle\\\"] = cv2.countNonZero(middle)\\n pixels[\\\"right\\\"] = cv2.countNonZero(right)\\n location = max(pixels, key=pixels.get)\\n\\n # map the relative position of the db (left, middle, right) to the correct Point()\\n locations[color] = db_locations[location]\\n \\n return locations\",\n \"def light_source_directions():\\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\\n [-0.05939919, -0.33739538, 0.93948714],\\n [-0.05710194, -0.21230722, 0.97553319],\\n [-0.05360061, -0.07800089, 0.99551134],\\n [-0.04919816, 0.05869781, 0.99706274],\\n [-0.04399823, 0.19019233, 0.98076044],\\n [-0.03839991, 0.31049925, 0.9497977],\\n [-0.03280081, 0.41611025, 0.90872238],\\n [-0.18449839, -0.43989616, 0.87889232],\\n [-0.18870114, -0.32950199, 0.92510557],\\n [-0.1901994, -0.20549935, 0.95999698],\\n [-0.18849605, -0.07269848, 0.97937948],\\n [-0.18329657, 0.06229884, 0.98108166],\\n [-0.17500445, 0.19220488, 0.96562453],\\n [-0.16449474, 0.31129005, 0.93597008],\\n [-0.15270716, 0.4160195, 0.89644202],\\n [-0.30139786, -0.42509698, 0.85349393],\\n [-0.31020115, -0.31660118, 0.89640333],\\n [-0.31489186, -0.19549495, 0.92877599],\\n [-0.31450962, -0.06640203, 0.94692897],\\n [-0.30880699, 0.06470146, 0.94892147],\\n [-0.2981084, 0.19100538, 0.93522635],\\n [-0.28359251, 0.30729189, 0.90837601],\\n [-0.26670649, 0.41020998, 0.87212122],\\n [-0.40709586, -0.40559588, 0.81839168],\\n [-0.41919869, -0.29999906, 0.85689732],\\n [-0.42618633, -0.18329412, 0.88587159],\\n [-0.42691512, -0.05950211, 0.90233197],\\n [-0.42090385, 0.0659006, 0.90470827],\\n [-0.40860354, 0.18720162, 0.89330773],\\n [-0.39141794, 0.29941372, 0.87013988],\\n [-0.3707838, 0.39958255, 0.83836338],\\n [-0.499596, -0.38319693, 0.77689378],\\n [-0.51360334, -0.28130183, 0.81060526],\\n [-0.52190667, -0.16990217, 0.83591069],\\n [-0.52326874, -0.05249686, 0.85054918],\\n [-0.51720021, 0.06620003, 0.85330035],\\n [-0.50428312, 0.18139393, 0.84427174],\\n [-0.48561334, 0.28870793, 0.82512267],\\n [-0.46289771, 0.38549809, 0.79819605],\\n [-0.57853599, -0.35932235, 0.73224555],\\n [-0.59329349, -0.26189713, 0.76119165],\\n [-0.60202327, -0.15630604, 0.78303027],\\n [-0.6037003, -0.04570002, 0.7959004],\\n [-0.59781529, 0.06590169, 0.79892043],\\n [-0.58486953, 0.17439091, 0.79215873],\\n [-0.56588359, 0.27639198, 0.77677747],\\n [-0.54241965, 0.36921337, 0.75462733],\\n [0.05220076, -0.43870637, 0.89711304],\\n [0.05199786, -0.33138635, 0.9420612],\\n [0.05109826, -0.20999284, 0.97636672],\\n [0.04919919, -0.07869871, 0.99568366],\\n [0.04640163, 0.05630197, 0.99733494],\\n [0.04279892, 0.18779527, 0.98127529],\\n [0.03870043, 0.30950341, 0.95011048],\\n [0.03440055, 0.41730662, 0.90811441],\\n [0.17290651, -0.43181626, 0.88523333],\\n [0.17839998, -0.32509996, 0.92869988],\\n [0.18160174, -0.20480196, 0.96180921],\\n [0.18200745, -0.07490306, 0.98044012],\\n [0.17919505, 0.05849838, 0.98207285],\\n [0.17329685, 0.18839658, 0.96668244],\\n [0.1649036, 0.30880674, 0.93672045],\\n [0.1549931, 0.41578148, 0.89616009],\\n [0.28720483, -0.41910705, 0.8613145],\\n [0.29740177, -0.31410186, 0.90160535],\\n [0.30420604, -0.1965039, 0.9321185],\\n [0.30640529, -0.07010121, 0.94931639],\\n [0.30361153, 0.05950226, 0.95093613],\\n [0.29588748, 0.18589214, 0.93696036],\\n [0.28409783, 0.30349768, 0.90949304],\\n [0.26939905, 0.40849857, 0.87209694],\\n [0.39120402, -0.40190413, 0.8279085],\\n [0.40481085, -0.29960803, 0.86392315],\\n [0.41411685, -0.18590756, 0.89103626],\\n [0.41769724, -0.06449957, 0.906294],\\n [0.41498764, 0.05959822, 0.90787296],\\n [0.40607977, 0.18089099, 0.89575537],\\n [0.39179226, 0.29439419, 0.87168279],\\n [0.37379609, 0.39649585, 0.83849122],\\n [0.48278794, -0.38169046, 0.78818031],\\n [0.49848546, -0.28279175, 0.8194761],\\n [0.50918069, -0.1740934, 0.84286803],\\n [0.51360856, -0.05870098, 0.85601427],\\n [0.51097962, 0.05899765, 0.8575658],\\n [0.50151639, 0.17420569, 0.84742769],\\n [0.48600297, 0.28260173, 0.82700506],\\n [0.46600106, 0.38110087, 0.79850181],\\n [0.56150442, -0.35990283, 0.74510586],\\n [0.57807114, -0.26498677, 0.77176147],\\n [0.58933134, -0.1617086, 0.7915421],\\n [0.59407609, -0.05289787, 0.80266769],\\n [0.59157958, 0.057798, 0.80417224],\\n [0.58198189, 0.16649482, 0.79597523],\\n [0.56620006, 0.26940003, 0.77900008],\\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\\n return L\",\n \"def process_image(image):\\n undist = calibrator.undistort(image)\\n binarized = binarizer.process(undist)\\n warped = warper.warp(binarized)\\n\\n lane.detect_lane(warped)\\n\\n debug_image = lane.get_debug_image(warped)\\n\\n visualizer.draw_debugging_output(undist, binarized, warped, debug_image)\\n visualizer.draw_text_info(undist, lane.center_curvature, lane.center_offset)\\n result = visualizer.draw_lane_on_road(undist, lane)\\n\\n return result\",\n \"def get_light_state(self):\\n\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n\\n #Get classification\\n tl_image_rgb, color_index = self.light_classifier.get_classification(cv_image)\\n tl_cv_image = cv2.cvtColor(tl_image_rgb, cv2.COLOR_RGB2BGR)\\n try:\\n self.tl_detected_image_pub.publish(self.bridge.cv2_to_imgmsg(tl_cv_image, \\\"bgr8\\\"))\\n except CvBridgeError as e:\\n print(e)\",\n \"def image_cb(self, msg):\\n self.has_image = True\\n self.camera_image = msg\\n light_wp, state = self.process_traffic_lights()\\n\\n '''\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n '''\\n if self.state != state:\\n self.state_count = 0\\n self.state = state\\n elif self.state_count >= STATE_COUNT_THRESHOLD:\\n self.last_state = self.state\\n light_wp = light_wp if state == TrafficLight.RED else -1\\n self.last_wp = light_wp\\n self.upcoming_red_light_pub.publish(Int32(light_wp))\\n else:\\n self.upcoming_red_light_pub.publish(Int32(self.last_wp))\\n self.state_count += 1\",\n \"def image_cb(self, msg):\\n self.has_image = True\\n self.camera_image = msg\\n self.row = int(msg.height)\\n self.col = int(msg.width)\\n light_wp, state = self.process_traffic_lights()\\n\\n '''\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n '''\\n if self.state != state:\\n self.state_count = 0\\n self.state = state\\n elif self.state_count >= STATE_COUNT_THRESHOLD:\\n self.last_state = self.state\\n if state == TrafficLight.GREEN and light_wp is not None:\\n light_wp = -light_wp\\n elif state == TrafficLight.UNKNOWN:\\n light_wp = -1\\n self.last_wp = light_wp\\n self.upcoming_light_pub.publish(Int32(light_wp))\\n else:\\n self.upcoming_light_pub.publish(Int32(self.last_wp))\\n self.state_count += 1\\n if self.init:\\n self.init = False\",\n \"def process_scan(self, msg):\\n if len(msg.ranges) <= 330:\\n # throw out scans that don't have more than 90% of the data\\n return\\n # get pose according to the odometry\\n p = PoseStamped(header=Header(stamp=msg.header.stamp, frame_id=\\\"base_link\\\"), pose=Pose())\\n self.odom_pose = self.tf_listener.transformPose(\\\"odom\\\", p)\\n self.base_pose = self.tf_listener.transformPose(\\\"base_laser_link\\\", p)\\n # convert the odom pose to the tuple (x,y,theta)\\n self.odom_pose = OccupancyGridMapper.convert_pose_to_xy_and_theta(self.odom_pose.pose)\\n #(-0.0069918, 0.000338577, 0.048387097)\\n #(1.0208817, 0.04827240, 0.048387)\\n self.base_pose = OccupancyGridMapper.convert_pose_to_xy_and_theta(self.base_pose.pose)\\n for i in range(len(msg.ranges)):\\n if 0.0 < msg.ranges[i] < 5.0: #for any reding within 5 meters\\n #Using the pose and the measurement nd the angle, find it in the world\\n map_x = self.odom_pose[0] + msg.ranges[i] * cos(i * pi / 180.0 + self.odom_pose[2])\\n map_y = self.odom_pose[1] + msg.ranges[i] * -sin(i * pi / 180.0 + self.odom_pose[2])\\n\\n #Relate that map measure with a place in the picture\\n x_detect = int((map_x - self.origin[0]) / self.resolution)\\n y_detect = int((map_y - self.origin[1]) / self.resolution)\\n\\n\\n #Determine how to mark the location in the map, along with the stuff inbetween\\n u = (map_x - self.odom_pose[0], map_y - self.odom_pose[1])\\n magnitude = sqrt(u[0] ** 2 + u[1] ** 2)\\n n_steps = max([1, int(ceil(magnitude / self.resolution))])\\n u_step = (u[0] / (n_steps - 1), u[1] / (n_steps - 1))\\n marked = set()\\n for i in range(n_steps):\\n curr_x = self.odom_pose[0] + i * u_step[0]\\n curr_y = self.odom_pose[1] + i * u_step[1]\\n if not (self.is_in_map(curr_x, curr_y)):\\n break\\n\\n x_ind = int((curr_x - self.origin[0]) / self.resolution)\\n y_ind = int((curr_y - self.origin[1]) / self.resolution)\\n if x_ind == x_detect and y_ind == y_detect:\\n break\\n if not ((x_ind, y_ind) in marked):\\n # odds ratio is updated according to the inverse sensor model\\n self.odds_ratios[x_ind, y_ind] *= self.p_occ / (1 - self.p_occ) * self.odds_ratio_miss\\n marked.add((x_ind, y_ind))\\n if self.is_in_map(map_x, map_y):\\n # odds ratio is updated according to the inverse sensor model\\n self.odds_ratios[x_detect, y_detect] *= self.p_occ / (1 - self.p_occ) * self.odds_ratio_hit\\n\\n self.seq += 1\\n # to save time, only publish the map every 10 scans that we process\\n if self.seq % 10 == 0:\\n # make occupancy grid\\n map = OccupancyGrid()\\n map.header.seq = self.seq\\n self.seq += 1\\n map.header.stamp = msg.header.stamp\\n map.header.frame_id = \\\"map\\\" # the name of the coordinate frame of the map\\n map.info.origin.position.x = self.origin[0]\\n map.info.origin.position.y = self.origin[1]\\n map.info.width = self.n\\n map.info.height = self.n\\n map.info.resolution = self.resolution\\n map.data = [0] * self.n ** 2 # map.data stores the n by n grid in row-major order\\n for i in range(self.n):\\n for j in range(self.n):\\n idx = i + self.n * j # this implements row major order\\n if self.odds_ratios[i, j] < 1 / 5.0: # consider a cell free if odds ratio is low enough\\n map.data[idx] = 0\\n elif self.odds_ratios[i, j] > 5.0: # consider a cell occupied if odds ratio is high enough\\n map.data[idx] = 100\\n else: # otherwise cell is unknown\\n map.data[idx] = -1\\n self.pub.publish(map)\\n\\n # create the image from the probabilities so we can visualize using opencv\\n im = np.zeros((self.odds_ratios.shape[0], self.odds_ratios.shape[1], 3))\\n for i in range(im.shape[0]):\\n for j in range(im.shape[1]):\\n if self.odds_ratios[i, j] < 1 / 5.0:\\n im[i, j, :] = 1.0\\n elif self.odds_ratios[i, j] > 5.0:\\n im[i, j, :] = 0.0\\n else:\\n im[i, j, :] = 0.5\\n\\n # compute the index of the odometry pose so we can mark it with a circle\\n x_odom_index = int((self.odom_pose[0] - self.origin[0]) / self.resolution)\\n y_odom_index = int((self.odom_pose[1] - self.origin[1]) / self.resolution)\\n\\n x_base_index = int((self.base_pose[0] - self.origin[0] - 1) / self.resolution)\\n y_base_index = int((self.base_pose[1] - self.origin[1]) / self.resolution)\\n\\n\\n # computer the ball locations so we can mark with a colored circle\\n #TODO Track and relate the robot's angle pose for accuracy\\n\\n if self.depth_red > 0:\\n self.y_camera_red = int(x_odom_index - self.depth_red * cos(self.angle_diff_red + pi - self.odom_pose[2])/self.resolution)\\n self.x_camera_red = int(y_odom_index - self.depth_red * sin(self.angle_diff_red + pi - self.odom_pose[2])/self.resolution)\\n cv2.circle(im, (self.x_camera_red, self.y_camera_red), 1, self.red)\\n\\n real_red_y = self.depth_red * cos(self.angle_diff_red + pi - self.odom_pose[2])\\n real_red_x = self.depth_red * sin(self.angle_diff_red + pi - self.odom_pose[2])\\n\\n self.rcoor_pub.publish(Vector3(-real_red_x, -real_red_y/2, 0))\\n else:\\n cv2.circle(im, (self.x_camera_red, self.y_camera_red), 1, self.red)\\n\\n if self.depth_blue > 0:\\n self.y_camera_blue = int(x_odom_index - self.depth_blue * cos(self.angle_diff_blue + pi - self.odom_pose[2])/self.resolution)\\n self.x_camera_blue = int(y_odom_index - self.depth_blue * sin(self.angle_diff_blue + pi - self.odom_pose[2])/self.resolution)\\n cv2.circle(im, (self.x_camera_blue, self.y_camera_blue), 1, self.blue)\\n\\n real_blue_y = self.depth_blue * cos(self.angle_diff_blue + pi - self.odom_pose[2])\\n real_blue_x = self.depth_blue * sin(self.angle_diff_blue + pi - self.odom_pose[2])\\n\\n self.bcoor_pub.publish(Vector3(-real_blue_x, -real_blue_y/2, 0))\\n else:\\n cv2.circle(im, (self.x_camera_blue, self.y_camera_blue), 1, self.blue)\\n\\n if self.depth_green > 0:\\n self.y_camera_green = int(x_odom_index - self.depth_green * cos(self.angle_diff_green + pi - self.odom_pose[2])/self.resolution)\\n self.x_camera_green = int(y_odom_index - self.depth_green * sin(self.angle_diff_green + pi - self.odom_pose[2])/self.resolution)\\n cv2.circle(im, (self.x_camera_green, self.y_camera_green), 1, self.green)\\n \\n real_green_y = self.depth_green * cos(self.angle_diff_green + pi - self.odom_pose[2])\\n real_green_x = self.depth_green * sin(self.angle_diff_green + pi - self.odom_pose[2])\\n\\n self.gcoor_pub.publish(Vector3(-real_green_x, -real_green_y/2, 0))\\n\\n if self.depth_yellow > 0:\\n self.y_camera_yellow = int(x_odom_index - self.depth_yellow * cos(self.angle_diff_yellow + pi - self.odom_pose[2])/self.resolution)\\n self.x_camera_yellow = int(y_odom_index - self.depth_yellow * sin(self.angle_diff_yellow + pi - self.odom_pose[2])/self.resolution)\\n cv2.circle(im, (self.x_camera_yellow, self.y_camera_yellow), 1, self.yellow)\\n \\n real_yellow_y = self.depth_yellow * cos(self.angle_diff_yellow + pi - self.odom_pose[2])\\n real_yellow_x = self.depth_yellow * sin(self.angle_diff_yellow + pi - self.odom_pose[2])\\n\\n self.ycoor_pub.publish(Vector3(-real_yellow_x, -real_yellow_y/2, 0))\\n else:\\n cv2.circle(im, (self.x_camera_yellow, self.y_camera_yellow), 1, self.yellow)\\n\\n # draw the robot\\n cv2.circle(im, (y_odom_index, x_odom_index), 2, (255, 0, 0))\\n \\n # display the image resized\\n cv2.imshow(\\\"map\\\", cv2.resize(im, (500, 500)))\\n cv2.waitKey(20)\",\n \"def proc_and_pub_pointcloud(self):\\n image = self.sonar_result[\\\"image_array\\\"]\\n\\n # Compute range and bearing maps using the ping result\\n ping_result = self.sonar_result[\\\"ping_result\\\"].data\\n resolution = ping_result[8]\\n [rows, cols] = np.shape(image)\\n range_max = rows*resolution\\n ranges = np.linspace(0,range_max, rows)\\n\\n # Check image frequency\\n high_freq = (ping_result[2] > 1000000)\\n if high_freq:\\n # bearings = np.tile(self.high_freq_brgs, (rows, 1))\\n bearing_mesh, range_mesh = np.meshgrid(self.high_freq_brgs, ranges)\\n else:\\n # bearings = np.tile(self.low_freq_brgs, (rows, 1))\\n bearing_mesh, range_mesh = np.meshgrid(self.high_freq_brgs, ranges)\\n\\n # TODO: Turn this into a gate (like the MBES)\\n # Threshold image\\n ret, image = cv2.threshold(image, self.image_threshold, 255, cv2.THRESH_TOZERO)\\n # TODO: Maybe can tune parameters better, good results with current values.\\n # Detect edges with second Laplacian and processes the shit out of the image\\n clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(5,5))\\n image = clahe.apply(image)\\n image = cv2.Canny(image, 200, 255, L2gradient=True)\\n kernel = np.ones((5,5), np.uint8)\\n image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)\\n edges = np.argmax(image, axis=0)\\n cols = np.arange(0,len(edges),1)\\n image_out = np.zeros(image.shape, np.uint8)\\n image_out[edges,cols] = 255\\n\\n # TODO: send the closest point's distance via UDP to Dune\\n min_distance = ranges[np.min(edges)]\\n self.udp_socket.sendto(min_distance, (\\\"\\\", 7777))\\n\\n if self.publish_edges:\\n # Publish processed edges as an image\\n image_msg = self.bridge.cv2_to_imgmsg(image_out, encoding=\\\"passthrough\\\")\\n self.image_pub.publish(image_msg)\\n\\n if self.publish_pointcloud:\\n # Publish processed edges as a 2D pointcloud\\n pointcloud_msg = self._build_pcl2_msg(image_out)\\n self.point_pub.publish(pointcloud_msg)\",\n \"def main():\\n cam = Realsense()\\n # cam.access_intr_and_extr()\\n profile = cam.pipeline.start(cam.config)\\n depth_sensor = profile.get_device().first_depth_sensor()\\n depth_scale = depth_sensor.get_depth_scale()\\n align_to = rs.stream.color\\n align = rs.align(align_to)\\n\\n objp = np.zeros((3*4,3), np.float32)\\n objp[:,:2] = np.mgrid[0:4,0:3].T.reshape(-1,2)\\n axis = np.float32([[1,0,0], [0,1,0], [0,0,-1]]).reshape(-1,3)\\n # print(objp)\\n\\n try:\\n while (True):\\n # detect ArUco markers in RGB images\\n frames = cam.pipeline.wait_for_frames()\\n aligned_frames = align.process(frames)\\n color_frame = aligned_frames.get_color_frame()\\n color_image = np.asanyarray(color_frame.get_data()) \\n frame = color_image\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n corners, ids, rvecs, tvecs = cam.detect_markers_realsense(frame)\\n \\n if np.all(ids != None): # if markers are detected\\n for i in range(0, ids.size):\\n aruco.drawAxis(frame, cam.newcameramtx, cam.dist, rvecs[i],\\n tvecs[i], 0.1) # Draw axis\\n aruco.drawDetectedMarkers(frame, corners) # draw square around markers\\n\\n ###### DRAW ID #####\\n strg = ''\\n for i in range(0, ids.size):\\n strg += str(ids[i][0])+', '\\n\\n cv2.putText(frame, \\\"Id: \\\" + strg, (0,25), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n\\t ###### Output marker positions in camera frame ######\\n \\t # output tvec\\n y0 = 60\\n dy = 40\\n for i in range(0, ids.size):\\n y = y0 + i*dy\\n cv2.putText(frame, str(tvecs[i][0]), (0, y), font, 1, (0,255,0),\\n 2, cv2.LINE_AA)\\n\\n else:\\n ##### DRAW \\\"NO IDS\\\" #####\\n cv2.putText(frame, \\\"No Ids\\\", (0,64), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n ret, corners = cv2.findChessboardCorners(gray, (4,3), None)\\n if ret == True:\\n corners2 = cv2.cornerSubPix(gray, corners,(11,11), (-1,-1),\\n cam.criteria)\\n corners2 = corners2[::-1]\\n # print(corners2)\\n # print(objp)\\n frame = cv2.drawChessboardCorners(frame, (4,3), corners2, ret)\\n # Find the rotation and translation vectors.\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners2, cam.newcameramtx,\\n cam.dist)\\n rot, _ = cv2.Rodrigues(rvecs)\\n # print(rot)\\n # project 3D points to image plane\\n imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs,\\n cam.newcameramtx, cam.dist)\\n frame = draw(frame, corners2, imgpts)\\n\\n # Display the resulting frame\\n cv2.imshow('frame',frame)\\n cv2.waitKey(5)\\n\\n # When everything done, release the capture\\n cv2.destroyAllWindows()\\n\\n finally:\\n cam.pipeline.stop()\",\n \"def traffic_light_detection(img_in, radii_range, noisy_image=False, max_x_offset=5):\\n\\n img = process_base_image(img_in, (7, 7))\\n\\n # find all the circles in an image using Hough Circles\\n min_radii = min(radii_range)\\n max_radii = max(radii_range)\\n # the distance between the circles should be the smallest possible circles that can touch.\\n min_dist = min_radii * 2 + 10\\n\\n # img, dp, min_dist, param1, param2, minRad, maxRad\\n if noisy_image:\\n circles = hough_circles(img, 1.55, min_dist, 20, 15, min_radii, max_radii)\\n else:\\n circles = hough_circles(img, 1.125, min_dist, 30, 20, min_radii, max_radii)\\n\\n if circles is None:\\n return (0, 0), None\\n else:\\n # cleanup circles so its easier to use.\\n circles = circles[0, :]\\n # round the numbers of the array to uint16 values.\\n circles = np.uint16(np.around(circles))\\n\\n if len(circles) < 3:\\n return (1000, 1000), None\\n else: # If there are more than 3 circles found, eliminate the outliers that shouldn't be detected.\\n # sort the circles first by x, then by Radius value, then by Y value.\\n circles = sorted(circles, key=lambda c: (c[0], c[2], c[1]))\\n\\n # since the traffic lights will be a group of 3 circles with a similar radius, then x value, then somewhat close\\n # in y value, use a \\\"window\\\" type of sliding group to create groups of 3 circles that can then be compared\\n # to each other to see if they would make up circles of a traffic light.\\n circle_groups = []\\n for c_idx in range(len(circles) - 2):\\n circle_group = circles[c_idx: c_idx + 3] # build the group\\n circle_groups.append(circle_group)\\n\\n circle_groups = np.array(circle_groups)\\n # for each circle group found, need to figure out the group with the lowest overall standard deviation.\\n # for each group, calculate the std deviations.\\n group_deviations = np.array([circle_group_deviations(g) for g in circle_groups])\\n\\n most_similar_idx = np.argmin(group_deviations)\\n final_circles = circle_groups[most_similar_idx]\\n\\n # if the circles aren't close to each other in the X direction, return\\n # none since its not a traffic light.\\n x_diffs = np.diff(final_circles[:, 0])\\n if np.any(x_diffs >= max_x_offset):\\n return (None, None), None\\n\\n # sort the circles from top down to allow color compare.\\n circles = final_circles[np.argsort(final_circles[:, 1])] # sort by Y direction.\\n # creating some names for clarity due to x, y being col, row.\\n red_row, red_col, yellow_row, yellow_col, green_row, green_col = [\\n circles[0][1],\\n circles[0][0],\\n circles[1][1],\\n circles[1][0],\\n circles[2][1],\\n circles[2][0],\\n ]\\n\\n # determine colors.\\n state = 'yellow' # default state.\\n cords = (yellow_col, yellow_row)\\n\\n red_color = np.array([0, 0, 255])\\n green_color = np.array([0, 255, 0])\\n\\n # stop for false positive labels.\\n if img_in[yellow_row, yellow_col][0] > 10:\\n return (None, None), None\\n\\n if (img_in[red_row, red_col] == red_color).all():\\n state = 'red'\\n elif (img_in[green_row, green_col] == green_color).all():\\n state = 'green'\\n\\n # print 'Color of TL midpoint is {}'.format(img_in[yellow_row, yellow_col])\\n\\n return cords, state\",\n \"def filter_lane_color(image):\\n \\n YELLOW_HSV_LOWER = np.array([20, 100, 100])\\n YELLOW_HSV_UPPER = np.array([40, 255, 255])\\n \\n WHITE_HSV_LOWER = np.array([0, 0, 220])\\n WHITE_HSV_UPPER = np.array([255, 255, 255])\\n \\n image_wk = np.copy(image) # working copy\\n image_hsv = cv2.cvtColor(image_wk, cv2.COLOR_RGB2HSV) # RGB -> HSV\\n \\n yellow_mask = cv2.inRange(image_hsv, YELLOW_HSV_LOWER, YELLOW_HSV_UPPER)\\n white_mask = cv2.inRange(image_hsv, WHITE_HSV_LOWER, WHITE_HSV_UPPER)\\n both_mask = yellow_mask + white_mask\\n \\n image_wk = grayscale(image_wk) # RGB -> GRAY\\n image_wk = cv2.bitwise_or(image_wk, both_mask) # GRAY + yellow/white mask\\n \\n # Output grayscale road image with enhanced yellow/white areas\\n return image_wk\",\n \"async def add_lights(self, context):\\n if str(context.author.id) in BANNED_USERS:\\n await context.send(f'I can\\\\'t do that, {context.author.mention}')\\n return print(f'{TIME}: {context.author} failed to add image Banned.')\\n\\n await add_image(context, 'lights')\",\n \"def red_points(self, plan, dlvl_sag_img, rphase_sag_img, root_cor_sequence, cor_sequence, sag_sequence):\\n # print(\\\"dlvl_sag_img: {}\\\".format(dlvl_sag_img))\\n # print(\\\"Cor Sequences: {}\\\".format(self.cor_sequences))\\n # print(\\\"Sag Sequences: {}\\\".format(self.sag_sequences))\\n cor_sequence = int(cor_sequence)\\n sag_sequence = int(sag_sequence)\\n # print(\\\"cor_sequence: {}\\\".format(cor_sequence))\\n # print(\\\"sag_sequence: {}\\\".format(sag_sequence))\\n column = self.cor_sequences.index(cor_sequence)\\n row = self.sag_sequences.index(sag_sequence)\\n # print(\\\"Column: {}\\\".format(column))\\n # print(\\\"Row: {}\\\".format(row))\\n\\n lpatterns = [x for x in self.dataset if int(x.split('-')[1]) == cor_sequence]\\n\\n pattern = [p for p in lpatterns if int(p.split('-')[3]) == sag_sequence][0]\\n\\n pts_pattern = self.pattern_coronal('{}.png'.format(pattern))\\n diaph_lvl = [max(x) for x in self.diaphragmatic_level_coronal(pts_pattern)]\\n resp_phase = self.respiratory_phase_coronal(self.diaphragmatic_level_coronal(pts_pattern))\\n\\n index_imgs_registered = list() # Store index of the coronal registered images\\n for index, i in enumerate(diaph_lvl):\\n if i == dlvl_sag_img[self.cor_sequences.index(cor_sequence)]:\\n index_imgs_registered.append(index)\\n # print(\\\"(Red) Index of registered images: {} ({})\\\\n\\\".format(index_imgs_registered, len(index_imgs_registered)))\\n\\n for index, i in enumerate(resp_phase):\\n if index in index_imgs_registered:\\n if resp_phase[index] != rphase_sag_img[self.cor_sequences.index(cor_sequence)]:\\n index_imgs_registered.remove(index)\\n # print(\\\"(Red) Index of registered images: {} ({})\\\\n\\\".format(index_imgs_registered, len(index_imgs_registered)))\\n\\n # print(\\\"lpatterns[sag_sequence]: {}, sag_sequence: {}\\\".format(lpatterns[self.sag_sequences.index(sag_sequence)], sag_sequence))\\n pts_pattern = self.pattern_coronal('{}.png'.format(lpatterns[self.sag_sequences.index(sag_sequence)]))\\n diaph_lvl = [max(x) for x in self.diaphragmatic_level_coronal(pts_pattern)]\\n\\n \\\"\\\"\\\" If analyzed point is green and there are at least one image registered in this\\n position, the diaphragmatic level and respiratory phase is equal and only\\n registration matrix is update \\\"\\\"\\\"\\n if self.matRegistration[row, column] == 2.0 and len(index_imgs_registered) > 0:\\n # print(\\\"{}x{}\\\\n\\\".format(row, column))\\n # print(\\\"matDL: {}, DL: {}\\\\n\\\".format(self.matDL[i, column], diaph_lvl[imgnum]))\\n self.matRegistration[row, column] = self.red\\n\\n # print(\\\"(Red) Diaphragmatic level matrix:\\\\n{}\\\\n\\\".format(self.matDL))\\n # print(\\\"(Red) Registration matrix:\\\\n{}\\\\n\\\".format(self.matRegistration))\\n # print(\\\"(Red) Respiratory phase:\\\\n{}\\\\n\\\".format(self.matRP))\",\n \"def get_light_state(self, traffic_light_state_truth):\\n if not self.has_image:\\n return False\\n\\n # Get classification\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)\\n\\n height = cv_image.shape[0]\\n width = cv_image.shape[1]\\n\\n boxes, scores, classes, num = self.sess.run([self.detection_boxes,\\n self.detection_scores,\\n self.detection_classes,\\n self.num_detections],\\n feed_dict={self.image_tensor: [cv_image]})\\n\\n new_boxes = []\\n new_classes = []\\n new_scores = []\\n for i in range(num):\\n if scores[0][i] > 0.5:\\n xmin = int(boxes[0][i][0] * height)\\n xmax = int(boxes[0][i][2] * height)\\n ymin = int(boxes[0][i][1] * width)\\n ymax = int(boxes[0][i][3] * width)\\n box = [xmin, xmax, ymin, ymax]\\n new_boxes.append(box)\\n new_classes.append(classes[0][i])\\n new_scores.append(scores[0][i])\\n\\n\\n\\n\\n if len(new_classes) != 0:\\n counts = np.bincount(new_classes)\\n light = np.argmax(counts)\\n if light == GREEN:\\n return TrafficLight.GREEN\\n elif light == RED:\\n return TrafficLight.RED\\n elif light == YELLOW:\\n return TrafficLight.YELLOW\\n else: return TrafficLight.UNKNOWN\",\n \"def pipeline(self,img,debug=0):\\n\\t\\timg = self.cam.undist(img)\\n\\t\\t#get warped binary image\\n\\t\\tbinary_warped = self.cam.warp(Image(img).binary_th())\\n\\t\\tbw_shape = binary_warped.shape\\n\\t\\t\\n\\t\\tif (self.leftLine.detected == True and self.rightLine.detected == True):\\n\\t\\t\\tself.quick_search(binary_warped,debug)\\n\\t\\telse:\\n\\t\\t\\tself.blind_search(binary_warped,debug)\\n\\t\\n\\t\\tif (self.leftLine.fit!=None and self.rightLine.fit!=None):\\n\\t\\t\\tpolygon = self.fill_lane(bw_shape)\\n\\t\\t\\tunwarped_polygon = self.cam.unwarp(polygon)\\n\\t\\t\\t# calculate position of lane's center \\n\\t\\t\\ttemp = np.nonzero(unwarped_polygon[-1,:,1])[0]\\n\\t\\t\\tleft, right = temp[0], temp[-1]\\n\\t\\t\\tself.center = (int(bw_shape[1]/2) - (int((right-left)/2)+int(left)))*7.4/1280\\n\\t\\t\\timg_lines = weighted_img(unwarped_polygon,img, α=1, β=0.5, λ=0.)\\n\\t\\t\\t# write text on image\\n\\t\\t\\tfont = cv2.FONT_HERSHEY_SIMPLEX\\n\\t\\t\\ttext1 = 'Radius of Curvature: {:.0f}m'.format(np.mean((self.leftLine.radius, self.rightLine.radius)))\\n\\t\\t\\ttext2 = 'Distance is {:.2f}m {} of center'.format(abs(self.center), 'left' if self.center<0 else 'right')\\n\\n\\t\\t\\tcv2.putText(img_lines, text1, (100,100), font, 1,(255,255,255),2)\\n\\t\\t\\tcv2.putText(img_lines, text2 ,(100,140), font, 1,(255,255,255),2)\\n\\t\\t\\t\\n\\t\\t\\tif (debug==1):\\n\\t\\t\\t\\tshow_2gr(polygon, unwarped_polygon)\\n\\t\\t\\t\\tshow_2gr(binary_warped, unwarped_polygon)\\n\\n\\t\\t\\treturn img_lines\\n\\n\\t\\telse:\\n\\t\\t\\t# no lines detected and not fit available: return original image\\n\\t\\t\\t# without lines\\n\\t\\t\\treturn img\",\n \"def refractive_index(self):\\n wd = np.arange(80,820,10)\\n nd = self.boundary.imat.refractive_index(wd) \\n\\n plt.plot(wd, nd)\\n\\n return wd, nd\",\n \"def geotag_photo(self, xml_photo):\\n photo_dt = datetime.strptime(xml_photo['datetaken'], '%Y-%m-%d %H:%M:%S')\\n prev_wp = None\\n prev_photo = None\\n found = False\\n for w in self.waypoints.all():\\n # Do we have a waypoint to compare with?\\n\\n if prev_wp:\\n\\n prev_adjusted = (prev_wp.localtime + self._offset_timedelta)\\n w_adjusted = (w.localtime + self._offset_timedelta)\\n # If this photo is taken between the two waypoints in the loop\\n if prev_adjusted < photo_dt and w_adjusted > photo_dt:\\n\\n print prev_adjusted\\n print 'p', photo_dt\\n print w_adjusted\\n\\n # get the timedelata between the waypoints\\n td = w_adjusted - prev_adjusted\\n total_difference = td.seconds\\n\\n # calculate the timedelta between the first waypoint and the phot being taken\\n td = photo_dt - prev_adjusted\\n\\n photo_difference = td.seconds\\n\\n # create a factor that plots the point between the two waypoint timings the photo was taken\\n dfactor = photo_difference / float(total_difference)\\n\\n # multiply the difference between the lat/lon/alt of the waypoins by this factor\\n photo_lat = float(prev_wp.latitude) + ((float(w.latitude) - float(prev_wp.latitude)) * dfactor)\\n photo_lon = float(prev_wp.longitude) + ((float(w.longitude) - float(prev_wp.longitude)) * dfactor)\\n photo_alt = float(prev_wp.altitude) + ((float(w.altitude) - float(prev_wp.altitude)) * dfactor)\\n\\n # Prepare a waypoint object to store the results of the geotagging calculations\\n\\n photo_waypoints = WayPoint.objects.filter(\\n\\n photo_id=xml_photo['id'],\\n\\n );\\n if len(photo_waypoints) > 0:\\n\\n photo_waypoint = photo_waypoints[0]\\n\\n else:\\n photo_waypoint = WayPoint()\\n photo_waypoint.photo_id = xml_photo['id']\\n\\n photo_waypoint.photo_title = xml_photo['title']\\n photo_waypoint.photo_secret = xml_photo['secret']\\n photo_waypoint.photo_farm = xml_photo['farm']\\n photo_waypoint.photo_server = xml_photo['server']\\n\\n photo_waypoint.latitude = str(photo_lat)\\n photo_waypoint.longitude = str(photo_lon)\\n photo_waypoint.altitude = str(photo_alt)\\n photo_waypoint.gmtime = photo_dt\\n photo_waypoint.localtime = photo_dt - self._offset_timedelta\\n\\n photo_waypoint.save()\\n # except:\\n # assert False, '.' + xml_photo['id'] + '.'\\n return photo_waypoint\\n\\n prev_wp = w\\n\\n return False\",\n \"def do_lights(self, line):\\n if not self.huuey.issetup():\\n print 'This session is not paired! Pair to a bridge first before continuing'\\n return\\n\\n if len(self.huuey.lights) > 0:\\n print 'List of Lights \\\\n'\\n print 'ID\\\\tUnique'\\n\\n for index, light in enumerate(self.huuey.lights):\\n print u\\\"{index}\\\\t{unique}\\\".format(index=index+1, unique=self.huuey.lights[light].uniqueid)\\n\\n else:\\n if self.huuey.issetup():\\n print 'No lights found on bridge'\\n else:\\n print 'Session not connected to bridge!'\",\n \"def frame_to_distance_images(frame):\\n \\n # distance from ridge midlines\\n frame = rgb2gray(frame)\\n ridges = enhance_ridges(frame)\\n thresh = filters.threshold_otsu(ridges)\\n prominent_ridges = ridges > 0.8*thresh\\n skeleton = morphology.skeletonize(prominent_ridges)\\n edge_dist = ndimage.distance_transform_edt(~skeleton)\\n edge_dist = filters.gaussian(edge_dist, sigma=2)\\n\\n # distance from skeleton branch points (ie, ridge intersections)\\n blurred_skeleton = uniform_filter(skeleton.astype(float), size=3)\\n corner_im = blurred_skeleton > 4./9\\n corner_dist = ndimage.distance_transform_edt(~corner_im)\\n \\n return edge_dist, corner_dist\",\n \"def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\\n image = np.array(Image.open(image_path))\\n\\n if json_path is None:\\n objects = None\\n else:\\n gt_data = json.load(open(json_path))\\n what = ['traffic light']\\n objects = [o for o in gt_data['objects'] if o['label'] in what]\\n\\n find_tfl_lights(image)\",\n \"def update_and_publish(self):\\n # 1. Find next_waypoint based on ego position & orientation\\n if self._update_next_waypoint():\\n\\n # 2. Generate the list of next LOOKAHEAD_WPS waypoints\\n num_base_wp = len(self.base_waypoints)\\n last_base_wp = num_base_wp-1\\n waypoint_idx = [idx % num_base_wp for idx in range(self.next_waypoint,self.next_waypoint+LOOKAHEAD_WPS)]\\n final_waypoints = [self.base_waypoints[wp] for wp in waypoint_idx]\\n\\n # 3. If there is a red light ahead, update velocity for them\\n if self.stop_on_red:\\n # Start from original velocities\\n self.restore_velocities(waypoint_idx)\\n try:\\n red_idx = waypoint_idx.index(self.red_light_waypoint)\\n self.decelerate(final_waypoints, red_idx, self.stop_distance)\\n except ValueError:\\n # No red light available: self.red_light_waypoint is None or not in final_waypoints\\n red_idx = None\\n if debugging:\\n v = self.get_waypoint_velocity(final_waypoints, 0)\\n rospy.loginfo(\\\"Target velocity: %.1f, RL:%s wps ahead\\\", v, str(red_idx))\\n\\n # 3b. If we are close to the end of the circuit, make sure that we stop there\\n if self.force_stop_on_last_waypoint or self.base_wp_orig_v[-1] < 1e-5:\\n try:\\n last_wp_idx = waypoint_idx.index(last_base_wp)\\n self.decelerate(final_waypoints, last_wp_idx, 0)\\n except ValueError:\\n # Last waypoint is not one of the next LOOKAHEAD_WPS\\n pass\\n\\n # 4. Publish waypoints to \\\"/final_waypoints\\\"\\n self.publish_msg(final_waypoints)\",\n \"def get_nrof_lights(self):\\n lights = 0\\n for l in self.light_array:\\n if l:\\n lights += 1\\n return lights\",\n \"async def lights(self, context):\\n\\n await random_image(context, 'lights')\",\n \"def image_cb(self, msg):\\n rospy.logdebug(\\\"TLDetector.image_cb\\\")\\n self.__has_image = True\\n self.__camera_image = msg\\n\\n cv_image = self.__bridge.imgmsg_to_cv2(msg, \\\"bgr8\\\")\\n light_wp, state = self.__process_traffic_lights()\\n if self.__mode == LABEL_MODE and not self.__classification_done and state != 4:\\n self.__classification_done = self.__light_classifier.save_image(\\n cv_image, state\\n )\\n if self.__classification_done:\\n rospy.loginfo(\\\"TLDetector.image_cb: Done generating labels.\\\")\\n\\n \\\"\\\"\\\"\\n Publish upcoming red lights at camera frequency.\\n Each predicted state has to occur `STATE_COUNT_THRESHOLD` number\\n of times till we start using it. Otherwise the previous stable state is\\n used.\\n \\\"\\\"\\\"\\n self.__publish_traffic_light_state(light_wp, state)\",\n \"def detect_lane_lines(image_edges, image_orig):\\n \\n HOUGH_RHO = 1 # distance resolution in pixels of the Hough grid\\n HOUGH_THETA = np.pi/180 # angular resolution in radians of the Hough grid\\n HOUGH_THRESH = 15 # minimum number of votes (intersections in Hough grid cell) <15,20>\\n HOUGH_MIN_LEN = 40 # minimum number of pixels making up a line <40,100>\\n HOUGH_MAX_GAP = 100 # maximum gap in pixels between connectable line segments <100,250>\\n \\n LINE_MIN_ANGLE = 20 # degrees\\n \\n image_wk = np.copy(image_orig) # working copy\\n \\n # Run Hough transform on edge-detected image\\n raw_lines = cv2.HoughLinesP(image_edges, HOUGH_RHO, HOUGH_THETA, HOUGH_THRESH, np.array([]),\\n HOUGH_MIN_LEN, HOUGH_MAX_GAP)\\n \\n # Group lines by left/right angle and side of center line\\n left_lines = []\\n right_lines = []\\n x_center = np.int32((image_wk.shape[1]/2))\\n for line in raw_lines:\\n for x1, y1, x2, y2 in line:\\n theta = np.arctan((y2-y1)/(x2-x1)) /np.pi*180\\n \\n if (theta < -LINE_MIN_ANGLE) and (x1 < x_center) and (x2 < x_center):\\n left_lines.append(line)\\n \\n elif (theta > LINE_MIN_ANGLE) and (x1 > x_center) and (x2 > x_center):\\n right_lines.append(line)\\n \\n # Draw raw left/right lines on road image\\n draw_lines(image_wk, left_lines, (255,0,255), 2)\\n draw_lines(image_wk, right_lines, (0,255,0), 2)\\n \\n # Output road image with drawn raw lines and lists of left/right line coordinates\\n return (image_wk, left_lines, right_lines)\",\n \"def get_displacement(self, color, depth):\\n displacement = None\\n keypoints, descriptors = self._feature_detector.detectAndCompute(color, None)\\n \\n if descriptors is not None and self._last_descriptors is not None:\\n matches = self._matcher.match(descriptors, self._last_descriptors)\\n matches = self._select_matches(matches) \\n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\\n t = []\\n horizontal = 0\\n for i in range(len(matches)):\\n d1 = depth[int(points[i][1]), int(points[i][0])]\\n d2 = self._last_depth[int(last_points[i][1]), int(points[i][0])]\\n #print(d1, d2)\\n \\n if d1 != 0 and abs(d1-d2) < 10:\\n t.append(matches[i])\\n horizontal += (points[i][0] - last_points[i][0]) * d1\\n \\n matches = t\\n horizontal /= len(t) \\n \\n if len(matches) > 0:\\n if self._config['show_matches']:\\n matches_preview = cv2.drawMatches(color, keypoints, self._last_color, self._last_keypoints, matches, None, flags=2)\\n cv2.imshow('Basic_Odometry_matches_preview', matches_preview)\\n \\n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\\n #It uses default values for parameters - there must be here because of broken python bindings I suppose\\n tf_mat = cv2.estimateRigidTransform(points, last_points, False, 500, 0.5, 3)\\n \\n if tf_mat is not None:\\n a11, a12, b1 = tf_mat[0][0], tf_mat[0][1], tf_mat[0][2]\\n a21, a22, b2 = -tf_mat[1][0], tf_mat[1][1], tf_mat[1][2]\\n roll = math.atan2(-a12, a11) \\n \\n displacement = {\\n 'roll': roll,\\n 'horizontal': horizontal,#b1,\\n 'vertical': b2,\\n 'depth': math.sqrt(a11**2+a12**2) * (-1 if a11 < 0 else 1)\\n }\\n \\n if descriptors is not None: \\n self._last_keypoints = keypoints\\n self._last_descriptors = descriptors\\n self._last_color = color\\n self._last_depth = depth\\n \\n return displacement\",\n \"def getLightIndex(gltf, idname):\\n\\n v3dExt = appendExtension(gltf, 'S8S_v3d_data', gltf)\\n\\n if v3dExt.get('lights') == None:\\n return -1\\n\\n lights = v3dExt['lights']\\n\\n index = 0\\n for light in lights:\\n key = 'id' if light.get('id') != None else 'name'\\n if light.get(key) == idname:\\n return index\\n\\n index += 1\\n\\n return -1\",\n \"def visualize_waypoints(current_robot_pose, current_camera_pose,\\n marker_id, last_robot_pose=None):\\n\\n waypoints = rospy.get_param(\\\"/scene_exploration_sm/waypoints\\\")\\n publisher = rospy.Publisher(waypoints, Marker, queue_size=10)\\n points = []\\n rospy.logdebug(\\\"last_robot_pose is: \\\" + str(last_robot_pose))\\n if last_robot_pose is not None:\\n points.append(Point(last_robot_pose.position.x,\\n last_robot_pose.position.y,\\n 0))\\n points.append(Point(current_robot_pose.position.x,\\n current_robot_pose.position.y,\\n 0))\\n\\n if current_camera_pose is not None:\\n z_pose = current_camera_pose.position.z\\n else:\\n z_pose = 1.35\\n\\n center = Point(current_robot_pose.position.x,\\n current_robot_pose.position.y,\\n z_pose / 2.0)\\n pose_marker = Marker()\\n pose_marker.header.stamp = rospy.Time.now()\\n pose_marker.header.frame_id = '/map'\\n pose_marker.ns = 'waypoints_cyl'\\n pose_marker.type = Marker.CYLINDER\\n pose_marker.id = marker_id + 2\\n pose_marker.action = Marker.ADD\\n pose_marker.scale = Vector3(0.05, 0.05, z_pose)\\n pose_marker.color = ColorRGBA(0, 0, 1, 1)\\n pose_marker.lifetime = rospy.Duration()\\n pose_marker.pose.position = center\\n\\n # Only on the first try we have to wait for the publisher,\\n # next times we know the last pose and this won't be executed\\n if last_robot_pose is None:\\n rospy.loginfo(\\\"Sleeping till waypoint publisher is ready\\\")\\n rospy.sleep(1)\\n\\n publisher.publish(pose_marker)\\n\\n marker = Marker()\\n marker.header.stamp = rospy.Time.now()\\n marker.header.frame_id = '/map'\\n marker.ns = 'waypoints_lines'\\n marker.type = Marker.LINE_LIST\\n marker.id = marker_id\\n marker.action = Marker.ADD\\n marker.scale = Vector3(0.02, 0.1, 0.1)\\n marker.color = ColorRGBA(0, 1, 1, 1)\\n marker.lifetime = rospy.Duration()\\n marker.points = points\\n\\n publisher.publish(marker)\\n\\n if current_camera_pose is not None:\\n arrow = Marker()\\n arrow.header.stamp = rospy.Time.now()\\n arrow.header.frame_id = '/map'\\n arrow.ns = 'waypoints_arrows'\\n arrow.pose = current_camera_pose\\n arrow.type = Marker.ARROW\\n arrow.id = marker_id + 1\\n arrow.action = Marker.ADD\\n arrow.scale = Vector3(0.5, 0.02, 0.02)\\n arrow.color = ColorRGBA(1, 1, 0, 1)\\n arrow.lifetime = rospy.Duration()\\n\\n publisher.publish(arrow)\",\n \"def detect_light(self, camera, image, send_q):\\n\\n # if we are sending images continuously, append current image to send_q\\n if self.frame_count == -1: # -1 code to send all frames continuously\\n text_and_image = (camera.text, image)\\n send_q.append(text_and_image)\\n\\n # crop ROI & convert to grayscale\\n x1, y1 = self.top_left\\n x2, y2 = self.bottom_right\\n ROI = image[y1:y2, x1:x2]\\n gray = cv2.cvtColor(ROI, cv2.COLOR_BGR2GRAY)\\n # calculate current_state of ROI\\n gray_mean = int(np.mean(gray))\\n if gray_mean > self.threshold:\\n state = 'lighted'\\n state_num = 1\\n else:\\n state = 'dark'\\n state_num = -1\\n if self.send_test_images:\\n images = []\\n images.append(('ROI', ROI,))\\n images.append(('Grayscale', gray,))\\n state_values = []\\n state_values.append(('State', state,))\\n state_values.append(('Mean Pixel Value', str(gray_mean),))\\n self.send_test_data(images, state_values, send_q)\\n self.state_history_q.append(state_num)\\n if len(self.state_history_q) < self.min_frames:\\n return # not enough history to check for a state change\\n\\n # have enough history now, so...\\n # determine if there has been a change in state\\n if self.state_history_q.count(-1) == self.min_frames:\\n self.current_state = 'dark'\\n elif self.state_history_q.count(1) == self.min_frames:\\n self.current_state = 'lighted'\\n else:\\n return # state has not stayed the same for self.min_frames\\n if self.current_state == self.last_state:\\n return # there has been no state change and hence no event yet\\n\\n # state has changed from last reported state, therefore\\n # send event message, reporting current_state, by appending it to send_q\\n text = '|'.join([self.event_text, self.current_state])\\n if self.log_roi_name:\\n text = '|'.join([text, self.roi_name])\\n text_and_image = (text, self.msg_image)\\n send_q.append(text_and_image)\\n\\n # if frame_count = -1, then already sending images continuously...\\n # so no need to send the images of this detected event\\n # if frame_count > 0, need to send send_count images from the cam_q\\n # by appending them to send_q\\n if self.frame_count > 0: # then need to send images of this event\\n send_count = min(len(camera.cam_q), self.send_count)\\n for i in range(-send_count, -1):\\n text_and_image = (camera.text, camera.cam_q[i])\\n send_q.append(text_and_image)\\n\\n # Now that current state has been sent, it becomes the last_state\\n self.last_state = self.current_state\",\n \"def depth_rendering(ref_view, disparity_map, lf_size = (64, 512, 512, 3)):\\n lf_one_way = int(math.floor(math.sqrt(lf_size[0])))\\n\\n x_indices = np.arange(lf_size[1])\\n y_indices = np.arange(lf_size[2])\\n b_indices = np.arange(lf_size[0])\\n\\n #Create a grid of size lf_size[:3] consisting of the pixel co ordinates of each image\\n _, x, y = np.meshgrid(b_indices, x_indices, y_indices, indexing= 'ij')\\n\\n # Create a grid of size (lf_size[0], 2) consiting of the row, col lf positions\\n grid = np.meshgrid(np.arange(lf_one_way), np.arange(lf_one_way), indexing= 'ij')\\n stacked = np.stack(grid, 2)\\n positions = stacked.reshape(-1, 2)\\n\\n # Compute the distance from each lf position from the reference view\\n # Repeat the elements of this to match the size of the disparity map\\n ref_pos = np.array(\\n [lf_one_way // 2, lf_one_way // 2])\\n distance = (np.tile(ref_pos, (lf_size[0], 1)) - positions).T\\n dis_repeated = np.repeat(distance, lf_size[1] * lf_size[2], axis = 1)\\n dis_repeated = dis_repeated.reshape(2, lf_size[0], lf_size[1], lf_size[2])\\n\\n\\n # Tile the disparity map so that there is one for each lf_position - lf_size[0]\\n tiled_map = np.tile(disparity_map, (lf_size[0], 1, 1))\\n\\n # Compute the shifted pixels\\n x_shifted = (x.astype(np.float32) - tiled_map * dis_repeated[0]).flatten()\\n y_shifted = (y.astype(np.float32) - tiled_map * dis_repeated[1]).flatten()\\n\\n #indices for linear interpolation in a square around the central point\\n x_low = np.around(x_shifted).astype(int)\\n #x_high = x_low + 1\\n\\n y_low = np.around(y_shifted).astype(int)\\n #y_high = y_low + 1\\n\\n #Place co-ordinates outside the image back into the image\\n x_low_clip = np.clip(x_low, 0, ref_view.shape[0] - 1)\\n #x_high_clip = np.clip(x_high, 0, ref_view.shape[0] - 1)\\n y_low_clip = np.clip(y_low, 0, ref_view.shape[1] - 1)\\n #y_high_clip = np.clip(y_high, 0, ref_view.shape[1] - 1)\\n\\n #Gather the interpolation points\\n interp_pts_1 = np.stack((x_low_clip, y_low_clip))\\n #interp_pts_2 = np.stack((x_low_clip, y_high_clip))\\n #interp_pts_3 = np.stack((x_high_clip, y_low_clip))\\n #interp_pts_4 = np.stack((x_high_clip, y_high_clip))\\n\\n #Index into the images\\n desired_shape = lf_size\\n res_1 = torch_big_sample(ref_view, interp_pts_1, desired_shape)\\n return res_1\\n res_2 = torch_big_sample(ref_view, interp_pts_2, desired_shape)\\n res_3 = torch_big_sample(ref_view, interp_pts_3, desired_shape)\\n res_4 = torch_big_sample(ref_view, interp_pts_4, desired_shape)\\n\\n #Compute interpolation weights\\n x_low_f = x_low.astype(np.float32)\\n d_x_low = 1.0 - (x_shifted.astype(np.float32) - x_low_f)\\n d_x_high = 1.0 - d_x_low\\n y_low_f = y_low.astype(np.float32)\\n d_y_low = 1.0 - (y_shifted.astype(np.float32) - y_low_f)\\n d_y_high = 1.0 - d_y_low\\n\\n w1 = torch.from_numpy(d_x_low * d_y_low)\\n w2 = torch.from_numpy(d_x_low * d_y_high)\\n w3 = torch.from_numpy(d_x_high * d_y_low)\\n w4 = torch.from_numpy(d_x_high * d_y_high)\\n\\n #THEY AGREE AT THIS POINT\\n weighted_1 = torch.mul(repeat_weights(w1, desired_shape), res_1)\\n weighted_2 = torch.mul(repeat_weights(w2, desired_shape), res_2)\\n weighted_3 = torch.mul(repeat_weights(w3, desired_shape), res_3)\\n weighted_4 = torch.mul(repeat_weights(w4, desired_shape), res_4)\\n\\n novel_view = torch.add(torch.add(weighted_1, weighted_2), weighted_3)\\n torch.add(novel_view, weighted_4, out=novel_view)\\n return novel_view\",\n \"def run():\\n step = 0\\n start_change = 0\\n duration = 0\\n # we start with phase 0 where NS has left green\\n traci.trafficlight.setPhase(\\\"Origin\\\", 0)\\n controlled_lanes = traci.trafficlight.getControlledLanes(\\\"Origin\\\")\\n # print(rg.get_wait_time_for_light(\\\"Origin\\\"))\\n while traci.simulation.getMinExpectedNumber() > 0:\\n traci.simulationStep()\\n wait_times = rg.get_network_waiting_time(summed=True)[0]\\n NS = wait_times[0]+wait_times[2]\\n EW = wait_times[1]+wait_times[3]\\n if(EW>(20+NS)):\\n if(traci.trafficlight.getPhase(\\\"Origin\\\") < 2):\\n traci.trafficlight.setPhase(\\\"Origin\\\", 2)\\n start_change = step\\n duration=0\\n else:\\n if(step-start_change>6):\\n if(duration<8):\\n #Left turns for EW\\n traci.trafficlight.setPhase(\\\"Origin\\\", 3)\\n duration+=1\\n else:\\n #Straight for EW\\n traci.trafficlight.setPhase(\\\"Origin\\\", 4)\\n elif(NS>(20+EW)):\\n if(traci.trafficlight.getPhase(\\\"Origin\\\") == 3 or traci.trafficlight.getPhase(\\\"Origin\\\") == 4):\\n traci.trafficlight.setPhase(\\\"Origin\\\", 5)\\n start_change = step\\n duration=0\\n else:\\n if(step-start_change>6):\\n if(duration<8):\\n #Left turns for EW\\n traci.trafficlight.setPhase(\\\"Origin\\\", 0)\\n duration+=1\\n else:\\n #Straight for EW\\n traci.trafficlight.setPhase(\\\"Origin\\\", 1)\\n step += 1\\n\\n traci.close()\\n sys.stdout.flush()\",\n \"def _change_seg_stop(self, seg_img, depth_img, stop_signs, cam, _region_size=6): \\r\\n for stop in stop_signs:\\r\\n\\r\\n _dist = self._get_distance(stop.get_transform().location)\\r\\n \\r\\n _region = np.abs(depth_img - _dist)\\r\\n\\r\\n seg_img[(_region < _region_size) & (seg_img == 12)] = 26\\r\\n\\r\\n # lane markings\\r\\n trigger = stop.trigger_volume\\r\\n\\r\\n _trig_loc_world = self._trig_to_world(np.array([[0], [0], [0], [1.0]]).T, stop, trigger)\\r\\n _x = self._world_to_sensor(_trig_loc_world, self._get_sensor_position(cam))[0,0]\\r\\n\\r\\n if _x > 0: # stop is in front of camera\\r\\n\\r\\n bb = self._create_2d_bb_points(trigger, 4)\\r\\n trig_loc_world = self._trig_to_world(bb, stop, trigger)\\r\\n cords_x_y_z = self._world_to_sensor(trig_loc_world, self._get_sensor_position(cam), True)\\r\\n\\r\\n #if cords_x_y_z.size: \\r\\n cords_x_y_z = cords_x_y_z[:3, :]\\r\\n cords_y_minus_z_x = np.concatenate([cords_x_y_z[1, :], -cords_x_y_z[2, :], cords_x_y_z[0, :]])\\r\\n bbox = (self._sensor_data['calibration'] @ cords_y_minus_z_x).T\\r\\n\\r\\n camera_bbox = np.concatenate([bbox[:, 0] / bbox[:, 2], bbox[:, 1] / bbox[:, 2], bbox[:, 2]], axis=1)\\r\\n\\r\\n if np.any(camera_bbox[:,2] > 0):\\r\\n\\r\\n camera_bbox = np.array(camera_bbox)\\r\\n\\r\\n polygon = [(camera_bbox[i, 0], camera_bbox[i, 1]) for i in range(len(camera_bbox))]\\r\\n\\r\\n img = Image.new('L', (self._sensor_data['width'], self._sensor_data['height']), 0)\\r\\n ImageDraw.Draw(img).polygon(polygon, outline=1, fill=1)\\r\\n _region = np.array(img)\\r\\n\\r\\n seg_img[(_region == 1) & (seg_img == 6)] = 27\",\n \"def update():\\n\\n scan = np.clip(\\n rc.lidar.get_samples() * LIDAR_OFFSET, 0, None\\n ) # smooth(rc.lidar.get_samples())\\n\\n scan_xy = None\\n\\n color_image = rc.camera.get_color_image()\\n depth_image = cv.bilateralFilter(rc.camera.get_depth_image(), 9, 75, 75)\\n vis_image = np.zeros((2 * VIS_RADIUS, 2 * VIS_RADIUS, 3), np.uint8, \\\"C\\\")\\n hsv_image = cv.cvtColor(color_image, cv.COLOR_BGR2HSV)\\n\\n # FSM\\n\\n speed = 0\\n angle = 0\\n global currentChallenge\\n global oldState\\n global colorPriority\\n\\n if currentChallenge == Challenge.ManualControl:\\n speed, angle = manualControl()\\n if rc.controller.was_pressed(rc.controller.Button.A):\\n currentChallenge = oldState\\n else:\\n if rc.controller.was_pressed(rc.controller.Button.A):\\n oldState = currentChallenge\\n currentChallenge = Challenge.ManualControl\\n\\n curve = None\\n path = None\\n if currentChallenge == Challenge.Line:\\n if colorPriority == None:\\n # scan AR tags\\n colorPriority = [\\n Color.Red,\\n Color.Green,\\n Color.Blue,\\n ] # {Color.Red: 1, Color.Blue: 2, Color.Green: 3}\\n\\n hsv_image[0 : height // 2, :] = [0, 0, 0] # crop out top half\\n\\n if colorPriority[2] == Color.Blue:\\n blue_r = np.array([])\\n blue_t = np.array([])\\n else:\\n mask = cv.inRange(hsv_image, BLUE[0], BLUE[1])\\n # rc.display.show_color_image(mask)\\n points = np.argwhere(mask != 0)\\n depths = depth_image[points[:, 0], points[:, 1]]\\n blue_r, blue_t = camera2Polar(points, depths)\\n\\n if colorPriority[2] == Color.Red:\\n red_r = np.array([])\\n red_t = np.array([])\\n else:\\n mask = cv.bitwise_or(\\n cv.inRange(hsv_image, RED1[0], RED1[1]),\\n cv.inRange(hsv_image, RED2[0], RED2[1]),\\n )\\n # rc.display.show_color_image(mask)\\n points = np.argwhere(mask != 0)\\n depths = depth_image[points[:, 0], points[:, 1]]\\n red_r, red_t = camera2Polar(points, depths)\\n\\n if colorPriority[2] == Color.Green:\\n green_r = np.array([])\\n green_t = np.array([])\\n else:\\n mask = cv.inRange(hsv_image, GREEN[0], GREEN[1])\\n # rc.display.show_color_image(mask)\\n points = np.argwhere(mask != 0)\\n depths = depth_image[points[:, 0], points[:, 1]]\\n green_r, green_t = camera2Polar(points, depths)\\n\\n depths = np.concatenate([blue_r, red_r, green_r])\\n sort = np.argsort(depths)\\n\\n points = np.array(\\n [\\n depths[sort],\\n np.concatenate([blue_t, red_t, green_t])[sort],\\n np.concatenate(\\n [\\n np.full_like(blue_r, Color.Blue),\\n np.full_like(red_r, Color.Red),\\n np.full_like(green_r, Color.Green),\\n ]\\n )[sort],\\n ]\\n )\\n\\n path = None\\n\\n if len(depths) > 5:\\n final_r = np.array([])\\n final_t = np.array([])\\n\\n oldt = -1\\n\\n for i in range(LINE_RADIUS // 5): # increments of 10 units\\n p = points[\\n :,\\n np.logical_and(points[0, :] >= i * 5, points[0, :] < (i + 1) * 5),\\n ]\\n l = p.shape[1]\\n if l > 0:\\n unique = np.unique(p[2])\\n # d = dict(zip(unique, counts))\\n for c in colorPriority:\\n if c in unique:\\n args = np.argwhere(p[2] == c)\\n tlist = p[1, args]\\n c_t = np.mean(tlist)\\n if oldt == -1 or abs(c_t - oldt) < 0.4: # radians\\n final_r = np.append(final_r, p[0, args])\\n final_t = np.append(final_t, tlist)\\n oldt = c_t\\n break\\n # else:\\n # final_r = np.append(final_r, p[0])\\n # final_t = np.append(final_t, p[1])\\n\\n path = polar2TopDown(final_r, final_t)\\n path[:, 1] -= 25\\n curve = fitCurveToPath(path, vis_image)\\n if currentChallenge == Challenge.Lane:\\n mask = cv.bitwise_or(\\n cv.inRange(hsv_image, PURPLE[0], PURPLE[1]),\\n cv.inRange(hsv_image, ORANGE[0], ORANGE[1]),\\n )\\n # rc.display.show_color_image(mask)\\n points = np.argwhere(mask != 0)\\n depths = depth_image[points[:, 0], points[:, 1]]\\n r, t = camera2Polar(points, depths)\\n path = polar2TopDown(r, t)\\n\\n if len(path) > 0:\\n final_x = np.array([])\\n final_y = np.array([])\\n\\n # path = path[np.absolute(path[:, 1]) < LANE_HORIZ_RADIUS]\\n\\n for i in range(VIS_RADIUS // 5):\\n p = path[np.logical_and(path[:, 1] >= i * 5, path[:, 1] < (i + 1) * 5)]\\n if len(p) > 0:\\n y = p[:, 1]\\n p = p[:, 0]\\n m = np.mean(p)\\n left_mean = np.mean(p[p < m])\\n right_mean = np.mean(p[p > m])\\n if (\\n abs(left_mean - right_mean) < 5\\n or abs(left_mean - right_mean) > 100\\n ):\\n continue # throw out this data, one side is not visible\\n m = (left_mean + right_mean) / 2\\n p[p > m] += m - right_mean\\n p[p < m] += m - left_mean\\n final_x = np.append(final_x, p)\\n final_y = np.append(final_y, y)\\n\\n path = np.transpose([final_x, final_y])\\n curve = fitCurveToPath(path, vis_image)\\n\\n if curve is not None: # line or lane gave valid result\\n # speed = 0.5\\n slope = npp.polyval(5, np.polyder(curve))\\n error = slope / 50\\n # angleError = TARGET_ANGLE - (rightWallAngle + leftWallAngle) / 2\\n # distError = npp.polyval(0, curve)\\n\\n # if abs(angleError) < ANGLE_THRESHHOLD:\\n # error = distError\\n # else:\\n # error = distError / 10 + np.sin(np.radians(angleError)) * 2 # angleError / 30\\n\\n # angle = rc_utils.clamp(Angle_PID.update(error, rc.get_delta_time()), -1, 1)\\n\\n if True: # currentChallenge == Challenge.Cones:\\n blue_image = np.zeros((VIS_RADIUS * 2, VIS_RADIUS * 2), dtype=np.uint8)\\n red_image = np.zeros((VIS_RADIUS * 2, VIS_RADIUS * 2), dtype=np.uint8)\\n\\n visualizeColor(blue_image, hsv_image, depth_image, BLUE, 255)\\n visualizeColor(red_image, hsv_image, depth_image, RED1, 255)\\n visualizeColor(red_image, hsv_image, depth_image, RED2, 255)\\n\\n cones = []\\n\\n keypoints = conedetector.detect(blue_image)\\n # vis_image = cv.drawKeypoints(\\n # vis_image,\\n # keypoints,\\n # np.array([]),\\n # (0, 255, 255),\\n # cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,\\n # )\\n\\n cones.append([[k.pt[0], k.pt[1], WaypointType.Blue] for k in keypoints])\\n\\n keypoints = conedetector.detect(red_image)\\n # vis_image = cv.drawKeypoints(\\n # vis_image,\\n # keypoints,\\n # np.array([]),\\n # (0, 255, 255),\\n # cv.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS,\\n # )\\n\\n cones.append([[k.pt[0], k.pt[1], WaypointType.Red] for k in keypoints])\\n\\n scan_xy = lidar2TopDown(scan) # , 30, 330)\\n scan_xy[:, 1] -= 15 # lidar offset\\n scan_xy = scan_xy[\\n (np.absolute(scan_xy) < 60).all(axis=1)\\n ] # scipy.cluster.vq.whiten(scan_xy)\\n\\n centroids = None\\n if scan_xy.size > 5:\\n try:\\n centroids, distortion = scipy.cluster.vq.kmeans(scan_xy, 3)\\n except:\\n print(\\\"K means error\\\")\\n\\n # print(c)\\n\\n if centroids is not None:\\n v = topDown2Vis(centroids)\\n for i in range(len(v[0])):\\n cones.append([v[1][i], v[0][i], WaypointType.Unknown])\\n # x = v[1][i]\\n # y = v[0][i]\\n # if x < VIS_RADIUS: # and y > VIS_RADIUS:\\n # red_cones.append([x, y])\\n # else:\\n # blue_cones.append([x, y])\\n # if c is not None:\\n # dist = min(np.minimum(c[:, 0] - x), np.minimum(c[:, 1] - y))\\n # if dist > 10:\\n # rc_utils.draw_circle(vis_image, (x, y), (0, 255, 255), 5)\\n # else:\\n # rc_utils.draw_circle(vis_image, (x, y), (0, 255, 255), 5)\\n\\n if len(cones) > 0:\\n for i in range(len(waypoints)):\\n\\n x = int(rc_utils.clamp(waypoints[c][0], 0, VIS_RADIUS * 2))\\n y = int(rc_utils.clamp(waypoints[c][1], 0, VIS_RADIUS * 2))\\n for i in waypoints[c + 1 :]:\\n d = (i[0] - x) ** 2 + (i[1] - y) ** 2\\n if d < 100:\\n break\\n\\n waypoints = []\\n gate_forming_cones = []\\n\\n for i in red_cones:\\n for j in blue_cones:\\n if abs(j[1] - i[1]) < 40 and 20 < abs(j[0] - i[0]) < 100: # found gate\\n x = abs(j[0] - i[0]) / 2\\n # y = (j[1] + i[1]) / 2\\n # if y >= 20:\\n waypoints.append([j[0] - x, j[1], WaypointType.Gate])\\n waypoints.append([i[0] + x, i[1], WaypointType.Gate])\\n gate_forming_cones.append(i)\\n gate_forming_cones.append(j)\\n # break\\n\\n # print(gate_forming_cones)\\n\\n # print(waypoints)\\n firstrun = True\\n for a in red_cones:\\n x = int(a[1])\\n y = int(a[0])\\n rc_utils.draw_circle(vis_image, (x, y), (0, 127, 255), 5)\\n for b in blue_cones:\\n xb = int(b[1])\\n yb = int(b[0])\\n if firstrun:\\n rc_utils.draw_circle(vis_image, (xb, yb), (255, 255, 0), 5)\\n d = (xb - x) ** 2 + (yb - y) ** 2\\n if d < 100:\\n gate_forming_cones.append(a)\\n firstrun = False\\n\\n for i in red_cones:\\n if i not in gate_forming_cones:\\n waypoints.append([i[0] + 30, i[1], WaypointType.Red])\\n waypoints.append([i[0] + 20, i[1] - 20, WaypointType.Red])\\n waypoints.append([i[0] + 20, i[1] + 20, WaypointType.Red])\\n\\n for i in blue_cones:\\n if i not in gate_forming_cones:\\n waypoints.append([i[0] - 30, i[1], WaypointType.Blue])\\n waypoints.append([i[0] - 20, i[1] - 20, WaypointType.Blue])\\n waypoints.append([i[0] - 20, i[1] + 20, WaypointType.Blue])\\n\\n if len(waypoints) > 0:\\n w = []\\n\\n for c in range(len(waypoints)):\\n x = int(rc_utils.clamp(waypoints[c][0], 0, VIS_RADIUS * 2))\\n y = int(rc_utils.clamp(waypoints[c][1], 0, VIS_RADIUS * 2))\\n for i in waypoints[c + 1 :]:\\n d = (i[0] - x) ** 2 + (i[1] - y) ** 2\\n if d < 100:\\n break\\n else:\\n w.append(waypoints[c])\\n rc_utils.draw_circle(vis_image, (y, x), (0, 255, 0), 5)\\n\\n # waypoints.append([VIS_RADIUS, VIS_RADIUS, WaypointType.Self])\\n waypoints = np.array(w)\\n\\n waypoints[:, 0:2] -= VIS_RADIUS\\n waypoints[:, 1] = np.negative(waypoints[:, 1])\\n # print(waypoints)\\n\\n # fit curve to path\\n try:\\n curve = scipy.interpolate.interp1d(\\n waypoints[:, 1],\\n waypoints[:, 0],\\n # type=\\\"cubic\\\",\\n fill_value=\\\"extrapolate\\\",\\n )\\n except:\\n print(\\\"Spline curve error\\\")\\n curve = None\\n\\n if curve is not None:\\n i = topDown2Vis(\\n np.transpose(\\n [\\n curve(np.arange(-VIS_RADIUS, VIS_RADIUS)),\\n np.arange(-VIS_RADIUS, VIS_RADIUS),\\n ]\\n )\\n )\\n if i is not None:\\n vis_image[i] = [255, 255, 0] # add pixels in color image\\n\\n speed = 0.2\\n slope = (curve(0.1) - curve(0)) / 0.1\\n error = curve(0) / 10 # + slope * 5 # angleError / 30\\n if np.isfinite(error):\\n angle = rc_utils.clamp(Angle_PID.update(error, rc.get_delta_time()), -1, 1)\\n global last_waypoint_type\\n last_waypoint_type = waypoints[np.argmin(np.absolute(waypoints[:, 1])), 2]\\n else:\\n if last_waypoint_type == WaypointType.Blue:\\n speed = 0.2\\n angle = 1\\n elif last_waypoint_type == WaypointType.Red:\\n speed = 0.2\\n angle = -1\\n\\n # print(\\\"centroids : \\\", centroids)\\n # print(\\\"distortion :\\\", distortion)\\n\\n # pass\\n # if currentChallenge == Challenge.Gate:\\n # pass\\n if currentChallenge == Challenge.Wall:\\n pass\\n\\n # green dot in middle for car\\n rc_utils.draw_circle(vis_image, (VIS_RADIUS, VIS_RADIUS), (0, 255, 255), 2)\\n\\n if scan_xy is not None:\\n i = topDown2Vis(scan_xy)\\n if i is not None:\\n vis_image[i] = [255, 255, 255]\\n\\n visualizeColor(vis_image, hsv_image, depth_image, BLUE, (255, 127, 0))\\n visualizeColor(vis_image, hsv_image, depth_image, RED1, (0, 0, 255))\\n visualizeColor(vis_image, hsv_image, depth_image, RED2, (0, 0, 255))\\n # visualizeColor(vis_image, hsv_image, depth_image, GREEN, (0, 255, 0))\\n\\n if path is not None:\\n i = topDown2Vis(path)\\n if i is not None:\\n vis_image[i] = [0, 255, 255] # add pixels in color image\\n\\n # mask[points[:, 0], points[:, 1]] = depths\\n # rc.display.show_depth_image(mask)\\n\\n # red = (255, 0, 0)\\n # blue = (255, 127, 0)\\n # green = (0, 255, 0)\\n # orange = (0, 127, 255)\\n # purple = (255, 0, 127)\\n # visualizeColor(vis_image, hsv_image, depth_image, PURPLE, (255, 0, 127))\\n # visualizeColor(vis_image, hsv_image, depth_image, ORANGE, (0, 127, 255))\\n\\n rc.display.show_color_image(vis_image)\\n # rc.display.show_depth_image(depth_image)\\n\\n rc.drive.set_speed_angle(speed, angle)\",\n \"def lineFollowTillIntersectionRightPID(kp = 1.0, ki = 0, kd = 0, color = ColorSensor(INPUT_1), color2 = ColorSensor(INPUT_3), \\n robot = MoveSteering(OUTPUT_A, OUTPUT_B)): # *an intersection is a line that is going through the line that the robot is following\\n \\n color.mode = 'COL-REFLECT' #setting color mode\\n color2.mode = 'COL-REFLECT' #setting color mode\\n lasterror = 0 \\n sound = Sound()\\n while color2.reflected_light_intensity <= Constants.WHITE and False == Constants.STOP:\\n error = ((Constants.WHITE + Constants.BLACK)/2) - color.reflected_light_intensity # colorLeft.reflected_light_intensity - colorRight.reflected_light_intensity\\n # correction = error * GAIN # correction = PID(error, lasterror, kp, ki, kd)\\n correction = PIDMath(error=error, lasterror = lasterror, kp=kp, ki=ki, kd=kd)\\n if correction > 100: correction = 100\\n if correction < -100: correction = -100\\n robot.on(speed = 20, steering = correction)\\n lasterror = error\\n sound.beep()\\n robot.off()\",\n \"def count_neighbors(lights, r, c):\\n neighbors = 0\\n\\n if r > 0 and c > 0: # 1\\n neighbors += 1 if lights[r - 1][c - 1] == \\\"#\\\" else 0\\n\\n if r > 0: # 2\\n neighbors += 1 if lights[r - 1][c] == \\\"#\\\" else 0\\n\\n if r > 0 and c < GRID_SIZE - 1: # 3\\n neighbors += 1 if lights[r - 1][c + 1] == \\\"#\\\" else 0\\n\\n if c < GRID_SIZE - 1: # 4\\n neighbors += 1 if lights[r][c + 1] == \\\"#\\\" else 0\\n\\n if r < GRID_SIZE - 1 and c < GRID_SIZE - 1: # 5\\n neighbors += 1 if lights[r + 1][c + 1] == \\\"#\\\" else 0\\n\\n if r < GRID_SIZE - 1: # 6\\n neighbors += 1 if lights[r + 1][c] == \\\"#\\\" else 0\\n\\n if r < GRID_SIZE - 1 and c > 0: # 7\\n neighbors += 1 if lights[r + 1][c - 1] == \\\"#\\\" else 0\\n\\n if c > 0: # 8\\n neighbors += 1 if lights[r][c - 1] == \\\"#\\\" else 0\\n\\n return neighbors\",\n \"def _change_seg_tl(self, seg_img, depth_img, traffic_lights, _region_size=4): \\r\\n for tl in traffic_lights:\\r\\n _dist = self._get_distance(tl.get_transform().location)\\r\\n \\r\\n _region = np.abs(depth_img - _dist)\\r\\n\\r\\n if tl.get_state() == carla.TrafficLightState.Red:\\r\\n state = 23\\r\\n elif tl.get_state() == carla.TrafficLightState.Yellow:\\r\\n state = 24\\r\\n elif tl.get_state() == carla.TrafficLightState.Green:\\r\\n state = 25\\r\\n else: #none of the states above, do not change class\\r\\n state = 18\\r\\n\\r\\n #seg_img[(_region >= _region_size)] = 0\\r\\n seg_img[(_region < _region_size) & (seg_img == 18)] = state\",\n \"def create_line_list(self,depth_arr):\\n\\n '''\\n depth_arr- depth image as numpy array\\n '''\\n\\n try:\\n body=[['shoulder_line',[self.rpts[11],self.rpts[12]]],['waist_line',[self.rpts[23],self.rpts[24]]],['left_shoulder_waist',[self.rpts[11],self.rpts[23]]],['right_shoulder_waist',[self.rpts[12],self.rpts[24]]],['right_thigh',[self.rpts[24],self.rpts[26]]],['left_thigh',[self.rpts[23],self.rpts[25]]],['right_leg',[self.rpts[26],self.rpts[28]]],['left_leg',[self.rpts[25],self.rpts[27]]],['right_forearm',[self.rpts[14],self.rpts[16]]],['left_forearm',[self.rpts[13],self.rpts[15]]],['right_bicep',[self.rpts[12],self.rpts[14]]],['left_bicep',[self.rpts[11],self.rpts[13]]]]\\n self.linelist.points=[]\\n self.linelist.header.frame_id = \\\"kinect_frame\\\"\\n self.linelist.header.stamp = rospy.Time.now()\\n self.linelist.type = Marker.LINE_LIST\\n \\n self.linelist.id=1\\n self.linelist.action = Marker.ADD \\n self. linelist.scale.x = 0.05\\n\\n self.linelist.color.g = 1.0\\n self.linelist.color.a = 1.0\\n\\n \\n\\n for _,pointl in body:\\n for pt in pointl:\\n depth_val=float(depth_arr[pt[1], pt[0]])\\n ptl_x,ptl_y,ptl_z=self.depth_to_xyz(pt[0],pt[1],depth_val)\\n \\n self.linelist_point=Point()\\n self.linelist_point.x = ptl_x\\n self.linelist_point.y = ptl_y\\n self.linelist_point.z = ptl_z\\n self.linelist.points.append(self.linelist_point)\\n \\n except:\\n pass\",\n \"def backtracking(self,image,out,image_list):\\r\\n loop=self.parent_orignal_data[self.goal_score]\\r\\n \\r\\n\\r\\n path=[self.goal]\\r\\n \\r\\n while int(self.start_score)!=int(loop) :\\r\\n \\r\\n \\r\\n parent_pos=self.data_with_string[loop]\\r\\n \\r\\n loop=self.parent_orignal_data[loop]\\r\\n index=self.data_with_string[loop]\\r\\n action_pair=self.action_index[loop]\\r\\n if index==self.start:\\r\\n break\\r\\n cv2.line(image,(parent_pos[1],self.maximum_size-parent_pos[0]),(index[1],self.maximum_size-index[0]),(255,0,0),1)\\r\\n #path.append(index)\\r\\n path.append(action_pair)\\r\\n image[self.maximum_size-index[0],index[1],:]=255,0,0\\r\\n out.write(image)\\r\\n cv2.imshow(\\\"image\\\",image)\\r\\n if cv2.waitKey(1) & 0xFF==ord('q'):\\r\\n\\r\\n\\r\\n break\\r\\n image_list.append(image)\\r\\n while True:\\r\\n cv2.imshow(\\\"image\\\",image)\\r\\n if cv2.waitKey(0) & 0xFF==ord('q'):\\r\\n \\r\\n \\r\\n break\\r\\n return path,image_list\",\n \"def find_reddest_pixel_fast(img): \\n img = np.array(img, dtype = 'int32')\\n location = cv2.minMaxLoc((img[:, :, 2] - img[:, :, 1]) + (img[:, :, 2] - img[:, :, 0]))[3]\\n return location\",\n \"def find_DPRIPs (roadline,windline):\\r\\n DPRIPs=[]\\r\\n ID = []\\r\\n i = 0 \\r\\n for w in windline:\\r\\n int_pt=[]\\r\\n for r in roadline:\\r\\n if w.intersection(r): \\r\\n int_pt.append(w.intersection(r))\\r\\n if len(int_pt)!=0: \\r\\n DPRIPs.append(int_pt)\\r\\n ID.append(1)\\r\\n else: \\r\\n ID.append(-999)\\r\\n i = i + 1\\r\\n \\r\\n source['road_access'] = ID\\r\\n #source with road access downiwnd \\r\\n swrad = source[source.road_access != -999]\\r\\n \\r\\n return swrad,DPRIPs\",\n \"def localize_pixel(img_pos,camera : Camera,lidar : Lidar, scan : LaserScan) -> tuple:\\n\\n # ---OBJ--\\n # x r1 /\\\\ r2 x\\n # / \\\\\\n #cam_ray / \\\\ average_ray\\n # / \\\\\\n # / \\\\\\n # CAM ----> LID\\n # \\n\\n # has to be 2d\\n assert (img_pos.size == 2)\\n\\n cam_ray = camera.get_ray_through_image(img_pos)\\n\\n cam_ray_robot = camera.get_ray_in_robot_frame(cam_ray)\\n\\n cam_ray_lidar = lidar.get_ray_in_lidar_frame(cam_ray_robot)\\n\\n # flatten camera ray\\n cam_ray_lidar_flat = lidar.get_ray_projection(cam_ray_lidar)\\n\\n # figure out which lidar rays correspond to the camera ray\\n (ray1,ray2) = lidar.get_corresponding_lidar_rays(cam_ray_lidar_flat,scan)\\n\\n # if no rays found corresponding to scan data\\n if ray1 is None or ray2 is None:\\n return (None,None)\\n\\n # get the normal to the lidar hit\\n intersection_normal = lidar.get_normal_to_plane(ray1,ray2)\\n\\n # get the distance data in horizontal plane, from lidar to object\\n lidar_to_target_length = lidar.get_camera_ray_length(cam_ray_lidar_flat,ray1,ray2)\\n\\n # get the vector from camera to lidar (flattened to lidar plane)\\n # i.e. origin of lidar frame in camera frame\\n lidar_to_cam_vec = cam_ray_lidar_flat.origin\\n cam_to_lidar_flat = Ray(lidar_to_cam_vec,-lidar_to_cam_vec,np.linalg.norm(lidar_to_cam_vec))\\n \\n # now workout the lidar to object ray, i.e. interpolate between ray1's and ray2's tips\\n lidar_to_object_flat = interpolated_ray(ray1,ray2,0.5,lidar_to_target_length)\\n\\n # now finally workout the vector from camera to object (flattened)\\n # this lets us access the true z-distance in the camera\\n cam_to_object_flat = lidar_to_object_flat.get_vec() + cam_to_lidar_flat.get_vec()\\n \\n cam_to_object_flat_length = np.linalg.norm(cam_to_object_flat)\\n\\n # angle from horizontal on camera ray\\n cam_ray_theta = angle_between(cam_ray_lidar.get_vec(),cam_to_object_flat)\\n\\n # length of original camera ray (knowing the length of its projection)\\n # will fail if ray is pointing straight up or down\\n cam_ray_robot.length = cam_to_object_flat_length / math.cos(cam_ray_theta)\\n\\n\\n object_robot = cam_ray_robot.get_vec()+cam_ray_robot.origin\\n\\n return (object_robot,intersection_normal)\",\n \"def _render_image(self):\\n\\n self._render_static_image_annotation()\\n\\n if self._goal_robot_pose is not None:\\n # Render the goal pose as the robot is driving to target...\\n self._goal_robot_pose.header.stamp = self._image_time # AHHHHH THIS IS NOT \\n self._tf_listener.waitForTransform('/map',\\n self._image_info.tf_frame, \\n self._image_time,\\n rospy.Duration(4))\\n\\n self._goal_robot_pose.pose.position.z = 1.5 # force goal point to be 1.5m\\n pose = self._tf_listener.transformPose(self._image_info.tf_frame,\\n self._goal_robot_pose)\\n u, v = self._image_info.project3dToPixel((pose.pose.position.x,\\n pose.pose.position.y,\\n pose.pose.position.z))\\n self._goal_robot_pose.pose.position.z=1.45 # force goal point to be 1.5m\\n pose = self._tf_listener.transformPose(self._image_info.tf_frame,\\n self._goal_robot_pose)\\n u2, v2 = self._image_info.project3dToPixel((pose.pose.position.x,\\n pose.pose.position.y,\\n pose.pose.position.z))\\n radius = int(math.sqrt((u2-u)**2 + (v2-v)**2))\\n if radius < 100:\\n cv2.putText(self._image, \\\"Goal Location\\\", (int(u+radius+1), int(v+radius+1)),\\n cv2.FONT_HERSHEY_SIMPLEX, radius/10.0, 255, radius/200 * 3)\\n cv2.circle(self._image, (int(u),int(v)), radius, (0,0,255,127),-1)\\n\\n\\n\\n if self._point_clouds is not None:\\n # Render the bouding boxes of objects...\\n # Project each response cluster into image\\n box_locations = []\\n print\\n for i, (cloud, label) in enumerate(zip(self._point_clouds, self._labels)):\\n print \\\"Object \\\",i,\\\"/\\\",len(self._point_clouds)\\n location = self._project_pointcloud(cloud)\\n print location\\n box_locations.append(location)\\n cv2.rectangle(self._image,\\n location[0],location[1],\\n (255, 0, 0),\\n 3)\\n cv2.putText(self._image, label,\\n (location[0][0], location[0][1]-10),\\n cv2.FONT_HERSHEY_SIMPLEX, 0.5, 255, 2)\",\n \"def execute_waypoint_sequence(detail_of_trip):\\n\\n # rets (route_line, line_points)\\n sliced_route_and_line_points = chunk_user_route(detail_of_trip)\\n\\n sliced_route = sliced_route_and_line_points[0]\\n line_points = sliced_route_and_line_points[1]\\n\\n # Interpolate/Break into 1/10 segments\\n segmented_points = interpolate_points(sliced_route, line_points)\\n waypoints = find_crime_areas(segmented_points)\\n\\n # print \\\"segmented_points\\\", json.dumps(segmented_points, indent=2)\\n print \\\"\\\\n\\\\n\\\\n\\\\n\\\" # compensating for the giant GET request\\n return waypoints\",\n \"def find_roads(\\n probability_map,\\n *,\\n input_threshold=0.3,\\n max_roads=None,\\n min_strength=0.17, #0.2,\\n num_angles=720,\\n roads_min_angle=np.pi/8,\\n roads_min_distance=50,\\n debugimage=None, # for debugging ...\\n debugprint=None): # for debugging ...\\n\\n # shorthand\\n im = probability_map\\n\\n # the angles to be used in the Hough transform\\n theta = np.linspace(-np.pi/2, np.pi/2, num_angles)\\n\\n # normalize almost anything to grayscale\\n if im.ndim == 3:\\n if im.shape[2] == 4:\\n im = im[:,:,:3] # throw away alpha\\n im = im.mean(axis=2) # convert RGB to grayscale\\n\\n if debugimage: debugimage('original', im, 0, 1, 'jet')\\n\\n assert im.ndim == 2\\n\\n if debugimage:\\n hspace, _, _ = hough_line(im, theta)\\n debugimage('original_hough_hspace', hspace)\\n\\n # create monochrome/binary input map\\n im[im >= input_threshold] = 1\\n im[im < input_threshold] = 0\\n\\n if debugimage: debugimage('threshold_applied', im)\\n\\n # Hough transform\\n hspace, angles, distances = hough_line(im, theta)\\n\\n hspace = np.asarray(hspace, dtype=np.float32)\\n hspace /= hspace.max() # normalize\\n\\n if debugimage: debugimage('hough_hspace', hspace)\\n\\n # convolution filters, rectangular, tuned for widths of 12, 32, 48 pixels\\n w12 = np.concatenate([-np.ones((6)), np.ones((12)), -np.ones((6))])\\n w32 = np.concatenate([-np.ones((16)), np.ones((32)), -np.ones((16))])\\n w48 = np.concatenate([-np.ones((24)), np.ones((48)), -np.ones((24))])\\n\\n # convolve\\n im12 = ndi.filters.convolve1d(hspace, w12, axis=0)\\n im32 = ndi.filters.convolve1d(hspace, w32, axis=0)\\n im48 = ndi.filters.convolve1d(hspace, w48, axis=0)\\n\\n # normalize signal strengths for different road widths\\n im12 /= 12\\n im32 /= 32\\n im48 /= 48\\n\\n ca = (None, None, 'jet',)\\n if debugimage: debugimage('hough_hspace_conv12', im12, *ca)\\n if debugimage: debugimage('hough_hspace_conv32', im32, *ca)\\n if debugimage: debugimage('hough_hspace_conv48', im48, *ca)\\n if debugimage:\\n debugimage('hough_hspace_combined',\\n np.hstack([im12, im32, im48]), *ca)\\n\\n # compute possible roads of all widths, sorted by signal strength\\n seq = np.stack((im12, im32, im48)).flatten()\\n sor = np.argsort(seq)\\n roads = np.column_stack((\\n seq,\\n np.tile(np.tile(angles, distances.shape[0]), 3),\\n np.tile(np.repeat(distances, angles.shape[0]), 3),\\n np.repeat([12, 32, 48], distances.shape[0] * angles.shape[0])\\n ))[sor][::-1]\\n\\n # columns: strength, angle, distance, width\\n found_roads = np.asarray([]).reshape(0, 4)\\n\\n # find as many as strong roads as desired, while dropping roads that are too\\n # similar to roads already found (non-max suppression)\\n for i in range(roads.shape[0]):\\n if roads[i,0] < min_strength:\\n break\\n a = roads[i,1]\\n d = roads[i,2]\\n close = (\\n np.logical_or(\\n np.logical_and(\\n np.abs(found_roads[:,1]-a) < roads_min_angle,\\n np.abs(found_roads[:,2]-d) < roads_min_distance),\\n np.logical_and(\\n np.pi - np.abs(found_roads[:,1]-a) < roads_min_angle,\\n np.abs(found_roads[:,2]+d) < roads_min_distance)))\\n if not np.any(close):\\n found_roads = np.vstack((found_roads, roads[i]))\\n if max_roads is not None and found_roads.shape[0] >= max_roads:\\n break\\n\\n return found_roads, im.shape\",\n \"def main():\\n camera = picamera.PiCamera()\\n camera.resolution = (RESOLUTIONX, RESOLUTIONY)\\n camera.iso = 800\\n time.sleep(2)\\n while True:\\n camera.capture('current-image.jpg')\\n adapt_steering(navigation.get_xposition('current-image.jpg'))\\n time.sleep(0.4)\",\n \"def do_intensity_projection(points, proj_W , proj_H, proj_fov_up, proj_fov_down, fn, idx):\\n\\n # print(points.shape)\\n\\n points = points[points.any(axis=1)]\\n\\n proj_range = np.zeros((proj_H, proj_W),\\n dtype=np.float64)\\n\\n # unprojected range (list of depths for each point)\\n unproj_range = np.zeros((0, 1), dtype=np.float32)\\n\\n # projected point cloud xyz - [H,W,3] xyz coord (-1 is no data)\\n proj_xyz = np.full((proj_H, proj_W, 4), -1,\\n dtype=np.float32)\\n\\n # projected remission - [H,W] intensity (-1 is no data)\\n proj_remission = np.full((proj_H, proj_W), -1,\\n dtype=np.float32)\\n\\n # projected index (for each pixel, what I am in the pointcloud)\\n # [H,W] index (-1 is no data)\\n proj_idx = np.full((proj_H, proj_W), -1,\\n dtype=np.int32)\\n\\n # for each point, where it is in the range image\\n proj_x = np.zeros((0, 1), dtype=np.int32) # [m, 1]: x\\n proj_y = np.zeros((0, 1), dtype=np.int32) # [m, 1]: y\\n\\n # mask containing for each pixel, if it contains a point or not\\n proj_mask = np.zeros((proj_H, proj_W),\\n dtype=np.int32) # [H,W] mask\\n\\n\\n\\n\\n # laser parameters\\n fov_up = proj_fov_up / 180.0 * np.pi # field of view up in rad\\n fov_down = proj_fov_down / 180.0 * np.pi # field of view down in rad\\n fov = abs(fov_down) + abs(fov_up) # get field of view total in rad\\n\\n\\n \\n depth = np.linalg.norm(points[:,:3], 2, axis=1)\\n\\n # print(points[:10,:])\\n \\n\\n # get scan components\\n scan_x = points[:, 0]\\n scan_y = points[:, 1]\\n scan_z = points[:, 2]\\n\\n # get angles of all points\\n yaw = -np.arctan2(scan_y, scan_x) \\n pitch = np.arcsin(scan_z / depth)\\n\\n # get projections in image coords\\n proj_x = 0.5 * (yaw / np.pi + 1.0) # in [0.0, 1.0]\\n proj_y = 1.0 - (pitch + abs(fov_down)) / fov # in [0.0, 1.0]\\n\\n proj_x = np.nan_to_num(proj_x)\\n\\n proj_y = np.nan_to_num(proj_y)\\n # scale to image size using angular resolution\\n proj_x *= proj_W # in [0.0, W]\\n proj_y *= proj_H # in [0.0, H]\\n\\n \\n \\n\\n # round and clamp for use as index\\n proj_x = np.floor(proj_x)\\n proj_x = np.minimum(proj_W - 1, proj_x)\\n proj_x = np.maximum(0, proj_x).astype(np.int32) # in [0,W-1]\\n proj_x = np.copy(proj_x) # store a copy in orig order\\n\\n proj_y = np.floor(proj_y)\\n proj_y = np.minimum(proj_H - 1, proj_y)\\n proj_y = np.maximum(0, proj_y).astype(np.int32) # in [0,H-1]\\n\\n proj_y = np.copy(proj_y) # stope a copy in original order\\n\\n\\n # # copy of depth in original order\\n # unproj_range = np.copy(depth)\\n\\n # indices = np.arange(depth.shape[0])\\n # order = np.argsort(depth)[::-1]\\n # depth = depth[order]\\n # indices = indices[order]\\n # points = points[order]\\n\\n # proj_y = proj_y[order]\\n # proj_x = proj_x[order]\\n \\n\\n if DATASET_TYPE == \\\"kitti\\\":\\n intensities = points[:,3]\\n print(\\\"kitti\\\")\\n # intensities = np.minimum(intensities, 1000)\\n # i_min = intensities.min()\\n # i_max = intensities.max()\\n # intensities = (intensities - i_min)/(i_max - i_min)\\n\\n\\n\\n if DATASET_TYPE == \\\"mulran\\\" or DATASET_TYPE == \\\"mulran2\\\":\\n intensities = points[:,3]\\n intensities = np.minimum(intensities, 1000)\\n i_min = intensities.min()\\n i_max = intensities.max()\\n \\n intensities = (intensities - i_min)/(i_max - i_min)\\n\\n if DATASET_TYPE == \\\"dso\\\":\\n \\n \\n \\n intensities = points[:,4]\\n \\n\\n minval = np.percentile(intensities, 2)\\n maxval = np.percentile(intensities, 98)\\n intensities = np.clip(intensities, minval, maxval)\\n # intensities = np.maximum(intensities, 5000)\\n # intensities = np.sqrt(intensities)\\n\\n \\n\\n\\n \\n i_min = intensities.min()\\n i_max = intensities.max()\\n\\n intensities = (intensities - i_min)/(i_max - i_min)\\n\\n \\n\\n\\n \\n\\n \\n\\n \\n \\n\\n\\n \\n \\n \\n \\n \\n pixel_tracker = {}\\n pc_tracker = {}\\n # print(proj_x.shape)\\n # print(scan_x.shape)\\n\\n \\n proj_3d_corres = np.zeros((proj_H, proj_W, 3),\\n dtype=np.float64)\\n\\n # print(proj_x[:20])\\n # print(proj_y[:70])\\n \\n \\n for i in range(proj_x.shape[0]):\\n x_val = proj_x[i]\\n y_val = proj_y[i]\\n\\n \\n\\n if proj_range[y_val, x_val] != 0:\\n continue\\n\\n \\n \\n intensity = intensities[i]\\n \\n \\n \\n \\n proj_range[y_val, x_val] = intensity\\n \\n proj_3d_corres[y_val,x_val, :] = np.array([scan_x[i], scan_y[i], scan_z[i]])\\n \\n\\n\\n \\n proj_range *= 255\\n\\n\\n \\n \\n \\n \\n proj_range = np.array(proj_range, dtype=np.uint8)\\n\\n \\n newPicPath = None\\n\\n\\n \\n\\n\\n img = Image.fromarray(proj_range, 'L')\\n pc_name = fn.split('.')[0]\\n newPicPath = os.path.join(CURRENT_DIR, \\\"intensity_images\\\", \\\"mulran_\\\" + (str(idx)) + \\\".png\\\")\\n img.save(newPicPath)\\n\\n\\n return newPicPath, proj_3d_corres, proj_range\",\n \"def _get_closest_light_ahead(self, pose):\\n #\\n # we have very few lights in either the simulation or the live test,\\n # so it is easiest just to loop thru them rather than use KDTree\\n #\\n pos = pose.position\\n x = pos.x\\n y = pos.y\\n closest_idx = -1\\n closest_dist2 = None\\n idx = 0\\n for light in self.lights:\\n xl = light.pose.pose.position.x\\n yl = light.pose.pose.position.y\\n\\n #\\n # make sure light is ahead, otherwise ignore it\\n # we can only do this if the car velocity is nonzero\\n #\\n skip_light = False\\n if self.velocity_unit_vector:\\n dx = xl - x\\n dy = yl - y\\n car_to_light = [dx,dy]\\n val = self.dot2d(car_to_light,self.velocity_unit_vector)\\n if val < 0.0:\\n #\\n # light is behind us so continue\\n #\\n skip_light = True\\n\\n if not skip_light:\\n if closest_dist2 is None:\\n closest_idx = idx\\n closest_dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\\n else:\\n dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\\n if dist2 < closest_dist2:\\n closest_idx = idx\\n closest_dist2 = dist2\\n idx+=1\\n \\n return closest_idx\",\n \"def render_dof(scene, camera, HEIGHT=100, WIDTH=100, V_SAMPLES=6, H_SAMPLES=6):\\n output = np.zeros((HEIGHT, WIDTH, RGB_CHANNELS), dtype=np.uint8)\\n if not scene or scene.is_empty() or not camera or camera.inside(\\n scene.objects\\n ):\\n print(\\\"Cannot generate an image\\\")\\n return output\\n total_samples = H_SAMPLES * V_SAMPLES\\n # This is for showing progress %\\n iterations = HEIGHT * WIDTH * total_samples\\n step_size = np.ceil((iterations * PERCENTAGE_STEP) / 100).astype('int')\\n counter = 0\\n bar = Bar('Raytracing', max=100 / PERCENTAGE_STEP)\\n # This is needed to use it in Git Bash\\n bar.check_tty = False\\n for j in range(HEIGHT):\\n for i in range(WIDTH):\\n color = np.array([0, 0, 0], dtype=float)\\n lens_sample_offsets = []\\n n0 = camera.n0\\n n1 = camera.n1\\n for n in range(V_SAMPLES):\\n for m in range(H_SAMPLES):\\n r0, r1 = np.random.random_sample(2)\\n ap_sx = camera.lens_params.ap_sx\\n ap_sy = camera.lens_params.ap_sy\\n x_offset = ((r0 - 0.5) * m) / H_SAMPLES * ap_sx\\n y_offset = ((r1 - 0.5) * n) / V_SAMPLES * ap_sy\\n lens_sample_offsets.append((x_offset, y_offset))\\n random_start = np.random.random_integers(0, total_samples - 1)\\n for n in range(V_SAMPLES):\\n for m in range(H_SAMPLES):\\n r0, r1 = np.random.random_sample(2)\\n x = i + ((float(m) + r0) / H_SAMPLES)\\n y = HEIGHT - 1 - j + ((float(n) + r1) / V_SAMPLES)\\n # Get x projected in view coord\\n xp = (x / float(WIDTH)) * camera.scale_x\\n # Get y projected in view coord\\n yp = (y / float(HEIGHT)) * camera.scale_y\\n pp = camera.p00 + xp * camera.n0 + yp * camera.n1\\n npe = utils.normalize(pp - camera.position)\\n sample_idx = n + m * H_SAMPLES - random_start\\n x_offset, y_offset = lens_sample_offsets[sample_idx]\\n ps = pp + x_offset * n0 + y_offset * n1\\n fp = pp + npe * camera.lens_params.f\\n director = utils.normalize(fp - ps)\\n ray = Ray(ps, director)\\n\\n color += raytrace(ray, scene) / float(total_samples)\\n counter += 1\\n if counter % step_size == 0:\\n bar.next()\\n output[j][i] = color.round().astype(np.uint8)\\n bar.finish()\\n return output\",\n \"def getLightSensor() -> int:\\n pass\",\n \"def illustrate_driving_lane_with_topdownview(image, left_line, right_line):\\n\\n rows, cols = image.shape[:2]\\n window_img = np.zeros_like(image)\\n\\n window_margin = 56\\n left_plotx, right_plotx = left_line, right_line\\n ploty = left_line\\n lane_width = right_line[0] - left_line[0]\\n lane_center = (right_line[0] + left_line[0]) / 2\\n lane_offset = cols / 2 - (2*left_line[0] + lane_width) / 2\\n car_offset = int(lane_center - 360)\\n \\n # Generate a polygon to illustrate the search window area\\n # And recast the x and y points into usable format for cv2.fillPoly()\\n left_line_window1 = np.array([np.transpose(np.vstack([right_plotx + lane_offset - lane_width - window_margin / 4, ploty]))])\\n left_line_window2 = np.array([np.flipud(np.transpose(np.vstack([right_plotx + lane_offset - lane_width+ window_margin / 4, ploty])))])\\n left_line_pts = np.hstack((left_line_window1, left_line_window2))\\n right_line_window1 = np.array([np.transpose(np.vstack([right_plotx + lane_offset - window_margin / 4, ploty]))])\\n right_line_window2 = np.array([np.flipud(np.transpose(np.vstack([right_plotx + lane_offset + window_margin / 4, ploty])))])\\n right_line_pts = np.hstack((right_line_window1, right_line_window2))\\n\\n # Draw the lane onto the warped blank image\\n cv.fillPoly(window_img, np.int_([left_line_pts]), (140, 0, 170))\\n cv.fillPoly(window_img, np.int_([right_line_pts]), (140, 0, 170))\\n\\n # Recast the x and y points into usable format for cv2.fillPoly()\\n pts_left = np.array([np.transpose(np.vstack([right_plotx + lane_offset - lane_width + window_margin / 4, ploty]))])\\n pts_right = np.array([np.flipud(np.transpose(np.vstack([right_plotx + lane_offset - window_margin / 4, ploty])))])\\n pts = np.hstack((pts_left, pts_right))\\n\\n # Draw the lane onto the warped blank image\\n cv.fillPoly(window_img, np.int_([pts]), (0, 160, 0))\\n\\n #window_img[10:133,300:360] = img\\n road_map = Image.new('RGBA', image.shape[:2], (0, 0, 0, 0))\\n window_img = Image.fromarray(window_img)\\n road_map.paste(window_img, (0, 0))\\n road_map = np.array(road_map)\\n road_map = cv.resize(road_map, (95, 95))\\n road_map = cv.cvtColor(road_map, cv.COLOR_BGRA2BGR)\\n\\n return road_map\",\n \"def my_lane_detection_pipeline(image, debug_images=False):\\n\\n # Step 1 - Filter and enhance image by lane color\\n image_s1 = filter_lane_color(image)\\n \\n # Step 2 - Canny edge detection with Gaussian blur and region mask\\n image_s2 = detect_lane_edges(image_s1)\\n \\n # Step 3 - Raw line detection by Hough transform and classify left/right by angle\\n (image_s3, left_lines, right_lines) = detect_lane_lines(image_s2, image)\\n \\n # Step 4 - Set left/right lanes by weighted linear polyfit of raw lines\\n image_s4 = set_lanes(left_lines, right_lines, image_s3)\\n \\n # Save images of each step for debugging and documentation\\n if debug_images:\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s0.jpg'), image)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s1.jpg'), image_s1, cmap = 'gray')\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s2.jpg'), image_s2)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s3.jpg'), image_s3)\\n mpimg.imsave('test_images_output/'+image_name.replace('.jpg','_s4.jpg'), image_s4)\\n \\n # Output image with overlaid raw lane lines and detected left/right lanes\\n return image_s4\",\n \"def main():\\n # color = rb.Color.BLUE.value\\n # move_to_color(color)\\n infared_sensor()\\n\\n # WHITE/RED does not work same with the BLUE/GREEN going down\",\n \"def recognize_color(self):\\n x = (self.x + DIRECTIONS[(self.facing_direction - self.config) % 8][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[(self.facing_direction - self.config) % 8][1]) % (self.image.shape[1] - 1)\\n color_left = self.image[x, y]\\n if abs(self.luminance(color_left) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.turn_left\\n x = (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\\n color_forward = self.image[x, y]\\n if abs(self.luminance(color_forward) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.move_forward\\n x = (self.x + DIRECTIONS[(self.facing_direction + self.config) % 8][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[(self.facing_direction + self.config) % 8][1]) % (self.image.shape[1] - 1)\\n color_right = self.image[x, y]\\n if abs(self.luminance(color_right) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.turn_right\\n return None\",\n \"def __init__(self, roi_warped_points):\\n\\n # was the line detected in the last iteration?\\n self.detected = False\\n # x values of the last n fits of the line\\n self.recent_xfitted = []\\n #average x values of the fitted line over the last n iterations\\n self.bestx = None\\n #polynomial coefficients averaged over the last n iterations\\n self.best_fit = [np.array([False])]\\n #polinomial coefficients for the last n fits of the lane\\n self.recent_fit = []\\n #polynomial coefficients for the most recent fit\\n self.current_fit = [np.array([False])]\\n #radius of curvature of the line in some units\\n self.radius_of_curvature = 0\\n #distance in meters of vehicle center from the line\\n self.line_base_pos = 0\\n #difference in fit coefficients between last and new fits\\n self.diffs = np.array([0,0,0], dtype='float')\\n #x values for detected line pixels\\n self.allx = None\\n #maximum number of iterations to average\\n self.max_n = 10 #25\\n\\n # roi image points in bird's view space\\n self.roi_warped_points = roi_warped_points\\n\\n #y values for detected line pixels\\n self.ally = np.linspace(0, self.roi_warped_points[2][1] - 1, self.roi_warped_points[2][1])\\n\\n # line base pos is calculated through the roi information\\n # the used four point ROI has two points at the bottom that are straight\\n # with respect to the bottom - as this points are right next to the lines,\\n # they can be translated from pixels into meters with the knowledge of\\n # a U.S. highway standard lane - this is an apprximation, but should be\\n # good enough for this project\\n # U.S. regulations minimum lane width: 3.7m\\n self.xm_per_pix = 3.7 / (self.roi_warped_points[1][0] - self.roi_warped_points[0][0])\\n\\n # each dashed line is 3m long --> about 33m for warped image\\n self.ym_per_pix = 33 / (self.roi_warped_points[2][1] - self.roi_warped_points[0][1])\",\n \"def route(self, ori, dest, pois):\\n #find one route from ori to dest\\n departure_time = int(time.time())\\n routes = util.query_routes(origin=ori, \\n destination=dest,\\n departure_time=departure_time)\\n if routes is None or routes['status'] != \\\"OK\\\":\\n print ',=====',routes\\n return None\\n\\n route = routes[\\\"routes\\\"][0] #get the first route\\n\\n #get the points in the route to search the potential poi\\n points = util.extract_points(route)\\n\\n if points is None or len(points) ==0:\\n print \\\"Error in extracting points\\\"\\n return None\\n #get the candiates in the route\\n candidates = []\\n way_points = pois.split(\\\"|\\\")\\n for point in points:\\n information = {}\\n information[\\\"location\\\"] = point\\n for way_p in way_points:\\n response = util.get_nearby_points(location=point, keyword=way_p)\\n if response is None or response[\\\"status\\\"] != \\\"OK\\\":\\n information[way_p] = []\\n continue\\n ps = []\\n for result in response[\\\"results\\\"]:\\n poi = {\\\"geometry\\\": result[\\\"geometry\\\"],\\n \\\"name\\\": result[\\\"name\\\"],\\n \\\"price_level\\\": result.get(\\\"price_level\\\", None),\\n \\\"rating\\\": result.get(\\\"rating\\\", None),\\n \\\"vicinity\\\": result[\\\"vicinity\\\"]}\\n ps.append(poi)\\n information[way_p] = ps\\n candidates.append(information)\\n \\n cost_matrix = waypoint.find_waypoints([candidates], way_points)\\n cost_matrix.sort(key=lambda x:x[1])\\n\\n top_candidate = cost_matrix[0]\\n json.dump(top_candidate, open('./top_candidate.json','w'))\\n final_route = self.get_direction(ori, dest, top_candidate)\\n json.dump(final_route, open(\\\"./real_route.json\\\", \\\"w\\\"))\\n\\n return final_route, top_candidate\",\n \"def locate_tracker(self, debug):\\n\\n # tmp_image =\\n # tmp_image = cv2.GaussianBlur(self.frame, (11, 11), 0) # Experiment with this\\n\\n hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) # Convert to HSV Color Space. This is temporary for testing using colored objects)\\n\\n mask = cv2.inRange(hsv, self.hueLower, self.hueUpper)\\n\\n try:\\n mask = cv2.inRange(hsv, self.hueLower2, self.hueUpper2) + mask\\n except AttributeError:\\n pass\\n\\n mask = cv2.erode(mask, None, iterations=2)\\n mask = cv2.dilate(mask, None, iterations=2)\\n\\n if debug:\\n tmpMask = imutils.resize(mask, width=1000, height=1000)\\n cv2.imshow(\\\"mask\\\", tmpMask)\\n\\n\\n # find contours in the mask and initialize the current (x, y) center of the object\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n center = None\\n\\n # only proceed if at least one contour was found\\n if len(cnts) > 0:\\n # find the largest contour in the mask, then use\\n # it to compute the minimum enclosing circle and\\n # centroid\\n c = max(cnts, key=cv2.contourArea)\\n\\n ((x, y), radius) = cv2.minEnclosingCircle(c)\\n M = cv2.moments(c)\\n center = (int(M[\\\"m10\\\"] / M[\\\"m00\\\"]), int(M[\\\"m01\\\"] / M[\\\"m00\\\"]))\\n\\n # only proceed if the radius meets a minimum size\\n # if radius > 10:\\n # # draw the circle and centroid on the frame,\\n # # then update the list of tracked points\\n # cv2.circle(frame, (int(x), int(y)), int(radius),\\n # (0, 255, 255), 2)\\n # cv2.circle(frame, center, 5, (0, 0, 255), -1)\\n if debug:\\n cv2.drawContours(self.frame, c, -1, (0, 255, 0), 20)\\n return center, radius\\n # update the points queue\\n cv2.imshow(\\\"mask\\\", imutils.resize(mask, width=1000, height=1000))\\n cv2.imshow(\\\"frame\\\", imutils.resize(self.frame, width=1000, height=1000))\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n raise OpenCVError(\\\"Could not find tracker!\\\")\\n\\n # return (1, 1), 1\",\n \"def run_record(self, state, pipeline, record_path):\\n e1 = cv2.getTickCount()\\n while state.record_btn:\\n # Wait for a coherent pair of frames: depth and color\\n frames = pipeline.wait_for_frames()\\n depth_frame = frames.get_depth_frame()\\n color_frame = frames.get_color_frame()\\n if not depth_frame or not color_frame:\\n continue\\n \\n # filter\\n depth_frame = self.th_filter.process(depth_frame)\\n depth_frame = self.sp_filter.process(depth_frame)\\n depth_frame = self.tmp_filter.process(depth_frame)\\n\\n depth_colormap = self.colorizer.colorize(depth_frame)\\n # Convert images to numpy arrays\\n depth_image = np.asanyarray(depth_colormap.get_data())\\n color_image = np.asanyarray(color_frame.get_data())\\n\\n lane_masked = self.lane_detector.detect(color_image)\\n # Show images\\n stacked_imgs = (color_image, depth_image, lane_masked)\\n images = np.hstack(stacked_imgs)\\n cv2.resizeWindow(state.WIN_NAME, \\n self.width*len(stacked_imgs), \\n self.height)\\n cv2.imshow(state.WIN_NAME, images)\\n cv2.setMouseCallback(state.WIN_NAME, state.mouse_controll)\\n key = cv2.waitKey(1)\\n if key == 27:\\n state.app_btn = False\\n state.record_btn = False\\n break\\n # Calculate Runtime Tick to quit\\n e2 = cv2.getTickCount()\\n tick = int((e2 - e1) / cv2.getTickFrequency())\\n # Save images per tick\\n if self.saveimg:\\n color_file = record_path / f\\\"color-{tick}.npy\\\"\\n depth_file = record_path / f\\\"depth-{tick}.npy\\\"\\n ps_file = record_path / f\\\"ps-{tick}.ply\\\"\\n if not ps_file.exists():\\n np.save(color_file, color_image)\\n np.save(depth_file, depth_image)\\n \\n # Create point cloud\\n if self.savepc and (not ps_file.exists()):\\n points = self.pc.calculate(depth_frame)\\n self.pc.map_to(depth_frame)\\n points.export_to_ply(str(ps_file), color_frame)\\n\\n if tick > self.record_time:\\n print(\\\"Finish Record\\\")\\n state.app_btn = False\\n state.record_btn = False\\n cv2.destroyAllWindows()\\n break\\n\\n if not state.app_btn:\\n break\",\n \"def apply(self, image):\\n\\n bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\\n\\n # Convert to float image\\n float_im = bgr.copy().astype('float32') / 255\\n blurred = cv2.GaussianBlur(float_im, ksize=(9, 9), sigmaX=1, sigmaY=9)\\n cplanes = colors.bgr2cpaces(blurred)\\n lanes, py, pw = finder.find_lane_pixels(cplanes, self.pfilter, gamma=0.4)\\n\\n binary = lanes\\n\\n # Find lanes and fit curves\\n if not self.curve:\\n self.sw.find(binary)\\n self.curve= CurveSearch(self.sw.left_fit, self.sw.right_fit,\\n image_size=self.warped_image_size, margin=20)\\n lane = self.sw.visualize_lane()\\n curve_rad = self.measure_curvature(self.sw.left_fit, self.sw.right_fit)\\n offset = self.measure_offset(self.sw.left_fit, self.sw.right_fit)\\n else:\\n self.curve.find(binary)\\n lane = self.curve.visualize_lane()\\n curve_rad = self.measure_curvature(self.curve.left_fit, self.curve.right_fit)\\n offset = self.measure_offset(self.curve.left_fit, self.curve.right_fit)\\n\\n non_warped_lane = self.warp_inverse(lane)\\n\\n result = cv2.addWeighted(image, 1, non_warped_lane, 0.3, 0)\\n cv2.putText(result, \\\"Curve Radius: {:.0f}m\\\".format(curve_rad), (50,50), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,255,255))\\n cv2.putText(result, \\\"Off Center: {:.2f}m\\\".format(offset), (50, 100),\\n cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255))\\n\\n return result\",\n \"def _route_chunk(data, host_url, annotations='duration', retries=10, extra_params=None):\\n\\t# offsets are used to make correct indice of the result dataframe\\n\\tsources, destinations, sources_offset, destinations_offset = data\\n\\tsources_count = len(sources)\\n\\tdestinations_count = len(destinations)\\n\\n\\t# OSRM takes all points as one list, and then numbers of sources & dests in it\\n\\tall_points = sources + destinations\\n\\tencoded = encode_poly([(p.y, p.x) for p in all_points])\\n\\n\\t# numerate sources & dests. sources come first\\n\\tsource_numbers = ';'.join(map(str, range(sources_count)))\\n\\tdestination_numbers = ';'.join(map(str,\\n\\t\\trange(sources_count, sources_count + destinations_count)))\\n\\n\\n\\textra_params = extra_params or {}\\n\\tparams = {\\n\\t\\t'sources': source_numbers,\\n\\t\\t'destinations': destination_numbers,\\n\\t\\t'generate_hints': 'false',\\n\\t\\t'annotations': annotations,\\n\\t\\t**extra_params\\n\\t}\\n\\n\\tencoded_params = urllib.parse.quote_plus(urllib.parse.urlencode(params))\\n\\t# if we pass url and params separately to requests.get, it will make a malformed URL\\n\\tencoded_url = f'{host_url}/table/v1/driving/polyline({encoded})?{encoded_params}'\\n\\tresp = get_retry(encoded_url, {}, retries)\\n\\n\\tif resp.status_code != 200:\\n\\t\\traise RuntimeError(f'OSRM server responded with {resp.status_code} code. Content: {resp.content}')\\n\\n\\tresp_data = resp.json()\\n\\tif resp_data.get('code', 'Ok') != 'Ok':\\n\\t\\traise RuntimeError(f'OSRM server responded with error message: {resp_data[\\\"message\\\"]}')\\n\\n\\t# if 'duration' is requested, then take resp_data['durations'], or resp_data['distances'] if distances.\\n\\t# also, 'duration,distance' might be requested, then take both and concatenate results (= join columns)\\n\\tresults = []\\n\\t\\n\\tfor key in annotations.split(','):\\n\\t\\tdf = pd.DataFrame(resp_data[f'{key}s']).reset_index().rename(columns={'index': 'source'}).melt(id_vars='source', var_name='destination', value_name=key)\\n\\t\\tdf[key] = df[key].astype(float)\\n\\t\\tif len(results) > 0:\\n\\t\\t\\t# only append the data column\\n\\t\\t\\tresults.append(df[[key]])\\n\\t\\telse:\\n\\t\\t\\tresults.append(df)\\n\\n\\tresult_df = pd.concat(results, axis=1)\\n\\n\\t# snapping distances\\n\\tresult_df['source_snap'] = result_df.source.map(pd.DataFrame(resp_data['sources'])['distance'])\\n\\tresult_df['destination_snap'] = result_df.destination.map(pd.DataFrame(resp_data['destinations'])['distance'])\\n\\n\\t# instead of join/merge lookup\\n\\tresult_df['geometry'] = result_df['source'].map({i: g for i, g in enumerate(sources)})\\n\\tresult_df['geometry_dest'] = result_df['destination'].map({i: g for i, g in enumerate(destinations)})\\n\\n\\t# shift back by the given offset\\n\\tresult_df['destination'] = result_df['destination'].astype(int) + destinations_offset\\n\\tresult_df['source'] = result_df['source'].astype(int) + sources_offset\\n\\treturn result_df\",\n \"def edge_detect_slide(self):\\r\\n img = self.master.images[-1] # Use the displayed image to perform edge detection\\r\\n gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Convert BGR image to Grayscale\\r\\n transformed_dim = edge_detector.edge_detector(gray_image, self.horizontal.get()) # Perform sobel edge\\r\\n # detection on grayscale image\\r\\n transformed_dim = transformed_dim.astype('float32') # Convert the transformed image into 8 bit float\\r\\n color_image = cv2.cvtColor(transformed_dim, cv2.COLOR_GRAY2BGR) # Convert the grayscale transformed image\\r\\n # back to BGR\\r\\n self.master.display_image.display_image(img=color_image) # Display the edge map\\r\\n self.master.images.append(color_image) # Append the displayed image to the stack\\r\",\n \"def extract(self, files):\\n for i in range(len(files)):\\n print(files[i])\\n img = cv2.imread('{}/{}'.format('{}/{}/{}'.format(DIR_2DST_Mask, self.patient, self.plan), files[i]), 0)\\n\\n \\\"\\\"\\\"\\n Find the indices of array elements that are non-zero, i.e,\\n find the pixels' positions that represents the respiratory\\n functions (pixels in the respiratory function are brighter).\\n \\\"\\\"\\\"\\n color_pts = np.argwhere(img > 70)\\n\\n \\\"\\\"\\\"\\n Sorts the pixels according to their x coordenate.\\n Obs: np.argwhere inverts x and y, it's like (y, x), because of it,\\n the parameter of itemgetter is 1 (to get x coordinate)\\n \\\"\\\"\\\"\\n lcolor_pts = sorted(color_pts.tolist(), key=itemgetter(1))\\n\\n \\\"\\\"\\\"\\n If there is no pixel representing the respiratory function\\n (i.e., lighter pixel) it creates an empty image (without any\\n respiratory function)\\n \\\"\\\"\\\"\\n if len(lcolor_pts) == 0:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open(\\n # '{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], []))\\n # file.close()\\n\\n continue\\n\\n # Reverse the coordinates and store the result in lordered_pts list\\n lordered_pts = []\\n for j in range(len(lcolor_pts)):\\n lordered_pts.append(lcolor_pts[j][::-1])\\n\\n \\\"\\\"\\\"\\n Convert pixels coordinates into a tuples and check which column\\n has pixels that corresponding to diaphragmatic level\\n Obs. There are some columns that doesnt have any pixel that\\n correpond to diaphragmatic level.\\n \\\"\\\"\\\"\\n # Columns that have a pixel corresponding diaphragmatic level\\n lcolumn_available = []\\n for j in range(len(lordered_pts)):\\n lordered_pts[j] = tuple(lordered_pts[j])\\n lcolumn_available.append(lordered_pts[j][0])\\n lcolumn_available = list(set(lcolumn_available))\\n # print(\\\"Ordered points: \\\", lordered_pts)\\n # print(\\\"Columns available: \\\", lcolumn_available)\\n\\n \\\"\\\"\\\"\\n If there is not enough columns to build a respiratory pattern,\\n create a blank image\\n \\\"\\\"\\\"\\n if len(lcolumn_available) < 20:\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n continue\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n first column, assign to it the value of the second y coordinate\\n \\\"\\\"\\\"\\n if lcolumn_available[0] is not 0:\\n y = max(\\n [x for x in lordered_pts if x[0] == lcolumn_available[0]],\\n key=itemgetter(1))[1]\\n lordered_pts.insert(0, (0, y))\\n lcolumn_available.insert(0, 0)\\n\\n \\\"\\\"\\\"\\n If there are no pixel that corresponding diaphragmatic level in the\\n last column, assign to it the value of the penultimate y coordinate\\n available\\n \\\"\\\"\\\"\\n if lcolumn_available[-1] is not 49:\\n lordered_pts.append(\\n (49, lordered_pts[len(lcolumn_available)][1]))\\n lcolumn_available.append(49)\\n\\n \\\"\\\"\\\"\\n Get the biggest y value in each column that represents the\\n diaphragmatic level\\n \\\"\\\"\\\"\\n column = 0\\n lcolumn = []\\n ldiaphragm_pts = []\\n for j in range(50):\\n # Get the column's points\\n lcolumn = [x for x in lordered_pts if x[0] == column]\\n # print('{}: {}'.format(j, lcolumn))\\n\\n if len(lcolumn) > 0:\\n ldiaphragm_pts.append(\\n max(lcolumn, key=itemgetter(1))) # Get the biggest y\\n else:\\n # Get the y value from the previous column\\n lcolumn_available.insert(column, column)\\n ldiaphragm_pts.append((column, ldiaphragm_pts[-1][1]))\\n column += 1\\n lcolumn = []\\n\\n # Draw diaphragmatic level\\n diaphragmatic_lvl = np.zeros((256, 50, 3), np.uint8)\\n j = 0\\n while(j < len(lcolumn_available) - 1):\\n cv2.line(\\n diaphragmatic_lvl,\\n ldiaphragm_pts[j], ldiaphragm_pts[j + 1],\\n (0, 0, 255), 1)\\n j = j + 1\\n\\n lcolumn_available = []\\n\\n print(\\\"Diaphragmatic's points: \\\", ldiaphragm_pts)\\n cv2.imshow('Diaphragmatic level', diaphragmatic_lvl)\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n cv2.imwrite('{}/{}/{}/{}'.format(\\n DIR_2DST_Diaphragm, patient, plan, files[i]), diaphragmatic_lvl)\\n\\n # file = open('{}/{}/{}/points.txt'.format(DIR_2DST_Diaphragm, self.patient, self.plan), 'a')\\n # file.write(\\\"{}:{}\\\\n\\\".format(files[i], ldiaphragm_pts))\\n # file.close()\\n\\n # return ldiaphragm_pts\",\n \"def flicker_lights(self):\\n print 'Lights Set'\",\n \"def skywalker(this, **kargs):\\n\\t\\t\\n\\t\\t# Arguments\\n\\t\\tbin = kargs.get('bin', this._BINARY)\\n\\t\\toffshore = kargs.get('offshore', 5)\\n\\t\\tminSize = kargs.get('minSize', 3)\\n\\t\\tblur = kargs.get('blur', False)\\n\\t\\t\\n\\t\\tif blur: # Flou de test\\n\\t\\t\\tkernel = np.ones((3, 3), np.float32)/9\\n\\t\\t\\tbin = cv2.filter2D(bin, -1, kernel)\\n\\t\\t\\n\\t\\t# On duplique l'image pour le rendu final\\n\\t\\tscan = EmptyFrom(bin, 3)\\n\\t\\tscan[:,:,0] = scan[:,:,1] = scan[:,:,2] = bin\\n\\t\\tthis._SCAN = scan\\n\\t\\t\\n\\t\\tstep = 0 # Compteur de pas dans le vide\\n\\t\\tstart, end = None, None\\n\\t\\t\\n\\t\\t# Dimensions de l'image à scanner\\n\\t\\tsize = D2Point(width(bin), height(bin))\\n\\t\\tratio = size if minSize < 1 else 1\\n\\t\\t\\n\\t\\t# Scan pixel par pixel, en partant du bas\\n\\t\\tfor v in xrange(int(size.y)-1, -1, -1):\\n\\t\\t\\tfor u in xrange(int(size.x)):\\n\\t\\t\\t\\n\\t\\t\\t\\tif bin.item((v, u)): # Si un pixel != 0:\\n\\t\\t\\t\\t\\tscan[v,u] = [0, 0, 255] # Rouge.\\n\\t\\t\\t\\t\\tstep = 0 # On reset le jump\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t# Si c'est le premier\\n\\t\\t\\t\\t\\tif not start:\\n\\t\\t\\t\\t\\t\\tstart = D2Point(u, v)\\n\\t\\t\\t\\t\\t\\tend = D2Point(u, v)\\n\\t\\t\\t\\t\\telse: # On trace\\n\\t\\t\\t\\t\\t\\tend.x, end.y = u, v\\n\\t\\t\\t\\t\\n\\t\\t\\t\\telif end:\\n\\t\\t\\t\\t\\tif step < offshore:\\n\\t\\t\\t\\t\\t\\tscan[v,u] = [0, 255, 255] # Jaune\\n\\t\\t\\t\\t\\t\\tstep += 1 # On continue\\n\\t\\t\\t\\t\\telif abs((start - end)/ratio) < minSize:\\n\\t\\t\\t\\t\\t\\tstart, end = None, None\\n\\t\\t\\t\\t\\telse: break\\n\\t\\t\\t\\t# elif end: break\\n\\t\\t\\t###\\n\\t\\t\\tif end: break\\n\\t\\t###\\n\\t\\t\\n\\t\\tif end: # Si on a trouvé une fin\\n\\t\\t\\t\\n\\t\\t\\t# Point médian = doigt\\n\\t\\t\\tresult = start % end\\n\\t\\t\\t\\n\\t\\t\\t# Visuel\\n\\t\\t\\tscan[:,result.x,:] = [0, 255, 0] # On trace une bande verte\\n\\t\\t\\tscan[result.y,:,:] = [0, 127, 0] # On trace une autre bande verte\\n\\t\\t\\t\\n\\t\\t\\t# Reformatage\\n\\t\\t\\tresult /= size-1 # On remet en ratio d'image\\n\\t\\t\\tresult.x = 1 - result.x # On inverse le côté de mesure\\n\\t\\t\\t\\n\\t\\t\\t# Stockage\\n\\t\\t\\tthis._DETECTED = result # On stocke le point détecté\\n\\t\\t\\tthis._BOTTOM = result.y == 1 # On clic ou bien ?\\n\\t\\t\\n\\t\\t# Si rien\\n\\t\\telse:\\n\\t\\t\\tresult = None\\n\\t\\t\\tthis._BOTTOM = False\\n\\t\\t\\n\\t\\t# Tchao\\n\\t\\treturn result\",\n \"def process(self, source0):\\r\\n self.__hsl_threshold_input = source0\\r\\n self.cameraInput = source0\\r\\n (self.hsl_threshold_output) = self.__hsl_threshold(self.__hsl_threshold_input, self.__hsl_threshold_hue, self.__hsl_threshold_saturation, self.__hsl_threshold_luminance)\\r\\n\\r\\n # Step RGB_Threshold0:\\r\\n \\\"\\\"\\\"\\r\\n self.__rgb_threshold_input = source0\\r\\n self.cameraInput = source0\\r\\n (self.rgb_threshold_output) = self.__rgb_threshold(self.__rgb_threshold_input,\\r\\n self.__rgb_threshold_red, self.__rgb_threshold_green, self.__rgb_threshold_blue)\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n # Step CV_erode0:\\r\\n self.__cv_erode_src = self.hsl_threshold_output\\r\\n (self.cv_erode_output) = self.__cv_erode(self.__cv_erode_src, self.__cv_erode_kernel,\\r\\n self.__cv_erode_anchor, self.__cv_erode_iterations, self.__cv_erode_bordertype, self.__cv_erode_bordervalue)\\r\\n\\r\\n # Step Find_Contours0:\\r\\n self.__find_contours_input = self.cv_erode_output\\r\\n (self.find_contours_output) = self.__find_contours(\\r\\n self.__find_contours_input, self.__find_contours_external_only)\",\n \"def main():\\n\\n # connect to the hue bridge\\n bridge = phue.Bridge()\\n bridge.connect() # throw an exception if connection was not established\\n\\n tracker = beat_tracker.BeatTracker()\\n tracker.start()\\n try:\\n\\n # obtain a list of lights to control\\n lights = get_lights(bridge)\\n\\n x = 0\\n ids = [l.light_id for l in lights]\\n\\n while True:\\n\\n time_between_beats = (60.0 / tracker.tempo)\\n\\n combos = [\\n [1, 0],\\n [1, 254],\\n [1, 0],\\n [500, 254],\\n ]\\n x = (x + 1) % 4\\n\\n temp, _brightness = combos[x]\\n\\n adjust = int(_brightness * (int(tracker.volume / 1500.0) * 2))\\n\\n if tracker.volume < 1000:\\n adjust = 0\\n\\n brightness = int(min(adjust, 254))\\n on = bool(tracker.volume > 800)\\n command = {\\\"ct\\\": temp, \\\"bri\\\": brightness, \\\"transitiontime\\\": 1, \\\"on\\\": on}\\n bridge.set_light(ids, command)\\n\\n if time_between_beats > 1:\\n time.sleep(1)\\n else:\\n time.sleep(time_between_beats)\\n\\n finally:\\n tracker.stop()\",\n \"def tokens_to_data_pairs(nusc: NuScenes,\\n cam_sd_tokens: List[str],\\n rad_sd_tokens: List[str],\\n depth: float, threshold: float) -> list(zip()):\\n rgb_images_list = []\\n for i in range(len(cam_sd_tokens)):\\n cam_sd_path = nusc.get_sample_data_path(cam_sd_tokens[i])\\n if not os.path.isfile(cam_sd_path):\\n continue\\n #im = Image.open(cam_sd_path)\\n #im = im.resize((IMAGE_WIDTH, IMAGE_HEIGHT), Image.BILINEAR)\\n img = cv2.imread(cam_sd_path)\\n #Resize with Bilinear interpolation\\n img = cv2.resize(img, (IMAGE_WIDTH, IMAGE_HEIGHT))\\n img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n rgb_images_list.append(img)\\n\\n radar_pcl_list = []\\n for i in range(len(rad_sd_tokens)):\\n rad_sd_path = nusc.get_sample_data_path(rad_sd_tokens[i])\\n if not os.path.isfile(rad_sd_path):\\n continue\\n #radar_pcl = RadarPointCloud.from_file(rad_sd_path, invalid_states = range(18), dynprop_states = range(18), ambig_states = range(18))\\n #radar_pcl = RadarPointCloud.from_file(rad_sd_path, invalid_states = None, dynprop_states = [0,2,6], ambig_states = None)\\n radar_pcl = RadarPointCloud.from_file(rad_sd_path)\\n # radar_pcl.points.shape is (18, num_points)\\n radar_pcl.points, dist_list = filter_pointcloud(radar_pcl.points, threshold)\\n # radar_pcl.points.shape became (3, num_points)\\n #RADNET expects shape (num_points, 4)\\n radar_pcl.points = radar_pcl.points.transpose()\\n #radar_pcl.points = radar_pcl.points[:, :3]\\n #radar_pcl.points = radar_pcl.points[radar_pcl.points[:, 0] < depth]\\n radar_pcl.points = np.hstack((radar_pcl.points, np.ones((radar_pcl.points.shape[0], 1), dtype=radar_pcl.points.dtype)))\\n\\n radar_pcl_list.append(radar_pcl)\\n\\n assert(len(rgb_images_list) == len(radar_pcl_list))\\n image_radar_pairs = list(zip(rgb_images_list, radar_pcl_list))\\n\\n del rgb_images_list\\n del radar_pcl_list\\n\\n return image_radar_pairs\",\n \"def follow_road(self):\\n\\n steering_net = SteeringNet()\\n steering_net.load(const.Storage.DEFAULT_STEERING_MODEL)\\n\\n self.start_driving()\\n\\n with Camera.instance() as camera:\\n while self.recorder_thread is not None:\\n image = camera.image\\n predicted_angle = steering_net.predict(image, self.angle)\\n self.angle = predicted_angle\\n\\n time.sleep(0.25)\\n\\n self.stop_driving()\",\n \"def node_route_data(th_object, topology_info, file_name):\\n route_information(th_object, topology_info, file_name, \\\"20\\\", \\\"91\\\", \\\"extracted_data/Route_data/\\\")\\n route_information(th_object, topology_info, file_name, \\\"22\\\", \\\"91\\\", \\\"extracted_data/Route_data/\\\")\\n route_information(th_object, topology_info, file_name, \\\"22\\\", \\\"71\\\", \\\"extracted_data/Route_data/\\\")\",\n \"def initiate_path_tracking(self, compress = False): \\r\\n\\r\\n start_contour = -1\\r\\n \\r\\n # input active particle and target particle\\r\\n while start_contour == -1:\\r\\n self.__define_particle('ActiveParticle')\\r\\n active_pos = mouse_click_pos\\r\\n self.__define_particle('Target')\\r\\n target_pos = mouse_click_pos\\r\\n \\r\\n start_contour = self.__get_contour_num(active_pos)\\r\\n print(start_contour)\\r\\n \\r\\n end_contour = self.__get_contour_num(target_pos)\\r\\n print(end_contour)\\r\\n\\r\\n start_x, start_y = self.centers[start_contour]\\r\\n if end_contour != -1:\\r\\n end_x, end_y = self.centers[end_contour]\\r\\n else:\\r\\n end_x, end_y = target_pos\\r\\n \\r\\n ret, not_image = cv2.threshold(self.image,127,255,cv2.THRESH_BINARY)\\r\\n \\r\\n masked_image = mask_particle_rect(not_image, self.boundRect[start_contour], (255,255,255))\\r\\n\\r\\n if end_contour != -1:\\r\\n masked_image = mask_particle_rect(masked_image, self.boundRect[end_contour], (255,255,255))\\r\\n \\r\\n\\r\\n path, runs = find_path(masked_image, (start_x,start_y), (end_x, end_y),\\r\\n 4, int(self.radius[start_contour]*3), compress)\\r\\n\\r\\n \\r\\n path_image = self.image\\r\\n\\r\\n for i in range(len(path)-1):\\r\\n x_start, y_start = path[i]\\r\\n x_end, y_end = path[i+1]\\r\\n\\r\\n path_image = cv2.line(path_image,(x_start,y_start),(x_end,y_end),(100,100,100),2)\\r\\n \\r\\n cv2.imshow('image', path_image)\\r\\n cv2.waitKey(0)\\r\\n cv2.destroyAllWindows()\\r\\n \\r\\n return path, self.boundRect[start_contour]\",\n \"def lineFollowTillIntersectionPID(kp = 1.0, ki = 0, kd = 0, color = ColorSensor(INPUT_1), color2 = ColorSensor(INPUT_3), \\n robot = MoveSteering(OUTPUT_A, OUTPUT_B)): # *an intersection is a line that is going through the line that the robot is following\\n \\n color.mode = 'COL-REFLECT' #setting color mode\\n color2.mode = 'COL-REFLECT' #setting color mode\\n lasterror = 0 \\n sound = Sound()\\n while color2.reflected_light_intensity <= Constants.WHITE and False == Constants.STOP:\\n error = color.reflected_light_intensity - ((Constants.WHITE + Constants.BLACK)/2) # colorLeft.reflected_light_intensity - colorRight.reflected_light_intensity\\n # correction = error * GAIN # correction = PID(error, lasterror, kp, ki, kd)\\n correction = PIDMath(error=error, lasterror = lasterror, kp=kp, ki=ki, kd=kd)\\n if correction > 100: correction = 100\\n if correction < -100: correction = -100\\n robot.on(speed = 20, steering = correction)\\n lasterror = error\\n sound.beep()\\n robot.off()\",\n \"def detect_lanes(binary_warped):\\n histogram = np.sum(binary_warped[(binary_warped.shape[0] // 2):, :], axis=0)\\n out_img = np.dstack((binary_warped, binary_warped, binary_warped)) * 255\\n\\n midpoint = np.int(histogram.shape[0] / 2)\\n leftx_base = np.argmax(histogram[:midpoint])\\n rightx_base = np.argmax(histogram[midpoint:]) + midpoint\\n\\n nwindows = 9\\n\\n window_height = np.int(binary_warped.shape[0] / nwindows)\\n\\n nonzero = binary_warped.nonzero()\\n nonzeroy = np.array(nonzero[0])\\n nonzerox = np.array(nonzero[1])\\n\\n # Current positions to be updated for each window\\n leftx_current = leftx_base\\n rightx_current = rightx_base\\n\\n # Set the width of the windows +/- margin\\n margin = 100\\n\\n # Set minimum number of pixels found to recenter window\\n minpix = 50\\n\\n # Create empty lists to receive left and right lane pixel indices\\n left_lane_inds = []\\n right_lane_inds = []\\n\\n # Step through the windows one by one\\n for window in range(nwindows):\\n # Identify window boundaries in x and y (and right and left)\\n win_y_low = binary_warped.shape[0] - (window + 1) * window_height\\n win_y_high = binary_warped.shape[0] - window * window_height\\n win_xleft_low = leftx_current - margin\\n win_xleft_high = leftx_current + margin\\n win_xright_low = rightx_current - margin\\n win_xright_high = rightx_current + margin\\n\\n # Draw the windows on the visualization image\\n cv2.rectangle(out_img, (win_xleft_low, win_y_low), (win_xleft_high, win_y_high), (0, 255, 0), 2)\\n cv2.rectangle(out_img, (win_xright_low, win_y_low), (win_xright_high, win_y_high), (0, 255, 0), 2)\\n\\n # Identify the nonzero pixels in x and y within the window\\n good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xleft_low) &\\n (nonzerox < win_xleft_high)).nonzero()[0]\\n good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) & (nonzerox >= win_xright_low) &\\n (nonzerox < win_xright_high)).nonzero()[0]\\n\\n # Append these indices to the lists\\n left_lane_inds.append(good_left_inds)\\n right_lane_inds.append(good_right_inds)\\n\\n # If you found > minpix pixels, recenter next window on their mean position\\n if len(good_left_inds) > minpix:\\n leftx_current = np.int(np.mean(nonzerox[good_left_inds]))\\n if len(good_right_inds) > minpix:\\n rightx_current = np.int(np.mean(nonzerox[good_right_inds]))\\n\\n # Concatenate the arrays of indices\\n left_lane_inds = np.concatenate(left_lane_inds)\\n right_lane_inds = np.concatenate(right_lane_inds)\\n\\n # Extract left and right line pixel positions\\n leftx = nonzerox[left_lane_inds]\\n lefty = nonzeroy[left_lane_inds]\\n rightx = nonzerox[right_lane_inds]\\n righty = nonzeroy[right_lane_inds]\\n\\n # Fit a second order polynomial to each\\n left_fit = np.polyfit(lefty, leftx, 2)\\n right_fit = np.polyfit(righty, rightx, 2)\\n\\n # Visualize\\n ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])\\n left_fitx = left_fit[0] * ploty ** 2 + left_fit[1] * ploty + left_fit[2]\\n right_fitx = right_fit[0] * ploty ** 2 + right_fit[1] * ploty + right_fit[2]\\n\\n out_img[nonzeroy[left_lane_inds], nonzerox[left_lane_inds]] = [255, 0, 0]\\n out_img[nonzeroy[right_lane_inds], nonzerox[right_lane_inds]] = [0, 0, 255]\\n\\n return Lane(left_fit, right_fit, left_fitx, right_fitx, leftx, rightx, lefty, righty), out_img\",\n \"def exportLights(self):\\n\\t\\t#TODO! REMOVE CONSTRAINS\\n\\t\\tlights = mc.ls( typ=['light','aiAreaLight','aiSkyDomeLight','aiVolumeScattering','aiSky'], l=1 )\\n\\t\\tmc.editRenderLayerGlobals( currentRenderLayer = 'defaultRenderLayer' )\\n\\t\\tlitsToExport = []\\n\\t\\tfor li in lights:\\n\\t\\t\\tfinalLi = li.split( '|' )\\n\\t\\t\\tif len(finalLi) == 1:\\n\\t\\t\\t\\tlitsToExport.append( finalLi[0] )\\n\\t\\t\\telse:\\n\\t\\t\\t\\tlitsToExport.append( finalLi[1] )\\n\\t\\tif litsToExport:\\n\\t\\t\\tmc.select( litsToExport, r=1, ne=1 )\\n\\t\\t\\tmc.file( self.lightPath.path, op=\\\"v=0\\\", typ=\\\"mayaAscii\\\", pr=1, es=1 )\\n\\t\\t\\t#export Light Linking\\n\\t\\t\\tself.exportLightLinking()\",\n \"def get_light_state(self, light):\\n if (not self.has_image):\\n self.prev_light_loc = None\\n return TrafficLight.UNKNOWN\\n\\n rgb = self.bridge.imgmsg_to_cv2(self.camera_image)\\n\\n if self.use_classifier:\\n light_state = self.light_classifier.get_classification(rgb)\\n rospy.logdebug('inference: {} / ground truth {}'.format(\\n light_state, light.state))\\n else:\\n light_state = light.state\\n\\n if self.save_images:\\n dist_to_light = self.calculate_distance(\\n self.pose.pose.position.x, light.pose.pose.position.x,\\n self.pose.pose.position.y, light.pose.pose.position.y)\\n\\n if dist_to_light <= self.save_images_min_dist:\\n bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)\\n cv2.imwrite(\\\"./data/test/test-{}-{}.{}.jpg\\\".format(\\n light_state, light.state, self.camera_image.header.seq),\\n bgr)\\n\\n return light_state\",\n \"def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\\n f = h5py.File(filename, \\\"r\\\")\\n meta_file = h5py.File(str(filename).replace(\\\"RESULT.erfh5\\\", \\\"meta_data.hdf5\\\"), 'r')\\n\\n try:\\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\\n multi_states = self.__get_pressure_data(f)\\n multi_states = multi_states.squeeze()\\n\\n activated_sensors = np.count_nonzero(multi_states, axis=1)\\n percentage_of_all_sensors = activated_sensors / 1140\\n len_wanted_seq = 100\\n current = 0\\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\\n frame_labels = []\\n\\n if self.aux_info:\\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\\n sample_percentages = np.full(len_wanted_seq, np.nan)\\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\\n\\n for i, sample in enumerate(single_states):\\n state_num = int(str(sample).replace(\\\"state\\\", \\\"0\\\"))\\n try:\\n sample_percentage = percentage_of_all_sensors[state_num - 1]\\n if sample_percentage >= current / len_wanted_seq:\\n data = multi_states[state_num - 1, :]\\n data = np.log(np.add(data, 1)) # TODO make log optional\\n if self.sensor_indizes != ((0, 1), (0, 1)):\\n rect = data.reshape(38, 30)\\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\\n data = sel.flatten()\\n sequence[current, :] = data\\n\\n frame_label = 0\\n if state_num in set_of_states:\\n frame_label = 1\\n frame_labels.append(frame_label)\\n\\n if self.aux_info:\\n original_frame_idxs[current] = state_num\\n frame_labels_aux[current] = frame_label\\n sample_percentages[current] = sample_percentage\\n single_state_indices[current] = i\\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\\n # norm_coords=_coords, data=flat_fillings[i])\\n current += 1\\n except IndexError:\\n continue\\n\\n # determine runlevel label using frame labels and threshold\\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\\n groupby(np.array(frame_labels) == 1) if key]\\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\\n label = 0 if max_len < threshold_min_counted_dryspots else 1\\n\\n f.close()\\n meta_file.close()\\n\\n if self.aux_info:\\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\\n aux = {\\\"framelabel\\\": frame_labels_aux,\\n \\\"original_frame_idx\\\": original_frame_idxs,\\n \\\"original_num_multi_states\\\": len(multi_states),\\n \\\"percent_of_sensors_filled\\\": sample_percentages,\\n \\\"single_state_indices\\\": single_state_indices,\\n }\\n return [(sequence, label, aux)]\\n\\n return [(sequence, label)]\\n except KeyError:\\n f.close()\\n meta_file.close()\\n return None\",\n \"def GEEviLandsat(ptsFile,metric,timeStep,sensor,buf,poly,username,folderOut, scalePix = 30):\\n \\n # load required libraries\\n import ee\\n import math\\n \\n # Initialize the Earth Engine object, using the authentication credentials.\\n ee.Initialize()\\n\\n ID_field = \\\"geeID\\\"\\n\\n #load pts or poly file\\n pts1 = ee.FeatureCollection('users/' + username + '/' + str(ptsFile))\\n\\n #define dictionary for raster random names\\n sensor_d = {}\\n sensor_d['L4'] = 'LANDSAT/LT04/C01/T1_SR'\\n sensor_d['L5'] = 'LANDSAT/LT05/C01/T1_SR'\\n sensor_d['L7'] = 'LANDSAT/LE07/C01/T1_SR'\\n sensor_d['L8'] = 'LANDSAT/LC08/C01/T1_SR'\\n\\n time_d = {}\\n time_d['lowest'] = 'rl'\\n time_d['month'] = 'rm'\\n time_d['year'] = 'ry'\\n \\n \\n #Computes the bits we need to extract.\\n def getQABits(image, start, end, newName):\\n pattern = 0\\n listB = list(range(start, end+1))\\n for one in listB:\\n pattern += math.pow(2, one)\\n pattern = int(pattern)\\n \\n return (image.select([0], [newName])\\n .bitwiseAnd(pattern)\\n .rightShift(start))\\n \\n for sen in sensor:\\n LS = ee.ImageCollection(sensor_d[sen])\\n #senL = [sen]\\n \\n def maskbyBits(img):\\n QA = img.select('pixel_qa')\\n QA1 = getQABits(QA, 3, 3, 'QA')\\n QA2 = getQABits(QA, 5, 5, 'QA')\\n\\n mask = QA1.eq(0).And(QA2.eq(0))\\n return img.updateMask(mask)\\n \\n LSm = LS.map(maskbyBits)\\n \\n lastImage = ee.Image(ee.ImageCollection(sensor_d[sen])\\n .sort('system:time_start',False)\\n .first())\\n lastImageDate = lastImage.get('system:index').getInfo()\\n\\n firstImage = ee.Image(ee.ImageCollection(sensor_d[sen])\\n .sort('system:time_start',True)\\n .first())\\n firstImageDate = firstImage.get('system:index').getInfo()\\n \\n startYear = int(firstImageDate[(len(firstImageDate)-8):(len(firstImageDate)-4)])\\n endYear = int(lastImageDate[(len(lastImageDate)-8):(len(lastImageDate)-4)])\\n startMonth = int(firstImageDate[(len(firstImageDate)-4):(len(firstImageDate)-2)])\\n endMonth = int(lastImageDate[(len(lastImageDate)-4):(len(lastImageDate)-2)])-1\\n startYearAll = startYear + 1\\n endYearAll = endYear - 1\\n \\n years = list(range(startYear, endYearAll + 1))\\n monthsEE = ee.List(list(range(startMonth,(12*len(years)+endMonth))))\\n yearsEE = ee.List(list(range(startYearAll, endYearAll + 1)))\\n \\n for met in metric:\\n # metL = [met]\\n\\n if (sen == 'L8' and met == \\\"NDVI\\\"):\\n bands = ['B5', 'B4']\\n elif (sen != 'L8' and met == \\\"NDVI\\\"):\\n bands = ['B4', 'B3']\\n elif (sen == 'L8' and met == \\\"NDWI\\\"):\\n bands = ['B5', 'B6']\\n elif (sen != 'L8' and met == \\\"NDWI\\\"):\\n bands = ['B4', 'B5']\\n elif (sen == 'L8' and met == \\\"NBR\\\"):\\n bands = ['B5', 'B7']\\n elif (sen != 'L8' and met == \\\"NBR\\\"):\\n bands = ['B4', 'B7']\\n #else:\\n #print(\\\"wrong metric specified\\\")\\n \\n def addVI(image):\\n vi = (image.normalizedDifference(bands)\\n .rename('VI'))\\n return image.addBands(vi)\\n\\n withVI = LSm.map(addVI)\\n\\n VI_col = withVI.select('VI')\\n\\n if timeStep == 'year':\\n\\n def map_m(i):\\n i = ee.Number(i).int()\\n image2 = (VI_col\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .first())\\n filtered = (VI_col\\n .filter(ee.Filter.calendarRange(i, i, 'year'))\\n .mean()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(yearsEE.map(map_m).flatten())\\n\\n elif timeStep == 'month':\\n \\n def map_m(i):\\n i = ee.Number(i)\\n y = i.divide(12).add(years[0]).int()\\n m = i.mod(12).add(1)\\n image2 = (VI_col\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .first())\\n filtered = (VI_col\\n .filter(ee.Filter.calendarRange(m, m, 'month'))\\n .filter(ee.Filter.calendarRange(y, y, 'year'))\\n .mean()\\n .copyProperties(image2,['system:time_start','system:time_end']))\\n return filtered\\n\\n img_col = ee.ImageCollection(monthsEE.map(map_m).flatten())\\n\\n elif timeStep == 'lowest':\\n\\n img_col = VI_col\\n\\n #else:\\n #print(\\\"incorrect time step specified\\\")\\n \\n if buf > 0:\\n bufL = [buf]\\n def bufferPoly(feature):\\n return feature.buffer(bufL[0])\\n\\n ptsB = pts1.map(bufferPoly)\\n def table_m(image):\\n table = (image\\n .select('VI')\\n .reduceRegions(collection = ptsB.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_ptsB',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n \\n #print ('buffered pts by:' + str(buf) + ' for Landsat: ' + sen + '_' + met)\\n\\n elif poly > 0:\\n \\n def table_m(image):\\n table = (image\\n .select('VI')\\n .reduceRegions(collection = pts1.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_poly1',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n \\n #print ('spatial mean in poly: no buffer for Landsat: ' + sen + '_' + met)\\n\\n else:\\n def table_m(image):\\n table = (image\\n .select('VI')\\n .reduceRegions(collection = pts1.select([ID_field]),\\n reducer = ee.Reducer.mean(),\\n scale = scalePix))\\n \\n def table_add_date(f):\\n return f.set('startDate', ee.Date(image.get('system:time_start')))\\n\\n return table.map(table_add_date)\\n\\n triplets = img_col.map(table_m).flatten()\\n\\n task_tc = ee.batch.Export.table.toDrive(collection = triplets\\n .filter(ee.Filter.neq('mean', None))\\n .select(['.*'],None,False),\\n description = str(time_d[timeStep])+'_'+str(sen)+'_'+str(met)+'_'+str(years[0])+'_'+str(years[len(years)-1])+'_pts1',\\n folder = folderOut,\\n fileFormat = 'CSV')\\n task_tc.start()\\n \\n #print('value at point: no buffer for Landsat: ' + sen + '_' + met)\",\n \"def extract_dl(driving_log_path):\\r\\n entries = []\\r\\n with open(driving_log_path) as csv_file:\\r\\n reader = csv.reader(csv_file)\\r\\n for entry in reader:\\r\\n entries.append(entry)\\r\\n empty_lists = [[] for i in range(7)]\\r\\n center_images, left_images, right_images, steerings, throttles, brakes, speeds = empty_lists\\r\\n for entry in entries:\\r\\n center_image_path, left_image_path, right_image_path = (entry[0], entry[1], entry[2])\\r\\n steering = float(entry[3])\\r\\n throttle = float(entry[4])\\r\\n brake = float(entry[5])\\r\\n speed = float(entry[6])\\r\\n center_image = cv2.imread(center_image_path)\\r\\n left_image = cv2.imread(left_image_path)\\r\\n right_image = cv2.imread(right_image_path)\\r\\n center_images.append(center_image)\\r\\n left_images.append(left_image)\\r\\n right_images.append(right_image)\\r\\n steerings.append(steering)\\r\\n throttles.append(throttle)\\r\\n brakes.append(brake)\\r\\n speeds.append(speed)\\r\\n return center_images, left_images, right_images, steerings, throttles, brakes, speeds\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7070285","0.7041899","0.6967643","0.6816919","0.6754921","0.6677822","0.6675664","0.6624752","0.6600227","0.64905286","0.6460968","0.63963324","0.6225359","0.6108355","0.6083328","0.5994978","0.59109867","0.57418406","0.5628054","0.5600468","0.55992246","0.5542279","0.5537093","0.55325854","0.53636366","0.5335605","0.53278154","0.5301768","0.5290622","0.5289048","0.5271774","0.52578026","0.5254543","0.5227274","0.52113366","0.5209796","0.51951116","0.5186564","0.5185572","0.51643896","0.51584464","0.5149973","0.514594","0.51448274","0.5118089","0.5081654","0.5076476","0.5036513","0.5024359","0.5019114","0.50169945","0.5006375","0.4971211","0.4963762","0.49565342","0.4952645","0.49432552","0.4942781","0.49407694","0.49241787","0.49114698","0.4909416","0.4896564","0.48953786","0.48928103","0.48919275","0.4890787","0.48893875","0.487771","0.4872182","0.4870892","0.48652783","0.48482534","0.4845878","0.48319632","0.4827728","0.48258334","0.48140988","0.48112863","0.48045522","0.47910815","0.47875008","0.47828528","0.47800112","0.4778378","0.47768825","0.4774901","0.47679612","0.47651106","0.47523946","0.47505277","0.4743397","0.47380027","0.4734965","0.47313014","0.47302133","0.47294894","0.4722157","0.4716952","0.47130758"],"string":"[\n \"0.7070285\",\n \"0.7041899\",\n \"0.6967643\",\n \"0.6816919\",\n \"0.6754921\",\n \"0.6677822\",\n \"0.6675664\",\n \"0.6624752\",\n \"0.6600227\",\n \"0.64905286\",\n \"0.6460968\",\n \"0.63963324\",\n \"0.6225359\",\n \"0.6108355\",\n \"0.6083328\",\n \"0.5994978\",\n \"0.59109867\",\n \"0.57418406\",\n \"0.5628054\",\n \"0.5600468\",\n \"0.55992246\",\n \"0.5542279\",\n \"0.5537093\",\n \"0.55325854\",\n \"0.53636366\",\n \"0.5335605\",\n \"0.53278154\",\n \"0.5301768\",\n \"0.5290622\",\n \"0.5289048\",\n \"0.5271774\",\n \"0.52578026\",\n \"0.5254543\",\n \"0.5227274\",\n \"0.52113366\",\n \"0.5209796\",\n \"0.51951116\",\n \"0.5186564\",\n \"0.5185572\",\n \"0.51643896\",\n \"0.51584464\",\n \"0.5149973\",\n \"0.514594\",\n \"0.51448274\",\n \"0.5118089\",\n \"0.5081654\",\n \"0.5076476\",\n \"0.5036513\",\n \"0.5024359\",\n \"0.5019114\",\n \"0.50169945\",\n \"0.5006375\",\n \"0.4971211\",\n \"0.4963762\",\n \"0.49565342\",\n \"0.4952645\",\n \"0.49432552\",\n \"0.4942781\",\n \"0.49407694\",\n \"0.49241787\",\n \"0.49114698\",\n \"0.4909416\",\n \"0.4896564\",\n \"0.48953786\",\n \"0.48928103\",\n \"0.48919275\",\n \"0.4890787\",\n \"0.48893875\",\n \"0.487771\",\n \"0.4872182\",\n \"0.4870892\",\n \"0.48652783\",\n \"0.48482534\",\n \"0.4845878\",\n \"0.48319632\",\n \"0.4827728\",\n \"0.48258334\",\n \"0.48140988\",\n \"0.48112863\",\n \"0.48045522\",\n \"0.47910815\",\n \"0.47875008\",\n \"0.47828528\",\n \"0.47800112\",\n \"0.4778378\",\n \"0.47768825\",\n \"0.4774901\",\n \"0.47679612\",\n \"0.47651106\",\n \"0.47523946\",\n \"0.47505277\",\n \"0.4743397\",\n \"0.47380027\",\n \"0.4734965\",\n \"0.47313014\",\n \"0.47302133\",\n \"0.47294894\",\n \"0.4722157\",\n \"0.4716952\",\n \"0.47130758\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56167054"},"document_rank":{"kind":"string","value":"19"}}},{"rowIdx":80588,"cells":{"query":{"kind":"string","value":"Identifies the closest path waypoint to the given position"},"document":{"kind":"string","value":"def get_closest_waypoint(self, pose):\n wpclosestDist = sys.maxint\n for index in range(len(self.waypoints.waypoints)):\n wp = self.waypoints.waypoints[index]\n wpdist = self.calcDistance_PoseStamped(pose, wp.pose)\n if(wpclosestDist > wpdist):\n wpclosestDist = wpdist\n wpindex = index\n return wpindex"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_closest_waypoint(self, pose):\n #TODO implement - Done\n # Iterate the base_waypoints' x value with current position's x value and find the closest\n # match, and pick that waypoint location index. \n min_idx = 0\n min_dist = None\n cur_x = pose.position.x\n cur_y = pose.position.y\n if self.waypoints is not None:\n for i, wp in enumerate(self.waypoints):\n wp_x = wp.pose.pose.position.x\n wp_y = wp.pose.pose.position.y\n dist = np.sqrt((cur_x - wp_x)**2 + (cur_y - wp_y)**2)\n if min_dist is None or min_dist >= dist:\n min_dist = dist\n min_idx = i\n \n # check whether the identified index is behind the current position, if so, move it by 1 index\n # https://gamedev.stackexchange.com/questions/75072/how-can-i-compare-two-quaternions-for-logical-equality\n # rospy.logwarn('min_idx before = %d', min_idx)\n eps = 1e-12\n if self.waypoints is not None:\n q1 = self.waypoints[min_idx].pose.pose.orientation\n q2 = pose.orientation\n q1_a = np.array([q1.x, q1.y, q1.z, q1.w])\n q2_a = np.array([q2.x, q2.y, q2.z, q2.w])\n direction = abs(np.dot(q1_a, q2_a))\n #rospy.logwarn('calculated direction %f', direction)\n wp_x = self.waypoints[min_idx].pose.pose.position.x\n if direction > 1-eps:\n if wp_x < cur_x:\n min_idx += 1\n else:\n min_idx -= 1\n else:\n if wp_x < cur_x:\n min_idx -= 1\n else:\n min_idx += 1\n\n # rospy.logwarn('min_idx after = %d', min_idx)\n return min_idx","def _get_closest_waypoint(self, pose):\n pos = pose.position\n x = pos.x\n y = pos.y\n closest_idx = self.waypoints_tree.query([x,y],1)[1]\n\n return closest_idx","def find_closest_path(self):\n\t\tclosest_distance = sys.maxint\n\t\tclosest_path = 0\n\t\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\n\t\tfor path_index in range(len(self.map_model.paths)):\n\t\t\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\n\t\t\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\n\t\t\tif (closest_distance > distance_to_bike):\n\t\t\t\tclosest_distance = distance_to_bike\n\t\t\t\tclosest_path = path_index \n\t\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\n\t\ttarget_path = (closest_path+1)%len(self.map_model.paths)\n\t\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\n\t\tif disp_next - np.abs(distance_next)>-0.01:\n\t\t\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\n\t\treturn closest_path","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.position.x,\n pose.position.y))\n else:\n return 0","def get_closest_waypoint(self, pose):\n if self.kdtree:\n return kdtree_closest_point(self.kdtree,\n (pose.x,\n pose.y))\n else:\n return 0","def FindClosestPoint(self, ):\n ...","def get_closest_waypoint(self, pose):\n # Find the nearest waypoint\n closest_distance = float('inf')\n closest_waypoint = 0\n for i in range(len(self.waypoints)):\n this_distance = self.distance_to_position(self.waypoints, i, pose.position)\n if this_distance < closest_distance:\n closest_distance = this_distance\n closest_waypoint = i\n return closest_waypoint","def get_closest_waypoint(self, pose, waypoints):\n #TODO implement\n\n\tmin_dist = float(\"inf\")\n\tclosest_wp_idx = -1\t\n\n for idx, wp in enumerate(waypoints):\n\t\tdist = self.dist_to_point(pose, wp.pose.pose)\n\t\tif(dist < min_dist):\n\t\t\tmin_dist = dist\n\t\t\tclosest_wp_idx = idx\n\treturn closest_wp_idx","def __get_closest_waypoint_index(self, x, y):\n return self.__waypoint_tree.query([x, y], 1)[1]","def get_closest_waypoint_idx(self):\n\n # TODO:\n # The churchlot waypoints are roughly circular but have self-\n # intersecting endpoints, so I'm not sure how this code will \n # yield good results. Might need some additional filtering\n # logic to force a choice consistent with the vehicle pose yaw\n # in order to avoid jumping onto the wrong path.\n\n # Vehicle position short reference\n pos = self.pose.pose.position\n\n # Find the closest waypoint index\n # If closest index is zero bump to 1 since we don't want slice for \n # prev_coord to look at the final map waypoint.\n closest_idx = max(self.waypoint_tree.query([pos.x, pos.y], 1)[1], 1)\n\n # Get closest point\n closest_coord = self.waypoints_2d[closest_idx]\n prev_coord = self.waypoints_2d[closest_idx-1]\n\n # Convert coordinates into 2D numpy vectors\n closest_vec = np.array(closest_coord)\n prev_vec = np.array(prev_coord)\n pos_vec = np.array([pos.x, pos.y])\n\n # Find vec(close-prev) dot vec(pos-close) \n val = np.dot(closest_vec - prev_vec, pos_vec - closest_vec)\n\n # If pos is ahead of closest...\n if val > 0: \n\n # Advance index so that closest is ahead of pos\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\n\n # Return closest index\n return closest_idx","def test_find_closest_waypoints_nearest(self):\n planner = WaypointPlanner(make_example_base_waypoints())\n\n planner.position = Vector3(0, 0, 0)\n waypoints = planner.find_closest_waypoints(1)\n self.assertEqual(1, len(waypoints))\n self.assertEqual(0, waypoints[0].pose.pose.position.x)\n self.assertEqual(0, waypoints[0].pose.pose.position.y)\n self.assertEqual(0, waypoints[0].pose.pose.position.z)\n\n planner.position = Vector3(0.9, 0.9, 0)\n waypoints = planner.find_closest_waypoints(2)\n self.assertEqual(2, len(waypoints))\n self.assertEqual(1, waypoints[0].pose.pose.position.x)\n self.assertEqual(1, waypoints[0].pose.pose.position.y)\n self.assertEqual(2, waypoints[1].pose.pose.position.x)\n self.assertEqual(2, waypoints[1].pose.pose.position.y)\n\n # Check it wraps back around to the start.\n planner.position = Vector3(0.9, 0.9, 0)\n waypoints = planner.find_closest_waypoints(3)\n self.assertEqual(3, len(waypoints))\n self.assertEqual(1, waypoints[0].pose.pose.position.x)\n self.assertEqual(1, waypoints[0].pose.pose.position.y)\n self.assertEqual(2, waypoints[1].pose.pose.position.x)\n self.assertEqual(2, waypoints[1].pose.pose.position.y)\n self.assertEqual(0, waypoints[2].pose.pose.position.x)\n self.assertEqual(0, waypoints[2].pose.pose.position.y)","def get_closest_waypoint(self, x, y):\n # TODO implement\n closest_idx = self.waypoint_tree.query([x, y], 1)[1]\n return closest_idx","def get_closest_waypoint(self, x, y):\n closest_idx = self.waypoint_tree.query([x, y])[1] # ckd tree (1st closest, idx)\n\n # Check if closest waypoint is ahead or behind vehicle\n closest_coord = self.waypoints_2d[closest_idx]\n prev_coord = self.waypoints_2d[closest_idx - 1]\n\n # Equation for hyperplane through closest_coors\n cl_vect = np.array(closest_coord)\n prev_vect = np.array(prev_coord)\n pos_vect = np.array([x, y])\n\n val = np.dot(cl_vect - prev_vect, pos_vect - cl_vect)\n # Car is ahead of the closest waypoint\n if val > 0:\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\n\n return closest_idx","def get_closest_waypoint_idx(self):\n\n # Position\n x = self.car_pose.pose.position.x\n y = self.car_pose.pose.position.y\n closest_idx = self.waypoint_tree.query([x, y], 1)[1]\n\n # Coordinates\n closest_coord = self.waypoints_2d[closest_idx]\n prev_coord = self.waypoints_2d[closest_idx - 1]\n\n # Hyper Plane\n cl_vect = np.array(closest_coord)\n prev_vect = np.array(prev_coord)\n pos_vect = np.array([x, y])\n\n val = np.dot(cl_vect - prev_vect, pos_vect - cl_vect)\n\n if val > 0:\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\n\n return closest_idx","def closest_waypoint(self, location: pylot.utils.Location):\n min_dist = np.infty\n min_index = 0\n for index, waypoint in enumerate(self.waypoints):\n dist = waypoint.location.distance(location)\n if dist < min_dist:\n min_dist = dist\n min_index = index\n return min_index","def get_closest_waypoint_idx(self, pose):\n d, kdwp = self.kdtree.query((pose.position.x, pose.position.y))\n return kdwp","def closest_on_screen_point(trajectory, viewpoint, yaw, gaze_on_screen):\n\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \n #pprint(traj_angles)\n\n #onscreen_idx, dists, *_ = find_closest_index(traj_angles, gaze_on_screen)\n #idx = closest_node(traj_angles, gaze_on_screen)\n idx = find_closest_index(traj_angles, gaze_on_screen)\n # print(idx)\n\n #traj_ref = trajectory[idx, :]\n screen_ref = traj_angles[idx, :]\n world_ref = trajectory[idx, :]\n\n path_dist = ab_path_length(trajectory, viewpoint, world_ref)\n path_dist /= 8.0 #time headway\n\n #plot_traj(screen_ref, gaze_on_screen, traj_angles)\n\n return(idx, screen_ref, world_ref, path_dist)#, traj_angles)","def get_closest_distance_to_path(self, path):\n min_distance_to_line = float(\"inf\")\n for p in path:\n game_path = p[:]\n\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\n\n try:\n point_after_A = p[p.index(point_A) + 1]\n point_before_A = p[p.index(point_A) - 1]\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\n except:\n if p.index(point_A) == 0:\n closest_to_A = p[p.index(point_A) + 1]\n \n elif p.index(point_A) == len(p) - 1:\n closest_to_A = p[p.index(point_A) - 1]\n finally:\n if closest_to_A[0] != point_A[0]:\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\n else:\n m = 2\n\n b = point_A[1] - m * point_A[0]\n\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\n min_distance_to_line = min(closest_distance, min_distance_to_line)\n \n return min_distance_to_line","def get_waypoint_pos(pos: list, waypoints: numpy.ndarray):\n dist = np.sum((pos - waypoints)**2, axis=1)\n wp_id = np.argmin(dist)\n return waypoints[wp_id], wp_id","def find_closest_move(self, position, valid_moves):\n closest = None\n closest_value = 100\n for move in valid_moves:\n if closest:\n x_dist = abs(position[0] - move[0])\n y_dist = abs(position[1] - move[1])\n if x_dist + y_dist < closest_value:\n closest = move\n closest_value = x_dist + y_dist\n else:\n closest = move\n\n return closest","def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\n \n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \n \n #pprint(traj_angles)\n\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\n ml_screen_ref = traj_angles[idx] \n\n return(idx, ml_screen_ref)","def test_find_closest_waypoints_no_position(self):\n planner = WaypointPlanner(make_example_base_waypoints())\n self.assertIsNone(planner.find_closest_waypoints(1))","def distance_to_current_waypoint():\n nextwaypoint = vehicle.commands.next\n if nextwaypoint == 0:\n return None\n missionitem = vehicle.commands[nextwaypoint -\n 1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\n targetWaypointLocation)\n return distancetopoint","def find_path(self):\n \n if self.line_num != -1:\n return self.line_num\n\n max_line = self.graph.gps_length - 1\n min_line = 0\n #last_id = dg.normalize(self.graph.lines[-1])[0]\n last_id = normalize_simple(self.graph.lines[-1])[0]\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n while cur_id != self.trip_id:\n if cur_id < self.trip_id:\n min_line = pivot\n else:\n max_line = pivot\n #TODO: could make this run in essentially constant time by hopping predetermined distance\n pivot = (min_line + max_line) / 2\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\n\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\n pivot -= 1\n\n pivot += 1\n self.line_num = pivot\n return pivot","def get_path(self):\r\n path = [self.city_map.get_tile_at_position(self.position)]\r\n destination_tile = self.city_map.get_tile_at_position(self.destination)\r\n\r\n neighbors = self.city_map.get_adjacent_intersections(self.position)\r\n closest_neighbor = None\r\n closest_neighbor_distance = math.inf\r\n for neighbor in neighbors:\r\n if distance(neighbor.position, self.position) < closest_neighbor_distance:\r\n closest_neighbor = neighbor\r\n closest_neighbor_distance = distance(neighbor.position, self.position)\r\n\r\n path.append(closest_neighbor)\r\n\r\n while destination_tile not in path:\r\n current_tile = path[-1]\r\n neighbors = self.city_map.get_adjacent_intersections(current_tile.position)\r\n closest_neighbor = None\r\n closest_neighbor_distance = math.inf\r\n for neighbor in neighbors:\r\n if current_tile.position['y'] == self.destination['y'] or current_tile.position['x'] == \\\r\n self.destination['x']:\r\n # If we're on the same row\r\n if current_tile.position['y'] == self.destination['y']:\r\n # And if the destination is between our current position and the next intersection over, go to it\r\n if (current_tile.position['x'] < self.destination['x'] <= neighbor.position['x'] or\r\n neighbor.position['x'] <= self.destination['x'] < current_tile.position['x']):\r\n path.append(destination_tile)\r\n break\r\n # If the neighbor gets us closer, go to it\r\n elif distance(neighbor.position, self.destination) < distance(current_tile.position,\r\n self.destination):\r\n path.append(neighbor)\r\n break\r\n if current_tile.position['x'] == self.destination['x']:\r\n if (current_tile.position['y'] < self.destination['y'] <= neighbor.position['y'] or\r\n neighbor.position['y'] <= self.destination['y'] < current_tile.position['y']):\r\n path.append(destination_tile)\r\n break\r\n # If the neighbor gets us closer, go to it\r\n elif distance(neighbor.position, self.destination) < distance(current_tile.position,\r\n self.destination):\r\n path.append(neighbor)\r\n break\r\n\r\n elif distance(neighbor.position, self.destination) < closest_neighbor_distance:\r\n closest_neighbor = neighbor\r\n closest_neighbor_distance = distance(neighbor.position, self.destination)\r\n\r\n # If the last iteration through the loop did reach the destination, don't append this\r\n if destination_tile not in path and closest_neighbor is not None:\r\n path.append(closest_neighbor)\r\n\r\n return path","def find_closest_trajectory_pose(self):\n np_state = numpy.array([[self.x], [self.y]])\n temp_distance = numpy.sum(\n (self.np_trajectory[0:2, :] - np_state) ** 2,\n axis=0)\n best_idx = numpy.argmin(temp_distance)\n return best_idx","def _find_path(maze, from_x, from_y, to_x, to_y):\n distance_map = _create_distance_map(maze, to_x, to_y)\n if distance_map is None or distance_map[from_x, from_y] < 0:\n return None\n\n path = []\n current_pos = [from_x, from_y]\n distance = distance_map[current_pos[0], current_pos[1]]\n\n offsets = [[-1, 0], [1, 0], [0, -1], [0, 1]]\n\n while distance != 0:\n for (offset_x, offset_y) in offsets:\n x = current_pos[0] + offset_x\n y = current_pos[1] + offset_y\n if (0 <= x < maze.shape[0] and 0 <= y < maze.shape[1] and\n distance_map[x, y] == distance - 1):\n path.append((x, y))\n current_pos = [x, y]\n distance -= 1\n break\n\n return path","def closest_breakpoint(self, chromosome, position):\n breaks = self.breaks[(chromosome, self.selected_k[chromosome])]\n i = bisect.bisect_right(breaks, position)\n if i == 0:\n return breaks[0]\n elif i == len(breaks):\n return breaks[i - 1]\n elif abs(position - breaks[i - 1]) < abs(position - breaks[i]):\n return breaks[i - 1]\n else:\n return breaks[i]","def get_closest_point(path, point):\n np_path = convert_path_type(path) # modify path to be a numpy array\n np_point = convert_point_type(point) # modify point to be a [x,y,z] numpy array\n\n # compute the distance from current location to every point in path and find index of the min distance\n distances = ((np_path[:,0] - np_point[0])**2 + (np_path[:,1] - np_point[1])**2)**0.5\n closest_idx = np.argmin(distances)\n\n if closest_idx != len(np_path) - 1: # check if this point is behind current location, if so use index+1\n closest_point = np_path[closest_idx]\n next_closest_point = np_path[closest_idx+1]\n\n # create vectors between the three points\n path_vector = next_closest_point - closest_point\n current_vector = np_point - closest_point\n\n # compute dot product to figure out whether location is behind or in front of closest_point\n dot_prod = np.dot(path_vector, current_vector)\n\n if dot_prod >= 0: # closest point is behind current location\n closest_idx += 1\n\n closest_point = path[closest_idx] # retrieve point from original `path` argument for type consistency\n\n return closest_point, closest_idx","def _update_next_waypoint(self):\n if not self.base_waypoints:\n #rospy.logwarn(\"Waypoints not updated: base_waypoints not available yet.\")\n return False\n\n if not self.current_pose:\n #rospy.logwarn(\"Waypoints not updated: current_pose not available yet.\")\n return False\n\n # Get ego car variables\n ego_x = self.current_pose.position.x\n ego_y = self.current_pose.position.y\n ego_theta = math.atan2(self.current_pose.orientation.y, self.current_pose.orientation.x)\n\n # If I do have a next_waypoint, I will start looking from it, and stop looking\n # as soon as get a local minimum. Otherwise I will do a full search across the whole track\n t = time.time()\n wp = None\n yaw = 0\n dist = 1000000 # Long number\n if self.next_waypoint:\n idx_offset = self.next_waypoint\n full_search = False\n else:\n idx_offset = 0\n full_search = True\n num_base_wp = len(self.base_waypoints)\n\n for i in range(num_base_wp):\n idx = (i + idx_offset)%(num_base_wp)\n wp_x = self.base_waypoints[idx].pose.pose.position.x\n wp_y = self.base_waypoints[idx].pose.pose.position.y\n wp_d = math.sqrt((ego_x - wp_x)**2 + (ego_y - wp_y)**2)\n\n if wp_d < dist:\n dist = wp_d\n wp = idx\n if debugging:\n # Angle betwee car heading and waypoint heading\n yaw = math.atan2(wp_y - ego_y, wp_x - ego_x) - ego_theta\n elif not full_search:\n # Local minimum. If the waypoint makes sense, just use it and break\n if dist < max_local_distance:\n break; # Found a point\n else:\n # Seem to have lost track. Do search again\n rospy.logwarn(\"Waypoint updater lost track (local min at %.1f m after %d waypoints). Going back to full search.\", dist, i+1)\n full_search = True\n\n if debugging:\n rospy.loginfo(\"New next wp [%d] -> (%.1f,%.1f) after searching %d points in %fs\", wp, dist * math.cos(yaw), dist * math.sin(yaw), i, time.time()-t)\n\n if wp is None:\n rospy.logwarn(\"Waypoint updater did not find a valid waypoint\")\n return False\n\n self.next_waypoint = wp\n return True","def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return source_to_source(most_important_up, most_important_down), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def goal(target, prediction):\n return closest_point_on_segment(prediction, target)","def target_position(self, time):\n \"\"\"\n start_pos = self.points[self.cur_start]\n seg_time = time - self.last_checkpoint_time\n\n #The arguement of target-velocity dosent matter\n cur_pos = self.target_velocity(time)*seg_time + start_pos\n\n \n # or time > (self.total_time / 4)*(self.cur_start + 1)\n cur_pos_norm = length(cur_pos - start_pos)\n\n next_corner = self.points[(self.cur_start + 1)%4]\n \n seg_norm = length(next_corner - start_pos)\n print(\"cur_pos : \", cur_pos, \"segment: \", self.cur_start, seg_norm - cur_pos_norm)\n\n if cur_pos_norm >= seg_norm:\n self.cur_start = (self.cur_start + 1) % 4\n self.last_checkpoint_time = time\n return cur_pos\n \"\"\"\n\n #Possibly use rospy.sleep()\n total_time = self.total_time\n\n\n if time < total_time/4:\n return self.path1.target_position(time)\n\n elif time - total_time/4 == 0:\n rospy.sleep(0.5)\n\n elif time < total_time/2:\n return self.path2.target_position(time - (total_time/4 + 0.5))\n # return self.path2.target_position(time - (total_time/4 ))\n\n\n elif time - total_time/2 == 0:\n rospy.sleep(0.5)\n\n elif time <= total_time/4*3:\n return self.path3.target_position(time - (total_time/2 + 1))\n # return self.path3.target_position(time - (total_time/2))\n\n\n elif time - total_time/4*3 == 0:\n rospy.sleep(0.5)\n\n else:\n return self.path4.target_position(time - (total_time/4*3 + 1.5))\n # return self.path4.target_position(time - (total_time/4*3))","def distance_to_current_waypoint(vehicle):\n nextwaypoint = vehicle.commands.next\n if nextwaypoint==0:\n return None\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\n lat = missionitem.x\n lon = missionitem.y\n alt = missionitem.z\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\n return distancetopoint","def distance_to_current_waypoint(self):\n next_waypoint = self.vehicle.commands.next\n if next_waypoint == 1:\n return None\n mission_item = self.vehicle.commands[next_waypoint]\n lat = mission_item.x\n lon = mission_item.y\n alt = mission_item.z\n waypoint_location = Location(lat, lon, alt, is_relative=True)\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\n return distance","def determineNextMove(player_location, opponentLocation, coins):\n global route, currentcoin, meta_route, best_weight, best_path, coins_to_search, index\n if opponentLocation in coins_to_search:\n coins_to_search, meta_route, route = change_way(coins, opponentLocation, player_location)[:3]\n index = 0\n elif currentcoin == player_location: \n if len(route) != 0:\n old_dist = algo.dijkstra(mazeMap, player_location)[1][meta_route[index+1]]\n coins_to_search2, meta_route2, route2, new_dist = change_way(coins, opponentLocation, player_location)\n\n #dist_matrix, route_matrix = u.update_dists_from_each(dists_matrix, routes_matrix, player_location, mazeMap, coins)\n #coins_to_search = get_n_shortest(3, coins, player_location, dists_matrix)\n \t\n #ennemy_dists = algo.dijkstra(mazeMap, opponentLocation)\n #for c in coins_to_search:\n #if len(coins_to_search) >= 2 and ennemy_dists[1][c] < dists_matrix[player_location][c]:\n # coins_to_search.remove(c)\n #break\n \t\t\n #best_weight = float(\"inf\")\n #best_path = []\n #exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\n #meta_route2 = [player_location] + best_path\n #route2 = u.location_list_to_route(meta_route2, route_matrix)\n #new_dist = dist_matrix[player_location][meta_route2[1]]\n\t\t\n if len(route) == 0 or old_dist - new_dist > 3:\n route = route2\n meta_route = meta_route2 \n index = 0\n index += 1\n currentcoin = meta_route[index]\n #api.debug(route)\n return u.direction(player_location, route.pop(0))","def FindClosestInsertedPoint(self, ):\n ...","def get_nearest_waypoint_id(self, pose):\n idx = self.__waypoints_tree.query([pose.position.x, pose.position.y])[1]\n\n closest_point = self.__base_waypoints_array[idx]\n previous_point = self.__base_waypoints_array[idx - 1]\n\n closest_vector = np.array(closest_point)\n previous_vector = np.array(previous_point)\n current_pos_vector = np.array([self.__current_pose.position.x, self.__current_pose.position.y])\n\n\n val = np.dot(closest_vector - previous_vector, current_pos_vector - closest_vector)\n if val > 0:\n return (idx + 1) % len(self.__base_waypoints_array)\n\n return idx","def closest(self, x, y):\n if self.direction == 'horizontal':\n p_pts = np.array([\n self.ax.transData.transform((p, 0))[0] for p in self.positions\n ])\n dist = abs(p_pts - x)\n else:\n p_pts = np.array([\n self.ax.transData.transform((0, p))[1] for p in self.positions\n ])\n dist = abs(p_pts - y)\n index = np.argmin(dist)\n return index, dist[index]","def find_path(required_pos, required_speed, current_pos, current_speed, path):\n if (required_pos == current_pos) and (required_speed == current_speed):\n# print(\"== Solution : \" + str(path), file=sys.stderr)\n return path # ok, we have a solution\n if required_speed <= 0:\n# print(\"negative speed\", file=sys.stderr)\n return -1\n if required_pos < current_pos:\n# print(\"negative position : {0} < {1}\".format(required_pos, current_pos),\n# file=sys.stderr)\n return -1 # No path from current pos to get to required pos\n\n path.append( [required_pos, required_speed] )\n# print(\"path : \" + str(path), file=sys.stderr)\n \n # find path, if we slow, keep speed or accelerate\n path_speed = find_path(required_pos - required_speed, required_speed+1,\n current_pos, current_speed, path.copy())\n path_wait = find_path(required_pos - required_speed, required_speed,\n current_pos, current_speed, path.copy())\n path_slow = find_path(required_pos - required_speed, required_speed-1,\n current_pos, current_speed, path.copy())\n \n # find best path\n best_path = -1\n for p in [path_slow, path_wait, path_speed]:\n if p == -1:\n continue\n if best_path == -1:\n best_path = p\n elif len(p) < len(best_path):\n best_path = p\n return best_path","def closest_point(self, shape, inf_dist=1.0, homogenous=True):\n\n self._check_pyb()\n\n if not _pyb: # pragma nocover\n raise ImportError(\n \"The package PyBullet is required for collision \"\n \"functionality. Install using pip install pybullet\"\n )\n\n if not self.pinit:\n self._init_pob()\n self._update_pyb()\n\n self._update_pyb()\n\n if not shape.pinit:\n shape._init_pob()\n shape._update_pyb()\n\n ret = p.getClosestPoints(self.co, shape.co, inf_dist)\n\n if homogenous:\n try:\n return ret[0][8], np.append(np.array(ret[0][5]), 1.0), np.append(np.array(ret[0][6]), 1.0)\n except ValueError:\n return None, None, None\n except IndexError:\n # Obstacle is further away than inf_dist\n return None, None, None\n else:\n try:\n return ret[0][8], np.array(ret[0][5]), np.array(ret[0][6])\n except ValueError:\n return None, None, None\n except IndexError:\n # Obstacle is further away than inf_dist\n return None, None, None","def closest_point(self, l):\n cos = np.dot(self.direction, l.direction)\n n = 1 - cos ** 2\n if n < sys.float_info.epsilon:\n # Lines are parallel.\n return self.zero\n\n d0 = l.zero - self.zero\n a = np.dot(d0, self.direction)\n b = np.dot(d0, l.direction)\n return self.zero + self.direction * ( a - b * cos) / n","def get_path_point(self):\n if len(self.current_path) == 0:\n return np.zeros(2), -1\n ego_x = self.pose.position.x\n ego_y = self.pose.position.y\n ego_pose = np.array([[ego_x, ego_y]])\n disps = (ego_pose - self.current_path)\n dists = np.hypot(disps[:, 0], disps[:, 1])\n path_point_idx = np.argmin(dists[self.path_point_idx:]) + self.path_point_idx\n path_point = self.current_path[path_point_idx]\n return path_point, path_point_idx","def next_move(self):\n\n # Calculate all paths to destination from current location and time.\n solution = self.calculate_best_solution((None, None), self.currentTurn, [self.character.path[-1]],\n self.character.spent)\n\n # Add travel weight to spent.\n if solution[1] is not None and solution[1][0] != solution[1][1]:\n self.character.spent += self.pekingMap.get_vertex(solution[1][0]).weight(solution[1][1])\n\n # Return next point in shortest path to location.\n if solution[1] is not None:\n return solution[1][1]\n\n return None","def closest_point_to(self, x):\n x = np.array(x)\n v = self.p1 - self.p0\n b = self.p0 - x\n\n t = -np.dot(v, b) / np.dot(v, v)\n if (0 <= t <= 1):\n closest = t*(self.p1 - self.p0) + self.p0\n return closest\n else:\n if np.linalg.norm(x - self.p0) < np.linalg.norm(x - self.p1):\n return self.p0\n else:\n return self.p1","def defenderGoal(self, point, myPos):\n (x, y) = point\n temp = self.scanmap.adjacentValidPoints(x, y)\n targets = []\n for i in temp:\n (x, y) = i\n targets += self.scanmap.adjacentValidPoints(x, y)\n targets = list(dict.fromkeys(targets))\n targets.remove(point)\n\n minDis = self.getMazeDistance(myPos, targets[0])\n nearestDefender = targets[0]\n for j in targets:\n dis = self.getMazeDistance(myPos, j)\n if dis < minDis:\n minDis = dis\n nearestDefender = j\n return nearestDefender","def target_position(self, time):\n path, path_time = self.get_current_path(time)\n return path.target_position(path_time)","def move_to(self, waypoint):\n self.set_final_wp(waypoint)\n self.go()\n currPos = np.asarray(self.rexarm.get_positions())\n while(np.linalg.norm(np.asarray(waypoint) - currPos) > 0.15):\n time.sleep(0.01)","def _find_fastest_path(self):\n from simulator import Robot\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\n facing=self._robot.facing,\n discovered_map=self._robot.discovered_map,\n real_map=[[0] * 15 for _ in range(20)])\n\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\n start=(1, 1),\n goal=self._way_point)\n\n if fastest_path_start_way_point:\n for move in fastest_path_start_way_point:\n clone_robot.move_robot(move)\n\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\n\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\n start=self._way_point,\n goal=(18, 13),\n before_start_point=before_way_point)\n\n return fastest_path_start_way_point + fastest_path_way_point_goal","def get_closest_lane_waypoint(self, location):\n loc = to_carla_location(location)\n waypoint = self._map.get_waypoint(loc,\n project_to_road=True,\n lane_type=carla.LaneType.Any)\n return waypoint","def _get_nearest_point(self, position):\n nearest_inds = np.round(position / self._maze.grid_side - 0.5)\n return nearest_inds.astype(int)","def nearest_segment(self, pose):\n global_x, global_y, global_a = pose\n track_pose = 0, 0, 0\n best = None, None\n best_dist = None\n for segment in self.segments:\n # convert global (x,y) into pose relative coordinates\n x, y, a = track_pose\n ca, sa = math.cos(-a), math.sin(-a) # rotate back\n sx = global_x - x\n sy = global_y - y\n sx, sy = ca*sx - sa*sy, sa*sx + ca*sy\n dist = segment.get_offset((sx, sy, global_a - a))[0]\n if dist is not None:\n if best_dist is None or abs(dist) < best_dist:\n best = segment, (sx, sy, global_a - a)\n best_dist = abs(dist)\n track_pose = segment.step(track_pose)\n return best","def _get_next_waypoint(self, tolerance_step):\n print('\\nGetting new nav plan.')\n\n for i in range(4):\n try:\n self.plan = self.swarmie.get_plan(\n self.goal,\n tolerance=self.tolerance,\n use_home_layer=self.avoid_home\n )\n break # plan received\n except rospy.ServiceException:\n print('ServiceException.')\n if i < 3:\n print('Expanding tolerance.')\n self.tolerance += tolerance_step\n else:\n raise # tried 3 times, we give up\n\n print('Received nav plan.')\n pose = self.plan.plan.poses[0]\n\n return Point(x=pose.pose.position.x, y=pose.pose.position.y)","def FindClosestPointWithinRadius(self, p_float, , p_float_4):\n ...","def pathfinder(starting_position: tuple, target_position: tuple, grid: np.ndarray) -> List[tuple] or None:\n moves_dict = {(1, 0): \"DOWN\", (-1, 0): \"UP\", (0, 1): \"RIGHT\", (0, -1): \"LEFT\"}\n\n moves = []\n path = []\n dead_ends = []\n\n def rate_position(current, target):\n \"\"\"\n Helper function to calculate distance to target\n \"\"\"\n return (target[0] - current[0]) ** 2 + (target[1] - current[1]) ** 2\n\n # Setting starting position\n current_position = starting_position\n while current_position != target_position:\n possible_moves = {}\n # Checking for each possible move and rating them\n for m in moves_dict.keys():\n if check_valid_move(grid, current_position, m):\n new_position = tuple(np.add(current_position, m))\n new_position_rating = rate_position(new_position, target_position)\n if new_position not in path and new_position not in dead_ends:\n possible_moves[new_position_rating] = m\n\n # if there are possible move, select the one, that would move us the closest to target\n if possible_moves:\n path.append(current_position) # save position to path\n moves.append(possible_moves[min(possible_moves)]) # save move to move list\n current_position = tuple(np.add(current_position, possible_moves[min(possible_moves)]))\n # if not, go back one move and add current position to dead ends\n else:\n # if no moves available from the start, return None\n if current_position == starting_position:\n return None\n dead_ends.append(current_position) # save position to dead ends\n current_position = path[-1] # move back one step\n path.pop(-1) # delete step from path\n moves.pop(-1) # delete move from move list\n\n return [tuple(moves_dict[move] for move in moves)]","def find_closest_index(traj, point):\n\n\t#TODO: vectorise function to receive any length of points.\n\n\tdistances = np.subtract(np.array(point),traj) \n\tdistances = distances.reshape(-1,2)\n\t#distances = distances[~np.isnan(distances)].reshape(-1,2)\n\n\t#print(\"distances\")\n\t#pprint(distances)\n\tdist_array = np.linalg.norm(distances, axis = 1)\n\t#pprint(dist_array)\n\t#dist_array = np.sqrt((distances[:,0]**2)+(distances[:,1]**2)) #array of distances from trajectory to gaze landing point in world. \n\tidx = np.nanargmin(abs(dist_array)) #find smallest difference in pythag distance from 0,0 to get closest point. \n\tdists = distances[idx, :]\n\tdist = dist_array[idx]\n\n\treturn idx#, dists, dist\n\t#return idx","def nextWaypoint(self, pose):\n #DONE implement\n location = pose.position\n dist = 100000.\n dl = lambda a, b: math.sqrt((a.x-b.x)**2 + (a.y-b.y)**2 + (a.z-b.z)**2)\n nwp = 0\n for i in range(len(self.waypoints)):\n d1 = dl(location, self.waypoints[i].pose.pose.position)\n if dist > d1:\n nwp = i\n dist = d1\n x = self.waypoints[nwp].pose.pose.position.x\n y = self.waypoints[nwp].pose.pose.position.y\n heading = np.arctan2((y-location.y), (x-location.x))\n angle = np.abs(self.theta-heading)\n if angle > np.pi/4.:\n nwp += 1\n if nwp >= len(self.waypoints):\n nwp = 0\n return nwp","def get_path(self, grid, start_wp, end_wp):\n # The open and closed sets\n openset = set()\n closedset = set()\n\n # Add the starting point to the open set\n openset.add(start_wp)\n\n # While the open set is not empty\n while openset:\n # Find the waypoint in the open set with the lowest G + H score\n current_wp = min(openset, key=lambda o: o.G + o.H)\n # Found the goal\n if current_wp == end_wp:\n path = []\n while current_wp.parent:\n path.append(current_wp)\n current_wp = current_wp.parent\n path.append(current_wp)\n print(\"Path found in {} moves: {}\".format(len(path), path))\n return path[::-1]\n\n # Remove the waypoint from the open set\n openset.remove(current_wp)\n # Add it to the closed set\n closedset.add(current_wp)\n\n # Generate children\n children = current_wp.generate_children(grid)\n\n for waypoint in children:\n # If it is already in the closed set, skip it\n if waypoint in closedset:\n continue\n # Otherwise if it is already in the open set\n if waypoint in openset:\n # Check if we beat the G score\n new_g = current_wp.G + 1\n\n if waypoint.G > new_g:\n # If so, update the waypoint to have a new parent\n waypoint.G = new_g\n waypoint.parent = current_wp\n else:\n # If it isn't in the open set, calculate the G and H score for the waypoint\n if waypoint.orientation != current_wp.orientation:\n waypoint.G = current_wp.G + 1.5 # Avoiding zigzag move by increase the cost of a rotation\n else:\n waypoint.G = current_wp.G + 1\n\n waypoint.H = abs(waypoint.x - end_wp.x) + abs(waypoint.y - end_wp.y)\n # Set the parent to our current_wp\n waypoint.parent = current_wp\n # Add it to the set\n openset.add(waypoint)\n\n # If there is no solution\n return [start_wp, end_wp]","def calc_nearest_ind(self, robot_pose):\n pass","def heuristic(cell, goal):\n return math.hypot(goal.x - cell.x, goal.y - cell.y)","def findPathToClosestDot(self, gameState):\n # Here are some useful elements of the startState\n startPosition = gameState.getPacmanPosition(self.index)\n food = gameState.getFood()\n walls = gameState.getWalls()\n problem = AnyFoodSearchProblem(gameState, self.index)\n\n\n \"*** YOUR CODE HERE ***\"\n return search.bfs(problem)","def search_path(self):\n\n nodes = [self.start]\n final_node = None\n \n count = 0\n while True:\n count += 1\n\n if count % self.pick_target == 0:\n pick = self.goal.pos[:2]\n else:\n pick = self.car.random_pos()[:2]\n \n nearest = self.get_nearest_node(nodes, pick)\n\n if count % self.check_dubins == 0:\n solutions = self.dubins.find_tangents(nearest.pos, self.goal.pos)\n dubins_route, cost, valid = self.dubins.best_tangent(solutions)\n \n if valid:\n final_node = nearest\n break\n\n phi = self.get_steering_angle(nearest.pos, pick)\n pos = nearest.pos\n branch = [pos[:2]]\n \n for i in range(self.max_steps):\n pos = self.car.step(pos, phi)\n branch.append(pos[:2])\n \n # check safety of route-----------------------\n if phi == 0:\n safe = self.dubins.is_straight_route_safe(nearest.pos, pos)\n else:\n d, c, r = self.car.get_params(nearest.pos, phi)\n safe = self.dubins.is_turning_route_safe(nearest.pos, pos, d, c, r)\n # --------------------------------------------\n \n if not safe:\n continue\n \n new_node = Node(pos, phi, i+1)\n \n if new_node in nodes:\n continue\n \n new_node.branch = branch\n new_node.parent = nearest\n nodes.append(new_node)\n \n route = self.backtracking(final_node) + dubins_route\n path = self.car.get_path(self.car.start_pos, route)\n print('Total iteration:', count)\n \n return path, nodes","def get_shortest_paths(distance_map: DistanceMap, agent_pos, agent_dir, max_depth: Optional[int] = None, agent_handle: Optional[int] = None) \\\n -> Dict[int, Optional[List[Waypoint]]]:\n shortest_paths = dict()\n\n def _shortest_path_for_agent(agent,agent_pos,agent_dir):\n if agent_pos is None :\n if agent.status == RailAgentStatus.READY_TO_DEPART:\n position = agent.initial_position\n elif agent.status == RailAgentStatus.ACTIVE:\n position = agent.position\n elif agent.status == RailAgentStatus.DONE:\n position = agent.target\n else:\n shortest_paths[agent.handle] = None\n return\n direction = agent.direction\n else :\n position = agent_pos\n direction = agent_dir \n shortest_paths[agent.handle] = []\n distance = math.inf\n depth = 0\n while (position != agent.target and (max_depth is None or depth < max_depth)):\n next_actions = get_valid_move_actions_(direction, position, distance_map.rail)\n best_next_action = None\n for next_action in next_actions:\n next_action_distance = distance_map.get()[\n agent.handle, next_action.next_position[0], next_action.next_position[\n 1], next_action.next_direction]\n if next_action_distance < distance:\n best_next_action = next_action\n distance = next_action_distance\n\n shortest_paths[agent.handle].append(Waypoint(position, direction))\n depth += 1\n\n # if there is no way to continue, the rail must be disconnected!\n # (or distance map is incorrect)\n if best_next_action is None:\n shortest_paths[agent.handle] = None\n return\n\n position = best_next_action.next_position\n direction = best_next_action.next_direction\n if max_depth is None or depth < max_depth:\n shortest_paths[agent.handle].append(Waypoint(position, direction))\n\n if agent_handle is not None:\n _shortest_path_for_agent(distance_map.agents[agent_handle],agent_pos,agent_dir)\n else:\n for agent in distance_map.agents:\n _shortest_path_for_agent(agent,agent_pos,agent_dir)\n\n return shortest_paths","def one_way_path(most_important, total_distance, to_source2, to_source1):\n\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(most_important), total_distance\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\n return most_important_to_source(to_source2[1]), to_source2[0]\n else:\n return most_important_to_source(to_source1[1], up=False), to_source1[0]","def find_path(self, origin, destination, max_time = 1):\r\n \r\n # Before we start, let's check we need to do something\r\n if origin == destination or self._heuristic_weight(origin, destination) == 0:\r\n return None\r\n \r\n # Add the starting point to the \"open\" list\r\n self.open_list.append(origin)\r\n self.g_cost[origin] = 0\r\n self.h_cost[origin] = self.f_cost[origin] = self._heuristic_weight(origin, destination)\r\n \r\n self.start_time = lib.clock()\r\n nearest_parent = {}\r\n self.path = PATH_INEXISTENT\r\n \r\n #while (lib.clock() - self.start_time) < max_time:\r\n while len(self.open_list):\r\n # The \"parent\" node, around which we look, is always the first node of the \"open\" list\r\n # This node is transferred to the \"closed\" list\r\n current_parent = self.open_list[0]\r\n self.closed_list.append(current_parent)\r\n del self.open_list[0]\r\n\r\n # The \"parent\" node is the destination : the path has been found.\r\n if current_parent == destination:\r\n self.path = PATH_FOUND\r\n break\r\n\r\n # Set the first element of the open list as the one that has the smallest F-cost\r\n for (i, node) in enumerate(self.open_list):\r\n if self.f_cost[self.open_list[0]] > self.f_cost[node]:\r\n (self.open_list[i], self.open_list[0]) = (self.open_list[0], node)\r\n \r\n # Check the adjacent nodes\r\n children = [road.end for road in current_parent.leaving_roads]\r\n \r\n for child in children:\r\n # Not already in the closed list neither in the open list\r\n if not (child in self.closed_list) and not (child in self.open_list):\r\n # Compute its G-cost, H-cost and F-cost\r\n self.g_cost[child] = self.g_cost[current_parent] + road.weight\r\n self.h_cost[child] = self._heuristic_weight(child, destination)\r\n self.f_cost[child] = self.g_cost[child] + self.h_cost[child]\r\n \r\n nearest_parent[child] = current_parent\r\n \r\n # Add the node to the open list, keeping the order (the first node has the smallest F-cost)\r\n if len(self.open_list) and (self.f_cost[self.open_list[0]] > self.f_cost[child]):\r\n self.open_list.insert(0, child)\r\n else:\r\n self.open_list.append(child)\r\n\r\n # Already in the open list : check to see if this path is a better one than the currently known path\r\n elif child in self.open_list:\r\n # Compute the G-cost of this possible new path\r\n current_g_cost = self.g_cost[current_parent] + road.weight\r\n \r\n # This path is shorter (lower G-cost) : store this path as default to reach this node\r\n if current_g_cost < self.g_cost[child]:\r\n # Set this path as the shortest path to reach this node\r\n nearest_parent[child] = current_parent\r\n self.g_cost[child] = current_g_cost\r\n self.f_cost[child] = self.g_cost[current_parent] + self.h_cost[child] # Do not forget to update the F-cost !\r\n \r\n # Check if the open list is still in the right order\r\n if self.f_cost[self.open_list[0]] > self.f_cost[child]:\r\n i = self.open_list.index(child)\r\n (self.open_list[0], self.open_list[i]) = (self.open_list[i], self.open_list[0])\r\n\r\n # Save the path if it exists.\r\n if self.path == PATH_FOUND:\r\n \r\n current_node = destination\r\n self.path = []\r\n self.path_length = 0\r\n \r\n while current_node != origin:\r\n self.path.insert(0, current_node)\r\n if current_node in nearest_parent:\r\n current_node = nearest_parent[current_node]\r\n else:\r\n raise Exception('ERROR (in gps.find_path()): ill-formed parent list, a node has no parent.')\r\n \r\n self.path_length += 1\r\n return self._build_path()\r\n\r\n return None","def findPathToClosestDot(self, gameState):\n # Here are some useful elements of the startState\n startPosition = gameState.getPacmanPosition()\n food = gameState.getFood()\n walls = gameState.getWalls()\n problem = AnyFoodSearchProblem(gameState)\n\n \"*** YOUR CODE HERE ***\"\n return breadthFirstSearch(problem)\n # util.raiseNotDefined()","def search(world_state, robot_pose, goal_pose):\n if world_state.shape[0] == 0 or world_state.shape[1] == 0:\n print(\"Error, empty world_state!!!\")\n return None\n if not is_pos_valid(robot_pose, world_state.shape):\n print(\"Error, invalid robot_pose!!!\", robot_pose)\n return None\n if not is_pos_valid(goal_pose, world_state.shape):\n print(\"Error, invalid goal_pose!!!\", goal_pose)\n return None\n\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # orthogonal directions\n found = False\n\n x, y = robot_pose\n g = 0\n h = heuristic(robot_pose, goal_pose)\n f = g + h\n open = [[f, x, y]]\n came_from = {}\n came_from[robot_pose] = None\n cost_so_far = {}\n cost_so_far[robot_pose] = 0\n\n while open:\n open.sort() # sort based on f value\n current = open.pop(0)\n\n x, y = current[1:]\n g = cost_so_far[(x, y)]\n\n if (x, y) == goal_pose:\n found = True\n break\n else:\n # find available next positions\n for direction in directions:\n x2 = x + direction[0]\n y2 = y + direction[1]\n\n # check whether x2 and y2 are valid\n if not is_pos_valid((x2, y2), world_state.shape):\n continue\n\n g2 = g + 1\n if world_state[x2, y2] == 0 and ((x2, y2) not in cost_so_far or g2 < cost_so_far[(x2, y2)]):\n\n h2 = heuristic((x2, y2), goal_pose)\n f2 = g2 + h2\n open.append([f2, x2, y2])\n came_from[(x2, y2)] = (x, y)\n cost_so_far[(x2, y2)] = g2\n if found:\n path = [goal_pose]\n current = goal_pose\n while came_from[current]:\n current = came_from[current]\n path.append(current)\n\n path.reverse()\n return path\n\n else:\n return None","def closest_other_location(state):\n locations = others_locations(state)\n target = closest_other(state)\n return locations[target]","def move_relative(state, location, towards):\n move_options = util.move_options_to_list(state['move_options'])\n\n move_options = [m for m in move_options if m['type'] == 'move']\n\n if len(move_options) == 0:\n return None\n\n my_location_ = my_location(state)\n move_targets = np.array([m['target'] for m in move_options])\n target_locations = move_targets + my_location_\n\n distances_ = distances(location, target_locations)\n\n if towards:\n target_index = np.argmin(distances_)\n else:\n target_index = np.argmax(distances_)\n\n return move_options[target_index]","def update_wp_position(self, event):\n wp = -1\n cur_pos = np.array(\n [self.global_pose.latitude, self.global_pose.longitude])\n for idx, waypoint in enumerate(self.waypoints):\n temp = np.array([waypoint['lat'], waypoint['long']])\n alt_diff = abs(self._rel_alt[-1] - waypoint['rel_alt'])\n if idx == 0 and (np.linalg.norm(cur_pos - temp) < self._radius):\n wp = idx\n break\n elif (np.linalg.norm(cur_pos - temp) <\n self._radius) and (alt_diff < self._alt_radius):\n wp = idx\n break\n self._current_wp = wp","def find_closest_pt(ref_lon, ref_lat, tlon, tlat):\n\n # compute great circle distance from location to model grid points\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\n\n # find j index of closest grid point\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\n jj = N.argsort(work)[0]\n\n # find i index of closest grid point\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\n ii = N.argsort(work)[0]\n\n return ii, jj","def _nearest_to_point(self, point):\n ptvertex = point.get_vertex(crs=self.crs)\n segments = zip(self.vertices.slice(0, -1), self.vertices.slice(1, 0))\n\n if isinstance(self.crs, CartesianCRS):\n func = _cvectorgeo.pt_nearest_planar\n def func(seg):\n return _cvectorgeo.pt_nearest_planar(ptvertex[0], ptvertex[1],\n seg[0][0], seg[0][1], seg[1][0], seg[1][1])\n else:\n fwd = self.crs.forward\n inv = self.crs.inverse\n def func(seg):\n return _cvectorgeo.pt_nearest_proj(fwd, inv, ptvertex,\n seg[0], seg[1], tol=0.01)\n\n point_dist = map(func, segments)\n min_point = None\n min_dist = -1.0\n for i, (point, dist) in enumerate(point_dist):\n if dist < min_dist or (i == 0):\n min_point = point\n min_dist = dist\n\n return min_dist, min_point","def closest_point(p1: Vector3, p2: Vector3, p3: Vector3) -> Vector3:\n k = ((p2.y - p1.y) * (p3.x - p1.x) - (p2.x - p1.x) * (p3.y - p1.y)) / ((p2.y - p1.y) ** 2 + (p2.x - p1.x) ** 2)\n x4 = p3.x - k * (p2.y - p1.y)\n y4 = p3.y + k * (p2.x - p1.x)\n\n return Vector3(x4, y4, 0)","def s_path(self, position: Vector) -> float:\n return self.path_coordinates(position)[0]","def next_gps(self):\n \n return Waypoint(0.0, 0.0)","def closest(self, x):\n # http://www.ahinson.com/algorithms_general/Sections/Geometry/PluckerLine.pdf\n # has different equation for moment, the negative\n\n x = arg.getvector(x, 3)\n\n lam = np.dot(x - self.pp, self.uw)\n p = self.point(lam) # is the closest point on the line\n d = np.linalg.norm( x - p)\n \n return namedtuple('closest', 'p d lam')(p, d, lam)","def closest(point, points):\n pts = [(Point.distance(point, p), p) for p in points]\n pts.sort()\n return pts[0][1]","def closest_point(point, points):\n return points[cdist([point], points).argmin()]","def compute_heuristic(self, position, goal):\n return abs(position[0] - goal[0]) + abs(position[1] - goal[1])","def nearest(self, pose):\n # type: (Pose) -> Pose\n assert (self.nodes), 'No nodes.'\n closest = min(self.nodes, key=lambda x: self.dist(x, pose))\n return closest","def get_next_destination(self) -> Location:\n # Find index of current location in route\n i = 0\n while i < len(self.route):\n this_loc = self.route[i]\n #\n if i > 0 and this_loc == self.route[-1]:\n return None\n if this_loc == self.current_location:\n return self.route[i + 1]\n i += 1","def is_straight_ahead(point_a, point_b, distance):\n\n _, route_initial = interpolate_trajectory(world, [point_a.location, point_b.location])\n if estimate_route_distance(route_initial) < distance or \\\n estimate_route_distance(route_initial) > 3*distance:\n print (\"Rejected because it is too small\")\n return False\n route = clean_route(route_initial)\n\n print (\" Straight test \")\n\n # TODO analize the size of the straight\n if len(route) > 3:\n print (\"Rejected because of size\")\n return False\n\n for point in route:\n\n # Check if there are any curve\n if point[2] == RoadOption.LEFT or point[2] == RoadOption.RIGHT:\n print (\"Rejected because of curve\")\n return False\n\n\n yaw_difference = point_a.rotation.yaw - point_b.rotation.yaw\n print (\" yaw difference is \", yaw_difference)\n if math.fabs(yaw_difference) > 10 and math.fabs(yaw_difference) < 340:\n print (\"Rejected because of curve\")\n return False\n\n\n return True","def heuristic(node, goal):\n return (abs((position(node)[0] - position(goal)[0]))\n + abs(position(node)[1] - position(goal)[1]))","def heuristic(self, node):\n res = 0\n np_node = np.array(node)\n for i in range(4):\n for j in range(4):\n tmp = self.goal[i][j]\n if tmp != 0:\n point = np.where(np_node == tmp)\n x = int(point[0])\n y = int(point[1])\n distance = np.sqrt(np.square(x - i) + np.square(y - j))\n res += distance\n return res","def LineClosestPoint(line, testpoint):\n line = rhutil.coerceline(line, True)\n testpoint = rhutil.coerce3dpoint(testpoint, True)\n return line.ClosestPoint(testpoint, False)","def optimized_path(coords, startid, mask):\n coords = np.column_stack((coords, mask))\n pass_by = np.asarray(coords)\n path = [coords[startid]]\n pass_by = np.delete(pass_by, startid, axis=0)\n while pass_by.any():\n nearest_id, nearest = min(\n enumerate(pass_by), key=lambda x: distance(path[-1][:2], x[1][:2]))\n path.append(nearest)\n pass_by = np.delete(pass_by, nearest_id, axis=0)\n\n return path","def findPathToClosestDot(self, gameState):\n startPosition = gameState.getPacmanPosition(self.index)\n food = gameState.getFood()\n walls = gameState.getWalls()\n problem = AnyFoodSearchProblem(gameState, self.index)\n return search.bfs(problem)\n util.raiseNotDefined()","def satisfied_waypoints(cls, home_pos, waypoints, uas_telemetry_logs):\n # Form utm for use as projection in distance calcluations.\n zone, north = distance.utm_zone(home_pos.latitude, home_pos.longitude)\n utm = distance.proj_utm(zone, north)\n\n # Reduce telemetry from telemetry to waypoint hits.\n # This will make future processing more efficient via data reduction.\n # While iterating, compute the best distance seen for feedback.\n best = {}\n hits = []\n for iu, start_log in enumerate(uas_telemetry_logs):\n end_log = None\n if iu + 1 < len(uas_telemetry_logs):\n end_log = uas_telemetry_logs[iu + 1]\n for iw, waypoint in enumerate(waypoints):\n dist = cls.closest_interpolated_distance(\n start_log, end_log, waypoint, utm)\n best[iw] = min(best.get(iw, dist), dist)\n score = cls.score_waypoint(dist)\n if score > 0:\n hits.append((iw, dist, score))\n # Remove redundant hits which wouldn't be part of best sequence.\n # This will make future processing more efficient via data reduction.\n hits = [\n max(g, key=lambda x: x[2])\n for _, g in itertools.groupby(hits, lambda x: x[0])\n ]\n\n # Find highest scoring sequence via dynamic programming.\n # Implement recurrence relation:\n # S(iw, ih) = s[iw, ih] + max_{k=[0,ih)} S(iw-1, k)\n dp = defaultdict(lambda: defaultdict(lambda: (0, None, None)))\n highest_total = None\n highest_total_pos = (None, None)\n for iw in xrange(len(waypoints)):\n for ih, (hiw, hdist, hscore) in enumerate(hits):\n # Compute score for assigning current hit to current waypoint.\n score = hscore if iw == hiw else 0.0\n # Compute best total score, which includes this match score and\n # best of all which could come before it.\n prev_iw = iw - 1\n total_score = score\n total_score_back = (None, None)\n if prev_iw >= 0:\n for prev_ih in xrange(ih + 1):\n (prev_total_score, _) = dp[prev_iw][prev_ih]\n new_total_score = prev_total_score + score\n if new_total_score > total_score:\n total_score = new_total_score\n total_score_back = (prev_iw, prev_ih)\n dp[iw][ih] = (total_score, total_score_back)\n # Track highest score seen.\n if total_score > highest_total:\n highest_total = total_score\n highest_total_pos = (iw, ih)\n # Traceback sequence to get scores and distance for score.\n scores = defaultdict(lambda: (0, None))\n cur_pos = highest_total_pos\n while cur_pos != (None, None):\n cur_iw, cur_ih = cur_pos\n hiw, hdist, hscore = hits[cur_ih]\n if cur_iw == hiw:\n scores[cur_iw] = (hscore, hdist)\n _, cur_pos = dp[cur_iw][cur_ih]\n\n # Convert to evaluation.\n waypoint_evals = []\n for iw, waypoint in enumerate(waypoints):\n score, dist = scores[iw]\n waypoint_eval = mission_pb2.WaypointEvaluation()\n waypoint_eval.id = iw\n waypoint_eval.score_ratio = score\n if dist is not None:\n waypoint_eval.closest_for_scored_approach_ft = dist\n if iw in best:\n waypoint_eval.closest_for_mission_ft = best[iw]\n waypoint_evals.append(waypoint_eval)\n return waypoint_evals","def closest_point_on_line(point, line):\n a, b = line\n ab = subtract_vectors(b, a)\n ap = subtract_vectors(point, a)\n c = vector_component(ap, ab)\n return add_vectors(a, c)","def navigate_waypoint(commands: list, verbose=False) -> tuple:\n\n position: list = [0, 0] # x, y\n waypoint_cartesian: list = [10, 1] # x, y (relative to ship)\n waypoint_polar: list = [0, 1, 10] # bearing, distance, and offset in clockwise direction\n\n conversion: dict = {'N': 1, 'S': -1, 'E': 1, 'W': -1, 'L': -1, 'R': 1, 'F': 1}\n \n if verbose: \n print(f'position: {position}, waypoint_cartesian: {waypoint_cartesian}, waypoint_polar: {waypoint_polar}')\n\n for command in commands: \n \n if verbose: \n print(f'command: {command}')\n \n change: int = command['value'] * conversion[command['action']]\n\n if command['action'] in ['N', 'S']: \n waypoint_cartesian[1] += change # in y\n waypoint_polar = cartesian_to_polar(waypoint_cartesian)\n elif command['action'] in ['E', 'W']: \n waypoint_cartesian[0] += change # in x\n waypoint_polar = cartesian_to_polar(waypoint_cartesian)\n elif command['action'] in ['L', 'R']: \n \n bearing_old = waypoint_polar[0]\n bearing_new = bearing_old + change\n\n if bearing_new > 270:\n bearing_new -= 360\n if bearing_new < 0: \n bearing_new += 360\n \n waypoint_polar[0] = bearing_new\n waypoint_cartesian = polar_to_cartesian(waypoint_polar)\n\n elif command['action'] == 'F': \n \n position[0] += waypoint_cartesian[0] * change\n position[1] += waypoint_cartesian[1] * change\n\n else: \n raise ValueError(\"Invalid action\")\n \n if verbose: \n print(f'position: {position}, waypoint_cartesian: {waypoint_cartesian}, waypoint_polar: {waypoint_polar}')\n\n return tuple(position)","def distance_to_line(a, b, p):\n return distance(closest_point(a, b, p), p)","def findPathToClosestDot(self, gameState):\n # Here are some useful elements of the startState\n startPosition = gameState.getPacmanPosition(self.index)\n food = gameState.getFood()\n walls = gameState.getWalls()\n problem = AnyFoodSearchProblem(gameState, self.index)\n\n return search.breadthFirstSearch(problem)\n util.raiseNotDefined()","def test_nearest_location_odd():\n assert nearest_location([(3, 6), (9, 13)], 7) == 0\n assert nearest_location([(3, 6), (9, 13)], 7, 1) == 1","def nearest_neighbor(self):\n steps = [{'Tour': [], 'Tourlength': 0}]\n tour = []\n original_nodes = self._datacontroller.get_data('nodes')\n nodes = copy.deepcopy(original_nodes)\n scale = self._datacontroller.get_data('scale')\n\n # Step 1: Get a tour start\n starts = [node for node in nodes if node.start]\n _start = 'Random from marked nodes'\n if not len(starts):\n starts = nodes\n _start = 'Random from all nodes'\n\n current = starts[randint(0, (len(starts) - 1))]\n while True:\n tour.append(current.nid)\n nodes.remove(current)\n steps.append(construct_step(tour, str(_start), 'random', original_nodes, scale))\n if not len(nodes):\n break\n current = nodes[tsputil.nearest_neighbor(nodes, current)[0]]\n tour.append(tour[0])\n steps.append(construct_step(tour, str(_start), 'random', original_nodes, scale))\n self._datacontroller.commit_change('pathsteps', steps)\n self._datacontroller.commit_change('path', steps[-1])","def getPosition(self, cur_time=timezone.now()):\n # Get waypoints\n if hasattr(self, 'preprocessed_waypoints'):\n waypoints = self.preprocessed_waypoints\n else:\n # Load waypoints for obstacle, filter for consecutive duplicates\n all_wpts = self.waypoints.order_by('order')\n waypoints = [\n all_wpts[i]\n for i in range(len(all_wpts))\n if i == 0 or all_wpts[i].distanceTo(all_wpts[i-1]) != 0]\n self.preprocessed_waypoints = waypoints\n\n # Waypoint counts of 0 or 1 can skip calc, so can no speed\n num_waypoints = len(waypoints)\n if num_waypoints == 0:\n return (0, 0, 0) # Undefined position\n elif num_waypoints == 1 or self.speed_avg <= 0:\n wpt = waypoints[0]\n return (wpt.position.gps_position.latitude,\n wpt.position.gps_position.longitude,\n wpt.position.altitude_msl)\n\n # Get spline representation\n if hasattr(self, 'preprocessed_spline_curve'):\n spline_curve = self.preprocessed_spline_curve\n else:\n spline_curve = self.getSplineCurve(waypoints)\n self.preprocessed_spline_curve = spline_curve\n (total_travel_time, spline_reps) = spline_curve\n\n # Sample spline at current time\n epoch_time = timezone.now().replace(\n year=1970, month=1, day=1, hour=0, minute=0, second=0,\n microsecond=0)\n cur_time_sec = (cur_time - epoch_time).total_seconds()\n cur_path_time = np.mod(cur_time_sec, total_travel_time)\n latitude = float(splev(cur_path_time, spline_reps[0]))\n longitude = float(splev(cur_path_time, spline_reps[1]))\n altitude_msl = float(splev(cur_path_time, spline_reps[2]))\n\n return (latitude, longitude, altitude_msl)","def closest_point_to(self, p):\n p = np.array(p)\n # align with z-axis so all triangle have same z-coord\n tri_rot, rot = self.align_with([0,0,1])\n tri_rot_z = tri_rot.a[-1]\n p_rot = np.dot(rot, p)\n\n p_2d = p_rot[:2]\n tri_2d = geometry2d.Triangle(tri_rot.a[:2], tri_rot.b[:2], tri_rot.c[:2])\n\n if tri_2d.is_inside(p_2d):\n # projects onto triangle, so return difference in z\n return np.dot(np.linalg.inv(rot), np.array(list(p_2d) + [tri_rot_z]))\n else:\n closest_pt_2d = tri_2d.closest_point_to(p_2d)[1]\n\n closest_pt_3d = np.array(list(closest_pt_2d) + [tri_rot_z])\n\n return np.dot(np.linalg.inv(rot), closest_pt_3d)","def find_path(source_point, destination_point, mesh):\r\n\r\n path = []\r\n boxes = {}\r\n\r\n sourceBox = None\r\n destBox = None\r\n\r\n # print(mesh)\r\n\r\n for box in mesh['boxes']:\r\n if box not in boxes and inBox(box, source_point):\r\n sourceBox = box\r\n # print(sourceBox)\r\n if box not in boxes and inBox(box, destination_point):\r\n destBox = box\r\n # print(destBox)\r\n\r\n if (sourceBox is None) or (destBox is None):\r\n print(\"No Path!\")\r\n return [], []\r\n\r\n dist = {}\r\n prev = {}\r\n boxCoords = {}\r\n\r\n dist[sourceBox] = 0\r\n prev[sourceBox] = None\r\n boxCoords[sourceBox] = source_point\r\n\r\n priorityQueue = []\r\n heappush(priorityQueue, (dist[sourceBox], sourceBox))\r\n\r\n adj = mesh[\"adj\"]\r\n\r\n while priorityQueue:\r\n\r\n currentCost, currentPos = heappop(priorityQueue)\r\n #neighbors = adj(graph, currentPos)\r\n\r\n # if currentPos == destination:\r\n # path = []\r\n # currPath = destination\r\n # while currPath is not None:\r\n # path.insert(0, currPath)\r\n # currPath = prev[currPath]\r\n # return path\r\n\r\n if currentPos == destBox:\r\n path = [boxCoords[currentPos], destination_point]\r\n\r\n backBox = prev[currentPos]\r\n backCoord = boxCoords[currentPos]\r\n\r\n while backBox is not None:\r\n path.insert(0, [boxCoords[backBox], backCoord])\r\n backBox = prev[backBox]\r\n backCoord = boxCoords[backBox]\r\n print(backCoord)\r\n\r\n return path, boxes.keys()\r\n\r\n # for neighborPos, neighborCost in neighbors:\r\n\r\n # alt = dist[currentPos] + neighborCost\r\n\r\n # if neighborPos not in dist or alt < dist[neighborPos]:\r\n # dist[neighborPos] = alt\r\n # prev[neighborPos] = currentPos\r\n # heappush(priorityQueue, (alt, neighborPos))\r\n\r\n for neighbor in adj[currentPos]:\r\n\r\n boxes[neighbor] = currentPos\r\n\r\n xRange = [max(currentPos[0], neighbor[0]),\r\n min(currentPos[1], neighbor[1])]\r\n yRange = [max(currentPos[2], neighbor[2]),\r\n min(currentPos[3], neighbor[3])]\r\n\r\n firstCost = euclideanDistance(\r\n (xRange[0], yRange[0]), boxCoords[currentPos])\r\n secondCost = euclideanDistance(\r\n (xRange[1], yRange[1]), boxCoords[currentPos])\r\n\r\n if firstCost <= secondCost:\r\n finalCost = firstCost\r\n finalPoint = (xRange[0], yRange[0])\r\n else:\r\n finalCost = secondCost\r\n finalPoint = (xRange[1], yRange[1])\r\n\r\n alt = currentCost + finalCost\r\n if neighbor not in dist or alt < dist[neighbor]:\r\n dist[neighbor] = alt\r\n prev[neighbor] = currentPos\r\n boxCoords[neighbor] = finalPoint\r\n heappush(priorityQueue, (alt, neighbor))\r\n return None","def heuristic(current, goal):\r\n # First tried manhattan distance but wasn't good enough so did direct distance which makes sense since the robot came move diagonally \r\n #return abs(current[0]-goal[0])+abs(current[1]-goal[1])\r\n return math.sqrt((current[0]-goal[0])**2+(current[1]-goal[1])**2)","def findPathToClosestDot(self, gameState):\n # Here are some useful elements of the startState\n startPosition = gameState.getPacmanPosition(self.index)\n food = gameState.getFood()\n walls = gameState.getWalls()\n problem = AnyFoodSearchProblem(gameState, self.index)\n\n\n explored = []\n actions = []\n initial = problem.getStartState()\n frontier = util.Queue()\n\n frontier.push((initial, actions))\n\n while not frontier.isEmpty():\n node, actions = frontier.pop()\n if node in explored:\n continue\n explored.append(node)\n if problem.isGoalState(node):\n return actions\n for successor, action, cost in problem.getSuccessors(node):\n frontier.push((successor, actions + [action]))","def closest_point_on_segment(point, segment):\n a, b = segment\n p = closest_point_on_line(point, segment)\n d = distance_point_point_sqrd(a, b)\n d1 = distance_point_point_sqrd(a, p)\n d2 = distance_point_point_sqrd(b, p)\n if d1 > d or d2 > d:\n if d1 < d2:\n return a\n return b\n return p"],"string":"[\n \"def get_closest_waypoint(self, pose):\\n #TODO implement - Done\\n # Iterate the base_waypoints' x value with current position's x value and find the closest\\n # match, and pick that waypoint location index. \\n min_idx = 0\\n min_dist = None\\n cur_x = pose.position.x\\n cur_y = pose.position.y\\n if self.waypoints is not None:\\n for i, wp in enumerate(self.waypoints):\\n wp_x = wp.pose.pose.position.x\\n wp_y = wp.pose.pose.position.y\\n dist = np.sqrt((cur_x - wp_x)**2 + (cur_y - wp_y)**2)\\n if min_dist is None or min_dist >= dist:\\n min_dist = dist\\n min_idx = i\\n \\n # check whether the identified index is behind the current position, if so, move it by 1 index\\n # https://gamedev.stackexchange.com/questions/75072/how-can-i-compare-two-quaternions-for-logical-equality\\n # rospy.logwarn('min_idx before = %d', min_idx)\\n eps = 1e-12\\n if self.waypoints is not None:\\n q1 = self.waypoints[min_idx].pose.pose.orientation\\n q2 = pose.orientation\\n q1_a = np.array([q1.x, q1.y, q1.z, q1.w])\\n q2_a = np.array([q2.x, q2.y, q2.z, q2.w])\\n direction = abs(np.dot(q1_a, q2_a))\\n #rospy.logwarn('calculated direction %f', direction)\\n wp_x = self.waypoints[min_idx].pose.pose.position.x\\n if direction > 1-eps:\\n if wp_x < cur_x:\\n min_idx += 1\\n else:\\n min_idx -= 1\\n else:\\n if wp_x < cur_x:\\n min_idx -= 1\\n else:\\n min_idx += 1\\n\\n # rospy.logwarn('min_idx after = %d', min_idx)\\n return min_idx\",\n \"def _get_closest_waypoint(self, pose):\\n pos = pose.position\\n x = pos.x\\n y = pos.y\\n closest_idx = self.waypoints_tree.query([x,y],1)[1]\\n\\n return closest_idx\",\n \"def find_closest_path(self):\\n\\t\\tclosest_distance = sys.maxint\\n\\t\\tclosest_path = 0\\n\\t\\tbike_position = (self.map_model.bike.xB, self.map_model.bike.yB)\\n\\t\\tfor path_index in range(len(self.map_model.paths)):\\n\\t\\t\\tnearest_point = geometry.nearest_point_on_path(self.map_model.paths[path_index], bike_position)\\n\\t\\t\\tdistance_to_bike = geometry.distance(nearest_point, bike_position)\\n\\t\\t\\tif (closest_distance > distance_to_bike):\\n\\t\\t\\t\\tclosest_distance = distance_to_bike\\n\\t\\t\\t\\tclosest_path = path_index \\n\\t\\tdisp_next = self.displacement_to_turn(target_path = (closest_path+1)%len(self.map_model.paths))\\n\\t\\ttarget_path = (closest_path+1)%len(self.map_model.paths)\\n\\t\\tdistance_next = geometry.distance_from_path(bike_position, self.map_model.paths[target_path])\\n\\t\\tif disp_next - np.abs(distance_next)>-0.01:\\n\\t\\t\\tclosest_path = np.mod(closest_path + 1,len(self.map_model.paths))\\n\\t\\treturn closest_path\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.position.x,\\n pose.position.y))\\n else:\\n return 0\",\n \"def get_closest_waypoint(self, pose):\\n if self.kdtree:\\n return kdtree_closest_point(self.kdtree,\\n (pose.x,\\n pose.y))\\n else:\\n return 0\",\n \"def FindClosestPoint(self, ):\\n ...\",\n \"def get_closest_waypoint(self, pose):\\n # Find the nearest waypoint\\n closest_distance = float('inf')\\n closest_waypoint = 0\\n for i in range(len(self.waypoints)):\\n this_distance = self.distance_to_position(self.waypoints, i, pose.position)\\n if this_distance < closest_distance:\\n closest_distance = this_distance\\n closest_waypoint = i\\n return closest_waypoint\",\n \"def get_closest_waypoint(self, pose, waypoints):\\n #TODO implement\\n\\n\\tmin_dist = float(\\\"inf\\\")\\n\\tclosest_wp_idx = -1\\t\\n\\n for idx, wp in enumerate(waypoints):\\n\\t\\tdist = self.dist_to_point(pose, wp.pose.pose)\\n\\t\\tif(dist < min_dist):\\n\\t\\t\\tmin_dist = dist\\n\\t\\t\\tclosest_wp_idx = idx\\n\\treturn closest_wp_idx\",\n \"def __get_closest_waypoint_index(self, x, y):\\n return self.__waypoint_tree.query([x, y], 1)[1]\",\n \"def get_closest_waypoint_idx(self):\\n\\n # TODO:\\n # The churchlot waypoints are roughly circular but have self-\\n # intersecting endpoints, so I'm not sure how this code will \\n # yield good results. Might need some additional filtering\\n # logic to force a choice consistent with the vehicle pose yaw\\n # in order to avoid jumping onto the wrong path.\\n\\n # Vehicle position short reference\\n pos = self.pose.pose.position\\n\\n # Find the closest waypoint index\\n # If closest index is zero bump to 1 since we don't want slice for \\n # prev_coord to look at the final map waypoint.\\n closest_idx = max(self.waypoint_tree.query([pos.x, pos.y], 1)[1], 1)\\n\\n # Get closest point\\n closest_coord = self.waypoints_2d[closest_idx]\\n prev_coord = self.waypoints_2d[closest_idx-1]\\n\\n # Convert coordinates into 2D numpy vectors\\n closest_vec = np.array(closest_coord)\\n prev_vec = np.array(prev_coord)\\n pos_vec = np.array([pos.x, pos.y])\\n\\n # Find vec(close-prev) dot vec(pos-close) \\n val = np.dot(closest_vec - prev_vec, pos_vec - closest_vec)\\n\\n # If pos is ahead of closest...\\n if val > 0: \\n\\n # Advance index so that closest is ahead of pos\\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\\n\\n # Return closest index\\n return closest_idx\",\n \"def test_find_closest_waypoints_nearest(self):\\n planner = WaypointPlanner(make_example_base_waypoints())\\n\\n planner.position = Vector3(0, 0, 0)\\n waypoints = planner.find_closest_waypoints(1)\\n self.assertEqual(1, len(waypoints))\\n self.assertEqual(0, waypoints[0].pose.pose.position.x)\\n self.assertEqual(0, waypoints[0].pose.pose.position.y)\\n self.assertEqual(0, waypoints[0].pose.pose.position.z)\\n\\n planner.position = Vector3(0.9, 0.9, 0)\\n waypoints = planner.find_closest_waypoints(2)\\n self.assertEqual(2, len(waypoints))\\n self.assertEqual(1, waypoints[0].pose.pose.position.x)\\n self.assertEqual(1, waypoints[0].pose.pose.position.y)\\n self.assertEqual(2, waypoints[1].pose.pose.position.x)\\n self.assertEqual(2, waypoints[1].pose.pose.position.y)\\n\\n # Check it wraps back around to the start.\\n planner.position = Vector3(0.9, 0.9, 0)\\n waypoints = planner.find_closest_waypoints(3)\\n self.assertEqual(3, len(waypoints))\\n self.assertEqual(1, waypoints[0].pose.pose.position.x)\\n self.assertEqual(1, waypoints[0].pose.pose.position.y)\\n self.assertEqual(2, waypoints[1].pose.pose.position.x)\\n self.assertEqual(2, waypoints[1].pose.pose.position.y)\\n self.assertEqual(0, waypoints[2].pose.pose.position.x)\\n self.assertEqual(0, waypoints[2].pose.pose.position.y)\",\n \"def get_closest_waypoint(self, x, y):\\n # TODO implement\\n closest_idx = self.waypoint_tree.query([x, y], 1)[1]\\n return closest_idx\",\n \"def get_closest_waypoint(self, x, y):\\n closest_idx = self.waypoint_tree.query([x, y])[1] # ckd tree (1st closest, idx)\\n\\n # Check if closest waypoint is ahead or behind vehicle\\n closest_coord = self.waypoints_2d[closest_idx]\\n prev_coord = self.waypoints_2d[closest_idx - 1]\\n\\n # Equation for hyperplane through closest_coors\\n cl_vect = np.array(closest_coord)\\n prev_vect = np.array(prev_coord)\\n pos_vect = np.array([x, y])\\n\\n val = np.dot(cl_vect - prev_vect, pos_vect - cl_vect)\\n # Car is ahead of the closest waypoint\\n if val > 0:\\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\\n\\n return closest_idx\",\n \"def get_closest_waypoint_idx(self):\\n\\n # Position\\n x = self.car_pose.pose.position.x\\n y = self.car_pose.pose.position.y\\n closest_idx = self.waypoint_tree.query([x, y], 1)[1]\\n\\n # Coordinates\\n closest_coord = self.waypoints_2d[closest_idx]\\n prev_coord = self.waypoints_2d[closest_idx - 1]\\n\\n # Hyper Plane\\n cl_vect = np.array(closest_coord)\\n prev_vect = np.array(prev_coord)\\n pos_vect = np.array([x, y])\\n\\n val = np.dot(cl_vect - prev_vect, pos_vect - cl_vect)\\n\\n if val > 0:\\n closest_idx = (closest_idx + 1) % len(self.waypoints_2d)\\n\\n return closest_idx\",\n \"def closest_waypoint(self, location: pylot.utils.Location):\\n min_dist = np.infty\\n min_index = 0\\n for index, waypoint in enumerate(self.waypoints):\\n dist = waypoint.location.distance(location)\\n if dist < min_dist:\\n min_dist = dist\\n min_index = index\\n return min_index\",\n \"def get_closest_waypoint_idx(self, pose):\\n d, kdwp = self.kdtree.query((pose.position.x, pose.position.y))\\n return kdwp\",\n \"def closest_on_screen_point(trajectory, viewpoint, yaw, gaze_on_screen):\\n\\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \\n #pprint(traj_angles)\\n\\n #onscreen_idx, dists, *_ = find_closest_index(traj_angles, gaze_on_screen)\\n #idx = closest_node(traj_angles, gaze_on_screen)\\n idx = find_closest_index(traj_angles, gaze_on_screen)\\n # print(idx)\\n\\n #traj_ref = trajectory[idx, :]\\n screen_ref = traj_angles[idx, :]\\n world_ref = trajectory[idx, :]\\n\\n path_dist = ab_path_length(trajectory, viewpoint, world_ref)\\n path_dist /= 8.0 #time headway\\n\\n #plot_traj(screen_ref, gaze_on_screen, traj_angles)\\n\\n return(idx, screen_ref, world_ref, path_dist)#, traj_angles)\",\n \"def get_closest_distance_to_path(self, path):\\n min_distance_to_line = float(\\\"inf\\\")\\n for p in path:\\n game_path = p[:]\\n\\n game_path.sort(key = lambda coord: calculate_distance(self, coord))\\n point_A = game_path[0] # Closest point out of all the points on the path to to the tower\\n\\n try:\\n point_after_A = p[p.index(point_A) + 1]\\n point_before_A = p[p.index(point_A) - 1]\\n closest_to_A = min(point_after_A, point_before_A, key = lambda point: calculate_distance(point_A, point))\\n except:\\n if p.index(point_A) == 0:\\n closest_to_A = p[p.index(point_A) + 1]\\n \\n elif p.index(point_A) == len(p) - 1:\\n closest_to_A = p[p.index(point_A) - 1]\\n finally:\\n if closest_to_A[0] != point_A[0]:\\n m = (closest_to_A[1] - point_A[1]) / (closest_to_A[0] - point_A[0])\\n else:\\n m = 2\\n\\n b = point_A[1] - m * point_A[0]\\n\\n closest_distance = abs(-m * self.x + self.y - b) / math.sqrt((-m) ** 2 + 1)\\n min_distance_to_line = min(closest_distance, min_distance_to_line)\\n \\n return min_distance_to_line\",\n \"def get_waypoint_pos(pos: list, waypoints: numpy.ndarray):\\n dist = np.sum((pos - waypoints)**2, axis=1)\\n wp_id = np.argmin(dist)\\n return waypoints[wp_id], wp_id\",\n \"def find_closest_move(self, position, valid_moves):\\n closest = None\\n closest_value = 100\\n for move in valid_moves:\\n if closest:\\n x_dist = abs(position[0] - move[0])\\n y_dist = abs(position[1] - move[1])\\n if x_dist + y_dist < closest_value:\\n closest = move\\n closest_value = x_dist + y_dist\\n else:\\n closest = move\\n\\n return closest\",\n \"def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\\n \\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \\n \\n #pprint(traj_angles)\\n\\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\\n ml_screen_ref = traj_angles[idx] \\n\\n return(idx, ml_screen_ref)\",\n \"def test_find_closest_waypoints_no_position(self):\\n planner = WaypointPlanner(make_example_base_waypoints())\\n self.assertIsNone(planner.find_closest_waypoints(1))\",\n \"def distance_to_current_waypoint():\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint == 0:\\n return None\\n missionitem = vehicle.commands[nextwaypoint -\\n 1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat, lon, alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame,\\n targetWaypointLocation)\\n return distancetopoint\",\n \"def find_path(self):\\n \\n if self.line_num != -1:\\n return self.line_num\\n\\n max_line = self.graph.gps_length - 1\\n min_line = 0\\n #last_id = dg.normalize(self.graph.lines[-1])[0]\\n last_id = normalize_simple(self.graph.lines[-1])[0]\\n pivot = int((self.trip_id-1)/float(last_id)*self.graph.gps_length)\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n while cur_id != self.trip_id:\\n if cur_id < self.trip_id:\\n min_line = pivot\\n else:\\n max_line = pivot\\n #TODO: could make this run in essentially constant time by hopping predetermined distance\\n pivot = (min_line + max_line) / 2\\n #cur_id = dg.normalize(self.graph.lines[pivot])[0]\\n cur_id = normalize_simple(self.graph.lines[pivot])[0]\\n\\n #while dg.normalize(self.graph.lines[pivot])[0] == self.trip_id:\\n while normalize_simple(self.graph.lines[pivot])[0] == self.trip_id:\\n pivot -= 1\\n\\n pivot += 1\\n self.line_num = pivot\\n return pivot\",\n \"def get_path(self):\\r\\n path = [self.city_map.get_tile_at_position(self.position)]\\r\\n destination_tile = self.city_map.get_tile_at_position(self.destination)\\r\\n\\r\\n neighbors = self.city_map.get_adjacent_intersections(self.position)\\r\\n closest_neighbor = None\\r\\n closest_neighbor_distance = math.inf\\r\\n for neighbor in neighbors:\\r\\n if distance(neighbor.position, self.position) < closest_neighbor_distance:\\r\\n closest_neighbor = neighbor\\r\\n closest_neighbor_distance = distance(neighbor.position, self.position)\\r\\n\\r\\n path.append(closest_neighbor)\\r\\n\\r\\n while destination_tile not in path:\\r\\n current_tile = path[-1]\\r\\n neighbors = self.city_map.get_adjacent_intersections(current_tile.position)\\r\\n closest_neighbor = None\\r\\n closest_neighbor_distance = math.inf\\r\\n for neighbor in neighbors:\\r\\n if current_tile.position['y'] == self.destination['y'] or current_tile.position['x'] == \\\\\\r\\n self.destination['x']:\\r\\n # If we're on the same row\\r\\n if current_tile.position['y'] == self.destination['y']:\\r\\n # And if the destination is between our current position and the next intersection over, go to it\\r\\n if (current_tile.position['x'] < self.destination['x'] <= neighbor.position['x'] or\\r\\n neighbor.position['x'] <= self.destination['x'] < current_tile.position['x']):\\r\\n path.append(destination_tile)\\r\\n break\\r\\n # If the neighbor gets us closer, go to it\\r\\n elif distance(neighbor.position, self.destination) < distance(current_tile.position,\\r\\n self.destination):\\r\\n path.append(neighbor)\\r\\n break\\r\\n if current_tile.position['x'] == self.destination['x']:\\r\\n if (current_tile.position['y'] < self.destination['y'] <= neighbor.position['y'] or\\r\\n neighbor.position['y'] <= self.destination['y'] < current_tile.position['y']):\\r\\n path.append(destination_tile)\\r\\n break\\r\\n # If the neighbor gets us closer, go to it\\r\\n elif distance(neighbor.position, self.destination) < distance(current_tile.position,\\r\\n self.destination):\\r\\n path.append(neighbor)\\r\\n break\\r\\n\\r\\n elif distance(neighbor.position, self.destination) < closest_neighbor_distance:\\r\\n closest_neighbor = neighbor\\r\\n closest_neighbor_distance = distance(neighbor.position, self.destination)\\r\\n\\r\\n # If the last iteration through the loop did reach the destination, don't append this\\r\\n if destination_tile not in path and closest_neighbor is not None:\\r\\n path.append(closest_neighbor)\\r\\n\\r\\n return path\",\n \"def find_closest_trajectory_pose(self):\\n np_state = numpy.array([[self.x], [self.y]])\\n temp_distance = numpy.sum(\\n (self.np_trajectory[0:2, :] - np_state) ** 2,\\n axis=0)\\n best_idx = numpy.argmin(temp_distance)\\n return best_idx\",\n \"def _find_path(maze, from_x, from_y, to_x, to_y):\\n distance_map = _create_distance_map(maze, to_x, to_y)\\n if distance_map is None or distance_map[from_x, from_y] < 0:\\n return None\\n\\n path = []\\n current_pos = [from_x, from_y]\\n distance = distance_map[current_pos[0], current_pos[1]]\\n\\n offsets = [[-1, 0], [1, 0], [0, -1], [0, 1]]\\n\\n while distance != 0:\\n for (offset_x, offset_y) in offsets:\\n x = current_pos[0] + offset_x\\n y = current_pos[1] + offset_y\\n if (0 <= x < maze.shape[0] and 0 <= y < maze.shape[1] and\\n distance_map[x, y] == distance - 1):\\n path.append((x, y))\\n current_pos = [x, y]\\n distance -= 1\\n break\\n\\n return path\",\n \"def closest_breakpoint(self, chromosome, position):\\n breaks = self.breaks[(chromosome, self.selected_k[chromosome])]\\n i = bisect.bisect_right(breaks, position)\\n if i == 0:\\n return breaks[0]\\n elif i == len(breaks):\\n return breaks[i - 1]\\n elif abs(position - breaks[i - 1]) < abs(position - breaks[i]):\\n return breaks[i - 1]\\n else:\\n return breaks[i]\",\n \"def get_closest_point(path, point):\\n np_path = convert_path_type(path) # modify path to be a numpy array\\n np_point = convert_point_type(point) # modify point to be a [x,y,z] numpy array\\n\\n # compute the distance from current location to every point in path and find index of the min distance\\n distances = ((np_path[:,0] - np_point[0])**2 + (np_path[:,1] - np_point[1])**2)**0.5\\n closest_idx = np.argmin(distances)\\n\\n if closest_idx != len(np_path) - 1: # check if this point is behind current location, if so use index+1\\n closest_point = np_path[closest_idx]\\n next_closest_point = np_path[closest_idx+1]\\n\\n # create vectors between the three points\\n path_vector = next_closest_point - closest_point\\n current_vector = np_point - closest_point\\n\\n # compute dot product to figure out whether location is behind or in front of closest_point\\n dot_prod = np.dot(path_vector, current_vector)\\n\\n if dot_prod >= 0: # closest point is behind current location\\n closest_idx += 1\\n\\n closest_point = path[closest_idx] # retrieve point from original `path` argument for type consistency\\n\\n return closest_point, closest_idx\",\n \"def _update_next_waypoint(self):\\n if not self.base_waypoints:\\n #rospy.logwarn(\\\"Waypoints not updated: base_waypoints not available yet.\\\")\\n return False\\n\\n if not self.current_pose:\\n #rospy.logwarn(\\\"Waypoints not updated: current_pose not available yet.\\\")\\n return False\\n\\n # Get ego car variables\\n ego_x = self.current_pose.position.x\\n ego_y = self.current_pose.position.y\\n ego_theta = math.atan2(self.current_pose.orientation.y, self.current_pose.orientation.x)\\n\\n # If I do have a next_waypoint, I will start looking from it, and stop looking\\n # as soon as get a local minimum. Otherwise I will do a full search across the whole track\\n t = time.time()\\n wp = None\\n yaw = 0\\n dist = 1000000 # Long number\\n if self.next_waypoint:\\n idx_offset = self.next_waypoint\\n full_search = False\\n else:\\n idx_offset = 0\\n full_search = True\\n num_base_wp = len(self.base_waypoints)\\n\\n for i in range(num_base_wp):\\n idx = (i + idx_offset)%(num_base_wp)\\n wp_x = self.base_waypoints[idx].pose.pose.position.x\\n wp_y = self.base_waypoints[idx].pose.pose.position.y\\n wp_d = math.sqrt((ego_x - wp_x)**2 + (ego_y - wp_y)**2)\\n\\n if wp_d < dist:\\n dist = wp_d\\n wp = idx\\n if debugging:\\n # Angle betwee car heading and waypoint heading\\n yaw = math.atan2(wp_y - ego_y, wp_x - ego_x) - ego_theta\\n elif not full_search:\\n # Local minimum. If the waypoint makes sense, just use it and break\\n if dist < max_local_distance:\\n break; # Found a point\\n else:\\n # Seem to have lost track. Do search again\\n rospy.logwarn(\\\"Waypoint updater lost track (local min at %.1f m after %d waypoints). Going back to full search.\\\", dist, i+1)\\n full_search = True\\n\\n if debugging:\\n rospy.loginfo(\\\"New next wp [%d] -> (%.1f,%.1f) after searching %d points in %fs\\\", wp, dist * math.cos(yaw), dist * math.sin(yaw), i, time.time()-t)\\n\\n if wp is None:\\n rospy.logwarn(\\\"Waypoint updater did not find a valid waypoint\\\")\\n return False\\n\\n self.next_waypoint = wp\\n return True\",\n \"def path(most_important_up, most_important_down, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return source_to_source(most_important_up, most_important_down), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def goal(target, prediction):\\n return closest_point_on_segment(prediction, target)\",\n \"def target_position(self, time):\\n \\\"\\\"\\\"\\n start_pos = self.points[self.cur_start]\\n seg_time = time - self.last_checkpoint_time\\n\\n #The arguement of target-velocity dosent matter\\n cur_pos = self.target_velocity(time)*seg_time + start_pos\\n\\n \\n # or time > (self.total_time / 4)*(self.cur_start + 1)\\n cur_pos_norm = length(cur_pos - start_pos)\\n\\n next_corner = self.points[(self.cur_start + 1)%4]\\n \\n seg_norm = length(next_corner - start_pos)\\n print(\\\"cur_pos : \\\", cur_pos, \\\"segment: \\\", self.cur_start, seg_norm - cur_pos_norm)\\n\\n if cur_pos_norm >= seg_norm:\\n self.cur_start = (self.cur_start + 1) % 4\\n self.last_checkpoint_time = time\\n return cur_pos\\n \\\"\\\"\\\"\\n\\n #Possibly use rospy.sleep()\\n total_time = self.total_time\\n\\n\\n if time < total_time/4:\\n return self.path1.target_position(time)\\n\\n elif time - total_time/4 == 0:\\n rospy.sleep(0.5)\\n\\n elif time < total_time/2:\\n return self.path2.target_position(time - (total_time/4 + 0.5))\\n # return self.path2.target_position(time - (total_time/4 ))\\n\\n\\n elif time - total_time/2 == 0:\\n rospy.sleep(0.5)\\n\\n elif time <= total_time/4*3:\\n return self.path3.target_position(time - (total_time/2 + 1))\\n # return self.path3.target_position(time - (total_time/2))\\n\\n\\n elif time - total_time/4*3 == 0:\\n rospy.sleep(0.5)\\n\\n else:\\n return self.path4.target_position(time - (total_time/4*3 + 1.5))\\n # return self.path4.target_position(time - (total_time/4*3))\",\n \"def distance_to_current_waypoint(vehicle):\\n nextwaypoint = vehicle.commands.next\\n if nextwaypoint==0:\\n return None\\n missionitem=vehicle.commands[nextwaypoint-1] #commands are zero indexed\\n lat = missionitem.x\\n lon = missionitem.y\\n alt = missionitem.z\\n targetWaypointLocation = LocationGlobalRelative(lat,lon,alt)\\n distancetopoint = get_distance_metres(vehicle.location.global_frame, targetWaypointLocation)\\n return distancetopoint\",\n \"def distance_to_current_waypoint(self):\\n next_waypoint = self.vehicle.commands.next\\n if next_waypoint == 1:\\n return None\\n mission_item = self.vehicle.commands[next_waypoint]\\n lat = mission_item.x\\n lon = mission_item.y\\n alt = mission_item.z\\n waypoint_location = Location(lat, lon, alt, is_relative=True)\\n distance = get_distance_meters(self.vehicle.location, waypoint_location)\\n return distance\",\n \"def determineNextMove(player_location, opponentLocation, coins):\\n global route, currentcoin, meta_route, best_weight, best_path, coins_to_search, index\\n if opponentLocation in coins_to_search:\\n coins_to_search, meta_route, route = change_way(coins, opponentLocation, player_location)[:3]\\n index = 0\\n elif currentcoin == player_location: \\n if len(route) != 0:\\n old_dist = algo.dijkstra(mazeMap, player_location)[1][meta_route[index+1]]\\n coins_to_search2, meta_route2, route2, new_dist = change_way(coins, opponentLocation, player_location)\\n\\n #dist_matrix, route_matrix = u.update_dists_from_each(dists_matrix, routes_matrix, player_location, mazeMap, coins)\\n #coins_to_search = get_n_shortest(3, coins, player_location, dists_matrix)\\n \\t\\n #ennemy_dists = algo.dijkstra(mazeMap, opponentLocation)\\n #for c in coins_to_search:\\n #if len(coins_to_search) >= 2 and ennemy_dists[1][c] < dists_matrix[player_location][c]:\\n # coins_to_search.remove(c)\\n #break\\n \\t\\t\\n #best_weight = float(\\\"inf\\\")\\n #best_path = []\\n #exhaustive(coins_to_search, player_location, [], 0, dist_matrix)\\n #meta_route2 = [player_location] + best_path\\n #route2 = u.location_list_to_route(meta_route2, route_matrix)\\n #new_dist = dist_matrix[player_location][meta_route2[1]]\\n\\t\\t\\n if len(route) == 0 or old_dist - new_dist > 3:\\n route = route2\\n meta_route = meta_route2 \\n index = 0\\n index += 1\\n currentcoin = meta_route[index]\\n #api.debug(route)\\n return u.direction(player_location, route.pop(0))\",\n \"def FindClosestInsertedPoint(self, ):\\n ...\",\n \"def get_nearest_waypoint_id(self, pose):\\n idx = self.__waypoints_tree.query([pose.position.x, pose.position.y])[1]\\n\\n closest_point = self.__base_waypoints_array[idx]\\n previous_point = self.__base_waypoints_array[idx - 1]\\n\\n closest_vector = np.array(closest_point)\\n previous_vector = np.array(previous_point)\\n current_pos_vector = np.array([self.__current_pose.position.x, self.__current_pose.position.y])\\n\\n\\n val = np.dot(closest_vector - previous_vector, current_pos_vector - closest_vector)\\n if val > 0:\\n return (idx + 1) % len(self.__base_waypoints_array)\\n\\n return idx\",\n \"def closest(self, x, y):\\n if self.direction == 'horizontal':\\n p_pts = np.array([\\n self.ax.transData.transform((p, 0))[0] for p in self.positions\\n ])\\n dist = abs(p_pts - x)\\n else:\\n p_pts = np.array([\\n self.ax.transData.transform((0, p))[1] for p in self.positions\\n ])\\n dist = abs(p_pts - y)\\n index = np.argmin(dist)\\n return index, dist[index]\",\n \"def find_path(required_pos, required_speed, current_pos, current_speed, path):\\n if (required_pos == current_pos) and (required_speed == current_speed):\\n# print(\\\"== Solution : \\\" + str(path), file=sys.stderr)\\n return path # ok, we have a solution\\n if required_speed <= 0:\\n# print(\\\"negative speed\\\", file=sys.stderr)\\n return -1\\n if required_pos < current_pos:\\n# print(\\\"negative position : {0} < {1}\\\".format(required_pos, current_pos),\\n# file=sys.stderr)\\n return -1 # No path from current pos to get to required pos\\n\\n path.append( [required_pos, required_speed] )\\n# print(\\\"path : \\\" + str(path), file=sys.stderr)\\n \\n # find path, if we slow, keep speed or accelerate\\n path_speed = find_path(required_pos - required_speed, required_speed+1,\\n current_pos, current_speed, path.copy())\\n path_wait = find_path(required_pos - required_speed, required_speed,\\n current_pos, current_speed, path.copy())\\n path_slow = find_path(required_pos - required_speed, required_speed-1,\\n current_pos, current_speed, path.copy())\\n \\n # find best path\\n best_path = -1\\n for p in [path_slow, path_wait, path_speed]:\\n if p == -1:\\n continue\\n if best_path == -1:\\n best_path = p\\n elif len(p) < len(best_path):\\n best_path = p\\n return best_path\",\n \"def closest_point(self, shape, inf_dist=1.0, homogenous=True):\\n\\n self._check_pyb()\\n\\n if not _pyb: # pragma nocover\\n raise ImportError(\\n \\\"The package PyBullet is required for collision \\\"\\n \\\"functionality. Install using pip install pybullet\\\"\\n )\\n\\n if not self.pinit:\\n self._init_pob()\\n self._update_pyb()\\n\\n self._update_pyb()\\n\\n if not shape.pinit:\\n shape._init_pob()\\n shape._update_pyb()\\n\\n ret = p.getClosestPoints(self.co, shape.co, inf_dist)\\n\\n if homogenous:\\n try:\\n return ret[0][8], np.append(np.array(ret[0][5]), 1.0), np.append(np.array(ret[0][6]), 1.0)\\n except ValueError:\\n return None, None, None\\n except IndexError:\\n # Obstacle is further away than inf_dist\\n return None, None, None\\n else:\\n try:\\n return ret[0][8], np.array(ret[0][5]), np.array(ret[0][6])\\n except ValueError:\\n return None, None, None\\n except IndexError:\\n # Obstacle is further away than inf_dist\\n return None, None, None\",\n \"def closest_point(self, l):\\n cos = np.dot(self.direction, l.direction)\\n n = 1 - cos ** 2\\n if n < sys.float_info.epsilon:\\n # Lines are parallel.\\n return self.zero\\n\\n d0 = l.zero - self.zero\\n a = np.dot(d0, self.direction)\\n b = np.dot(d0, l.direction)\\n return self.zero + self.direction * ( a - b * cos) / n\",\n \"def get_path_point(self):\\n if len(self.current_path) == 0:\\n return np.zeros(2), -1\\n ego_x = self.pose.position.x\\n ego_y = self.pose.position.y\\n ego_pose = np.array([[ego_x, ego_y]])\\n disps = (ego_pose - self.current_path)\\n dists = np.hypot(disps[:, 0], disps[:, 1])\\n path_point_idx = np.argmin(dists[self.path_point_idx:]) + self.path_point_idx\\n path_point = self.current_path[path_point_idx]\\n return path_point, path_point_idx\",\n \"def next_move(self):\\n\\n # Calculate all paths to destination from current location and time.\\n solution = self.calculate_best_solution((None, None), self.currentTurn, [self.character.path[-1]],\\n self.character.spent)\\n\\n # Add travel weight to spent.\\n if solution[1] is not None and solution[1][0] != solution[1][1]:\\n self.character.spent += self.pekingMap.get_vertex(solution[1][0]).weight(solution[1][1])\\n\\n # Return next point in shortest path to location.\\n if solution[1] is not None:\\n return solution[1][1]\\n\\n return None\",\n \"def closest_point_to(self, x):\\n x = np.array(x)\\n v = self.p1 - self.p0\\n b = self.p0 - x\\n\\n t = -np.dot(v, b) / np.dot(v, v)\\n if (0 <= t <= 1):\\n closest = t*(self.p1 - self.p0) + self.p0\\n return closest\\n else:\\n if np.linalg.norm(x - self.p0) < np.linalg.norm(x - self.p1):\\n return self.p0\\n else:\\n return self.p1\",\n \"def defenderGoal(self, point, myPos):\\n (x, y) = point\\n temp = self.scanmap.adjacentValidPoints(x, y)\\n targets = []\\n for i in temp:\\n (x, y) = i\\n targets += self.scanmap.adjacentValidPoints(x, y)\\n targets = list(dict.fromkeys(targets))\\n targets.remove(point)\\n\\n minDis = self.getMazeDistance(myPos, targets[0])\\n nearestDefender = targets[0]\\n for j in targets:\\n dis = self.getMazeDistance(myPos, j)\\n if dis < minDis:\\n minDis = dis\\n nearestDefender = j\\n return nearestDefender\",\n \"def target_position(self, time):\\n path, path_time = self.get_current_path(time)\\n return path.target_position(path_time)\",\n \"def move_to(self, waypoint):\\n self.set_final_wp(waypoint)\\n self.go()\\n currPos = np.asarray(self.rexarm.get_positions())\\n while(np.linalg.norm(np.asarray(waypoint) - currPos) > 0.15):\\n time.sleep(0.01)\",\n \"def _find_fastest_path(self):\\n from simulator import Robot\\n clone_robot = Robot(exploration_status=self._robot.exploration_status,\\n facing=self._robot.facing,\\n discovered_map=self._robot.discovered_map,\\n real_map=[[0] * 15 for _ in range(20)])\\n\\n fastest_path_start_way_point = get_shortest_path_moves(clone_robot,\\n start=(1, 1),\\n goal=self._way_point)\\n\\n if fastest_path_start_way_point:\\n for move in fastest_path_start_way_point:\\n clone_robot.move_robot(move)\\n\\n before_way_point = previous_cell(clone_robot.center, clone_robot.facing)\\n\\n fastest_path_way_point_goal = get_shortest_path_moves(clone_robot,\\n start=self._way_point,\\n goal=(18, 13),\\n before_start_point=before_way_point)\\n\\n return fastest_path_start_way_point + fastest_path_way_point_goal\",\n \"def get_closest_lane_waypoint(self, location):\\n loc = to_carla_location(location)\\n waypoint = self._map.get_waypoint(loc,\\n project_to_road=True,\\n lane_type=carla.LaneType.Any)\\n return waypoint\",\n \"def _get_nearest_point(self, position):\\n nearest_inds = np.round(position / self._maze.grid_side - 0.5)\\n return nearest_inds.astype(int)\",\n \"def nearest_segment(self, pose):\\n global_x, global_y, global_a = pose\\n track_pose = 0, 0, 0\\n best = None, None\\n best_dist = None\\n for segment in self.segments:\\n # convert global (x,y) into pose relative coordinates\\n x, y, a = track_pose\\n ca, sa = math.cos(-a), math.sin(-a) # rotate back\\n sx = global_x - x\\n sy = global_y - y\\n sx, sy = ca*sx - sa*sy, sa*sx + ca*sy\\n dist = segment.get_offset((sx, sy, global_a - a))[0]\\n if dist is not None:\\n if best_dist is None or abs(dist) < best_dist:\\n best = segment, (sx, sy, global_a - a)\\n best_dist = abs(dist)\\n track_pose = segment.step(track_pose)\\n return best\",\n \"def _get_next_waypoint(self, tolerance_step):\\n print('\\\\nGetting new nav plan.')\\n\\n for i in range(4):\\n try:\\n self.plan = self.swarmie.get_plan(\\n self.goal,\\n tolerance=self.tolerance,\\n use_home_layer=self.avoid_home\\n )\\n break # plan received\\n except rospy.ServiceException:\\n print('ServiceException.')\\n if i < 3:\\n print('Expanding tolerance.')\\n self.tolerance += tolerance_step\\n else:\\n raise # tried 3 times, we give up\\n\\n print('Received nav plan.')\\n pose = self.plan.plan.poses[0]\\n\\n return Point(x=pose.pose.position.x, y=pose.pose.position.y)\",\n \"def FindClosestPointWithinRadius(self, p_float, , p_float_4):\\n ...\",\n \"def pathfinder(starting_position: tuple, target_position: tuple, grid: np.ndarray) -> List[tuple] or None:\\n moves_dict = {(1, 0): \\\"DOWN\\\", (-1, 0): \\\"UP\\\", (0, 1): \\\"RIGHT\\\", (0, -1): \\\"LEFT\\\"}\\n\\n moves = []\\n path = []\\n dead_ends = []\\n\\n def rate_position(current, target):\\n \\\"\\\"\\\"\\n Helper function to calculate distance to target\\n \\\"\\\"\\\"\\n return (target[0] - current[0]) ** 2 + (target[1] - current[1]) ** 2\\n\\n # Setting starting position\\n current_position = starting_position\\n while current_position != target_position:\\n possible_moves = {}\\n # Checking for each possible move and rating them\\n for m in moves_dict.keys():\\n if check_valid_move(grid, current_position, m):\\n new_position = tuple(np.add(current_position, m))\\n new_position_rating = rate_position(new_position, target_position)\\n if new_position not in path and new_position not in dead_ends:\\n possible_moves[new_position_rating] = m\\n\\n # if there are possible move, select the one, that would move us the closest to target\\n if possible_moves:\\n path.append(current_position) # save position to path\\n moves.append(possible_moves[min(possible_moves)]) # save move to move list\\n current_position = tuple(np.add(current_position, possible_moves[min(possible_moves)]))\\n # if not, go back one move and add current position to dead ends\\n else:\\n # if no moves available from the start, return None\\n if current_position == starting_position:\\n return None\\n dead_ends.append(current_position) # save position to dead ends\\n current_position = path[-1] # move back one step\\n path.pop(-1) # delete step from path\\n moves.pop(-1) # delete move from move list\\n\\n return [tuple(moves_dict[move] for move in moves)]\",\n \"def find_closest_index(traj, point):\\n\\n\\t#TODO: vectorise function to receive any length of points.\\n\\n\\tdistances = np.subtract(np.array(point),traj) \\n\\tdistances = distances.reshape(-1,2)\\n\\t#distances = distances[~np.isnan(distances)].reshape(-1,2)\\n\\n\\t#print(\\\"distances\\\")\\n\\t#pprint(distances)\\n\\tdist_array = np.linalg.norm(distances, axis = 1)\\n\\t#pprint(dist_array)\\n\\t#dist_array = np.sqrt((distances[:,0]**2)+(distances[:,1]**2)) #array of distances from trajectory to gaze landing point in world. \\n\\tidx = np.nanargmin(abs(dist_array)) #find smallest difference in pythag distance from 0,0 to get closest point. \\n\\tdists = distances[idx, :]\\n\\tdist = dist_array[idx]\\n\\n\\treturn idx#, dists, dist\\n\\t#return idx\",\n \"def nextWaypoint(self, pose):\\n #DONE implement\\n location = pose.position\\n dist = 100000.\\n dl = lambda a, b: math.sqrt((a.x-b.x)**2 + (a.y-b.y)**2 + (a.z-b.z)**2)\\n nwp = 0\\n for i in range(len(self.waypoints)):\\n d1 = dl(location, self.waypoints[i].pose.pose.position)\\n if dist > d1:\\n nwp = i\\n dist = d1\\n x = self.waypoints[nwp].pose.pose.position.x\\n y = self.waypoints[nwp].pose.pose.position.y\\n heading = np.arctan2((y-location.y), (x-location.x))\\n angle = np.abs(self.theta-heading)\\n if angle > np.pi/4.:\\n nwp += 1\\n if nwp >= len(self.waypoints):\\n nwp = 0\\n return nwp\",\n \"def get_path(self, grid, start_wp, end_wp):\\n # The open and closed sets\\n openset = set()\\n closedset = set()\\n\\n # Add the starting point to the open set\\n openset.add(start_wp)\\n\\n # While the open set is not empty\\n while openset:\\n # Find the waypoint in the open set with the lowest G + H score\\n current_wp = min(openset, key=lambda o: o.G + o.H)\\n # Found the goal\\n if current_wp == end_wp:\\n path = []\\n while current_wp.parent:\\n path.append(current_wp)\\n current_wp = current_wp.parent\\n path.append(current_wp)\\n print(\\\"Path found in {} moves: {}\\\".format(len(path), path))\\n return path[::-1]\\n\\n # Remove the waypoint from the open set\\n openset.remove(current_wp)\\n # Add it to the closed set\\n closedset.add(current_wp)\\n\\n # Generate children\\n children = current_wp.generate_children(grid)\\n\\n for waypoint in children:\\n # If it is already in the closed set, skip it\\n if waypoint in closedset:\\n continue\\n # Otherwise if it is already in the open set\\n if waypoint in openset:\\n # Check if we beat the G score\\n new_g = current_wp.G + 1\\n\\n if waypoint.G > new_g:\\n # If so, update the waypoint to have a new parent\\n waypoint.G = new_g\\n waypoint.parent = current_wp\\n else:\\n # If it isn't in the open set, calculate the G and H score for the waypoint\\n if waypoint.orientation != current_wp.orientation:\\n waypoint.G = current_wp.G + 1.5 # Avoiding zigzag move by increase the cost of a rotation\\n else:\\n waypoint.G = current_wp.G + 1\\n\\n waypoint.H = abs(waypoint.x - end_wp.x) + abs(waypoint.y - end_wp.y)\\n # Set the parent to our current_wp\\n waypoint.parent = current_wp\\n # Add it to the set\\n openset.add(waypoint)\\n\\n # If there is no solution\\n return [start_wp, end_wp]\",\n \"def calc_nearest_ind(self, robot_pose):\\n pass\",\n \"def heuristic(cell, goal):\\n return math.hypot(goal.x - cell.x, goal.y - cell.y)\",\n \"def findPathToClosestDot(self, gameState):\\n # Here are some useful elements of the startState\\n startPosition = gameState.getPacmanPosition(self.index)\\n food = gameState.getFood()\\n walls = gameState.getWalls()\\n problem = AnyFoodSearchProblem(gameState, self.index)\\n\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return search.bfs(problem)\",\n \"def search_path(self):\\n\\n nodes = [self.start]\\n final_node = None\\n \\n count = 0\\n while True:\\n count += 1\\n\\n if count % self.pick_target == 0:\\n pick = self.goal.pos[:2]\\n else:\\n pick = self.car.random_pos()[:2]\\n \\n nearest = self.get_nearest_node(nodes, pick)\\n\\n if count % self.check_dubins == 0:\\n solutions = self.dubins.find_tangents(nearest.pos, self.goal.pos)\\n dubins_route, cost, valid = self.dubins.best_tangent(solutions)\\n \\n if valid:\\n final_node = nearest\\n break\\n\\n phi = self.get_steering_angle(nearest.pos, pick)\\n pos = nearest.pos\\n branch = [pos[:2]]\\n \\n for i in range(self.max_steps):\\n pos = self.car.step(pos, phi)\\n branch.append(pos[:2])\\n \\n # check safety of route-----------------------\\n if phi == 0:\\n safe = self.dubins.is_straight_route_safe(nearest.pos, pos)\\n else:\\n d, c, r = self.car.get_params(nearest.pos, phi)\\n safe = self.dubins.is_turning_route_safe(nearest.pos, pos, d, c, r)\\n # --------------------------------------------\\n \\n if not safe:\\n continue\\n \\n new_node = Node(pos, phi, i+1)\\n \\n if new_node in nodes:\\n continue\\n \\n new_node.branch = branch\\n new_node.parent = nearest\\n nodes.append(new_node)\\n \\n route = self.backtracking(final_node) + dubins_route\\n path = self.car.get_path(self.car.start_pos, route)\\n print('Total iteration:', count)\\n \\n return path, nodes\",\n \"def get_shortest_paths(distance_map: DistanceMap, agent_pos, agent_dir, max_depth: Optional[int] = None, agent_handle: Optional[int] = None) \\\\\\n -> Dict[int, Optional[List[Waypoint]]]:\\n shortest_paths = dict()\\n\\n def _shortest_path_for_agent(agent,agent_pos,agent_dir):\\n if agent_pos is None :\\n if agent.status == RailAgentStatus.READY_TO_DEPART:\\n position = agent.initial_position\\n elif agent.status == RailAgentStatus.ACTIVE:\\n position = agent.position\\n elif agent.status == RailAgentStatus.DONE:\\n position = agent.target\\n else:\\n shortest_paths[agent.handle] = None\\n return\\n direction = agent.direction\\n else :\\n position = agent_pos\\n direction = agent_dir \\n shortest_paths[agent.handle] = []\\n distance = math.inf\\n depth = 0\\n while (position != agent.target and (max_depth is None or depth < max_depth)):\\n next_actions = get_valid_move_actions_(direction, position, distance_map.rail)\\n best_next_action = None\\n for next_action in next_actions:\\n next_action_distance = distance_map.get()[\\n agent.handle, next_action.next_position[0], next_action.next_position[\\n 1], next_action.next_direction]\\n if next_action_distance < distance:\\n best_next_action = next_action\\n distance = next_action_distance\\n\\n shortest_paths[agent.handle].append(Waypoint(position, direction))\\n depth += 1\\n\\n # if there is no way to continue, the rail must be disconnected!\\n # (or distance map is incorrect)\\n if best_next_action is None:\\n shortest_paths[agent.handle] = None\\n return\\n\\n position = best_next_action.next_position\\n direction = best_next_action.next_direction\\n if max_depth is None or depth < max_depth:\\n shortest_paths[agent.handle].append(Waypoint(position, direction))\\n\\n if agent_handle is not None:\\n _shortest_path_for_agent(distance_map.agents[agent_handle],agent_pos,agent_dir)\\n else:\\n for agent in distance_map.agents:\\n _shortest_path_for_agent(agent,agent_pos,agent_dir)\\n\\n return shortest_paths\",\n \"def one_way_path(most_important, total_distance, to_source2, to_source1):\\n\\n if total_distance == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(most_important), total_distance\\n elif to_source2[0] == min(total_distance, to_source2[0], to_source1[0]):\\n return most_important_to_source(to_source2[1]), to_source2[0]\\n else:\\n return most_important_to_source(to_source1[1], up=False), to_source1[0]\",\n \"def find_path(self, origin, destination, max_time = 1):\\r\\n \\r\\n # Before we start, let's check we need to do something\\r\\n if origin == destination or self._heuristic_weight(origin, destination) == 0:\\r\\n return None\\r\\n \\r\\n # Add the starting point to the \\\"open\\\" list\\r\\n self.open_list.append(origin)\\r\\n self.g_cost[origin] = 0\\r\\n self.h_cost[origin] = self.f_cost[origin] = self._heuristic_weight(origin, destination)\\r\\n \\r\\n self.start_time = lib.clock()\\r\\n nearest_parent = {}\\r\\n self.path = PATH_INEXISTENT\\r\\n \\r\\n #while (lib.clock() - self.start_time) < max_time:\\r\\n while len(self.open_list):\\r\\n # The \\\"parent\\\" node, around which we look, is always the first node of the \\\"open\\\" list\\r\\n # This node is transferred to the \\\"closed\\\" list\\r\\n current_parent = self.open_list[0]\\r\\n self.closed_list.append(current_parent)\\r\\n del self.open_list[0]\\r\\n\\r\\n # The \\\"parent\\\" node is the destination : the path has been found.\\r\\n if current_parent == destination:\\r\\n self.path = PATH_FOUND\\r\\n break\\r\\n\\r\\n # Set the first element of the open list as the one that has the smallest F-cost\\r\\n for (i, node) in enumerate(self.open_list):\\r\\n if self.f_cost[self.open_list[0]] > self.f_cost[node]:\\r\\n (self.open_list[i], self.open_list[0]) = (self.open_list[0], node)\\r\\n \\r\\n # Check the adjacent nodes\\r\\n children = [road.end for road in current_parent.leaving_roads]\\r\\n \\r\\n for child in children:\\r\\n # Not already in the closed list neither in the open list\\r\\n if not (child in self.closed_list) and not (child in self.open_list):\\r\\n # Compute its G-cost, H-cost and F-cost\\r\\n self.g_cost[child] = self.g_cost[current_parent] + road.weight\\r\\n self.h_cost[child] = self._heuristic_weight(child, destination)\\r\\n self.f_cost[child] = self.g_cost[child] + self.h_cost[child]\\r\\n \\r\\n nearest_parent[child] = current_parent\\r\\n \\r\\n # Add the node to the open list, keeping the order (the first node has the smallest F-cost)\\r\\n if len(self.open_list) and (self.f_cost[self.open_list[0]] > self.f_cost[child]):\\r\\n self.open_list.insert(0, child)\\r\\n else:\\r\\n self.open_list.append(child)\\r\\n\\r\\n # Already in the open list : check to see if this path is a better one than the currently known path\\r\\n elif child in self.open_list:\\r\\n # Compute the G-cost of this possible new path\\r\\n current_g_cost = self.g_cost[current_parent] + road.weight\\r\\n \\r\\n # This path is shorter (lower G-cost) : store this path as default to reach this node\\r\\n if current_g_cost < self.g_cost[child]:\\r\\n # Set this path as the shortest path to reach this node\\r\\n nearest_parent[child] = current_parent\\r\\n self.g_cost[child] = current_g_cost\\r\\n self.f_cost[child] = self.g_cost[current_parent] + self.h_cost[child] # Do not forget to update the F-cost !\\r\\n \\r\\n # Check if the open list is still in the right order\\r\\n if self.f_cost[self.open_list[0]] > self.f_cost[child]:\\r\\n i = self.open_list.index(child)\\r\\n (self.open_list[0], self.open_list[i]) = (self.open_list[i], self.open_list[0])\\r\\n\\r\\n # Save the path if it exists.\\r\\n if self.path == PATH_FOUND:\\r\\n \\r\\n current_node = destination\\r\\n self.path = []\\r\\n self.path_length = 0\\r\\n \\r\\n while current_node != origin:\\r\\n self.path.insert(0, current_node)\\r\\n if current_node in nearest_parent:\\r\\n current_node = nearest_parent[current_node]\\r\\n else:\\r\\n raise Exception('ERROR (in gps.find_path()): ill-formed parent list, a node has no parent.')\\r\\n \\r\\n self.path_length += 1\\r\\n return self._build_path()\\r\\n\\r\\n return None\",\n \"def findPathToClosestDot(self, gameState):\\n # Here are some useful elements of the startState\\n startPosition = gameState.getPacmanPosition()\\n food = gameState.getFood()\\n walls = gameState.getWalls()\\n problem = AnyFoodSearchProblem(gameState)\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n return breadthFirstSearch(problem)\\n # util.raiseNotDefined()\",\n \"def search(world_state, robot_pose, goal_pose):\\n if world_state.shape[0] == 0 or world_state.shape[1] == 0:\\n print(\\\"Error, empty world_state!!!\\\")\\n return None\\n if not is_pos_valid(robot_pose, world_state.shape):\\n print(\\\"Error, invalid robot_pose!!!\\\", robot_pose)\\n return None\\n if not is_pos_valid(goal_pose, world_state.shape):\\n print(\\\"Error, invalid goal_pose!!!\\\", goal_pose)\\n return None\\n\\n directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # orthogonal directions\\n found = False\\n\\n x, y = robot_pose\\n g = 0\\n h = heuristic(robot_pose, goal_pose)\\n f = g + h\\n open = [[f, x, y]]\\n came_from = {}\\n came_from[robot_pose] = None\\n cost_so_far = {}\\n cost_so_far[robot_pose] = 0\\n\\n while open:\\n open.sort() # sort based on f value\\n current = open.pop(0)\\n\\n x, y = current[1:]\\n g = cost_so_far[(x, y)]\\n\\n if (x, y) == goal_pose:\\n found = True\\n break\\n else:\\n # find available next positions\\n for direction in directions:\\n x2 = x + direction[0]\\n y2 = y + direction[1]\\n\\n # check whether x2 and y2 are valid\\n if not is_pos_valid((x2, y2), world_state.shape):\\n continue\\n\\n g2 = g + 1\\n if world_state[x2, y2] == 0 and ((x2, y2) not in cost_so_far or g2 < cost_so_far[(x2, y2)]):\\n\\n h2 = heuristic((x2, y2), goal_pose)\\n f2 = g2 + h2\\n open.append([f2, x2, y2])\\n came_from[(x2, y2)] = (x, y)\\n cost_so_far[(x2, y2)] = g2\\n if found:\\n path = [goal_pose]\\n current = goal_pose\\n while came_from[current]:\\n current = came_from[current]\\n path.append(current)\\n\\n path.reverse()\\n return path\\n\\n else:\\n return None\",\n \"def closest_other_location(state):\\n locations = others_locations(state)\\n target = closest_other(state)\\n return locations[target]\",\n \"def move_relative(state, location, towards):\\n move_options = util.move_options_to_list(state['move_options'])\\n\\n move_options = [m for m in move_options if m['type'] == 'move']\\n\\n if len(move_options) == 0:\\n return None\\n\\n my_location_ = my_location(state)\\n move_targets = np.array([m['target'] for m in move_options])\\n target_locations = move_targets + my_location_\\n\\n distances_ = distances(location, target_locations)\\n\\n if towards:\\n target_index = np.argmin(distances_)\\n else:\\n target_index = np.argmax(distances_)\\n\\n return move_options[target_index]\",\n \"def update_wp_position(self, event):\\n wp = -1\\n cur_pos = np.array(\\n [self.global_pose.latitude, self.global_pose.longitude])\\n for idx, waypoint in enumerate(self.waypoints):\\n temp = np.array([waypoint['lat'], waypoint['long']])\\n alt_diff = abs(self._rel_alt[-1] - waypoint['rel_alt'])\\n if idx == 0 and (np.linalg.norm(cur_pos - temp) < self._radius):\\n wp = idx\\n break\\n elif (np.linalg.norm(cur_pos - temp) <\\n self._radius) and (alt_diff < self._alt_radius):\\n wp = idx\\n break\\n self._current_wp = wp\",\n \"def find_closest_pt(ref_lon, ref_lat, tlon, tlat):\\n\\n # compute great circle distance from location to model grid points\\n dist = gc_dist(ref_lon, ref_lat, tlon, tlat)\\n\\n # find j index of closest grid point\\n work = N.take(dist,N.argmin(dist,0),0).diagonal()\\n jj = N.argsort(work)[0]\\n\\n # find i index of closest grid point\\n work = N.take(dist,N.argmin(dist,1),1).diagonal()\\n ii = N.argsort(work)[0]\\n\\n return ii, jj\",\n \"def _nearest_to_point(self, point):\\n ptvertex = point.get_vertex(crs=self.crs)\\n segments = zip(self.vertices.slice(0, -1), self.vertices.slice(1, 0))\\n\\n if isinstance(self.crs, CartesianCRS):\\n func = _cvectorgeo.pt_nearest_planar\\n def func(seg):\\n return _cvectorgeo.pt_nearest_planar(ptvertex[0], ptvertex[1],\\n seg[0][0], seg[0][1], seg[1][0], seg[1][1])\\n else:\\n fwd = self.crs.forward\\n inv = self.crs.inverse\\n def func(seg):\\n return _cvectorgeo.pt_nearest_proj(fwd, inv, ptvertex,\\n seg[0], seg[1], tol=0.01)\\n\\n point_dist = map(func, segments)\\n min_point = None\\n min_dist = -1.0\\n for i, (point, dist) in enumerate(point_dist):\\n if dist < min_dist or (i == 0):\\n min_point = point\\n min_dist = dist\\n\\n return min_dist, min_point\",\n \"def closest_point(p1: Vector3, p2: Vector3, p3: Vector3) -> Vector3:\\n k = ((p2.y - p1.y) * (p3.x - p1.x) - (p2.x - p1.x) * (p3.y - p1.y)) / ((p2.y - p1.y) ** 2 + (p2.x - p1.x) ** 2)\\n x4 = p3.x - k * (p2.y - p1.y)\\n y4 = p3.y + k * (p2.x - p1.x)\\n\\n return Vector3(x4, y4, 0)\",\n \"def s_path(self, position: Vector) -> float:\\n return self.path_coordinates(position)[0]\",\n \"def next_gps(self):\\n \\n return Waypoint(0.0, 0.0)\",\n \"def closest(self, x):\\n # http://www.ahinson.com/algorithms_general/Sections/Geometry/PluckerLine.pdf\\n # has different equation for moment, the negative\\n\\n x = arg.getvector(x, 3)\\n\\n lam = np.dot(x - self.pp, self.uw)\\n p = self.point(lam) # is the closest point on the line\\n d = np.linalg.norm( x - p)\\n \\n return namedtuple('closest', 'p d lam')(p, d, lam)\",\n \"def closest(point, points):\\n pts = [(Point.distance(point, p), p) for p in points]\\n pts.sort()\\n return pts[0][1]\",\n \"def closest_point(point, points):\\n return points[cdist([point], points).argmin()]\",\n \"def compute_heuristic(self, position, goal):\\n return abs(position[0] - goal[0]) + abs(position[1] - goal[1])\",\n \"def nearest(self, pose):\\n # type: (Pose) -> Pose\\n assert (self.nodes), 'No nodes.'\\n closest = min(self.nodes, key=lambda x: self.dist(x, pose))\\n return closest\",\n \"def get_next_destination(self) -> Location:\\n # Find index of current location in route\\n i = 0\\n while i < len(self.route):\\n this_loc = self.route[i]\\n #\\n if i > 0 and this_loc == self.route[-1]:\\n return None\\n if this_loc == self.current_location:\\n return self.route[i + 1]\\n i += 1\",\n \"def is_straight_ahead(point_a, point_b, distance):\\n\\n _, route_initial = interpolate_trajectory(world, [point_a.location, point_b.location])\\n if estimate_route_distance(route_initial) < distance or \\\\\\n estimate_route_distance(route_initial) > 3*distance:\\n print (\\\"Rejected because it is too small\\\")\\n return False\\n route = clean_route(route_initial)\\n\\n print (\\\" Straight test \\\")\\n\\n # TODO analize the size of the straight\\n if len(route) > 3:\\n print (\\\"Rejected because of size\\\")\\n return False\\n\\n for point in route:\\n\\n # Check if there are any curve\\n if point[2] == RoadOption.LEFT or point[2] == RoadOption.RIGHT:\\n print (\\\"Rejected because of curve\\\")\\n return False\\n\\n\\n yaw_difference = point_a.rotation.yaw - point_b.rotation.yaw\\n print (\\\" yaw difference is \\\", yaw_difference)\\n if math.fabs(yaw_difference) > 10 and math.fabs(yaw_difference) < 340:\\n print (\\\"Rejected because of curve\\\")\\n return False\\n\\n\\n return True\",\n \"def heuristic(node, goal):\\n return (abs((position(node)[0] - position(goal)[0]))\\n + abs(position(node)[1] - position(goal)[1]))\",\n \"def heuristic(self, node):\\n res = 0\\n np_node = np.array(node)\\n for i in range(4):\\n for j in range(4):\\n tmp = self.goal[i][j]\\n if tmp != 0:\\n point = np.where(np_node == tmp)\\n x = int(point[0])\\n y = int(point[1])\\n distance = np.sqrt(np.square(x - i) + np.square(y - j))\\n res += distance\\n return res\",\n \"def LineClosestPoint(line, testpoint):\\n line = rhutil.coerceline(line, True)\\n testpoint = rhutil.coerce3dpoint(testpoint, True)\\n return line.ClosestPoint(testpoint, False)\",\n \"def optimized_path(coords, startid, mask):\\n coords = np.column_stack((coords, mask))\\n pass_by = np.asarray(coords)\\n path = [coords[startid]]\\n pass_by = np.delete(pass_by, startid, axis=0)\\n while pass_by.any():\\n nearest_id, nearest = min(\\n enumerate(pass_by), key=lambda x: distance(path[-1][:2], x[1][:2]))\\n path.append(nearest)\\n pass_by = np.delete(pass_by, nearest_id, axis=0)\\n\\n return path\",\n \"def findPathToClosestDot(self, gameState):\\n startPosition = gameState.getPacmanPosition(self.index)\\n food = gameState.getFood()\\n walls = gameState.getWalls()\\n problem = AnyFoodSearchProblem(gameState, self.index)\\n return search.bfs(problem)\\n util.raiseNotDefined()\",\n \"def satisfied_waypoints(cls, home_pos, waypoints, uas_telemetry_logs):\\n # Form utm for use as projection in distance calcluations.\\n zone, north = distance.utm_zone(home_pos.latitude, home_pos.longitude)\\n utm = distance.proj_utm(zone, north)\\n\\n # Reduce telemetry from telemetry to waypoint hits.\\n # This will make future processing more efficient via data reduction.\\n # While iterating, compute the best distance seen for feedback.\\n best = {}\\n hits = []\\n for iu, start_log in enumerate(uas_telemetry_logs):\\n end_log = None\\n if iu + 1 < len(uas_telemetry_logs):\\n end_log = uas_telemetry_logs[iu + 1]\\n for iw, waypoint in enumerate(waypoints):\\n dist = cls.closest_interpolated_distance(\\n start_log, end_log, waypoint, utm)\\n best[iw] = min(best.get(iw, dist), dist)\\n score = cls.score_waypoint(dist)\\n if score > 0:\\n hits.append((iw, dist, score))\\n # Remove redundant hits which wouldn't be part of best sequence.\\n # This will make future processing more efficient via data reduction.\\n hits = [\\n max(g, key=lambda x: x[2])\\n for _, g in itertools.groupby(hits, lambda x: x[0])\\n ]\\n\\n # Find highest scoring sequence via dynamic programming.\\n # Implement recurrence relation:\\n # S(iw, ih) = s[iw, ih] + max_{k=[0,ih)} S(iw-1, k)\\n dp = defaultdict(lambda: defaultdict(lambda: (0, None, None)))\\n highest_total = None\\n highest_total_pos = (None, None)\\n for iw in xrange(len(waypoints)):\\n for ih, (hiw, hdist, hscore) in enumerate(hits):\\n # Compute score for assigning current hit to current waypoint.\\n score = hscore if iw == hiw else 0.0\\n # Compute best total score, which includes this match score and\\n # best of all which could come before it.\\n prev_iw = iw - 1\\n total_score = score\\n total_score_back = (None, None)\\n if prev_iw >= 0:\\n for prev_ih in xrange(ih + 1):\\n (prev_total_score, _) = dp[prev_iw][prev_ih]\\n new_total_score = prev_total_score + score\\n if new_total_score > total_score:\\n total_score = new_total_score\\n total_score_back = (prev_iw, prev_ih)\\n dp[iw][ih] = (total_score, total_score_back)\\n # Track highest score seen.\\n if total_score > highest_total:\\n highest_total = total_score\\n highest_total_pos = (iw, ih)\\n # Traceback sequence to get scores and distance for score.\\n scores = defaultdict(lambda: (0, None))\\n cur_pos = highest_total_pos\\n while cur_pos != (None, None):\\n cur_iw, cur_ih = cur_pos\\n hiw, hdist, hscore = hits[cur_ih]\\n if cur_iw == hiw:\\n scores[cur_iw] = (hscore, hdist)\\n _, cur_pos = dp[cur_iw][cur_ih]\\n\\n # Convert to evaluation.\\n waypoint_evals = []\\n for iw, waypoint in enumerate(waypoints):\\n score, dist = scores[iw]\\n waypoint_eval = mission_pb2.WaypointEvaluation()\\n waypoint_eval.id = iw\\n waypoint_eval.score_ratio = score\\n if dist is not None:\\n waypoint_eval.closest_for_scored_approach_ft = dist\\n if iw in best:\\n waypoint_eval.closest_for_mission_ft = best[iw]\\n waypoint_evals.append(waypoint_eval)\\n return waypoint_evals\",\n \"def closest_point_on_line(point, line):\\n a, b = line\\n ab = subtract_vectors(b, a)\\n ap = subtract_vectors(point, a)\\n c = vector_component(ap, ab)\\n return add_vectors(a, c)\",\n \"def navigate_waypoint(commands: list, verbose=False) -> tuple:\\n\\n position: list = [0, 0] # x, y\\n waypoint_cartesian: list = [10, 1] # x, y (relative to ship)\\n waypoint_polar: list = [0, 1, 10] # bearing, distance, and offset in clockwise direction\\n\\n conversion: dict = {'N': 1, 'S': -1, 'E': 1, 'W': -1, 'L': -1, 'R': 1, 'F': 1}\\n \\n if verbose: \\n print(f'position: {position}, waypoint_cartesian: {waypoint_cartesian}, waypoint_polar: {waypoint_polar}')\\n\\n for command in commands: \\n \\n if verbose: \\n print(f'command: {command}')\\n \\n change: int = command['value'] * conversion[command['action']]\\n\\n if command['action'] in ['N', 'S']: \\n waypoint_cartesian[1] += change # in y\\n waypoint_polar = cartesian_to_polar(waypoint_cartesian)\\n elif command['action'] in ['E', 'W']: \\n waypoint_cartesian[0] += change # in x\\n waypoint_polar = cartesian_to_polar(waypoint_cartesian)\\n elif command['action'] in ['L', 'R']: \\n \\n bearing_old = waypoint_polar[0]\\n bearing_new = bearing_old + change\\n\\n if bearing_new > 270:\\n bearing_new -= 360\\n if bearing_new < 0: \\n bearing_new += 360\\n \\n waypoint_polar[0] = bearing_new\\n waypoint_cartesian = polar_to_cartesian(waypoint_polar)\\n\\n elif command['action'] == 'F': \\n \\n position[0] += waypoint_cartesian[0] * change\\n position[1] += waypoint_cartesian[1] * change\\n\\n else: \\n raise ValueError(\\\"Invalid action\\\")\\n \\n if verbose: \\n print(f'position: {position}, waypoint_cartesian: {waypoint_cartesian}, waypoint_polar: {waypoint_polar}')\\n\\n return tuple(position)\",\n \"def distance_to_line(a, b, p):\\n return distance(closest_point(a, b, p), p)\",\n \"def findPathToClosestDot(self, gameState):\\n # Here are some useful elements of the startState\\n startPosition = gameState.getPacmanPosition(self.index)\\n food = gameState.getFood()\\n walls = gameState.getWalls()\\n problem = AnyFoodSearchProblem(gameState, self.index)\\n\\n return search.breadthFirstSearch(problem)\\n util.raiseNotDefined()\",\n \"def test_nearest_location_odd():\\n assert nearest_location([(3, 6), (9, 13)], 7) == 0\\n assert nearest_location([(3, 6), (9, 13)], 7, 1) == 1\",\n \"def nearest_neighbor(self):\\n steps = [{'Tour': [], 'Tourlength': 0}]\\n tour = []\\n original_nodes = self._datacontroller.get_data('nodes')\\n nodes = copy.deepcopy(original_nodes)\\n scale = self._datacontroller.get_data('scale')\\n\\n # Step 1: Get a tour start\\n starts = [node for node in nodes if node.start]\\n _start = 'Random from marked nodes'\\n if not len(starts):\\n starts = nodes\\n _start = 'Random from all nodes'\\n\\n current = starts[randint(0, (len(starts) - 1))]\\n while True:\\n tour.append(current.nid)\\n nodes.remove(current)\\n steps.append(construct_step(tour, str(_start), 'random', original_nodes, scale))\\n if not len(nodes):\\n break\\n current = nodes[tsputil.nearest_neighbor(nodes, current)[0]]\\n tour.append(tour[0])\\n steps.append(construct_step(tour, str(_start), 'random', original_nodes, scale))\\n self._datacontroller.commit_change('pathsteps', steps)\\n self._datacontroller.commit_change('path', steps[-1])\",\n \"def getPosition(self, cur_time=timezone.now()):\\n # Get waypoints\\n if hasattr(self, 'preprocessed_waypoints'):\\n waypoints = self.preprocessed_waypoints\\n else:\\n # Load waypoints for obstacle, filter for consecutive duplicates\\n all_wpts = self.waypoints.order_by('order')\\n waypoints = [\\n all_wpts[i]\\n for i in range(len(all_wpts))\\n if i == 0 or all_wpts[i].distanceTo(all_wpts[i-1]) != 0]\\n self.preprocessed_waypoints = waypoints\\n\\n # Waypoint counts of 0 or 1 can skip calc, so can no speed\\n num_waypoints = len(waypoints)\\n if num_waypoints == 0:\\n return (0, 0, 0) # Undefined position\\n elif num_waypoints == 1 or self.speed_avg <= 0:\\n wpt = waypoints[0]\\n return (wpt.position.gps_position.latitude,\\n wpt.position.gps_position.longitude,\\n wpt.position.altitude_msl)\\n\\n # Get spline representation\\n if hasattr(self, 'preprocessed_spline_curve'):\\n spline_curve = self.preprocessed_spline_curve\\n else:\\n spline_curve = self.getSplineCurve(waypoints)\\n self.preprocessed_spline_curve = spline_curve\\n (total_travel_time, spline_reps) = spline_curve\\n\\n # Sample spline at current time\\n epoch_time = timezone.now().replace(\\n year=1970, month=1, day=1, hour=0, minute=0, second=0,\\n microsecond=0)\\n cur_time_sec = (cur_time - epoch_time).total_seconds()\\n cur_path_time = np.mod(cur_time_sec, total_travel_time)\\n latitude = float(splev(cur_path_time, spline_reps[0]))\\n longitude = float(splev(cur_path_time, spline_reps[1]))\\n altitude_msl = float(splev(cur_path_time, spline_reps[2]))\\n\\n return (latitude, longitude, altitude_msl)\",\n \"def closest_point_to(self, p):\\n p = np.array(p)\\n # align with z-axis so all triangle have same z-coord\\n tri_rot, rot = self.align_with([0,0,1])\\n tri_rot_z = tri_rot.a[-1]\\n p_rot = np.dot(rot, p)\\n\\n p_2d = p_rot[:2]\\n tri_2d = geometry2d.Triangle(tri_rot.a[:2], tri_rot.b[:2], tri_rot.c[:2])\\n\\n if tri_2d.is_inside(p_2d):\\n # projects onto triangle, so return difference in z\\n return np.dot(np.linalg.inv(rot), np.array(list(p_2d) + [tri_rot_z]))\\n else:\\n closest_pt_2d = tri_2d.closest_point_to(p_2d)[1]\\n\\n closest_pt_3d = np.array(list(closest_pt_2d) + [tri_rot_z])\\n\\n return np.dot(np.linalg.inv(rot), closest_pt_3d)\",\n \"def find_path(source_point, destination_point, mesh):\\r\\n\\r\\n path = []\\r\\n boxes = {}\\r\\n\\r\\n sourceBox = None\\r\\n destBox = None\\r\\n\\r\\n # print(mesh)\\r\\n\\r\\n for box in mesh['boxes']:\\r\\n if box not in boxes and inBox(box, source_point):\\r\\n sourceBox = box\\r\\n # print(sourceBox)\\r\\n if box not in boxes and inBox(box, destination_point):\\r\\n destBox = box\\r\\n # print(destBox)\\r\\n\\r\\n if (sourceBox is None) or (destBox is None):\\r\\n print(\\\"No Path!\\\")\\r\\n return [], []\\r\\n\\r\\n dist = {}\\r\\n prev = {}\\r\\n boxCoords = {}\\r\\n\\r\\n dist[sourceBox] = 0\\r\\n prev[sourceBox] = None\\r\\n boxCoords[sourceBox] = source_point\\r\\n\\r\\n priorityQueue = []\\r\\n heappush(priorityQueue, (dist[sourceBox], sourceBox))\\r\\n\\r\\n adj = mesh[\\\"adj\\\"]\\r\\n\\r\\n while priorityQueue:\\r\\n\\r\\n currentCost, currentPos = heappop(priorityQueue)\\r\\n #neighbors = adj(graph, currentPos)\\r\\n\\r\\n # if currentPos == destination:\\r\\n # path = []\\r\\n # currPath = destination\\r\\n # while currPath is not None:\\r\\n # path.insert(0, currPath)\\r\\n # currPath = prev[currPath]\\r\\n # return path\\r\\n\\r\\n if currentPos == destBox:\\r\\n path = [boxCoords[currentPos], destination_point]\\r\\n\\r\\n backBox = prev[currentPos]\\r\\n backCoord = boxCoords[currentPos]\\r\\n\\r\\n while backBox is not None:\\r\\n path.insert(0, [boxCoords[backBox], backCoord])\\r\\n backBox = prev[backBox]\\r\\n backCoord = boxCoords[backBox]\\r\\n print(backCoord)\\r\\n\\r\\n return path, boxes.keys()\\r\\n\\r\\n # for neighborPos, neighborCost in neighbors:\\r\\n\\r\\n # alt = dist[currentPos] + neighborCost\\r\\n\\r\\n # if neighborPos not in dist or alt < dist[neighborPos]:\\r\\n # dist[neighborPos] = alt\\r\\n # prev[neighborPos] = currentPos\\r\\n # heappush(priorityQueue, (alt, neighborPos))\\r\\n\\r\\n for neighbor in adj[currentPos]:\\r\\n\\r\\n boxes[neighbor] = currentPos\\r\\n\\r\\n xRange = [max(currentPos[0], neighbor[0]),\\r\\n min(currentPos[1], neighbor[1])]\\r\\n yRange = [max(currentPos[2], neighbor[2]),\\r\\n min(currentPos[3], neighbor[3])]\\r\\n\\r\\n firstCost = euclideanDistance(\\r\\n (xRange[0], yRange[0]), boxCoords[currentPos])\\r\\n secondCost = euclideanDistance(\\r\\n (xRange[1], yRange[1]), boxCoords[currentPos])\\r\\n\\r\\n if firstCost <= secondCost:\\r\\n finalCost = firstCost\\r\\n finalPoint = (xRange[0], yRange[0])\\r\\n else:\\r\\n finalCost = secondCost\\r\\n finalPoint = (xRange[1], yRange[1])\\r\\n\\r\\n alt = currentCost + finalCost\\r\\n if neighbor not in dist or alt < dist[neighbor]:\\r\\n dist[neighbor] = alt\\r\\n prev[neighbor] = currentPos\\r\\n boxCoords[neighbor] = finalPoint\\r\\n heappush(priorityQueue, (alt, neighbor))\\r\\n return None\",\n \"def heuristic(current, goal):\\r\\n # First tried manhattan distance but wasn't good enough so did direct distance which makes sense since the robot came move diagonally \\r\\n #return abs(current[0]-goal[0])+abs(current[1]-goal[1])\\r\\n return math.sqrt((current[0]-goal[0])**2+(current[1]-goal[1])**2)\",\n \"def findPathToClosestDot(self, gameState):\\n # Here are some useful elements of the startState\\n startPosition = gameState.getPacmanPosition(self.index)\\n food = gameState.getFood()\\n walls = gameState.getWalls()\\n problem = AnyFoodSearchProblem(gameState, self.index)\\n\\n\\n explored = []\\n actions = []\\n initial = problem.getStartState()\\n frontier = util.Queue()\\n\\n frontier.push((initial, actions))\\n\\n while not frontier.isEmpty():\\n node, actions = frontier.pop()\\n if node in explored:\\n continue\\n explored.append(node)\\n if problem.isGoalState(node):\\n return actions\\n for successor, action, cost in problem.getSuccessors(node):\\n frontier.push((successor, actions + [action]))\",\n \"def closest_point_on_segment(point, segment):\\n a, b = segment\\n p = closest_point_on_line(point, segment)\\n d = distance_point_point_sqrd(a, b)\\n d1 = distance_point_point_sqrd(a, p)\\n d2 = distance_point_point_sqrd(b, p)\\n if d1 > d or d2 > d:\\n if d1 < d2:\\n return a\\n return b\\n return p\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7640383","0.718817","0.7167996","0.7131444","0.7131107","0.70338064","0.7031135","0.7023831","0.70102865","0.6980016","0.69242376","0.6840171","0.68167746","0.67727935","0.67419153","0.6639293","0.6608368","0.66068965","0.65030026","0.6495123","0.6488173","0.6472869","0.63848215","0.63194185","0.62900186","0.62602574","0.6259464","0.62232363","0.61725193","0.6156092","0.6115853","0.6105906","0.6104445","0.60843265","0.6083796","0.6065738","0.60653627","0.6065023","0.6054196","0.6047731","0.6042709","0.6020711","0.6017563","0.6014848","0.5970649","0.59651417","0.59370786","0.5928742","0.5922218","0.59129924","0.59004474","0.58958864","0.58848435","0.58832127","0.58788013","0.58738637","0.5865221","0.5842335","0.58385503","0.58377045","0.5834738","0.5822988","0.58190763","0.5809296","0.58011717","0.57997984","0.5791566","0.5760581","0.5758001","0.57471794","0.57434565","0.5737762","0.57318443","0.5714551","0.56934357","0.5677619","0.56703997","0.56661314","0.5654564","0.564761","0.56431633","0.56353766","0.56319577","0.5627739","0.5626726","0.56259966","0.56188834","0.5615952","0.56144506","0.56056565","0.56018513","0.557498","0.55662394","0.55643076","0.55513114","0.55500925","0.5548419","0.55415547","0.55332273","0.5531233"],"string":"[\n \"0.7640383\",\n \"0.718817\",\n \"0.7167996\",\n \"0.7131444\",\n \"0.7131107\",\n \"0.70338064\",\n \"0.7031135\",\n \"0.7023831\",\n \"0.70102865\",\n \"0.6980016\",\n \"0.69242376\",\n \"0.6840171\",\n \"0.68167746\",\n \"0.67727935\",\n \"0.67419153\",\n \"0.6639293\",\n \"0.6608368\",\n \"0.66068965\",\n \"0.65030026\",\n \"0.6495123\",\n \"0.6488173\",\n \"0.6472869\",\n \"0.63848215\",\n \"0.63194185\",\n \"0.62900186\",\n \"0.62602574\",\n \"0.6259464\",\n \"0.62232363\",\n \"0.61725193\",\n \"0.6156092\",\n \"0.6115853\",\n \"0.6105906\",\n \"0.6104445\",\n \"0.60843265\",\n \"0.6083796\",\n \"0.6065738\",\n \"0.60653627\",\n \"0.6065023\",\n \"0.6054196\",\n \"0.6047731\",\n \"0.6042709\",\n \"0.6020711\",\n \"0.6017563\",\n \"0.6014848\",\n \"0.5970649\",\n \"0.59651417\",\n \"0.59370786\",\n \"0.5928742\",\n \"0.5922218\",\n \"0.59129924\",\n \"0.59004474\",\n \"0.58958864\",\n \"0.58848435\",\n \"0.58832127\",\n \"0.58788013\",\n \"0.58738637\",\n \"0.5865221\",\n \"0.5842335\",\n \"0.58385503\",\n \"0.58377045\",\n \"0.5834738\",\n \"0.5822988\",\n \"0.58190763\",\n \"0.5809296\",\n \"0.58011717\",\n \"0.57997984\",\n \"0.5791566\",\n \"0.5760581\",\n \"0.5758001\",\n \"0.57471794\",\n \"0.57434565\",\n \"0.5737762\",\n \"0.57318443\",\n \"0.5714551\",\n \"0.56934357\",\n \"0.5677619\",\n \"0.56703997\",\n \"0.56661314\",\n \"0.5654564\",\n \"0.564761\",\n \"0.56431633\",\n \"0.56353766\",\n \"0.56319577\",\n \"0.5627739\",\n \"0.5626726\",\n \"0.56259966\",\n \"0.56188834\",\n \"0.5615952\",\n \"0.56144506\",\n \"0.56056565\",\n \"0.56018513\",\n \"0.557498\",\n \"0.55662394\",\n \"0.55643076\",\n \"0.55513114\",\n \"0.55500925\",\n \"0.5548419\",\n \"0.55415547\",\n \"0.55332273\",\n \"0.5531233\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67397225"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":80589,"cells":{"query":{"kind":"string","value":"Finds closest visible traffic light, if one exists, and determines its location and color"},"document":{"kind":"string","value":"def process_traffic_lights(self):\n light = None\n\n #some plausability checks before starting the processing\n if None is self.waypoints:\n return -1, TrafficLight.UNKNOWN\n if None is self.pose:\n return -1, TrafficLight.UNKNOWN\n if len( self.stopLineIndex) == 0:\n return -1, TrafficLight.UNKNOWN\n \n car_wp_idx = self.get_closest_waypoint(self.pose)\n closestStopLineIdx = self.find_next_stoplineIndex(car_wp_idx)\n totalNoWP = len(self.waypoints.waypoints)\n \n \n \n #we assume that we can see traffic lights up to a distance of 40 m\n distance = 0.\n #resulting list of stoplights in sight\n tl_index_in_distance = []\n if car_wp_idx == self.stopLineIndex[closestStopLineIdx][0]:\n tl_index_in_distance.append(closestStopLineIdx)\n closestStopLineIdx = (closestStopLineIdx + 1) % len(self.stopLineIndex)\n \n noWPScanned = 0 \n while distance < 40.:\n next_car_wp_idx = (car_wp_idx + 1) % totalNoWP\n distance += self.get_waypoint_distance(car_wp_idx, next_car_wp_idx)\n car_wp_idx = next_car_wp_idx\n #if there is another stoplight in distance, append it to the array \n #of stoplight indices\n if car_wp_idx == self.stopLineIndex[closestStopLineIdx][0]:\n tl_index_in_distance.append(closestStopLineIdx)\n closestStopLineIdx = (closestStopLineIdx + 1) % len(self.stopLineIndex)\n noWPScanned += 1\n for idx in tl_index_in_distance:\n trafficLightIndex = self.stopLineIndex[idx][1]\n trafficLightWaypoint = self.stopLineIndex[idx][0]\n if TrafficLight.RED == self.get_light_status(trafficLightIndex):\n return trafficLightWaypoint, TrafficLight.RED\n return -1, TrafficLight.UNKNOWN"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def process_traffic_lights(self):\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\n if self.init:\n state = self.get_light_state(0)\n return -1, TrafficLight.UNKNOWN\n elif self.ntlwp:\n state = self.get_light_state(self.ntlwp)\n # state = TrafficLight.RED\n return self.ntlwp, state\n return -1, TrafficLight.UNKNOWN","def process_traffic_lights(self):\n closest_light = None\n line_wp_index = None\n\n # We want to find the smallest \"diff\". Initialize to the maximum possible value: total number of waypoints\n diff = len(self.base_waypoints.waypoints)\n\n # List of positions that correspond to the line to stop in front of for a given intersection\n stop_line_positions = self.config['stop_line_positions']\n\n if(self.pose):\n car_wp_index = self.get_closest_waypoint(self.pose.pose.position.x, self.pose.pose.position.y)\n\n #TODO find the closest visible traffic light (if one exists)\n\n # Now go over each light position in the known map (total of 8)\n for i, light in enumerate(self.lights):\n line = stop_line_positions[i] # position of the stop line\n\n # Extract the closest waypoint associated to traffic light (index = i) and in front of the ego\n temp_wp_idx = self.get_closest_waypoint(line[0], line[1])\n\n # Find the number of waypoints between the ego and the temp_wp_idx\n d = temp_wp_idx - car_wp_index\n\n # If this the smallest so far?\n if (d >= 0) and (d < diff):\n diff = d\n closest_light = light\n line_wp_index = temp_wp_idx\n\n # If we did find a closest light:\n if (closest_light):\n # Read the state of the closest light and update the state (i.e., the color of the light)\n # Red: 0, Yellow: 1, Green: 2, Unknown: 4\n state = self.get_light_state(closest_light)\n is_close = (diff < 5) # CLOSE_THRESH\n \n '''\n color_dict = { TrafficLight.RED: 'Red', \\\n TrafficLight.YELLOW: 'Yellow', \\\n TrafficLight.GREEN: 'Green', \\\n TrafficLight.UNKNOWN: 'Unknown'}\n \n rospy.logwarn(\"Closest Traffic Light: ({0}, {1})\".format( color_dict[state], line_wp_index) )\n '''\n return line_wp_index, state, is_close\n else:\n # rospy.logwarn(\"No traffic light found.\")\n return -1, TrafficLight.UNKNOWN, False","def find_tfl_lights(image: np.ndarray):\n kernel = np.array(\n [[0, 0, 0],\n [0, 0, 0],\n [0, 1, 0],\n [1, 3, 1],\n [0, 1, 0]])\n\n kernel = kernel - kernel.mean()\n\n red_image = image.copy()\n red_image = red_image[:, :, 0]\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(red_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n red_points = np.where(mask)\n positions = []\n final_red_points = []\n for point1 in range(len(red_points[0])):\n point = (red_points[0][point1], red_points[1][point1])\n pixel = image[point[0], point[1]]\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\n final_red_points.append(point)\n final_red_points = filter_points(final_red_points)\n positions += final_red_points\n auxilary = ['r'] * len(positions)\n red_x = [val[1] for val in final_red_points]\n red_y = [val[0] for val in final_red_points]\n green_image = image.copy()\n green_image = green_image[:, :, 1]\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\n output = cv2.filter2D(green_image, -1, kernel)\n output_copy = output.copy()\n output = ndimage.maximum_filter(output, size=30)\n output = output - output_copy\n mask = ((output == 0) & (output_copy > 0))\n green_points = np.where(mask)\n final_green_points = []\n for point1 in range(len(green_points[0])):\n point = (green_points[0][point1], green_points[1][point1])\n pixel = image[point[0], point[1]]\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\n final_green_points.append(point)\n\n final_green_points = filter_points(final_green_points)\n positions += final_green_points\n auxilary += ['g'] * len(final_green_points)\n green_x = [val[1] for val in final_green_points]\n green_y = [val[0] for val in final_green_points]\n print(f\"There are {len(green_x) + len(red_x)} points\")\n return positions, auxilary","def process_traffic_lights(self):\n light = None\n light_wp = -1\n\n if not self.waypoints:\n return -1, TrafficLight.UNKNOWN\n if not self.lights:\n return -1, TrafficLight.UNKNOWN\n\n stop_line_positions = self.config['stop_line_positions']\n car_position_idx = 0\n if (self.pose):\n car_position_idx = self.get_closest_waypoint_idx(self.pose.pose)\n car_position = self.waypoints[car_position_idx]\n #rospy.loginfo(\"tl_detector - pose %s %s\", self.pose.pose.position, car_position.pose.pose.position)\n\n #TODO find the closest visible traffic light (if one exists)\n # Fined the closet visible traffic light based on current position\n dist_min = float('inf')\n closest_stop_line_idx = -1\n for i, stop_line_pose in enumerate(stop_line_positions):\n if self.is_ahead_of(car_position.pose.pose, stop_line_pose[0],\n stop_line_pose[1]):\n dist = self.calculate_distance(\n car_position.pose.pose.position.x, stop_line_pose[0],\n car_position.pose.pose.position.y, stop_line_pose[1])\n if dist < dist_min:\n dist_min = dist\n closest_stop_line_idx = i\n\n if dist_min < self.max_tl_dist and closest_stop_line_idx >= 0:\n # Find wp index in waypoints which is closest to the traffic light\n light = self.lights[closest_stop_line_idx]\n dist_min = float('inf')\n wp = self.get_closest_waypoint_xy(\n stop_line_positions[closest_stop_line_idx])\n\n if wp > car_position_idx:\n light_wp = wp\n\n state = self.get_light_state(light)\n return light_wp, state\n return -1, TrafficLight.UNKNOWN","def _get_closest_light_ahead(self, pose):\n #\n # we have very few lights in either the simulation or the live test,\n # so it is easiest just to loop thru them rather than use KDTree\n #\n pos = pose.position\n x = pos.x\n y = pos.y\n closest_idx = -1\n closest_dist2 = None\n idx = 0\n for light in self.lights:\n xl = light.pose.pose.position.x\n yl = light.pose.pose.position.y\n\n #\n # make sure light is ahead, otherwise ignore it\n # we can only do this if the car velocity is nonzero\n #\n skip_light = False\n if self.velocity_unit_vector:\n dx = xl - x\n dy = yl - y\n car_to_light = [dx,dy]\n val = self.dot2d(car_to_light,self.velocity_unit_vector)\n if val < 0.0:\n #\n # light is behind us so continue\n #\n skip_light = True\n\n if not skip_light:\n if closest_dist2 is None:\n closest_idx = idx\n closest_dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\n else:\n dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\n if dist2 < closest_dist2:\n closest_idx = idx\n closest_dist2 = dist2\n idx+=1\n \n return closest_idx","def process_traffic_lights(self):\n\n # Our closest visible traffic light starts off as none\n t1 = time()\n\n\n closest_traffic_light_waypoint = -1\n\n # Get the list of 'stop line' positions\n stop_line_positions = self.config['stop_line_positions']\n\n # Find which waypoint the car is closest to\n closest_stop_line_waypoint = -1\n traffic_light_state = TrafficLight.UNKNOWN\n if(self.pose):\n car_position_waypoint = self.get_closest_waypoint(self.pose.pose)\n\n # Find the closest traffic light based on stop positions\n index, closest_stop_line_waypoint = self.get_closest_stop_line_waypoint(self.waypoints, car_position_waypoint, stop_line_positions)\n\n # Get traffic light state ground truth from simulator provided lights list\n traffic_light_state_truth = TrafficLight.UNKNOWN\n if len(self.lights) > 0 and index >= 0 and index < len(self.lights):\n # Use matching index from stop_line_positions and hope that they align\n traffic_light_state_truth = self.lights[index].state\n\n # Get traffic light state from camera image\n traffic_light_state = self.get_light_state(traffic_light_state_truth)\n\n text = \"\"\n if traffic_light_state == 0: text = \"Red.\"\n if traffic_light_state == 1: text = \"Yellow.\"\n if traffic_light_state == 2: text = \"Green.\"\n if traffic_light_state == 3: text = \"Unknown.\"\n real = \"\"\n if traffic_light_state_truth == 0: real = \"Red.\"\n if traffic_light_state_truth == 1: real = \"Yellow.\"\n if traffic_light_state_truth == 2: real = \"Green.\"\n if traffic_light_state_truth == 3: real = \"Unknown.\"\n\n return closest_stop_line_waypoint, traffic_light_state","def process_traffic_lights(self):\n closest_light = None\n\tline_wp_idx = None\n\n # List of positions that correspond to the line to stop in front of for a given intersection\n stop_line_positions = self.config['stop_line_positions']\n if(self.pose):\n\n \tcar_wp_idx = self.get_closest_waypoint(self.pose.pose, self.lights)\n\t\ttl = self.lights[car_wp_idx]\n\n \t#TODO find the closest visible traffic light (if one exists)\n\t\tdiff = len(self.waypoints)\n\t\tfor i, light in enumerate(self.lights):\n\t\t\tline = stop_line_positions[i]\n\n\t\t\tline_pose = Pose()\n\t\t\tline_pose.position.x = line[0]\n\t\t\tline_pose.position.y = line[1]\n\n\t\t\ttemp_wp_idx = self.get_closest_waypoint(line_pose, self.waypoints)\n\n\t\t\td = temp_wp_idx - car_wp_idx\n\t\t\tif d >= 0 and d < diff:\n\t\t\t\tdiff = d\n\t\t\t\tclosest_light = light\n\t\t\t\tline_wp_idx = temp_wp_idx\n\n\tcar_dist = self.dist_to_point(self.pose.pose, tl.pose.pose)\n\n#\trospy.logwarn(\"DISTANCE: {}, LAST_DISTANCE: {}\".format(car_dist, self.last_dist))\n\n if closest_light and car_dist<self.distance_threshold_max and car_dist>self.distance_threshold_min and self.last_dist>=car_dist:\n\t\tcv_img = self.bridge.imgmsg_to_cv2(self.camera_image, 'rgb8')\n\t\ttl_image = self.detect_traffic_light(cv_img)\n\t\tif tl_image is not None:\n\t\t\tstate = self.light_classifier.get_classification(tl_image)\n\t\t\tstate = state if(state != self.invalid_state_number) else TrafficLight.UNKNOWN\t\n\t\t\t\n\t\t\trospy.logwarn(\"[TL_DETECTOR] State of traffic light is {}\".format(state))\n\t\telse:\n\t\t\trospy.logwarn(\"[TL_DETECTOR] No TL is detected\")\t\n\t\tself.last_dist = car_dist\n return line_wp_idx, state\n \n\tself.last_dist = car_dist\n return -1, TrafficLight.UNKNOWN","def process_traffic_lights(self):\n light = None\n\n if self.waypoints and self.pose:\n self.car_wpidx = self.waypoints.find_closest_waypoint([self.pose.pose.position.x, self.pose.pose.position.y])\n for traffic_light_wp in self.traffic_light_waypoints:\n # rospy.loginfo(\"Traffic Waypoiny: %d\", traffic_light_wp[1])\n # rospy.loginfo(\"Car position: %d\", self.car_wpidx)\n if traffic_light_wp[1] > self.car_wpidx:\n light = True\n light_id = traffic_light_wp[0]\n light_wp = traffic_light_wp[1]\n break\n\n if light and light_wp - self.car_wpidx < self.traffic_light_lookahead_wps:\n state, max_output_score, _ = self.get_light_state(self.lights[light_id])\n if self.loglevel >= 4:\n rospy.loginfo(\"Traffic state: %d, score: %f\", state, max_output_score)\n return light_wp, state\n if light:\n return light_wp, TrafficLight.UNKNOWN\n return -1, TrafficLight.UNKNOWN","def find_tfl_lights(c_image: np.ndarray):\n red_img = c_image[:, :, 0]\n green_img = c_image[:, :, 1]\n new_red = convolution(red_img)\n new_green = convolution(green_img)\n x_red, y_red = get_max_candidate(new_red)\n x_green, y_green = get_max_candidate(new_green)\n return x_red, y_red, x_green, y_green","def process_traffic_lights(self):\n light = None\n\n car_position = None\n\n light_wp = None\n\n # List of positions that correspond to the line\n # to stop in front of for a given intersection\n stop_line_positions = self.config['stop_line_positions']\n if(self.pose):\n car_position = self.get_closest_waypoint(self.pose.pose)\n\n # TODO find the closest visible traffic light (if one exists)\n\n # rospy.logerr(self.waypoints_list[5000:6000])\n\n closest_upcoming_tl = None\n\n if car_position:\n\n car_index = car_position[2]\n next_car_index = car_index + 1\n next_car_position = self.waypoints_list[next_car_index]\n\n for stop_line_position in stop_line_positions:\n # Add None to the last element to not block\n stop_line_index = kdtree_closest_point(\n self.kdtree, stop_line_position)[2]\n if stop_line_index > car_index:\n light_wp = stop_line_index\n light = True\n break\n\n # time.sleep(1000)\n\n # rospy.logerr(car_position)\n # rospy.logerr(upcoming_stop_line_positions)\n\n # tl_kdtree = build_kdtree(stop_line_positions)\n # closest_upcoming_tl = kdtree_closest_point(tl_kdtree, car_position)\n#\n #if closest_upcoming_tl:\n # light = True\n # light_wp = kdtree_closest_point(\n # self.kdtree, closest_upcoming_tl)[2]\n\n # rospy.logerr(light_wp)\n\n if light:\n state = 1\n state = self.get_light_state(light)\n # rospy.logerr(\"state\")\n # rospy.logerr(state)\n return light_wp, state\n self.waypoints = None\n return -1, TrafficLight.UNKNOWN","def traffic_light_detection(img_in, radii_range):\n\n thresh1 = 110\n thresh2 = 60\n cannyEdges = cv2.Canny(img_in, thresh1, thresh2)\n\n circles = cv2.HoughCircles(cannyEdges,cv2.HOUGH_GRADIENT, 1, 20, param1=50,param2=30,minRadius=0,maxRadius=0)\n circles_selected = select_three(circles)\n\n for circle in circles_selected:\n column = circle[0]\n row = circle[1]\n coordinates = (column, row)\n state_pixels = img_in[int(row), int(column), :]\n # print(state_pixels)\n if state_pixels[1] == 255 and state_pixels[2] != 255 :\n state = 'green'\n if state_pixels[1] != 255 and state_pixels[2] == 255 :\n state = 'red'\n if state_pixels[1] == 255 and state_pixels[2] == 255 :\n state = 'yellow'\n\n column_2 = circles_selected[1][0]\n row_2 = circles_selected[1][1]\n coordinates_2 = (column_2, row_2)\n state_pixels_2 = img_in[int(row_2), int(column_2), :]\n\n return coordinates_2, state\n raise NotImplementedError","def neighboring_light(glow, block):\n\n return clamp(glow - blocks[block].dim, 0, 15)","def traffic_light_detection(img_in, radii_range, noisy_image=False, max_x_offset=5):\n\n img = process_base_image(img_in, (7, 7))\n\n # find all the circles in an image using Hough Circles\n min_radii = min(radii_range)\n max_radii = max(radii_range)\n # the distance between the circles should be the smallest possible circles that can touch.\n min_dist = min_radii * 2 + 10\n\n # img, dp, min_dist, param1, param2, minRad, maxRad\n if noisy_image:\n circles = hough_circles(img, 1.55, min_dist, 20, 15, min_radii, max_radii)\n else:\n circles = hough_circles(img, 1.125, min_dist, 30, 20, min_radii, max_radii)\n\n if circles is None:\n return (0, 0), None\n else:\n # cleanup circles so its easier to use.\n circles = circles[0, :]\n # round the numbers of the array to uint16 values.\n circles = np.uint16(np.around(circles))\n\n if len(circles) < 3:\n return (1000, 1000), None\n else: # If there are more than 3 circles found, eliminate the outliers that shouldn't be detected.\n # sort the circles first by x, then by Radius value, then by Y value.\n circles = sorted(circles, key=lambda c: (c[0], c[2], c[1]))\n\n # since the traffic lights will be a group of 3 circles with a similar radius, then x value, then somewhat close\n # in y value, use a \"window\" type of sliding group to create groups of 3 circles that can then be compared\n # to each other to see if they would make up circles of a traffic light.\n circle_groups = []\n for c_idx in range(len(circles) - 2):\n circle_group = circles[c_idx: c_idx + 3] # build the group\n circle_groups.append(circle_group)\n\n circle_groups = np.array(circle_groups)\n # for each circle group found, need to figure out the group with the lowest overall standard deviation.\n # for each group, calculate the std deviations.\n group_deviations = np.array([circle_group_deviations(g) for g in circle_groups])\n\n most_similar_idx = np.argmin(group_deviations)\n final_circles = circle_groups[most_similar_idx]\n\n # if the circles aren't close to each other in the X direction, return\n # none since its not a traffic light.\n x_diffs = np.diff(final_circles[:, 0])\n if np.any(x_diffs >= max_x_offset):\n return (None, None), None\n\n # sort the circles from top down to allow color compare.\n circles = final_circles[np.argsort(final_circles[:, 1])] # sort by Y direction.\n # creating some names for clarity due to x, y being col, row.\n red_row, red_col, yellow_row, yellow_col, green_row, green_col = [\n circles[0][1],\n circles[0][0],\n circles[1][1],\n circles[1][0],\n circles[2][1],\n circles[2][0],\n ]\n\n # determine colors.\n state = 'yellow' # default state.\n cords = (yellow_col, yellow_row)\n\n red_color = np.array([0, 0, 255])\n green_color = np.array([0, 255, 0])\n\n # stop for false positive labels.\n if img_in[yellow_row, yellow_col][0] > 10:\n return (None, None), None\n\n if (img_in[red_row, red_col] == red_color).all():\n state = 'red'\n elif (img_in[green_row, green_col] == green_color).all():\n state = 'green'\n\n # print 'Color of TL midpoint is {}'.format(img_in[yellow_row, yellow_col])\n\n return cords, state","def process_traffic_lights(self):\n stopping_waypoint_index = int(self.stopping_waypoint_index)\n nearest_light = self.stopping_waypoint_distance\n # the result of the image_cb function is in the equation below\n traffic_light_value = self.last_state\n #obtain the minimum stopping distance possible given the acceleration, and jerk limits, and slow stop point\n acceleration_limit = 10.0 - 1.0\n slow_stop_point = 0\n min_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\n #obtain the maximum stopping distance by changing the acceleration limit to 6\n acceleration_limit -= 3.0\n max_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\n #add on the current_velocity*rate to make sure it does not overlook the time gap\n max_stop_distance += self.current_velocity*1.0/self.loop_rate\n #if the previous light was red and the car began to stop, continue stopping\n if (traffic_light_value==self.Red_Light and self.prev_traffic_light_value==self.Red_Light and self.prev_stopping_waypoint_index>=0):\n None\n #else if the traffic light is green, ignore it.\n elif traffic_light_value==self.Green_Light:\n stopping_waypoint_index = -1\n #If the velocity is less than 2*slow_stop_point and the distance to the light is less than 2*(0.5*slow_stop_point**2) and the light is red\n elif (self.current_velocity<=5 and nearest_light<=5 and traffic_light_value==self.Red_Light):\n None\n #if the distance to the nearest_light is more than the max_stop_distance, ignore it\n elif nearest_light > max(max_stop_distance,10):\n stopping_waypoint_index = -1\n # else if the traffic light is Yellow or Red and the distance to the nearest light is more than the min_stop_distance\n elif ((traffic_light_value==self.Red_Light or traffic_light_value==self.Yellow_Light) and nearest_light>min_stop_distance):\n None\n #else if the traffic light is unknown, stopping waypoint will be -2, telling whatever previous action to keep proceeding\n elif traffic_light_value==self.Unknown_Light:\n stopping_waypoint_index = -2\n # #else if the traffic light is green, ignore it.\n # elif traffic_light_value==self.Green_Light:\n # stopping_waypoint_index = -1\n #publish the stopping waypoint index\n # self.upcoming_red_light_pub.publish(stopping_waypoint_index)\n self.prev_traffic_light_value = traffic_light_value\n self.prev_stopping_waypoint_index = stopping_waypoint_index\n return stopping_waypoint_index","def lightness_correction(self):\n points = self.color_lookup_table_points\n lightness_max_value = math.sqrt(3 * (255**2))\n deadpool = list()\n for index, point in enumerate(points[0]):\n point = self.get_value_tuple(index)\n lightness = int(math.sqrt(point[0]**2 + point[1]**2 + point[2]**2) * 255 / lightness_max_value)\n if not self.to_dark < lightness < self.to_bright:\n deadpool.append(index)\n self.color_lookup_table_points = (np.delete(points[0], deadpool),\n np.delete(points[1], deadpool),\n np.delete(points[2], deadpool))\n self.point_count = len(self.color_lookup_table_points[0])","def light_source_directions():\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\n [-0.05939919, -0.33739538, 0.93948714],\n [-0.05710194, -0.21230722, 0.97553319],\n [-0.05360061, -0.07800089, 0.99551134],\n [-0.04919816, 0.05869781, 0.99706274],\n [-0.04399823, 0.19019233, 0.98076044],\n [-0.03839991, 0.31049925, 0.9497977],\n [-0.03280081, 0.41611025, 0.90872238],\n [-0.18449839, -0.43989616, 0.87889232],\n [-0.18870114, -0.32950199, 0.92510557],\n [-0.1901994, -0.20549935, 0.95999698],\n [-0.18849605, -0.07269848, 0.97937948],\n [-0.18329657, 0.06229884, 0.98108166],\n [-0.17500445, 0.19220488, 0.96562453],\n [-0.16449474, 0.31129005, 0.93597008],\n [-0.15270716, 0.4160195, 0.89644202],\n [-0.30139786, -0.42509698, 0.85349393],\n [-0.31020115, -0.31660118, 0.89640333],\n [-0.31489186, -0.19549495, 0.92877599],\n [-0.31450962, -0.06640203, 0.94692897],\n [-0.30880699, 0.06470146, 0.94892147],\n [-0.2981084, 0.19100538, 0.93522635],\n [-0.28359251, 0.30729189, 0.90837601],\n [-0.26670649, 0.41020998, 0.87212122],\n [-0.40709586, -0.40559588, 0.81839168],\n [-0.41919869, -0.29999906, 0.85689732],\n [-0.42618633, -0.18329412, 0.88587159],\n [-0.42691512, -0.05950211, 0.90233197],\n [-0.42090385, 0.0659006, 0.90470827],\n [-0.40860354, 0.18720162, 0.89330773],\n [-0.39141794, 0.29941372, 0.87013988],\n [-0.3707838, 0.39958255, 0.83836338],\n [-0.499596, -0.38319693, 0.77689378],\n [-0.51360334, -0.28130183, 0.81060526],\n [-0.52190667, -0.16990217, 0.83591069],\n [-0.52326874, -0.05249686, 0.85054918],\n [-0.51720021, 0.06620003, 0.85330035],\n [-0.50428312, 0.18139393, 0.84427174],\n [-0.48561334, 0.28870793, 0.82512267],\n [-0.46289771, 0.38549809, 0.79819605],\n [-0.57853599, -0.35932235, 0.73224555],\n [-0.59329349, -0.26189713, 0.76119165],\n [-0.60202327, -0.15630604, 0.78303027],\n [-0.6037003, -0.04570002, 0.7959004],\n [-0.59781529, 0.06590169, 0.79892043],\n [-0.58486953, 0.17439091, 0.79215873],\n [-0.56588359, 0.27639198, 0.77677747],\n [-0.54241965, 0.36921337, 0.75462733],\n [0.05220076, -0.43870637, 0.89711304],\n [0.05199786, -0.33138635, 0.9420612],\n [0.05109826, -0.20999284, 0.97636672],\n [0.04919919, -0.07869871, 0.99568366],\n [0.04640163, 0.05630197, 0.99733494],\n [0.04279892, 0.18779527, 0.98127529],\n [0.03870043, 0.30950341, 0.95011048],\n [0.03440055, 0.41730662, 0.90811441],\n [0.17290651, -0.43181626, 0.88523333],\n [0.17839998, -0.32509996, 0.92869988],\n [0.18160174, -0.20480196, 0.96180921],\n [0.18200745, -0.07490306, 0.98044012],\n [0.17919505, 0.05849838, 0.98207285],\n [0.17329685, 0.18839658, 0.96668244],\n [0.1649036, 0.30880674, 0.93672045],\n [0.1549931, 0.41578148, 0.89616009],\n [0.28720483, -0.41910705, 0.8613145],\n [0.29740177, -0.31410186, 0.90160535],\n [0.30420604, -0.1965039, 0.9321185],\n [0.30640529, -0.07010121, 0.94931639],\n [0.30361153, 0.05950226, 0.95093613],\n [0.29588748, 0.18589214, 0.93696036],\n [0.28409783, 0.30349768, 0.90949304],\n [0.26939905, 0.40849857, 0.87209694],\n [0.39120402, -0.40190413, 0.8279085],\n [0.40481085, -0.29960803, 0.86392315],\n [0.41411685, -0.18590756, 0.89103626],\n [0.41769724, -0.06449957, 0.906294],\n [0.41498764, 0.05959822, 0.90787296],\n [0.40607977, 0.18089099, 0.89575537],\n [0.39179226, 0.29439419, 0.87168279],\n [0.37379609, 0.39649585, 0.83849122],\n [0.48278794, -0.38169046, 0.78818031],\n [0.49848546, -0.28279175, 0.8194761],\n [0.50918069, -0.1740934, 0.84286803],\n [0.51360856, -0.05870098, 0.85601427],\n [0.51097962, 0.05899765, 0.8575658],\n [0.50151639, 0.17420569, 0.84742769],\n [0.48600297, 0.28260173, 0.82700506],\n [0.46600106, 0.38110087, 0.79850181],\n [0.56150442, -0.35990283, 0.74510586],\n [0.57807114, -0.26498677, 0.77176147],\n [0.58933134, -0.1617086, 0.7915421],\n [0.59407609, -0.05289787, 0.80266769],\n [0.59157958, 0.057798, 0.80417224],\n [0.58198189, 0.16649482, 0.79597523],\n [0.56620006, 0.26940003, 0.77900008],\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\n return L","def _process_traffic_lights(self):\n #\n # handle bad data just in case\n #\n if self.waypoints is None or self.waypoints_tree is None:\n #rospy.logwarn(\"[TL_DETECTOR]: No waypoints available\")\n return -1, TrafficLight.UNKNOWN\n\n if self.pose is None:\n #rospy.logwarn(\"[TL_DETECTOR]: car pose is None\")\n return -1, TrafficLight.UNKNOWN\n\n if not self.use_ground_truth and not self.has_image:\n #rospy.logwarn(\"[TL_DETECTOR]: no image available for detection\")\n return -1, TrafficLight.UNKNOWN\n\n if not self.lights:\n #rospy.logwarn(\"[TL_DETECTOR]: no lights found\")\n return -1, TrafficLight.UNKNOWN\n\n ############################################\n # no errors, so real processing begins here\n ############################################\n #\n # find the nearest traffic light ahead\n #\n light = None\n light_idx = self._get_closest_light_ahead(self.pose)\n #\n # handle case where there is no light ahead at any distance\n #\n if light_idx < 0:\n return -1, TrafficLight.UNKNOWN\n\n light = self.lights[light_idx]\n light_pos = light.pose.pose.position\n\n #\n # don't worry about the light if it is too far away\n #\n dist_to_light = self._find_distance(self.pose.position.x,\n self.pose.position.y,\n light.pose.pose.position.x,\n light.pose.pose.position.y)\n\n if dist_to_light > MAX_TRAFFIC_LIGHT_DETECTION_DISTANCE:\n return -1, TrafficLight.UNKNOWN\n\n \n #\n # get stop line for light\n #\n stop_line_for_light = self.stop_line_positions[light_idx]\n\n #\n # get closest waypoints to the stop line for this light\n #\n stop_line_pose = Pose()\n stop_line_pose.position.x = stop_line_for_light[0]\n stop_line_pose.position.y = stop_line_for_light[1]\n stop_line_waypoint_idx = self._get_closest_waypoint(stop_line_pose)\n\n #\n # get closest waypoint to the car\n #\n car_waypoint_idx = self._get_closest_waypoint(self.pose)\n\n #\n # get light state\n #\n state = TrafficLight.UNKNOWN \n if self.use_ground_truth:\n #rospy.logwarn(\"GROUND TRUTH\")\n state = light.state\n else:\n #rospy.logwarn(\"CLASSIFYING IMAGE\")\n state = self._get_light_state(light) \n\n #\n # test against gt_state in sim\n #\n if not self.is_site:\n gt_state = light.state\n pred_state = state\n if gt_state == pred_state:\n self.num_correct_predictions += 1\n else:\n self.num_incorrect_predictions += 1\n self.num_predictions += 1\n\n if self.num_predictions > 0 and self.num_predictions % 10 == 0:\n pred_acc = 100.0*float(self.num_correct_predictions)/float(self.num_predictions) \n rospy.logwarn('[TL_DETECTOR] prediction accuracy is %f percent' % pred_acc)\n\n #\n # return waypoint index of stopline and the light state\n #\n return stop_line_waypoint_idx, state","def light(color, dist):\n return tuple( float(x*dist*dist) for x in color )","def process_traffic_lights(self):\n\n # Clear closest light\n closest_light = None\n\n # Clear closest line index\n line_wp_idx = None\n \n # Load stop line positions from config\n stop_line_positions = self.config['stop_line_positions']\n\n # If we've received valid pose information...\n if self.pose:\n\n # Find index of waypoint closest to current car position\n car_wp_idx = self.waypoint_tree.query([self.pose.pose.position.x, self.pose.pose.position.y],1)[-1]\n\n # Largest possible offset from car to light\n diff = len(self.waypoints.waypoints)\n\n # For each light in the list of traffic lights...\n for i, light in enumerate(self.lights):\n\n # Get stop line position i\n line = stop_line_positions[i]\n\n # Find index of waypoint closest to the light\n wp_idx = self.waypoint_tree.query(line,1)[-1]\n\n # How many waypoints ahead to light? \n wps = wp_idx - car_wp_idx\n\n # If light is ahead of or abreast of car\n # and we haven't encuntered a closer one...\n if wps>=0 and wps<diff:\n\n # Keep track of least positive waypoint count\n diff = wps\n\n # Save this light\n closest_light = light\n\n # Save the waypoint index for this light\n line_wp_idx = wp_idx\n\n # If there is a traffic light in front of us...\n if closest_light:\n\n # Get its state\n state = self.get_light_state(closest_light)\n\n # Return its line index and state\n return line_wp_idx, state\n\n # Otherwise return sentinel indicating no light\n return -1, TrafficLight.UNKNOWN","def nextLight():\n global light\n pin.setAllOutPinsLow()\n light += 1\n light %= len(traffic_lights)\n print traffic_colors[light]\n pin.setOutPinHigh(traffic_lights[light])","def light_color(self):\n return self._spots[constants.CROSSING_LOCATION - 1].light_color()","def check_light(light: pykulersky.Light):\n light.connect()\n light.get_color()","def get_light_state(self, light):\n if (not self.has_image):\n self.prev_light_loc = None\n return TrafficLight.UNKNOWN\n\n rgb = self.bridge.imgmsg_to_cv2(self.camera_image)\n\n if self.use_classifier:\n light_state = self.light_classifier.get_classification(rgb)\n rospy.logdebug('inference: {} / ground truth {}'.format(\n light_state, light.state))\n else:\n light_state = light.state\n\n if self.save_images:\n dist_to_light = self.calculate_distance(\n self.pose.pose.position.x, light.pose.pose.position.x,\n self.pose.pose.position.y, light.pose.pose.position.y)\n\n if dist_to_light <= self.save_images_min_dist:\n bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)\n cv2.imwrite(\"./data/test/test-{}-{}.{}.jpg\".format(\n light_state, light.state, self.camera_image.header.seq),\n bgr)\n\n return light_state","def get_light_state(self, light):\n if(not self.has_image):\n self.prev_light_loc = None\n return TrafficLight.RED\n\n # fixing convoluted camera encoding...\n if hasattr(self.camera_image, 'encoding'):\n self.attribute = self.camera_image.encoding\n if self.camera_image.encoding == '8UC3':\n self.camera_image.encoding = \"rgb8\"\n else:\n self.camera_image.encoding = 'rgb8'\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"rgb8\")\n\n #Get classification\n if self.light_classifier is not None:\n classification = self.light_classifier.get_classification(cv_image)\n else:\n classification = TrafficLight.UNKNOWN\n print \"traffic light: \", label[classification]\n return classification","def find_reddest_pixel_fast(img): \n img = np.array(img, dtype = 'int32')\n location = cv2.minMaxLoc((img[:, :, 2] - img[:, :, 1]) + (img[:, :, 2] - img[:, :, 0]))[3]\n return location","def __process_traffic_lights(self):\n rospy.logdebug(\"TLDetector.__process_traffic_lights\")\n\n closest_light, line_index = self.__get_closest_light()\n\n if closest_light:\n if self.__mode == CLSFY_MODE:\n state = self.__get_light_state(closest_light)\n elif self.__mode == LABEL_MODE:\n if line_index - self.__get_car_index() <= 100:\n state = closest_light.state\n else:\n state = 4\n rospy.loginfo(\n \"TLDetector: Publishing index: \"\n + str(line_index)\n + \" and state: \"\n + str(state)\n )\n return line_index, state\n rospy.logdebug(\"TLDetector: Publishing default\")\n return -1, TrafficLight.UNKNOWN","def get_atmospheric_light(self,img, *, size, percent):\n #Get the atmospheric light factor from the image\n m, n, _ = img.shape\n\n flat_img = img.reshape(m * n, 3)\n flat_dark = self.get_dark_channel(img, size=size).ravel()\n count = math.ceil(m * n * percent / 100)\n indices = np.argpartition(flat_dark, -count)[:-count]\n\n return np.amax(np.take(flat_img, indices, axis=0), axis=0)","def nearest(self, red, green, blue):\n # BAW: should we use Voronoi diagrams, Delaunay triangulation, or\n # octree for speeding up the locating of nearest point? Exhaustive\n # search is inefficient, but seems fast enough.\n nearest = -1\n nearest_name = ''\n for name, aliases in self.__byrgb.values():\n r, g, b = self.__byname[name.lower()]\n rdelta = red - r\n gdelta = green - g\n bdelta = blue - b\n distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta\n if nearest == -1 or distance < nearest:\n nearest = distance\n nearest_name = name\n return nearest_name","def lightness(color):\n\n strongest = max(color.red, color.green, color.blue)\n weakest = min(color.red, color.green, color.blue)\n return 0.5 * (strongest + weakest) / 255","def get_light_state(self, light):\n\treturn light.state \n\n\t#if(not self.has_image):\n # self.prev_light_loc = None\n # return False","def getLight(self):\n return self.light","def identify_color(animal):\n min_dist = None\n identified_color = None\n for color in animal.colors:\n color_rgb = color_rgbs[color]\n dist = ((animal.get_red() - color_rgb[0]) ** 2) + (\n (animal.get_green() - color_rgb[1]) ** 2) + ((animal.get_blue() - color_rgb[2]) ** 2)\n if (min_dist is None) or (dist < min_dist):\n min_dist = dist\n identified_color = color\n return identified_color","def diffuse_light(self):\n return self._diffuse_light","def get_light_state(self, light):\n \tif (not self.has_image):\n return light.state, 1.0, None if light else TrafficLight.UNKNOWN, 0, None\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"rgb8\")\n #Get classification\n \treturn self.light_classifier.get_classification(cv_image)","def getCarLocation():\n cams = CAMS\n img1, img2 = cams[0].getImage(), cams[1].getImage()\n potint1op, point2op = GetBalloonOld.getCar(img1), GetBalloonOld.getCar(\n img2)\n for j in range(len(point1op)):\n point1op[j] = np.array(np.array([point1op[j][0], point1op[j][1]]))\n for j in range(len(point2op)):\n point2op[j] = np.array(np.array([point2op[j][0], point2op[j][1]]))\n if len(point1op) == 0 or len(point2op) == 0:\n return None\n points = [[point1op[0]], [point2op[0]]]\n car = getTargetsPlaces(copy.deepcopy(points))[0]\n diff = abs(car[2] - CAR_Z)\n for op1 in point1op:\n for op2 in point2op:\n testPoint = [[op1], [op2]]\n testCar = getTargetsPlaces(copy.deepcopy(testPoint))[0]\n testDiff = abs(testCar[2] - CAR_Z)\n if testDiff < diff:\n diff = testDiff\n car = testCar\n return car","def get_nearest_color(color):\n\n result = color_re.match(color)\n if result is not None and len(result.groups()) == 5:\n color_red = int(result.groups()[1])\n color_green = int(result.groups()[2])\n color_blue = int(result.groups()[3])\n color_actual = np.array([color_red, color_green, color_blue])\n\n nearest_color = None\n best_distance = 99999.99\n for candidate_color in base_colors:\n color_class = candidate_color[0]\n color_rgb = candidate_color[1]\n color_distance = calc_color_distance(color_actual, color_rgb)\n if color_distance < best_distance:\n best_distance = color_distance\n nearest_color = color_class\n else:\n nearest_color = base_colors[0][0]\n\n return nearest_color","def get_light_state(self, light):\n if(not self.has_image):\n self.prev_light_loc = None\n return False\n\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"bgr8\")\n\n #cv2.imshow('image',cv_image)\n #cv2.waitKey(0)\n\n # Get classification\n if self.init_ok == True:\n return self.light_classifier.get_classification(cv_image)\n else:\n return TrafficLight.UNKNOWN","def find_wall(self, data):\n minimum = min(data.ranges)\n min_index = data.ranges.index(minimum)\n\n # convert angle to be centered around front laser \n # set differences and constants\n if min_index <= 180:\n diff_ang = min_index\n else:\n diff_ang = min_index - 360\n diff_dist = minimum - distance\n k_d_dist = 0.5\n k_d_ang = 0.01\n \n if min_index < 5 or min_index > 355:\n # Go forward until it reaches close to wall\n self.twist.angular.z = k_d_ang * diff_ang\n self.twist.linear.x = k_d_dist * diff_dist\n else:\n # keep turning until it faces closest wall\n self.twist.angular.z =k_d_ang * diff_ang\n if self.twist.linear.x > 0:\n self.twist.linear.x = k_d_dist * diff_dist","def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\n image = np.array(Image.open(image_path))\n if json_path is None:\n objects = None\n else:\n gt_data = json.load(open(json_path))\n what = ['traffic light']\n objects = [o for o in gt_data['objects'] if o['label'] in what]\n\n show_image_and_gt(image, objects, fig_num)\n\n red_x, red_y, green_x, green_y = find_tfl_lights(image)\n plt.plot(red_x, red_y, 'ro', color='r', markersize=3)\n plt.plot(green_x, green_y, 'ro', color='g', markersize=3)","def lightness(self):\n min_component = min(self.red, self.green, self.blue)\n max_component = max(self.red, self.green, self.blue)\n avg = (max_component + min_component) / 2\n light = avg / 255\n return light","def recognize_color(self):\n x = (self.x + DIRECTIONS[(self.facing_direction - self.config) % 8][0]) % (self.image.shape[0] - 1)\n y = (self.y + DIRECTIONS[(self.facing_direction - self.config) % 8][1]) % (self.image.shape[1] - 1)\n color_left = self.image[x, y]\n if abs(self.luminance(color_left) - self.luminance_fcolor) <= self.lum_threshold:\n return self.turn_left\n x = (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1)\n y = (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\n color_forward = self.image[x, y]\n if abs(self.luminance(color_forward) - self.luminance_fcolor) <= self.lum_threshold:\n return self.move_forward\n x = (self.x + DIRECTIONS[(self.facing_direction + self.config) % 8][0]) % (self.image.shape[0] - 1)\n y = (self.y + DIRECTIONS[(self.facing_direction + self.config) % 8][1]) % (self.image.shape[1] - 1)\n color_right = self.image[x, y]\n if abs(self.luminance(color_right) - self.luminance_fcolor) <= self.lum_threshold:\n return self.turn_right\n return None","def extract_target_pixel_location(self):\n #Respective Image location\n pixel_array = self.imageprepare(self.image_path)\n\n #Select less_than_target color point --> must be calibrated\n #?? Should we use an abstract class here instead of an if statment ??\n if self.color == \"g\":\n less_than_target = .15\n else:\n raise ValueError(\"Unknown color value\")\n\n #Chooses target pixels as well as it's location\n target_pixels = []\n for pixel in enumerate(pixel_array):\n if pixel[1] < less_than_target:\n target_pixels.append(pixel[0])\n\n return target_pixels","def getLightSensor() -> int:\n pass","def recognize_color(color, palette):\n min_distance = np.inf\n most_similar_color = None\n for cname, cvalue in palette.items():\n distance = np.sum(np.abs(np.array(color) - np.array(cvalue)))\n if distance < min_distance:\n min_distance = distance\n most_similar_color = cname\n return most_similar_color","def get_light_state(self, light):\n\n # If there is no image to process...\n if self.camera_image == None:\n\n # Don't know the color\n return TrafficLight.UNKNOWN\n\n else:\n\n # Convert image format\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"bgr8\")\n\n # Classify the image\n return self.light_classifier.get_classification(cv_image)","def get_light_state(self, traffic_light_state_truth):\n if not self.has_image:\n return False\n\n # Get classification\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"bgr8\")\n cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)\n\n height = cv_image.shape[0]\n width = cv_image.shape[1]\n\n boxes, scores, classes, num = self.sess.run([self.detection_boxes,\n self.detection_scores,\n self.detection_classes,\n self.num_detections],\n feed_dict={self.image_tensor: [cv_image]})\n\n new_boxes = []\n new_classes = []\n new_scores = []\n for i in range(num):\n if scores[0][i] > 0.5:\n xmin = int(boxes[0][i][0] * height)\n xmax = int(boxes[0][i][2] * height)\n ymin = int(boxes[0][i][1] * width)\n ymax = int(boxes[0][i][3] * width)\n box = [xmin, xmax, ymin, ymax]\n new_boxes.append(box)\n new_classes.append(classes[0][i])\n new_scores.append(scores[0][i])\n\n\n\n\n if len(new_classes) != 0:\n counts = np.bincount(new_classes)\n light = np.argmax(counts)\n if light == GREEN:\n return TrafficLight.GREEN\n elif light == RED:\n return TrafficLight.RED\n elif light == YELLOW:\n return TrafficLight.YELLOW\n else: return TrafficLight.UNKNOWN","def get_displacement(self, color, depth):\n displacement = None\n keypoints, descriptors = self._feature_detector.detectAndCompute(color, None)\n \n if descriptors is not None and self._last_descriptors is not None:\n matches = self._matcher.match(descriptors, self._last_descriptors)\n matches = self._select_matches(matches) \n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\n t = []\n horizontal = 0\n for i in range(len(matches)):\n d1 = depth[int(points[i][1]), int(points[i][0])]\n d2 = self._last_depth[int(last_points[i][1]), int(points[i][0])]\n #print(d1, d2)\n \n if d1 != 0 and abs(d1-d2) < 10:\n t.append(matches[i])\n horizontal += (points[i][0] - last_points[i][0]) * d1\n \n matches = t\n horizontal /= len(t) \n \n if len(matches) > 0:\n if self._config['show_matches']:\n matches_preview = cv2.drawMatches(color, keypoints, self._last_color, self._last_keypoints, matches, None, flags=2)\n cv2.imshow('Basic_Odometry_matches_preview', matches_preview)\n \n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\n #It uses default values for parameters - there must be here because of broken python bindings I suppose\n tf_mat = cv2.estimateRigidTransform(points, last_points, False, 500, 0.5, 3)\n \n if tf_mat is not None:\n a11, a12, b1 = tf_mat[0][0], tf_mat[0][1], tf_mat[0][2]\n a21, a22, b2 = -tf_mat[1][0], tf_mat[1][1], tf_mat[1][2]\n roll = math.atan2(-a12, a11) \n \n displacement = {\n 'roll': roll,\n 'horizontal': horizontal,#b1,\n 'vertical': b2,\n 'depth': math.sqrt(a11**2+a12**2) * (-1 if a11 < 0 else 1)\n }\n \n if descriptors is not None: \n self._last_keypoints = keypoints\n self._last_descriptors = descriptors\n self._last_color = color\n self._last_depth = depth\n \n return displacement","def _find_hilight(self):\n traverse = deque([self.item])\n while traverse:\n item = traverse.popleft()\n if item.hilight:\n return item.hilight\n traverse.extendleft(reversed(item.subitems))","def getNear(self):\n return self.light.node().getLens().getNear()","def place_blue_light():\n glMatrixMode(GL_MODELVIEW)\n lx = 3.0\n ly = light_height\n lz = 1.0\n light_position = [ lx, ly, lz, 1.0 ]\n\n lightb_ambient = [0.0, 0, 1, 1] #blue\n lightb_diffuse = [0.4, 0.4, 0.6, 1] #blue\n lightb_specular = [0.0, 0, 0.8, 1] #blue\n light_direction = [ 1.0, -1.0, 1.0, 0.0 ] # Light points down\n\n\n # For Light 0 (blue), set position, ambient, diffuse, and specular values\n glLightfv(GL_LIGHT0, GL_POSITION, light_position)\n glLightfv(GL_LIGHT0, GL_AMBIENT, lightb_ambient)\n glLightfv(GL_LIGHT0, GL_DIFFUSE, lightb_diffuse)\n glLightfv(GL_LIGHT0, GL_SPECULAR, lightb_specular)\n\n\n\n # Constant attenuation (for distance, etc.)\n # Only works for fixed light locations! Otherwise disabled\n glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0)\n glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.0)\n glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.0)\n\n # Create a spotlight effect (none at the moment)\n if blue_light:\n glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0)\n glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.0)\n glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_direction)\n else:\n glLightf(GL_LIGHT0, GL_SPOT_CUTOFF,180.0)\n glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.0)\n \n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\n # Try GL_TRUE - but then watch what happens when light is low\n \n glEnable(GL_LIGHT0)\n\n\n # This part draws a SELF-COLORED sphere (in spot where light is!)\n glPushMatrix()\n glTranslatef(lx,ly,lz)\n glDisable(GL_LIGHTING)\n glColor3f(0, 0, brightness)\n glutSolidSphere(0.5, 20, 20)\n glEnable(GL_LIGHTING)\n glPopMatrix()","def get_object(img, color,cam='front'):\n if color == \"yellow\":\n if cam == \"front\":\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\n lower = np.array([15, 146, 0], dtype=np.uint8)\n upper = np.array([62, 255, 255], dtype=np.uint8)\n mask = cv.inRange(hsv, lower, upper)\n if cam == \"bottom\":\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\n lower = np.array([15, 146, 0], dtype=np.uint8)\n upper = np.array([62, 255, 255], dtype=np.uint8)\n mask = cv.inRange(hsv, lower, upper)\n elif color == \"red\":\n if world == \"real\":\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\n lower1 = np.array([0, 39, 17], dtype=np.uint8)\n upper1 = np.array([32, 208, 115], dtype=np.uint8)\n lower2 = np.array([122, 39, 17], dtype=np.uint8)\n upper2 = np.array([180, 208, 115], dtype=np.uint8)\n mask1 = cv.inRange(hsv, lower1, upper1)\n mask2 = cv.inRange(hsv, lower2, upper2)\n mask = cv.bitwise_or(mask1, mask2)\n if world == \"sim\":\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\n lower1 = np.array([0, 85, 12], dtype=np.uint8)\n upper1 = np.array([11, 234, 234], dtype=np.uint8)\n lower2 = np.array([158, 85, 12], dtype=np.uint8)\n upper2 = np.array([180, 234, 234], dtype=np.uint8)\n mask1 = cv.inRange(hsv, lower1, upper1)\n mask2 = cv.inRange(hsv, lower2, upper2)\n mask = cv.bitwise_or(mask1, mask2)\n return mask","def trace(self, ray): # type: (Ray) -> Vector\n hit_object = None\n t = numpy.inf\n\n for scene_object in self.scene.shapes:\n t0 = scene_object.intersect(ray)\n if t0 < t:\n t = t0\n hit_object = scene_object\n\n # if there were no intersections, then return the background colour\n if t == numpy.inf:\n return self.scene.camera.background\n\n hit_point = ray.origin + ray.direction * t\n normal = hit_object.normal(hit_point)\n luminance = 0.0\n\n # perform shading calculations\n for light in self.scene.lights:\n hit_point_to_light = (light.centre - hit_point).normal\n\n #check whether this light contributes to the shading\n in_shadow = False\n for shadower in self.scene.shapes:\n # we don't want to test against itself\n if shadower == hit_object:\n continue\n shadow_ray = Ray(hit_point + normal * 0.0001, hit_point_to_light)\n if shadower.intersect(shadow_ray) < numpy.inf:\n in_shadow = True\n break\n if in_shadow:\n continue\n\n # super simple lambertian lighting model\n luminance += hit_point_to_light.dot(normal) * light.power\n\n # calculate shaded colour - luminance may be over one if there are multiple light sources\n # normally this would be dealt with by HDR and tone mapping but is just clipped\n # in demo ray tracers\n object_colour = hit_object.material.colour * min(luminance, 1.0)\n\n # calculate reflection colour if material has reflectance\n if hit_object.material.reflectance != 0.0 and ray.depth != self.scene.camera.depth:\n reflected_direction = (ray.direction - normal * 2 * (ray.direction.dot(normal))).normal\n # we need to 'translate' the reflection vector away from the hitpoint otherwise\n # we risk intersecting the original hit point again which causes artifacts in the reflection\n reflected_ray = Ray(hit_point + reflected_direction * 0.0001, reflected_direction, ray.depth + 1)\n reflection_colour = self.trace(reflected_ray)\n\n # interpolate shaded colour and reflected colour based on reflectance\n return Vector(*[lerp(object_colour.data[i], reflection_colour.data[i], hit_object.material.reflectance) for i in range(3)])\n\n return object_colour","def place_red_light():\n glMatrixMode(GL_MODELVIEW)\n lx = 4.0\n ly = light_height\n lz = 2.0\n light_position = [lx, ly, lz, 1.0]\n lightr_ambient = [1.0, 0, 0, 1] # red\n lightb_diffuse = [0.4, 0.4, 0.6, 1] # blue\n lightb_specular = [0.0, 0, 0.8, 1] # blue\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\n\n\n # For Light 1 (red), set position, ambient, diffuse, and specular values\n glLightfv(GL_LIGHT1, GL_POSITION, light_position)\n glLightfv(GL_LIGHT1, GL_AMBIENT, lightr_ambient)\n glLightfv(GL_LIGHT1, GL_DIFFUSE, lightb_diffuse)\n glLightfv(GL_LIGHT1, GL_SPECULAR, lightb_specular)\n\n # Constant attenuation (for distance, etc.)\n # Only works for fixed light locations! Otherwise disabled\n glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\n glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\n glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\n\n # Create a spotlight effect (none at the moment)\n if red_light:\n glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0)\n glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 0.0)\n glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, light_direction)\n else:\n glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 180.0)\n glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 0.0)\n\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\n # Try GL_TRUE - but then watch what happens when light is low\n\n glEnable(GL_LIGHT1)\n\n # This part draws a SELF-COLORED sphere (in spot where light is!)\n glPushMatrix()\n glTranslatef(lx, ly, lz)\n glDisable(GL_LIGHTING)\n glColor3f(brightness, 0, 0)\n glutSolidSphere(0.5, 20, 20)\n glEnable(GL_LIGHTING)\n glPopMatrix()","def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\n \n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \n \n #pprint(traj_angles)\n\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\n ml_screen_ref = traj_angles[idx] \n\n return(idx, ml_screen_ref)","def get_light(self, light, text=False):\n if not self.have_light(light):\n return None\n if text:\n return text_switch[self.light_status[light]]\n return self.light_status[light]","def planes_with_light_profiles(tracer):\n # NOTE: Find all planes with light profiles\n # NOTE:\n # # image = tracer.galaxies[1].profile_image_from_grid(grid=grid)\n # # plt.figure()\n # # plt.imshow(image.in_2d)\n # # plt.show()\n #\n # # asd = list(map(lambda plane: plane.has_light_profile, tracer.planes))\n # # print(asd)\n # #print(tracer.planes)\n #\n # #print(tracer.has_light_profile)\n # #print(list(map(lambda plane: plane.has_light_profile, tracer.planes)))\n # #print(tracer.galaxies_with_light_profile)\n #\n # #print(tracer.planes[1].galaxies_with_light_profile)\n #\n # galaxies = tracer.planes[1].galaxies_with_light_profile\n # galaxy = galaxies[0]\n #\n # galaxy_light_profiles = galaxy.light_profiles\n #\n # image_0 = galaxy_light_profiles[0].profile_image_from_grid(grid=grid)\n # image_0_in_2d = image_0.in_2d\n #\n # image_1 = galaxy_light_profiles[1].profile_image_from_grid(grid=grid)\n # image_1_in_2d = image_1.in_2d","def closest_battery(self, old_battery, house):\r\n batteries = self.child.batteries\r\n nearest_battery = None\r\n shortest_distance = 0\r\n\r\n for battery in batteries:\r\n distance = abs(batteries.get(battery).x_cor - house.x_cor) + abs(batteries.get(battery).y_cor - house.y_cor)\r\n\r\n if shortest_distance == 0:\r\n shortest_distance = distance\r\n nearest_battery = batteries.get(battery)\r\n else:\r\n if distance < shortest_distance:\r\n shortest_distance = distance\r\n nearest_battery = batteries.get(battery)\r\n return nearest_battery","def light_row(row):\n def filter_row(col, rw):\n \"\"\"For a given pixel position, turn on if it matches our row\n \"\"\"\n return rw == row\n light(MAX_BRIGHTNESS, filter_row)","def localize_pixel(img_pos,camera : Camera,lidar : Lidar, scan : LaserScan) -> tuple:\n\n # ---OBJ--\n # x r1 /\\ r2 x\n # / \\\n #cam_ray / \\ average_ray\n # / \\\n # / \\\n # CAM ----> LID\n # \n\n # has to be 2d\n assert (img_pos.size == 2)\n\n cam_ray = camera.get_ray_through_image(img_pos)\n\n cam_ray_robot = camera.get_ray_in_robot_frame(cam_ray)\n\n cam_ray_lidar = lidar.get_ray_in_lidar_frame(cam_ray_robot)\n\n # flatten camera ray\n cam_ray_lidar_flat = lidar.get_ray_projection(cam_ray_lidar)\n\n # figure out which lidar rays correspond to the camera ray\n (ray1,ray2) = lidar.get_corresponding_lidar_rays(cam_ray_lidar_flat,scan)\n\n # if no rays found corresponding to scan data\n if ray1 is None or ray2 is None:\n return (None,None)\n\n # get the normal to the lidar hit\n intersection_normal = lidar.get_normal_to_plane(ray1,ray2)\n\n # get the distance data in horizontal plane, from lidar to object\n lidar_to_target_length = lidar.get_camera_ray_length(cam_ray_lidar_flat,ray1,ray2)\n\n # get the vector from camera to lidar (flattened to lidar plane)\n # i.e. origin of lidar frame in camera frame\n lidar_to_cam_vec = cam_ray_lidar_flat.origin\n cam_to_lidar_flat = Ray(lidar_to_cam_vec,-lidar_to_cam_vec,np.linalg.norm(lidar_to_cam_vec))\n \n # now workout the lidar to object ray, i.e. interpolate between ray1's and ray2's tips\n lidar_to_object_flat = interpolated_ray(ray1,ray2,0.5,lidar_to_target_length)\n\n # now finally workout the vector from camera to object (flattened)\n # this lets us access the true z-distance in the camera\n cam_to_object_flat = lidar_to_object_flat.get_vec() + cam_to_lidar_flat.get_vec()\n \n cam_to_object_flat_length = np.linalg.norm(cam_to_object_flat)\n\n # angle from horizontal on camera ray\n cam_ray_theta = angle_between(cam_ray_lidar.get_vec(),cam_to_object_flat)\n\n # length of original camera ray (knowing the length of its projection)\n # will fail if ray is pointing straight up or down\n cam_ray_robot.length = cam_to_object_flat_length / math.cos(cam_ray_theta)\n\n\n object_robot = cam_ray_robot.get_vec()+cam_ray_robot.origin\n\n return (object_robot,intersection_normal)","def nearest(self, location, exclude=[]):\n r = numpy.fromiter(\n (t.distance(location) for t in self._thermals), dtype=float)\n idx = numpy.argmin(r)\n\n idx = 0\n sort_idx = numpy.argsort(r)\n while self._thermals[sort_idx[idx]].id in exclude:\n idx += 1\n return (self._thermals[sort_idx[idx]], sort_idx[idx])\n\n include = numpy.ones((len(self._thermals),), dtype=bool)\n include[exclude] = False\n\n idx = numpy.arange(len(self._thermals))[include]\n sub_idx = idx[numpy.argmin(r[include])]\n return (self._thermals[sub_idx], sub_idx)","def handle_colordetection(self):\n self.robot.sensormap.tank_drive.stop()\n if self.robot.sensormap.cs_l.color in self.colors and self.robot.sensormap.cs_l.color not in self.detected:\n self.detected.add(self.robot.sensormap.cs_l.color)\n elif self.robot.sensormap.cs_r.color in self.colors and self.robot.sensormap.cs_r.color not in self.detected:\n self.detected.add(self.robot.sensormap.cs_r.color)\n elif self.robot.sensormap.cs_m.color in self.colors and self.robot.sensormap.cs_m.color not in self.detected:\n self.detected.add(self.robot.sensormap.cs_m.color)","def whatsgreen2(image):\n green = image.hueDistance(color= Color('green'), minvalue=40).binarize()\n return green","def calculateLighting(x,y,z, xnormal, ynormal, znormal):\n dummy = 0\n clr = dislin.getlit(x,y,z,xn,yn,zn,dummy)","def get_light(name):\n if name not in _cache:\n get_lights() # do nothing with response\n\n if name in _cache:\n return _cache[name]\n else:\n return None","def __get_light_state(self, light):\n rospy.logdebug(\"TLDetector.__get_light_state\")\n if not self.__has_image:\n self.__prev_light_loc = None\n return False\n\n cv_image = self.__bridge.imgmsg_to_cv2(self.__camera_image, \"bgr8\")\n\n rospy.logdebug(\"TLDetector: classifying light\")\n return self.__light_classifier.get_classification(cv_image)","def _get_twilight(self, datetime_today, lon, lat, alt):\r\n\r\n dusk = self._astral.dusk_utc(datetime_today, lat, lon,\r\n observer_elevation=alt,\r\n depression=self.twilight_alt)\r\n\r\n dawn = self._astral.dawn_utc(datetime_today + _delta_dt, lat, lon,\r\n observer_elevation=alt,\r\n depression=self.twilight_alt)\r\n\r\n return dusk, dawn","def testOccultedLightSource(self):\n torch = objects.Thing(store=self.store, name=u\"torch\")\n objects.LightSource.createFor(torch, candelas=80)\n\n c = objects.Container.createFor(self.observer, capacity=1000)\n\n torch.moveTo(self.observer)\n c.closed = True\n\n found = visibles(self.observer.idea)\n self.assertDarkRoom(found[0])\n self.assertEquals(len(found), 1)","def _apply_laser(self, color):\n path = self.get_laser_path(color)\n if path[-1].type is LaserPathType.hit:\n square = self.get(path[-1].position.x, path[-1].position.y)\n if (square.piece.type is PieceType.anubis and square.piece.orientation is Orientation.delta(path[-1].direction,-180)) \\\n or square.piece.type is PieceType.sphinx:\n # Hit but not destroyed\n pass\n else:\n piece = self.remove_piece(path[-1].position)\n return path, piece\n return path, None","def get_light_state(self):\n\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"bgr8\")\n\n #Get classification\n tl_image_rgb, color_index = self.light_classifier.get_classification(cv_image)\n tl_cv_image = cv2.cvtColor(tl_image_rgb, cv2.COLOR_RGB2BGR)\n try:\n self.tl_detected_image_pub.publish(self.bridge.cv2_to_imgmsg(tl_cv_image, \"bgr8\"))\n except CvBridgeError as e:\n print(e)","def detect_bridge():\n # Initialize color ranges for detection\n color_range = [Color(\"Brug\", [0, 0, 0], [0, 255, 107]),\n Color(\"Gat\", [0, 0, 0], [0, 0, 255]),\n Color(\"Rand\", [0, 0, 185], [0, 0, 255]),\n Color(\"White-ish\", [0, 0, 68], [180, 98, 255])]\n\n cam = Recognize(color_range)\n cam.run()","def filter_lane_color(image):\n \n YELLOW_HSV_LOWER = np.array([20, 100, 100])\n YELLOW_HSV_UPPER = np.array([40, 255, 255])\n \n WHITE_HSV_LOWER = np.array([0, 0, 220])\n WHITE_HSV_UPPER = np.array([255, 255, 255])\n \n image_wk = np.copy(image) # working copy\n image_hsv = cv2.cvtColor(image_wk, cv2.COLOR_RGB2HSV) # RGB -> HSV\n \n yellow_mask = cv2.inRange(image_hsv, YELLOW_HSV_LOWER, YELLOW_HSV_UPPER)\n white_mask = cv2.inRange(image_hsv, WHITE_HSV_LOWER, WHITE_HSV_UPPER)\n both_mask = yellow_mask + white_mask\n \n image_wk = grayscale(image_wk) # RGB -> GRAY\n image_wk = cv2.bitwise_or(image_wk, both_mask) # GRAY + yellow/white mask\n \n # Output grayscale road image with enhanced yellow/white areas\n return image_wk","def locate_tracker(self, debug):\n\n # tmp_image =\n # tmp_image = cv2.GaussianBlur(self.frame, (11, 11), 0) # Experiment with this\n\n hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) # Convert to HSV Color Space. This is temporary for testing using colored objects)\n\n mask = cv2.inRange(hsv, self.hueLower, self.hueUpper)\n\n try:\n mask = cv2.inRange(hsv, self.hueLower2, self.hueUpper2) + mask\n except AttributeError:\n pass\n\n mask = cv2.erode(mask, None, iterations=2)\n mask = cv2.dilate(mask, None, iterations=2)\n\n if debug:\n tmpMask = imutils.resize(mask, width=1000, height=1000)\n cv2.imshow(\"mask\", tmpMask)\n\n\n # find contours in the mask and initialize the current (x, y) center of the object\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\n center = None\n\n # only proceed if at least one contour was found\n if len(cnts) > 0:\n # find the largest contour in the mask, then use\n # it to compute the minimum enclosing circle and\n # centroid\n c = max(cnts, key=cv2.contourArea)\n\n ((x, y), radius) = cv2.minEnclosingCircle(c)\n M = cv2.moments(c)\n center = (int(M[\"m10\"] / M[\"m00\"]), int(M[\"m01\"] / M[\"m00\"]))\n\n # only proceed if the radius meets a minimum size\n # if radius > 10:\n # # draw the circle and centroid on the frame,\n # # then update the list of tracked points\n # cv2.circle(frame, (int(x), int(y)), int(radius),\n # (0, 255, 255), 2)\n # cv2.circle(frame, center, 5, (0, 0, 255), -1)\n if debug:\n cv2.drawContours(self.frame, c, -1, (0, 255, 0), 20)\n return center, radius\n # update the points queue\n cv2.imshow(\"mask\", imutils.resize(mask, width=1000, height=1000))\n cv2.imshow(\"frame\", imutils.resize(self.frame, width=1000, height=1000))\n cv2.waitKey(0)\n cv2.destroyAllWindows()\n raise OpenCVError(\"Could not find tracker!\")\n\n # return (1, 1), 1","def bridge_problem3(here):\r\n\r\n def all_over(state):\r\n here, _ = state\r\n return not here or here == set([\"light\"])\r\n\r\n start = (frozenset(here) | frozenset([\"light\"]), frozenset())\r\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)","def closest_on_screen_point(trajectory, viewpoint, yaw, gaze_on_screen):\n\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \n #pprint(traj_angles)\n\n #onscreen_idx, dists, *_ = find_closest_index(traj_angles, gaze_on_screen)\n #idx = closest_node(traj_angles, gaze_on_screen)\n idx = find_closest_index(traj_angles, gaze_on_screen)\n # print(idx)\n\n #traj_ref = trajectory[idx, :]\n screen_ref = traj_angles[idx, :]\n world_ref = trajectory[idx, :]\n\n path_dist = ab_path_length(trajectory, viewpoint, world_ref)\n path_dist /= 8.0 #time headway\n\n #plot_traj(screen_ref, gaze_on_screen, traj_angles)\n\n return(idx, screen_ref, world_ref, path_dist)#, traj_angles)","def find_dark_states(excited_state, ground_states):","def get_light_state(self, light):\n if self.use_classifier: \n if(not self.has_image):\n return None\n\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \"bgr8\")\n\n #Get classification\n return self.light_classifier.get_classification(cv_image) \n \n else:\n # For testing, just return the ground-truth light state, directly coming from simulator\n return light.state","def place_headlamp_light():\n\n lx = 1.0\n ly = light_height\n lz = 2.0\n #light_position = [lx, ly, lz, 1.0]\n light_position = [0.0, 0.0, 0.0, 1]\n light_ambient = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_diffuse = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_specular = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\n # glViewport(0, 0, win_width, win_height)\n # glMatrixMode(GL_PROJECTION)\n # glLoadIdentity()\n # gluPerspective(40.0, float(win_width) / float(win_height), 0.01, 100.0)\n #\n # glMatrixMode(GL_MODELVIEW)\n # glLoadIdentity()\n # glPushMatrix()\n glLightfv(GL_LIGHT4, GL_POSITION, light_position)\n\n\n\n #glLightfv(GL_LIGHT4, GL_POSITION, (GLfloat * 4)(0.0, 0.0, 0.0, 1))\n glLightfv(GL_LIGHT4, GL_AMBIENT, light_ambient)\n glLightfv(GL_LIGHT4, GL_DIFFUSE, light_diffuse)\n glLightfv(GL_LIGHT4, GL_SPECULAR, light_specular)\n\n # Constant attenuation (for distance, etc.)\n # Only works for fixed light locations! Otherwise disabled\n # glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\n # glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\n # glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\n\n glLightf(GL_LIGHT4, GL_CONSTANT_ATTENUATION, 3.0)\n glLightf(GL_LIGHT4, GL_LINEAR_ATTENUATION, 0.0)\n glLightf(GL_LIGHT4, GL_QUADRATIC_ATTENUATION, 0.0)\n\n # Create a spotlight effect (none at the moment)\n if headlamp_is_on:\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 30.0)\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\n glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, light_direction)\n else:\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 180.0)\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\n\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\n # Try GL_TRUE - but then watch what happens when light is low\n\n glEnable(GL_LIGHT4)\n\n # This part draws a SELF-COLORED sphere (in spot where light is!)\n glPushMatrix()\n glTranslatef(lx, ly, lz)\n glDisable(GL_LIGHTING)\n glColor3f(brightness, brightness, brightness)\n glutSolidSphere(0.5, 20, 20)\n glEnable(GL_LIGHTING)\n glPopMatrix()","def traffic_cb(self, msg):\n prev_red_light_waypoint = self.red_light_waypoint\n self.red_light_waypoint = msg.data if msg.data >= 0 else None\n if prev_red_light_waypoint != self.red_light_waypoint:\n if debugging:\n rospy.loginfo(\"TrafficLight changed: %s\", str(self.red_light_waypoint))\n if publish_on_light_change:\n self.update_and_publish() # Refresh if next traffic light has changed","def color_for_temp(temp):\n color = None\n for temp_ceil in sorted(color_map.iterkeys()):\n color = color_map[temp_ceil]\n if(temp < temp_ceil):\n break\n return adjust_color(color)","def main():\n # color = rb.Color.BLUE.value\n # move_to_color(color)\n infared_sensor()\n\n # WHITE/RED does not work same with the BLUE/GREEN going down","def match(self, color: Color) -> ColorPoint:\n results = self.tree.search_nn(color.hsl)\n if not results:\n raise KeyError('No match found for color: {}'.format(color))\n return results[0].data","def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\n image = np.array(Image.open(image_path))\n\n if json_path is None:\n objects = None\n else:\n gt_data = json.load(open(json_path))\n what = ['traffic light']\n objects = [o for o in gt_data['objects'] if o['label'] in what]\n\n find_tfl_lights(image)","def light_circles():\n global frame_1, frame_2\n x_circle_center = int(camera_width/11)\n y_circle_center = int(camera_hight/9)\n circle_radius = int(camera_width*.07)\n cv2.circle(\n frame_1, (x_circle_center, (circle_radius+(4*circle_radius))),\n circle_radius, green_color, thickness=thick_1_a)\n cv2.circle(\n frame_1, (x_circle_center, (circle_radius+(2*circle_radius))),\n circle_radius, yellow_color, thickness=thick_1_b)\n cv2.circle(\n frame_1, (x_circle_center, circle_radius),\n circle_radius, red_color, thickness=thick_1_c)\n cv2.circle(\n frame_2, (x_circle_center, (circle_radius+(4*circle_radius))),\n circle_radius, green_color, thickness=thick_2_a)\n cv2.circle(\n frame_2, (x_circle_center, (circle_radius+(2*circle_radius))),\n circle_radius, yellow_color, thickness=thick_2_b)\n cv2.circle(\n frame_2, (x_circle_center, circle_radius),\n circle_radius, red_color, thickness=thick_2_c)","def place_green_light():\n glMatrixMode(GL_MODELVIEW)\n lx = 5.0\n ly = light_height\n lz = 3.0\n light_position = [lx, ly, lz, 1.0]\n lightg_ambient = [0, 1.0, 0, 1] # green\n lightb_diffuse = [0.4, 0.4, 0.6, 1] # blue\n lightb_specular = [0.0, 0, 0.8, 1] # blue\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\n\n # For Light 2 (green), set position, ambient, diffuse, and specular values\n glLightfv(GL_LIGHT2, GL_POSITION, light_position)\n glLightfv(GL_LIGHT2, GL_AMBIENT, lightg_ambient)\n glLightfv(GL_LIGHT2, GL_DIFFUSE, lightb_diffuse)\n glLightfv(GL_LIGHT2, GL_SPECULAR, lightb_specular)\n\n glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 3.0)\n glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, 0.0)\n glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, 0.0)\n\n # Create a spotlight effect (none at the moment)\n if green_light:\n glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 45.0)\n glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, 0.0)\n glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, light_direction)\n else:\n glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 180.0)\n glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, 0.0)\n\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\n # Try GL_TRUE - but then watch what happens when light is low\n\n\n glEnable(GL_LIGHT2)\n\n # This part draws a SELF-COLORED sphere (in spot where light is!)\n glPushMatrix()\n glTranslatef(lx, ly, lz)\n glDisable(GL_LIGHTING)\n glColor3f(0, brightness, 0)\n glutSolidSphere(0.5, 20, 20)\n glEnable(GL_LIGHTING)\n glPopMatrix()","def gl_lighting():\n for viewer in nuke.allNodes('Viewer'):\n val = int(viewer.knob('gl_lighting').getValue())\n viewer.knob('gl_lighting').setValue(not val)","def getFar(self):\n return self.light.node().getLens().getFar()","def get_traffic_lights_obstacles(traffic_lights, depth_frame, segmented_frame,\n town_name):\n camera_transform = depth_frame.camera_setup.get_transform()\n # Iterate over all the traffic lights, and figure out which ones are\n # facing us and are visible in the camera view.\n detected = []\n for light in traffic_lights:\n if not light.is_traffic_light_visible(camera_transform, town_name):\n continue\n detected.extend(\n light.get_all_detected_traffic_light_boxes(\n town_name, depth_frame, segmented_frame.as_numpy_array()))\n return detected","def on_road(self):\n for obj in self.model.grid[self.pos[0]][self.pos[1]]:\n if obj.agent_type == \"road\":\n return obj","def _get_light_state(self, light):\n if(not self.has_image):\n return False\n\n #\n # we want to convert the image from internal ROS format to\n # CV2 GBR8 format because we trained our classifier model using GBR8 images.\n # The original raining images were in PNG and JPG format and in folders\n # that make it look like they are RGB, but we must remember that the training\n # loads the images using cv2.imread() which loads the images into BGR8\n # format, NOT RGB8!\n #\n cv2_image_bgr = self.bridge.imgmsg_to_cv2(self.camera_image_msg, \"bgr8\")\n\n #\n #Get classification\n #\n return self.light_classifier.get_classification(cv2_image_bgr)","def get_colour(self):\n \n distorted = []\n if piCameraFound:\n # Use piCamera\n \n #frame = self.capture_generator.next()\n #distorted = frame.array\n self.cam.capture(self.rawCapture, format=\"bgr\", use_video_port=True)\n distorted = self.rawCapture.array\n \n # clear the stream in preparation for the next frame\n self.rawCapture.truncate(0)\n \n else: # Use OpenCV\n retval, distorted = self.cam.read() # Read frame\n\n if not retval: # Error\n print \"Camera.get_colour: Could not read next frame\";\n exit(-1);\n \n \n #colour = cv2.remap(distorted, self.mapx, self.mapy, cv2.CV_INTER_LINEAR)\n #colour = cv2.remap(distorted, self.mapx, self.mapy, cv2.INTER_LINEAR)\n \n # Skip this part because it is slow\n #colour = cv2.undistort(distorted, self.intrinsic_matrix, self.distortion_coeffs)\n colour = distorted\n return colour, distorted","def find_reddest_pixel(img):\n # HINTS/ADVICE-------------\n # Use a nested for loop here.\n #\n # BE CAREFUL DOING ARITHMETIC WITH UNSIGNED INTEGERS: \n # >>> a = np.array([2], dtype='uint8')\n # >>> b = np.array([3], dtype='uint8')\n # >>> a - b\n # array([255], dtype=uint8)\n #\n # Reminder:\n # numpy arrays have a \"shape\" attribute that stores the layout:\n # img.shape[0] - rows\n # img.shape[1] - columns\n # img.shape[2] - color channels\n\n max_redness = 0\n max_x = 0\n max_y = 0\n \n img = np.array(img, dtype = 'int32')\n for r in range(img.shape[0]):\n for c in range(img.shape[1]):\n red = img[r, c, 2]\n green = img[r, c, 1]\n blue = img[r, c, 0] \n redness = (red - green) + (red - blue)\n\n if redness > max_redness:\n max_redness = redness\n max_x = c\n max_y = r\n \n return (max_x, max_y)","def get_lights(bridge):\n\n target_names = [\n \"Console Lamp\",\n \"Bedroom Table Lamp\",\n \"Kitchen light\",\n ]\n\n targets = [light for light in bridge.lights if light.name in target_names]\n\n if len(targets) != len(target_names):\n print(\"%s: not found ... %s\" % (target_names, targets))\n exit(1)\n\n return targets","def check_location_confidence(self):\n\t\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\n\t\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\n\t\tepsilon_meters = .08\n\t\tpixel_distances = []\n\t\tactual_distances = []\n\t\tnum_observed = 0\n\t\tfor ti in self.targs:\n\t\t\tif ti.props_are_set:\n\t\t\t\tfor tj in self.targs:\n\t\t\t\t\tif tj.props_are_set: \n\t\t\t\t\t\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\n\t\t\t\t\t\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\n\t\t\t\t\t\tif pixel_dist == 0:\n\t\t\t\t\t\t\tpixel_dist = 10000 #ignore two of the same points\n\t\t\t\t\t\t\tactual_dist = 10000\n\t\t\t\t\t\tpixel_distances.append(pixel_dist)\t\n\t\t\t\t\t\tactual_distances.append(actual_dist)\n\t\t\t\t\telse:\n\t\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\t\tactual_distances.append(10000)\n\t\t\telse:\n\t\t\t\tfor _ in self.targs:\n\t\t\t\t\tpixel_distances.append(10000)\n\t\t\t\t\tactual_distances.append(10000)\n\t\tmin_ind_pixel = np.argmin(pixel_distances)\n\t\tmin_ind_actual = np.argmin(actual_distances)\n\t\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\n\t\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\n\t\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\n\t\t\t#measurements are not trustworthy, return nothing\n\t\t\treturn None\n\n\t\treturn best_guys","def get_freenet_coordinates(self, location):\n # TODO(ionel): This method assumes that the location has the\n # same orientation as the lanes (i.e., it will always return a\n # positive d).\n loc = to_carla_location(location)\n waypoint = self._map.get_waypoint(loc,\n project_to_road=False,\n lane_type=carla.LaneType.Any)\n current_lane_w = waypoint\n d0_location = None\n while True:\n # Keep on moving left until we're outside the road or on the\n # oposite lane.\n left_lane_w = current_lane_w.get_left_lane()\n if (left_lane_w.lane_type != carla.LaneType.Driving or\n (current_lane_w.transform.rotation.yaw -\n left_lane_w.transform.rotation.yaw) > 170):\n # If the left lane is drivable then we've reached the left hand\n # side of a one way road. Alternatively, if the lane is rotated\n # then the lane is on the other side of the road.\n d0_location = current_lane_w\n half_lane = carla.Location(\n 0, - current_lane_w.lane_width / 2.0, 0)\n d0_location = current_lane_w.transform.transform(half_lane)\n break\n current_lane_w = left_lane_w\n\n # TODO(ionel): Handle the case when the road id changes -> s resets.\n # TODO(ionel): Handle case when the center lane is bidirectional.\n return waypoint.s, self.__get_distance(location, d0_location)","def __lightness(self, color):\n hsv = color.toHsv()\n return hsv.valueF()","def get_pixel_obs(self):\n delta = self.side / (self.pixel_side - 1)\n bd1 = -self.side / 2\n bd2 = self.side / 2 + delta\n x, y = np.meshgrid(np.arange(bd1, bd2, delta), np.arange(bd2, bd1, -delta))\n if self.robot.sensor.lower() == \"rgb\":\n obs1, obs2, obs3 = np.zeros(x.shape), np.zeros(x.shape), np.zeros(x.shape)\n # Color humans:\n for human in self.humans:\n robot_distance = np.sqrt(\n (human.px - self.robot.px) ** 2 + (human.py - self.robot.py) ** 2\n )\n if robot_distance < self.robot.horizon:\n obs1[\n np.nonzero((x - human.px) ** 2 + (y - human.py) ** 2 <= human.radius ** 2)\n ] = 1\n # Color goal:\n obs2[\n np.nonzero(\n (x - self.robot.gx) ** 2 + (y - self.robot.gy) ** 2 <= self.goal_radius ** 2\n )\n ] = 1\n # Color robot:\n obs3[\n np.nonzero(\n (x - self.robot.px) ** 2 + (y - self.robot.py) ** 2 <= self.robot.radius ** 2\n )\n ] = 1\n obs = np.concatenate(\n (np.expand_dims(obs1, 0), np.expand_dims(obs2, 0), np.expand_dims(obs3, 0)), axis=0\n )\n return np.float32(np.expand_dims(obs, 0))\n elif self.robot.sensor.lower() == \"gray\":\n obs = np.zeros(x.shape)\n # Color humans:\n for human in self.humans:\n robot_distance = np.sqrt(\n (human.px - self.robot.px) ** 2 + (human.py - self.robot.py) ** 2\n )\n if robot_distance < self.robot.horizon:\n obs[\n np.nonzero((x - human.px) ** 2 + (y - human.py) ** 2 <= human.radius ** 2)\n ] = (1.0 / 3)\n # Color goal:\n obs[\n np.nonzero(\n (x - self.robot.gx) ** 2 + (y - self.robot.gy) ** 2 <= self.goal_radius ** 2\n )\n ] = (2.0 / 3)\n # Color robot:\n obs[\n np.nonzero(\n (x - self.robot.px) ** 2 + (y - self.robot.py) ** 2 <= self.robot.radius ** 2\n )\n ] = 1.0\n return np.float32(np.expand_dims(np.expand_dims(obs, 0), 0))\n else:\n raise ValueError(\"Robot sensor incompatible with pixel observation.\")","def get_rgb_light():\n return list(light.rgb())","def watershed(img):\n\ttmp = img.copy()\n\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\n\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\n\tkernel = np.ones((3,3), np.uint8)\n\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\n\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\n\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\n\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\n\tsure_fg = np.uint8(sure_fg)\n\tunknown = cv2.subtract(sure_bg, sure_fg)\n\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\n\tmarkers = markers+1\n\tmarkers[unknown==255] = 0\n\tmarkers = cv2.watershed(tmp, markers)\n\ttmp[markers == -1] = [255,0,0]\n\treturn tmp","def track_closest_aircraft(latitude, longitude, elevation, host, port, q):\n try:\n d = Dump1090(host, port)\n q.put(True)\n except IOError as exc:\n q.put(exc)\n return\n\n target = None\n target_distance = None\n aad = AzimuthAltitudeDistance(latitude, longitude, elevation)\n\n try:\n for aircraft in d.updates():\n lat, lng = aircraft.position\n azimuth, altitude, distance = aad.calculate(\n lat,\n lng,\n aircraft.altitude\n )\n\n # if we don't have a target we do now\n # or target is old, then use this new aircraft\n # or new aircraft isn't the target, but it is closer, so we switch!\n if (target is None or target.age > 60 or\n (target.icao != aircraft.icao and distance < target_distance)):\n target = aircraft\n\n # if we aren't the target at this point then bail\n if target.icao != aircraft.icao:\n continue\n\n target = aircraft\n target_distance = distance\n q.put((target, azimuth, altitude, distance))\n except KeyboardInterrupt:\n pass","def apply_laser(self, color):\n if self.winner is not None:\n raise RuntimeError(\"Game is already complete \" + str(self.winner.value) + \" won\")\n results = {}\n path, piece = self._apply_laser(color)\n\n if piece is not None:\n results[\"destroyed\"] = piece\n if piece.type is PieceType.pharaoh:\n self.winner = TeamColor.opposite_color(piece.color)\n results[\"winner\"] = self.winner\n\n results[\"path\"] = path\n return results"],"string":"[\n \"def process_traffic_lights(self):\\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\\n if self.init:\\n state = self.get_light_state(0)\\n return -1, TrafficLight.UNKNOWN\\n elif self.ntlwp:\\n state = self.get_light_state(self.ntlwp)\\n # state = TrafficLight.RED\\n return self.ntlwp, state\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n closest_light = None\\n line_wp_index = None\\n\\n # We want to find the smallest \\\"diff\\\". Initialize to the maximum possible value: total number of waypoints\\n diff = len(self.base_waypoints.waypoints)\\n\\n # List of positions that correspond to the line to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n\\n if(self.pose):\\n car_wp_index = self.get_closest_waypoint(self.pose.pose.position.x, self.pose.pose.position.y)\\n\\n #TODO find the closest visible traffic light (if one exists)\\n\\n # Now go over each light position in the known map (total of 8)\\n for i, light in enumerate(self.lights):\\n line = stop_line_positions[i] # position of the stop line\\n\\n # Extract the closest waypoint associated to traffic light (index = i) and in front of the ego\\n temp_wp_idx = self.get_closest_waypoint(line[0], line[1])\\n\\n # Find the number of waypoints between the ego and the temp_wp_idx\\n d = temp_wp_idx - car_wp_index\\n\\n # If this the smallest so far?\\n if (d >= 0) and (d < diff):\\n diff = d\\n closest_light = light\\n line_wp_index = temp_wp_idx\\n\\n # If we did find a closest light:\\n if (closest_light):\\n # Read the state of the closest light and update the state (i.e., the color of the light)\\n # Red: 0, Yellow: 1, Green: 2, Unknown: 4\\n state = self.get_light_state(closest_light)\\n is_close = (diff < 5) # CLOSE_THRESH\\n \\n '''\\n color_dict = { TrafficLight.RED: 'Red', \\\\\\n TrafficLight.YELLOW: 'Yellow', \\\\\\n TrafficLight.GREEN: 'Green', \\\\\\n TrafficLight.UNKNOWN: 'Unknown'}\\n \\n rospy.logwarn(\\\"Closest Traffic Light: ({0}, {1})\\\".format( color_dict[state], line_wp_index) )\\n '''\\n return line_wp_index, state, is_close\\n else:\\n # rospy.logwarn(\\\"No traffic light found.\\\")\\n return -1, TrafficLight.UNKNOWN, False\",\n \"def find_tfl_lights(image: np.ndarray):\\n kernel = np.array(\\n [[0, 0, 0],\\n [0, 0, 0],\\n [0, 1, 0],\\n [1, 3, 1],\\n [0, 1, 0]])\\n\\n kernel = kernel - kernel.mean()\\n\\n red_image = image.copy()\\n red_image = red_image[:, :, 0]\\n _, red_image = cv2.threshold(red_image, 200, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(red_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n red_points = np.where(mask)\\n positions = []\\n final_red_points = []\\n for point1 in range(len(red_points[0])):\\n point = (red_points[0][point1], red_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if (pixel[1] < 170 or pixel[2] < 120) and pixel[0] >= 200:\\n final_red_points.append(point)\\n final_red_points = filter_points(final_red_points)\\n positions += final_red_points\\n auxilary = ['r'] * len(positions)\\n red_x = [val[1] for val in final_red_points]\\n red_y = [val[0] for val in final_red_points]\\n green_image = image.copy()\\n green_image = green_image[:, :, 1]\\n _, green_image = cv2.threshold(green_image, 190, 255, cv2.THRESH_BINARY)\\n output = cv2.filter2D(green_image, -1, kernel)\\n output_copy = output.copy()\\n output = ndimage.maximum_filter(output, size=30)\\n output = output - output_copy\\n mask = ((output == 0) & (output_copy > 0))\\n green_points = np.where(mask)\\n final_green_points = []\\n for point1 in range(len(green_points[0])):\\n point = (green_points[0][point1], green_points[1][point1])\\n pixel = image[point[0], point[1]]\\n if pixel[0] <= 180 and pixel[1] >= 220 and pixel[2] >= 160:\\n final_green_points.append(point)\\n\\n final_green_points = filter_points(final_green_points)\\n positions += final_green_points\\n auxilary += ['g'] * len(final_green_points)\\n green_x = [val[1] for val in final_green_points]\\n green_y = [val[0] for val in final_green_points]\\n print(f\\\"There are {len(green_x) + len(red_x)} points\\\")\\n return positions, auxilary\",\n \"def process_traffic_lights(self):\\n light = None\\n light_wp = -1\\n\\n if not self.waypoints:\\n return -1, TrafficLight.UNKNOWN\\n if not self.lights:\\n return -1, TrafficLight.UNKNOWN\\n\\n stop_line_positions = self.config['stop_line_positions']\\n car_position_idx = 0\\n if (self.pose):\\n car_position_idx = self.get_closest_waypoint_idx(self.pose.pose)\\n car_position = self.waypoints[car_position_idx]\\n #rospy.loginfo(\\\"tl_detector - pose %s %s\\\", self.pose.pose.position, car_position.pose.pose.position)\\n\\n #TODO find the closest visible traffic light (if one exists)\\n # Fined the closet visible traffic light based on current position\\n dist_min = float('inf')\\n closest_stop_line_idx = -1\\n for i, stop_line_pose in enumerate(stop_line_positions):\\n if self.is_ahead_of(car_position.pose.pose, stop_line_pose[0],\\n stop_line_pose[1]):\\n dist = self.calculate_distance(\\n car_position.pose.pose.position.x, stop_line_pose[0],\\n car_position.pose.pose.position.y, stop_line_pose[1])\\n if dist < dist_min:\\n dist_min = dist\\n closest_stop_line_idx = i\\n\\n if dist_min < self.max_tl_dist and closest_stop_line_idx >= 0:\\n # Find wp index in waypoints which is closest to the traffic light\\n light = self.lights[closest_stop_line_idx]\\n dist_min = float('inf')\\n wp = self.get_closest_waypoint_xy(\\n stop_line_positions[closest_stop_line_idx])\\n\\n if wp > car_position_idx:\\n light_wp = wp\\n\\n state = self.get_light_state(light)\\n return light_wp, state\\n return -1, TrafficLight.UNKNOWN\",\n \"def _get_closest_light_ahead(self, pose):\\n #\\n # we have very few lights in either the simulation or the live test,\\n # so it is easiest just to loop thru them rather than use KDTree\\n #\\n pos = pose.position\\n x = pos.x\\n y = pos.y\\n closest_idx = -1\\n closest_dist2 = None\\n idx = 0\\n for light in self.lights:\\n xl = light.pose.pose.position.x\\n yl = light.pose.pose.position.y\\n\\n #\\n # make sure light is ahead, otherwise ignore it\\n # we can only do this if the car velocity is nonzero\\n #\\n skip_light = False\\n if self.velocity_unit_vector:\\n dx = xl - x\\n dy = yl - y\\n car_to_light = [dx,dy]\\n val = self.dot2d(car_to_light,self.velocity_unit_vector)\\n if val < 0.0:\\n #\\n # light is behind us so continue\\n #\\n skip_light = True\\n\\n if not skip_light:\\n if closest_dist2 is None:\\n closest_idx = idx\\n closest_dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\\n else:\\n dist2 = (x-xl)*(x-xl) + (y-yl)*(y-yl)\\n if dist2 < closest_dist2:\\n closest_idx = idx\\n closest_dist2 = dist2\\n idx+=1\\n \\n return closest_idx\",\n \"def process_traffic_lights(self):\\n\\n # Our closest visible traffic light starts off as none\\n t1 = time()\\n\\n\\n closest_traffic_light_waypoint = -1\\n\\n # Get the list of 'stop line' positions\\n stop_line_positions = self.config['stop_line_positions']\\n\\n # Find which waypoint the car is closest to\\n closest_stop_line_waypoint = -1\\n traffic_light_state = TrafficLight.UNKNOWN\\n if(self.pose):\\n car_position_waypoint = self.get_closest_waypoint(self.pose.pose)\\n\\n # Find the closest traffic light based on stop positions\\n index, closest_stop_line_waypoint = self.get_closest_stop_line_waypoint(self.waypoints, car_position_waypoint, stop_line_positions)\\n\\n # Get traffic light state ground truth from simulator provided lights list\\n traffic_light_state_truth = TrafficLight.UNKNOWN\\n if len(self.lights) > 0 and index >= 0 and index < len(self.lights):\\n # Use matching index from stop_line_positions and hope that they align\\n traffic_light_state_truth = self.lights[index].state\\n\\n # Get traffic light state from camera image\\n traffic_light_state = self.get_light_state(traffic_light_state_truth)\\n\\n text = \\\"\\\"\\n if traffic_light_state == 0: text = \\\"Red.\\\"\\n if traffic_light_state == 1: text = \\\"Yellow.\\\"\\n if traffic_light_state == 2: text = \\\"Green.\\\"\\n if traffic_light_state == 3: text = \\\"Unknown.\\\"\\n real = \\\"\\\"\\n if traffic_light_state_truth == 0: real = \\\"Red.\\\"\\n if traffic_light_state_truth == 1: real = \\\"Yellow.\\\"\\n if traffic_light_state_truth == 2: real = \\\"Green.\\\"\\n if traffic_light_state_truth == 3: real = \\\"Unknown.\\\"\\n\\n return closest_stop_line_waypoint, traffic_light_state\",\n \"def process_traffic_lights(self):\\n closest_light = None\\n\\tline_wp_idx = None\\n\\n # List of positions that correspond to the line to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n if(self.pose):\\n\\n \\tcar_wp_idx = self.get_closest_waypoint(self.pose.pose, self.lights)\\n\\t\\ttl = self.lights[car_wp_idx]\\n\\n \\t#TODO find the closest visible traffic light (if one exists)\\n\\t\\tdiff = len(self.waypoints)\\n\\t\\tfor i, light in enumerate(self.lights):\\n\\t\\t\\tline = stop_line_positions[i]\\n\\n\\t\\t\\tline_pose = Pose()\\n\\t\\t\\tline_pose.position.x = line[0]\\n\\t\\t\\tline_pose.position.y = line[1]\\n\\n\\t\\t\\ttemp_wp_idx = self.get_closest_waypoint(line_pose, self.waypoints)\\n\\n\\t\\t\\td = temp_wp_idx - car_wp_idx\\n\\t\\t\\tif d >= 0 and d < diff:\\n\\t\\t\\t\\tdiff = d\\n\\t\\t\\t\\tclosest_light = light\\n\\t\\t\\t\\tline_wp_idx = temp_wp_idx\\n\\n\\tcar_dist = self.dist_to_point(self.pose.pose, tl.pose.pose)\\n\\n#\\trospy.logwarn(\\\"DISTANCE: {}, LAST_DISTANCE: {}\\\".format(car_dist, self.last_dist))\\n\\n if closest_light and car_dist<self.distance_threshold_max and car_dist>self.distance_threshold_min and self.last_dist>=car_dist:\\n\\t\\tcv_img = self.bridge.imgmsg_to_cv2(self.camera_image, 'rgb8')\\n\\t\\ttl_image = self.detect_traffic_light(cv_img)\\n\\t\\tif tl_image is not None:\\n\\t\\t\\tstate = self.light_classifier.get_classification(tl_image)\\n\\t\\t\\tstate = state if(state != self.invalid_state_number) else TrafficLight.UNKNOWN\\t\\n\\t\\t\\t\\n\\t\\t\\trospy.logwarn(\\\"[TL_DETECTOR] State of traffic light is {}\\\".format(state))\\n\\t\\telse:\\n\\t\\t\\trospy.logwarn(\\\"[TL_DETECTOR] No TL is detected\\\")\\t\\n\\t\\tself.last_dist = car_dist\\n return line_wp_idx, state\\n \\n\\tself.last_dist = car_dist\\n return -1, TrafficLight.UNKNOWN\",\n \"def process_traffic_lights(self):\\n light = None\\n\\n if self.waypoints and self.pose:\\n self.car_wpidx = self.waypoints.find_closest_waypoint([self.pose.pose.position.x, self.pose.pose.position.y])\\n for traffic_light_wp in self.traffic_light_waypoints:\\n # rospy.loginfo(\\\"Traffic Waypoiny: %d\\\", traffic_light_wp[1])\\n # rospy.loginfo(\\\"Car position: %d\\\", self.car_wpidx)\\n if traffic_light_wp[1] > self.car_wpidx:\\n light = True\\n light_id = traffic_light_wp[0]\\n light_wp = traffic_light_wp[1]\\n break\\n\\n if light and light_wp - self.car_wpidx < self.traffic_light_lookahead_wps:\\n state, max_output_score, _ = self.get_light_state(self.lights[light_id])\\n if self.loglevel >= 4:\\n rospy.loginfo(\\\"Traffic state: %d, score: %f\\\", state, max_output_score)\\n return light_wp, state\\n if light:\\n return light_wp, TrafficLight.UNKNOWN\\n return -1, TrafficLight.UNKNOWN\",\n \"def find_tfl_lights(c_image: np.ndarray):\\n red_img = c_image[:, :, 0]\\n green_img = c_image[:, :, 1]\\n new_red = convolution(red_img)\\n new_green = convolution(green_img)\\n x_red, y_red = get_max_candidate(new_red)\\n x_green, y_green = get_max_candidate(new_green)\\n return x_red, y_red, x_green, y_green\",\n \"def process_traffic_lights(self):\\n light = None\\n\\n car_position = None\\n\\n light_wp = None\\n\\n # List of positions that correspond to the line\\n # to stop in front of for a given intersection\\n stop_line_positions = self.config['stop_line_positions']\\n if(self.pose):\\n car_position = self.get_closest_waypoint(self.pose.pose)\\n\\n # TODO find the closest visible traffic light (if one exists)\\n\\n # rospy.logerr(self.waypoints_list[5000:6000])\\n\\n closest_upcoming_tl = None\\n\\n if car_position:\\n\\n car_index = car_position[2]\\n next_car_index = car_index + 1\\n next_car_position = self.waypoints_list[next_car_index]\\n\\n for stop_line_position in stop_line_positions:\\n # Add None to the last element to not block\\n stop_line_index = kdtree_closest_point(\\n self.kdtree, stop_line_position)[2]\\n if stop_line_index > car_index:\\n light_wp = stop_line_index\\n light = True\\n break\\n\\n # time.sleep(1000)\\n\\n # rospy.logerr(car_position)\\n # rospy.logerr(upcoming_stop_line_positions)\\n\\n # tl_kdtree = build_kdtree(stop_line_positions)\\n # closest_upcoming_tl = kdtree_closest_point(tl_kdtree, car_position)\\n#\\n #if closest_upcoming_tl:\\n # light = True\\n # light_wp = kdtree_closest_point(\\n # self.kdtree, closest_upcoming_tl)[2]\\n\\n # rospy.logerr(light_wp)\\n\\n if light:\\n state = 1\\n state = self.get_light_state(light)\\n # rospy.logerr(\\\"state\\\")\\n # rospy.logerr(state)\\n return light_wp, state\\n self.waypoints = None\\n return -1, TrafficLight.UNKNOWN\",\n \"def traffic_light_detection(img_in, radii_range):\\n\\n thresh1 = 110\\n thresh2 = 60\\n cannyEdges = cv2.Canny(img_in, thresh1, thresh2)\\n\\n circles = cv2.HoughCircles(cannyEdges,cv2.HOUGH_GRADIENT, 1, 20, param1=50,param2=30,minRadius=0,maxRadius=0)\\n circles_selected = select_three(circles)\\n\\n for circle in circles_selected:\\n column = circle[0]\\n row = circle[1]\\n coordinates = (column, row)\\n state_pixels = img_in[int(row), int(column), :]\\n # print(state_pixels)\\n if state_pixels[1] == 255 and state_pixels[2] != 255 :\\n state = 'green'\\n if state_pixels[1] != 255 and state_pixels[2] == 255 :\\n state = 'red'\\n if state_pixels[1] == 255 and state_pixels[2] == 255 :\\n state = 'yellow'\\n\\n column_2 = circles_selected[1][0]\\n row_2 = circles_selected[1][1]\\n coordinates_2 = (column_2, row_2)\\n state_pixels_2 = img_in[int(row_2), int(column_2), :]\\n\\n return coordinates_2, state\\n raise NotImplementedError\",\n \"def neighboring_light(glow, block):\\n\\n return clamp(glow - blocks[block].dim, 0, 15)\",\n \"def traffic_light_detection(img_in, radii_range, noisy_image=False, max_x_offset=5):\\n\\n img = process_base_image(img_in, (7, 7))\\n\\n # find all the circles in an image using Hough Circles\\n min_radii = min(radii_range)\\n max_radii = max(radii_range)\\n # the distance between the circles should be the smallest possible circles that can touch.\\n min_dist = min_radii * 2 + 10\\n\\n # img, dp, min_dist, param1, param2, minRad, maxRad\\n if noisy_image:\\n circles = hough_circles(img, 1.55, min_dist, 20, 15, min_radii, max_radii)\\n else:\\n circles = hough_circles(img, 1.125, min_dist, 30, 20, min_radii, max_radii)\\n\\n if circles is None:\\n return (0, 0), None\\n else:\\n # cleanup circles so its easier to use.\\n circles = circles[0, :]\\n # round the numbers of the array to uint16 values.\\n circles = np.uint16(np.around(circles))\\n\\n if len(circles) < 3:\\n return (1000, 1000), None\\n else: # If there are more than 3 circles found, eliminate the outliers that shouldn't be detected.\\n # sort the circles first by x, then by Radius value, then by Y value.\\n circles = sorted(circles, key=lambda c: (c[0], c[2], c[1]))\\n\\n # since the traffic lights will be a group of 3 circles with a similar radius, then x value, then somewhat close\\n # in y value, use a \\\"window\\\" type of sliding group to create groups of 3 circles that can then be compared\\n # to each other to see if they would make up circles of a traffic light.\\n circle_groups = []\\n for c_idx in range(len(circles) - 2):\\n circle_group = circles[c_idx: c_idx + 3] # build the group\\n circle_groups.append(circle_group)\\n\\n circle_groups = np.array(circle_groups)\\n # for each circle group found, need to figure out the group with the lowest overall standard deviation.\\n # for each group, calculate the std deviations.\\n group_deviations = np.array([circle_group_deviations(g) for g in circle_groups])\\n\\n most_similar_idx = np.argmin(group_deviations)\\n final_circles = circle_groups[most_similar_idx]\\n\\n # if the circles aren't close to each other in the X direction, return\\n # none since its not a traffic light.\\n x_diffs = np.diff(final_circles[:, 0])\\n if np.any(x_diffs >= max_x_offset):\\n return (None, None), None\\n\\n # sort the circles from top down to allow color compare.\\n circles = final_circles[np.argsort(final_circles[:, 1])] # sort by Y direction.\\n # creating some names for clarity due to x, y being col, row.\\n red_row, red_col, yellow_row, yellow_col, green_row, green_col = [\\n circles[0][1],\\n circles[0][0],\\n circles[1][1],\\n circles[1][0],\\n circles[2][1],\\n circles[2][0],\\n ]\\n\\n # determine colors.\\n state = 'yellow' # default state.\\n cords = (yellow_col, yellow_row)\\n\\n red_color = np.array([0, 0, 255])\\n green_color = np.array([0, 255, 0])\\n\\n # stop for false positive labels.\\n if img_in[yellow_row, yellow_col][0] > 10:\\n return (None, None), None\\n\\n if (img_in[red_row, red_col] == red_color).all():\\n state = 'red'\\n elif (img_in[green_row, green_col] == green_color).all():\\n state = 'green'\\n\\n # print 'Color of TL midpoint is {}'.format(img_in[yellow_row, yellow_col])\\n\\n return cords, state\",\n \"def process_traffic_lights(self):\\n stopping_waypoint_index = int(self.stopping_waypoint_index)\\n nearest_light = self.stopping_waypoint_distance\\n # the result of the image_cb function is in the equation below\\n traffic_light_value = self.last_state\\n #obtain the minimum stopping distance possible given the acceleration, and jerk limits, and slow stop point\\n acceleration_limit = 10.0 - 1.0\\n slow_stop_point = 0\\n min_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\\n #obtain the maximum stopping distance by changing the acceleration limit to 6\\n acceleration_limit -= 3.0\\n max_stop_distance = .2*self.current_velocity + (self.current_velocity*(self.current_velocity-slow_stop_point)/acceleration_limit - acceleration_limit/2.0*((self.current_velocity-slow_stop_point)/acceleration_limit)**2) + (0.5*slow_stop_point**2)\\n #add on the current_velocity*rate to make sure it does not overlook the time gap\\n max_stop_distance += self.current_velocity*1.0/self.loop_rate\\n #if the previous light was red and the car began to stop, continue stopping\\n if (traffic_light_value==self.Red_Light and self.prev_traffic_light_value==self.Red_Light and self.prev_stopping_waypoint_index>=0):\\n None\\n #else if the traffic light is green, ignore it.\\n elif traffic_light_value==self.Green_Light:\\n stopping_waypoint_index = -1\\n #If the velocity is less than 2*slow_stop_point and the distance to the light is less than 2*(0.5*slow_stop_point**2) and the light is red\\n elif (self.current_velocity<=5 and nearest_light<=5 and traffic_light_value==self.Red_Light):\\n None\\n #if the distance to the nearest_light is more than the max_stop_distance, ignore it\\n elif nearest_light > max(max_stop_distance,10):\\n stopping_waypoint_index = -1\\n # else if the traffic light is Yellow or Red and the distance to the nearest light is more than the min_stop_distance\\n elif ((traffic_light_value==self.Red_Light or traffic_light_value==self.Yellow_Light) and nearest_light>min_stop_distance):\\n None\\n #else if the traffic light is unknown, stopping waypoint will be -2, telling whatever previous action to keep proceeding\\n elif traffic_light_value==self.Unknown_Light:\\n stopping_waypoint_index = -2\\n # #else if the traffic light is green, ignore it.\\n # elif traffic_light_value==self.Green_Light:\\n # stopping_waypoint_index = -1\\n #publish the stopping waypoint index\\n # self.upcoming_red_light_pub.publish(stopping_waypoint_index)\\n self.prev_traffic_light_value = traffic_light_value\\n self.prev_stopping_waypoint_index = stopping_waypoint_index\\n return stopping_waypoint_index\",\n \"def lightness_correction(self):\\n points = self.color_lookup_table_points\\n lightness_max_value = math.sqrt(3 * (255**2))\\n deadpool = list()\\n for index, point in enumerate(points[0]):\\n point = self.get_value_tuple(index)\\n lightness = int(math.sqrt(point[0]**2 + point[1]**2 + point[2]**2) * 255 / lightness_max_value)\\n if not self.to_dark < lightness < self.to_bright:\\n deadpool.append(index)\\n self.color_lookup_table_points = (np.delete(points[0], deadpool),\\n np.delete(points[1], deadpool),\\n np.delete(points[2], deadpool))\\n self.point_count = len(self.color_lookup_table_points[0])\",\n \"def light_source_directions():\\n L = np.array([[-0.06059872, -0.44839055, 0.8917812],\\n [-0.05939919, -0.33739538, 0.93948714],\\n [-0.05710194, -0.21230722, 0.97553319],\\n [-0.05360061, -0.07800089, 0.99551134],\\n [-0.04919816, 0.05869781, 0.99706274],\\n [-0.04399823, 0.19019233, 0.98076044],\\n [-0.03839991, 0.31049925, 0.9497977],\\n [-0.03280081, 0.41611025, 0.90872238],\\n [-0.18449839, -0.43989616, 0.87889232],\\n [-0.18870114, -0.32950199, 0.92510557],\\n [-0.1901994, -0.20549935, 0.95999698],\\n [-0.18849605, -0.07269848, 0.97937948],\\n [-0.18329657, 0.06229884, 0.98108166],\\n [-0.17500445, 0.19220488, 0.96562453],\\n [-0.16449474, 0.31129005, 0.93597008],\\n [-0.15270716, 0.4160195, 0.89644202],\\n [-0.30139786, -0.42509698, 0.85349393],\\n [-0.31020115, -0.31660118, 0.89640333],\\n [-0.31489186, -0.19549495, 0.92877599],\\n [-0.31450962, -0.06640203, 0.94692897],\\n [-0.30880699, 0.06470146, 0.94892147],\\n [-0.2981084, 0.19100538, 0.93522635],\\n [-0.28359251, 0.30729189, 0.90837601],\\n [-0.26670649, 0.41020998, 0.87212122],\\n [-0.40709586, -0.40559588, 0.81839168],\\n [-0.41919869, -0.29999906, 0.85689732],\\n [-0.42618633, -0.18329412, 0.88587159],\\n [-0.42691512, -0.05950211, 0.90233197],\\n [-0.42090385, 0.0659006, 0.90470827],\\n [-0.40860354, 0.18720162, 0.89330773],\\n [-0.39141794, 0.29941372, 0.87013988],\\n [-0.3707838, 0.39958255, 0.83836338],\\n [-0.499596, -0.38319693, 0.77689378],\\n [-0.51360334, -0.28130183, 0.81060526],\\n [-0.52190667, -0.16990217, 0.83591069],\\n [-0.52326874, -0.05249686, 0.85054918],\\n [-0.51720021, 0.06620003, 0.85330035],\\n [-0.50428312, 0.18139393, 0.84427174],\\n [-0.48561334, 0.28870793, 0.82512267],\\n [-0.46289771, 0.38549809, 0.79819605],\\n [-0.57853599, -0.35932235, 0.73224555],\\n [-0.59329349, -0.26189713, 0.76119165],\\n [-0.60202327, -0.15630604, 0.78303027],\\n [-0.6037003, -0.04570002, 0.7959004],\\n [-0.59781529, 0.06590169, 0.79892043],\\n [-0.58486953, 0.17439091, 0.79215873],\\n [-0.56588359, 0.27639198, 0.77677747],\\n [-0.54241965, 0.36921337, 0.75462733],\\n [0.05220076, -0.43870637, 0.89711304],\\n [0.05199786, -0.33138635, 0.9420612],\\n [0.05109826, -0.20999284, 0.97636672],\\n [0.04919919, -0.07869871, 0.99568366],\\n [0.04640163, 0.05630197, 0.99733494],\\n [0.04279892, 0.18779527, 0.98127529],\\n [0.03870043, 0.30950341, 0.95011048],\\n [0.03440055, 0.41730662, 0.90811441],\\n [0.17290651, -0.43181626, 0.88523333],\\n [0.17839998, -0.32509996, 0.92869988],\\n [0.18160174, -0.20480196, 0.96180921],\\n [0.18200745, -0.07490306, 0.98044012],\\n [0.17919505, 0.05849838, 0.98207285],\\n [0.17329685, 0.18839658, 0.96668244],\\n [0.1649036, 0.30880674, 0.93672045],\\n [0.1549931, 0.41578148, 0.89616009],\\n [0.28720483, -0.41910705, 0.8613145],\\n [0.29740177, -0.31410186, 0.90160535],\\n [0.30420604, -0.1965039, 0.9321185],\\n [0.30640529, -0.07010121, 0.94931639],\\n [0.30361153, 0.05950226, 0.95093613],\\n [0.29588748, 0.18589214, 0.93696036],\\n [0.28409783, 0.30349768, 0.90949304],\\n [0.26939905, 0.40849857, 0.87209694],\\n [0.39120402, -0.40190413, 0.8279085],\\n [0.40481085, -0.29960803, 0.86392315],\\n [0.41411685, -0.18590756, 0.89103626],\\n [0.41769724, -0.06449957, 0.906294],\\n [0.41498764, 0.05959822, 0.90787296],\\n [0.40607977, 0.18089099, 0.89575537],\\n [0.39179226, 0.29439419, 0.87168279],\\n [0.37379609, 0.39649585, 0.83849122],\\n [0.48278794, -0.38169046, 0.78818031],\\n [0.49848546, -0.28279175, 0.8194761],\\n [0.50918069, -0.1740934, 0.84286803],\\n [0.51360856, -0.05870098, 0.85601427],\\n [0.51097962, 0.05899765, 0.8575658],\\n [0.50151639, 0.17420569, 0.84742769],\\n [0.48600297, 0.28260173, 0.82700506],\\n [0.46600106, 0.38110087, 0.79850181],\\n [0.56150442, -0.35990283, 0.74510586],\\n [0.57807114, -0.26498677, 0.77176147],\\n [0.58933134, -0.1617086, 0.7915421],\\n [0.59407609, -0.05289787, 0.80266769],\\n [0.59157958, 0.057798, 0.80417224],\\n [0.58198189, 0.16649482, 0.79597523],\\n [0.56620006, 0.26940003, 0.77900008],\\n [0.54551481, 0.36380988, 0.7550205]], dtype=float)\\n return L\",\n \"def _process_traffic_lights(self):\\n #\\n # handle bad data just in case\\n #\\n if self.waypoints is None or self.waypoints_tree is None:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: No waypoints available\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if self.pose is None:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: car pose is None\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if not self.use_ground_truth and not self.has_image:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: no image available for detection\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n if not self.lights:\\n #rospy.logwarn(\\\"[TL_DETECTOR]: no lights found\\\")\\n return -1, TrafficLight.UNKNOWN\\n\\n ############################################\\n # no errors, so real processing begins here\\n ############################################\\n #\\n # find the nearest traffic light ahead\\n #\\n light = None\\n light_idx = self._get_closest_light_ahead(self.pose)\\n #\\n # handle case where there is no light ahead at any distance\\n #\\n if light_idx < 0:\\n return -1, TrafficLight.UNKNOWN\\n\\n light = self.lights[light_idx]\\n light_pos = light.pose.pose.position\\n\\n #\\n # don't worry about the light if it is too far away\\n #\\n dist_to_light = self._find_distance(self.pose.position.x,\\n self.pose.position.y,\\n light.pose.pose.position.x,\\n light.pose.pose.position.y)\\n\\n if dist_to_light > MAX_TRAFFIC_LIGHT_DETECTION_DISTANCE:\\n return -1, TrafficLight.UNKNOWN\\n\\n \\n #\\n # get stop line for light\\n #\\n stop_line_for_light = self.stop_line_positions[light_idx]\\n\\n #\\n # get closest waypoints to the stop line for this light\\n #\\n stop_line_pose = Pose()\\n stop_line_pose.position.x = stop_line_for_light[0]\\n stop_line_pose.position.y = stop_line_for_light[1]\\n stop_line_waypoint_idx = self._get_closest_waypoint(stop_line_pose)\\n\\n #\\n # get closest waypoint to the car\\n #\\n car_waypoint_idx = self._get_closest_waypoint(self.pose)\\n\\n #\\n # get light state\\n #\\n state = TrafficLight.UNKNOWN \\n if self.use_ground_truth:\\n #rospy.logwarn(\\\"GROUND TRUTH\\\")\\n state = light.state\\n else:\\n #rospy.logwarn(\\\"CLASSIFYING IMAGE\\\")\\n state = self._get_light_state(light) \\n\\n #\\n # test against gt_state in sim\\n #\\n if not self.is_site:\\n gt_state = light.state\\n pred_state = state\\n if gt_state == pred_state:\\n self.num_correct_predictions += 1\\n else:\\n self.num_incorrect_predictions += 1\\n self.num_predictions += 1\\n\\n if self.num_predictions > 0 and self.num_predictions % 10 == 0:\\n pred_acc = 100.0*float(self.num_correct_predictions)/float(self.num_predictions) \\n rospy.logwarn('[TL_DETECTOR] prediction accuracy is %f percent' % pred_acc)\\n\\n #\\n # return waypoint index of stopline and the light state\\n #\\n return stop_line_waypoint_idx, state\",\n \"def light(color, dist):\\n return tuple( float(x*dist*dist) for x in color )\",\n \"def process_traffic_lights(self):\\n\\n # Clear closest light\\n closest_light = None\\n\\n # Clear closest line index\\n line_wp_idx = None\\n \\n # Load stop line positions from config\\n stop_line_positions = self.config['stop_line_positions']\\n\\n # If we've received valid pose information...\\n if self.pose:\\n\\n # Find index of waypoint closest to current car position\\n car_wp_idx = self.waypoint_tree.query([self.pose.pose.position.x, self.pose.pose.position.y],1)[-1]\\n\\n # Largest possible offset from car to light\\n diff = len(self.waypoints.waypoints)\\n\\n # For each light in the list of traffic lights...\\n for i, light in enumerate(self.lights):\\n\\n # Get stop line position i\\n line = stop_line_positions[i]\\n\\n # Find index of waypoint closest to the light\\n wp_idx = self.waypoint_tree.query(line,1)[-1]\\n\\n # How many waypoints ahead to light? \\n wps = wp_idx - car_wp_idx\\n\\n # If light is ahead of or abreast of car\\n # and we haven't encuntered a closer one...\\n if wps>=0 and wps<diff:\\n\\n # Keep track of least positive waypoint count\\n diff = wps\\n\\n # Save this light\\n closest_light = light\\n\\n # Save the waypoint index for this light\\n line_wp_idx = wp_idx\\n\\n # If there is a traffic light in front of us...\\n if closest_light:\\n\\n # Get its state\\n state = self.get_light_state(closest_light)\\n\\n # Return its line index and state\\n return line_wp_idx, state\\n\\n # Otherwise return sentinel indicating no light\\n return -1, TrafficLight.UNKNOWN\",\n \"def nextLight():\\n global light\\n pin.setAllOutPinsLow()\\n light += 1\\n light %= len(traffic_lights)\\n print traffic_colors[light]\\n pin.setOutPinHigh(traffic_lights[light])\",\n \"def light_color(self):\\n return self._spots[constants.CROSSING_LOCATION - 1].light_color()\",\n \"def check_light(light: pykulersky.Light):\\n light.connect()\\n light.get_color()\",\n \"def get_light_state(self, light):\\n if (not self.has_image):\\n self.prev_light_loc = None\\n return TrafficLight.UNKNOWN\\n\\n rgb = self.bridge.imgmsg_to_cv2(self.camera_image)\\n\\n if self.use_classifier:\\n light_state = self.light_classifier.get_classification(rgb)\\n rospy.logdebug('inference: {} / ground truth {}'.format(\\n light_state, light.state))\\n else:\\n light_state = light.state\\n\\n if self.save_images:\\n dist_to_light = self.calculate_distance(\\n self.pose.pose.position.x, light.pose.pose.position.x,\\n self.pose.pose.position.y, light.pose.pose.position.y)\\n\\n if dist_to_light <= self.save_images_min_dist:\\n bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)\\n cv2.imwrite(\\\"./data/test/test-{}-{}.{}.jpg\\\".format(\\n light_state, light.state, self.camera_image.header.seq),\\n bgr)\\n\\n return light_state\",\n \"def get_light_state(self, light):\\n if(not self.has_image):\\n self.prev_light_loc = None\\n return TrafficLight.RED\\n\\n # fixing convoluted camera encoding...\\n if hasattr(self.camera_image, 'encoding'):\\n self.attribute = self.camera_image.encoding\\n if self.camera_image.encoding == '8UC3':\\n self.camera_image.encoding = \\\"rgb8\\\"\\n else:\\n self.camera_image.encoding = 'rgb8'\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"rgb8\\\")\\n\\n #Get classification\\n if self.light_classifier is not None:\\n classification = self.light_classifier.get_classification(cv_image)\\n else:\\n classification = TrafficLight.UNKNOWN\\n print \\\"traffic light: \\\", label[classification]\\n return classification\",\n \"def find_reddest_pixel_fast(img): \\n img = np.array(img, dtype = 'int32')\\n location = cv2.minMaxLoc((img[:, :, 2] - img[:, :, 1]) + (img[:, :, 2] - img[:, :, 0]))[3]\\n return location\",\n \"def __process_traffic_lights(self):\\n rospy.logdebug(\\\"TLDetector.__process_traffic_lights\\\")\\n\\n closest_light, line_index = self.__get_closest_light()\\n\\n if closest_light:\\n if self.__mode == CLSFY_MODE:\\n state = self.__get_light_state(closest_light)\\n elif self.__mode == LABEL_MODE:\\n if line_index - self.__get_car_index() <= 100:\\n state = closest_light.state\\n else:\\n state = 4\\n rospy.loginfo(\\n \\\"TLDetector: Publishing index: \\\"\\n + str(line_index)\\n + \\\" and state: \\\"\\n + str(state)\\n )\\n return line_index, state\\n rospy.logdebug(\\\"TLDetector: Publishing default\\\")\\n return -1, TrafficLight.UNKNOWN\",\n \"def get_atmospheric_light(self,img, *, size, percent):\\n #Get the atmospheric light factor from the image\\n m, n, _ = img.shape\\n\\n flat_img = img.reshape(m * n, 3)\\n flat_dark = self.get_dark_channel(img, size=size).ravel()\\n count = math.ceil(m * n * percent / 100)\\n indices = np.argpartition(flat_dark, -count)[:-count]\\n\\n return np.amax(np.take(flat_img, indices, axis=0), axis=0)\",\n \"def nearest(self, red, green, blue):\\n # BAW: should we use Voronoi diagrams, Delaunay triangulation, or\\n # octree for speeding up the locating of nearest point? Exhaustive\\n # search is inefficient, but seems fast enough.\\n nearest = -1\\n nearest_name = ''\\n for name, aliases in self.__byrgb.values():\\n r, g, b = self.__byname[name.lower()]\\n rdelta = red - r\\n gdelta = green - g\\n bdelta = blue - b\\n distance = rdelta * rdelta + gdelta * gdelta + bdelta * bdelta\\n if nearest == -1 or distance < nearest:\\n nearest = distance\\n nearest_name = name\\n return nearest_name\",\n \"def lightness(color):\\n\\n strongest = max(color.red, color.green, color.blue)\\n weakest = min(color.red, color.green, color.blue)\\n return 0.5 * (strongest + weakest) / 255\",\n \"def get_light_state(self, light):\\n\\treturn light.state \\n\\n\\t#if(not self.has_image):\\n # self.prev_light_loc = None\\n # return False\",\n \"def getLight(self):\\n return self.light\",\n \"def identify_color(animal):\\n min_dist = None\\n identified_color = None\\n for color in animal.colors:\\n color_rgb = color_rgbs[color]\\n dist = ((animal.get_red() - color_rgb[0]) ** 2) + (\\n (animal.get_green() - color_rgb[1]) ** 2) + ((animal.get_blue() - color_rgb[2]) ** 2)\\n if (min_dist is None) or (dist < min_dist):\\n min_dist = dist\\n identified_color = color\\n return identified_color\",\n \"def diffuse_light(self):\\n return self._diffuse_light\",\n \"def get_light_state(self, light):\\n \\tif (not self.has_image):\\n return light.state, 1.0, None if light else TrafficLight.UNKNOWN, 0, None\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"rgb8\\\")\\n #Get classification\\n \\treturn self.light_classifier.get_classification(cv_image)\",\n \"def getCarLocation():\\n cams = CAMS\\n img1, img2 = cams[0].getImage(), cams[1].getImage()\\n potint1op, point2op = GetBalloonOld.getCar(img1), GetBalloonOld.getCar(\\n img2)\\n for j in range(len(point1op)):\\n point1op[j] = np.array(np.array([point1op[j][0], point1op[j][1]]))\\n for j in range(len(point2op)):\\n point2op[j] = np.array(np.array([point2op[j][0], point2op[j][1]]))\\n if len(point1op) == 0 or len(point2op) == 0:\\n return None\\n points = [[point1op[0]], [point2op[0]]]\\n car = getTargetsPlaces(copy.deepcopy(points))[0]\\n diff = abs(car[2] - CAR_Z)\\n for op1 in point1op:\\n for op2 in point2op:\\n testPoint = [[op1], [op2]]\\n testCar = getTargetsPlaces(copy.deepcopy(testPoint))[0]\\n testDiff = abs(testCar[2] - CAR_Z)\\n if testDiff < diff:\\n diff = testDiff\\n car = testCar\\n return car\",\n \"def get_nearest_color(color):\\n\\n result = color_re.match(color)\\n if result is not None and len(result.groups()) == 5:\\n color_red = int(result.groups()[1])\\n color_green = int(result.groups()[2])\\n color_blue = int(result.groups()[3])\\n color_actual = np.array([color_red, color_green, color_blue])\\n\\n nearest_color = None\\n best_distance = 99999.99\\n for candidate_color in base_colors:\\n color_class = candidate_color[0]\\n color_rgb = candidate_color[1]\\n color_distance = calc_color_distance(color_actual, color_rgb)\\n if color_distance < best_distance:\\n best_distance = color_distance\\n nearest_color = color_class\\n else:\\n nearest_color = base_colors[0][0]\\n\\n return nearest_color\",\n \"def get_light_state(self, light):\\n if(not self.has_image):\\n self.prev_light_loc = None\\n return False\\n\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n\\n #cv2.imshow('image',cv_image)\\n #cv2.waitKey(0)\\n\\n # Get classification\\n if self.init_ok == True:\\n return self.light_classifier.get_classification(cv_image)\\n else:\\n return TrafficLight.UNKNOWN\",\n \"def find_wall(self, data):\\n minimum = min(data.ranges)\\n min_index = data.ranges.index(minimum)\\n\\n # convert angle to be centered around front laser \\n # set differences and constants\\n if min_index <= 180:\\n diff_ang = min_index\\n else:\\n diff_ang = min_index - 360\\n diff_dist = minimum - distance\\n k_d_dist = 0.5\\n k_d_ang = 0.01\\n \\n if min_index < 5 or min_index > 355:\\n # Go forward until it reaches close to wall\\n self.twist.angular.z = k_d_ang * diff_ang\\n self.twist.linear.x = k_d_dist * diff_dist\\n else:\\n # keep turning until it faces closest wall\\n self.twist.angular.z =k_d_ang * diff_ang\\n if self.twist.linear.x > 0:\\n self.twist.linear.x = k_d_dist * diff_dist\",\n \"def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\\n image = np.array(Image.open(image_path))\\n if json_path is None:\\n objects = None\\n else:\\n gt_data = json.load(open(json_path))\\n what = ['traffic light']\\n objects = [o for o in gt_data['objects'] if o['label'] in what]\\n\\n show_image_and_gt(image, objects, fig_num)\\n\\n red_x, red_y, green_x, green_y = find_tfl_lights(image)\\n plt.plot(red_x, red_y, 'ro', color='r', markersize=3)\\n plt.plot(green_x, green_y, 'ro', color='g', markersize=3)\",\n \"def lightness(self):\\n min_component = min(self.red, self.green, self.blue)\\n max_component = max(self.red, self.green, self.blue)\\n avg = (max_component + min_component) / 2\\n light = avg / 255\\n return light\",\n \"def recognize_color(self):\\n x = (self.x + DIRECTIONS[(self.facing_direction - self.config) % 8][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[(self.facing_direction - self.config) % 8][1]) % (self.image.shape[1] - 1)\\n color_left = self.image[x, y]\\n if abs(self.luminance(color_left) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.turn_left\\n x = (self.x + DIRECTIONS[self.facing_direction][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[self.facing_direction][1]) % (self.image.shape[1] - 1)\\n color_forward = self.image[x, y]\\n if abs(self.luminance(color_forward) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.move_forward\\n x = (self.x + DIRECTIONS[(self.facing_direction + self.config) % 8][0]) % (self.image.shape[0] - 1)\\n y = (self.y + DIRECTIONS[(self.facing_direction + self.config) % 8][1]) % (self.image.shape[1] - 1)\\n color_right = self.image[x, y]\\n if abs(self.luminance(color_right) - self.luminance_fcolor) <= self.lum_threshold:\\n return self.turn_right\\n return None\",\n \"def extract_target_pixel_location(self):\\n #Respective Image location\\n pixel_array = self.imageprepare(self.image_path)\\n\\n #Select less_than_target color point --> must be calibrated\\n #?? Should we use an abstract class here instead of an if statment ??\\n if self.color == \\\"g\\\":\\n less_than_target = .15\\n else:\\n raise ValueError(\\\"Unknown color value\\\")\\n\\n #Chooses target pixels as well as it's location\\n target_pixels = []\\n for pixel in enumerate(pixel_array):\\n if pixel[1] < less_than_target:\\n target_pixels.append(pixel[0])\\n\\n return target_pixels\",\n \"def getLightSensor() -> int:\\n pass\",\n \"def recognize_color(color, palette):\\n min_distance = np.inf\\n most_similar_color = None\\n for cname, cvalue in palette.items():\\n distance = np.sum(np.abs(np.array(color) - np.array(cvalue)))\\n if distance < min_distance:\\n min_distance = distance\\n most_similar_color = cname\\n return most_similar_color\",\n \"def get_light_state(self, light):\\n\\n # If there is no image to process...\\n if self.camera_image == None:\\n\\n # Don't know the color\\n return TrafficLight.UNKNOWN\\n\\n else:\\n\\n # Convert image format\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n\\n # Classify the image\\n return self.light_classifier.get_classification(cv_image)\",\n \"def get_light_state(self, traffic_light_state_truth):\\n if not self.has_image:\\n return False\\n\\n # Get classification\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n cv_image = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)\\n\\n height = cv_image.shape[0]\\n width = cv_image.shape[1]\\n\\n boxes, scores, classes, num = self.sess.run([self.detection_boxes,\\n self.detection_scores,\\n self.detection_classes,\\n self.num_detections],\\n feed_dict={self.image_tensor: [cv_image]})\\n\\n new_boxes = []\\n new_classes = []\\n new_scores = []\\n for i in range(num):\\n if scores[0][i] > 0.5:\\n xmin = int(boxes[0][i][0] * height)\\n xmax = int(boxes[0][i][2] * height)\\n ymin = int(boxes[0][i][1] * width)\\n ymax = int(boxes[0][i][3] * width)\\n box = [xmin, xmax, ymin, ymax]\\n new_boxes.append(box)\\n new_classes.append(classes[0][i])\\n new_scores.append(scores[0][i])\\n\\n\\n\\n\\n if len(new_classes) != 0:\\n counts = np.bincount(new_classes)\\n light = np.argmax(counts)\\n if light == GREEN:\\n return TrafficLight.GREEN\\n elif light == RED:\\n return TrafficLight.RED\\n elif light == YELLOW:\\n return TrafficLight.YELLOW\\n else: return TrafficLight.UNKNOWN\",\n \"def get_displacement(self, color, depth):\\n displacement = None\\n keypoints, descriptors = self._feature_detector.detectAndCompute(color, None)\\n \\n if descriptors is not None and self._last_descriptors is not None:\\n matches = self._matcher.match(descriptors, self._last_descriptors)\\n matches = self._select_matches(matches) \\n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\\n t = []\\n horizontal = 0\\n for i in range(len(matches)):\\n d1 = depth[int(points[i][1]), int(points[i][0])]\\n d2 = self._last_depth[int(last_points[i][1]), int(points[i][0])]\\n #print(d1, d2)\\n \\n if d1 != 0 and abs(d1-d2) < 10:\\n t.append(matches[i])\\n horizontal += (points[i][0] - last_points[i][0]) * d1\\n \\n matches = t\\n horizontal /= len(t) \\n \\n if len(matches) > 0:\\n if self._config['show_matches']:\\n matches_preview = cv2.drawMatches(color, keypoints, self._last_color, self._last_keypoints, matches, None, flags=2)\\n cv2.imshow('Basic_Odometry_matches_preview', matches_preview)\\n \\n points, last_points = self._get_points_from_matches(keypoints, self._last_keypoints, matches)\\n #It uses default values for parameters - there must be here because of broken python bindings I suppose\\n tf_mat = cv2.estimateRigidTransform(points, last_points, False, 500, 0.5, 3)\\n \\n if tf_mat is not None:\\n a11, a12, b1 = tf_mat[0][0], tf_mat[0][1], tf_mat[0][2]\\n a21, a22, b2 = -tf_mat[1][0], tf_mat[1][1], tf_mat[1][2]\\n roll = math.atan2(-a12, a11) \\n \\n displacement = {\\n 'roll': roll,\\n 'horizontal': horizontal,#b1,\\n 'vertical': b2,\\n 'depth': math.sqrt(a11**2+a12**2) * (-1 if a11 < 0 else 1)\\n }\\n \\n if descriptors is not None: \\n self._last_keypoints = keypoints\\n self._last_descriptors = descriptors\\n self._last_color = color\\n self._last_depth = depth\\n \\n return displacement\",\n \"def _find_hilight(self):\\n traverse = deque([self.item])\\n while traverse:\\n item = traverse.popleft()\\n if item.hilight:\\n return item.hilight\\n traverse.extendleft(reversed(item.subitems))\",\n \"def getNear(self):\\n return self.light.node().getLens().getNear()\",\n \"def place_blue_light():\\n glMatrixMode(GL_MODELVIEW)\\n lx = 3.0\\n ly = light_height\\n lz = 1.0\\n light_position = [ lx, ly, lz, 1.0 ]\\n\\n lightb_ambient = [0.0, 0, 1, 1] #blue\\n lightb_diffuse = [0.4, 0.4, 0.6, 1] #blue\\n lightb_specular = [0.0, 0, 0.8, 1] #blue\\n light_direction = [ 1.0, -1.0, 1.0, 0.0 ] # Light points down\\n\\n\\n # For Light 0 (blue), set position, ambient, diffuse, and specular values\\n glLightfv(GL_LIGHT0, GL_POSITION, light_position)\\n glLightfv(GL_LIGHT0, GL_AMBIENT, lightb_ambient)\\n glLightfv(GL_LIGHT0, GL_DIFFUSE, lightb_diffuse)\\n glLightfv(GL_LIGHT0, GL_SPECULAR, lightb_specular)\\n\\n\\n\\n # Constant attenuation (for distance, etc.)\\n # Only works for fixed light locations! Otherwise disabled\\n glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 1.0)\\n glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.0)\\n glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n # Create a spotlight effect (none at the moment)\\n if blue_light:\\n glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0)\\n glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.0)\\n glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, light_direction)\\n else:\\n glLightf(GL_LIGHT0, GL_SPOT_CUTOFF,180.0)\\n glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.0)\\n \\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\\n # Try GL_TRUE - but then watch what happens when light is low\\n \\n glEnable(GL_LIGHT0)\\n\\n\\n # This part draws a SELF-COLORED sphere (in spot where light is!)\\n glPushMatrix()\\n glTranslatef(lx,ly,lz)\\n glDisable(GL_LIGHTING)\\n glColor3f(0, 0, brightness)\\n glutSolidSphere(0.5, 20, 20)\\n glEnable(GL_LIGHTING)\\n glPopMatrix()\",\n \"def get_object(img, color,cam='front'):\\n if color == \\\"yellow\\\":\\n if cam == \\\"front\\\":\\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\\n lower = np.array([15, 146, 0], dtype=np.uint8)\\n upper = np.array([62, 255, 255], dtype=np.uint8)\\n mask = cv.inRange(hsv, lower, upper)\\n if cam == \\\"bottom\\\":\\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\\n lower = np.array([15, 146, 0], dtype=np.uint8)\\n upper = np.array([62, 255, 255], dtype=np.uint8)\\n mask = cv.inRange(hsv, lower, upper)\\n elif color == \\\"red\\\":\\n if world == \\\"real\\\":\\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\\n lower1 = np.array([0, 39, 17], dtype=np.uint8)\\n upper1 = np.array([32, 208, 115], dtype=np.uint8)\\n lower2 = np.array([122, 39, 17], dtype=np.uint8)\\n upper2 = np.array([180, 208, 115], dtype=np.uint8)\\n mask1 = cv.inRange(hsv, lower1, upper1)\\n mask2 = cv.inRange(hsv, lower2, upper2)\\n mask = cv.bitwise_or(mask1, mask2)\\n if world == \\\"sim\\\":\\n hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)\\n lower1 = np.array([0, 85, 12], dtype=np.uint8)\\n upper1 = np.array([11, 234, 234], dtype=np.uint8)\\n lower2 = np.array([158, 85, 12], dtype=np.uint8)\\n upper2 = np.array([180, 234, 234], dtype=np.uint8)\\n mask1 = cv.inRange(hsv, lower1, upper1)\\n mask2 = cv.inRange(hsv, lower2, upper2)\\n mask = cv.bitwise_or(mask1, mask2)\\n return mask\",\n \"def trace(self, ray): # type: (Ray) -> Vector\\n hit_object = None\\n t = numpy.inf\\n\\n for scene_object in self.scene.shapes:\\n t0 = scene_object.intersect(ray)\\n if t0 < t:\\n t = t0\\n hit_object = scene_object\\n\\n # if there were no intersections, then return the background colour\\n if t == numpy.inf:\\n return self.scene.camera.background\\n\\n hit_point = ray.origin + ray.direction * t\\n normal = hit_object.normal(hit_point)\\n luminance = 0.0\\n\\n # perform shading calculations\\n for light in self.scene.lights:\\n hit_point_to_light = (light.centre - hit_point).normal\\n\\n #check whether this light contributes to the shading\\n in_shadow = False\\n for shadower in self.scene.shapes:\\n # we don't want to test against itself\\n if shadower == hit_object:\\n continue\\n shadow_ray = Ray(hit_point + normal * 0.0001, hit_point_to_light)\\n if shadower.intersect(shadow_ray) < numpy.inf:\\n in_shadow = True\\n break\\n if in_shadow:\\n continue\\n\\n # super simple lambertian lighting model\\n luminance += hit_point_to_light.dot(normal) * light.power\\n\\n # calculate shaded colour - luminance may be over one if there are multiple light sources\\n # normally this would be dealt with by HDR and tone mapping but is just clipped\\n # in demo ray tracers\\n object_colour = hit_object.material.colour * min(luminance, 1.0)\\n\\n # calculate reflection colour if material has reflectance\\n if hit_object.material.reflectance != 0.0 and ray.depth != self.scene.camera.depth:\\n reflected_direction = (ray.direction - normal * 2 * (ray.direction.dot(normal))).normal\\n # we need to 'translate' the reflection vector away from the hitpoint otherwise\\n # we risk intersecting the original hit point again which causes artifacts in the reflection\\n reflected_ray = Ray(hit_point + reflected_direction * 0.0001, reflected_direction, ray.depth + 1)\\n reflection_colour = self.trace(reflected_ray)\\n\\n # interpolate shaded colour and reflected colour based on reflectance\\n return Vector(*[lerp(object_colour.data[i], reflection_colour.data[i], hit_object.material.reflectance) for i in range(3)])\\n\\n return object_colour\",\n \"def place_red_light():\\n glMatrixMode(GL_MODELVIEW)\\n lx = 4.0\\n ly = light_height\\n lz = 2.0\\n light_position = [lx, ly, lz, 1.0]\\n lightr_ambient = [1.0, 0, 0, 1] # red\\n lightb_diffuse = [0.4, 0.4, 0.6, 1] # blue\\n lightb_specular = [0.0, 0, 0.8, 1] # blue\\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\\n\\n\\n # For Light 1 (red), set position, ambient, diffuse, and specular values\\n glLightfv(GL_LIGHT1, GL_POSITION, light_position)\\n glLightfv(GL_LIGHT1, GL_AMBIENT, lightr_ambient)\\n glLightfv(GL_LIGHT1, GL_DIFFUSE, lightb_diffuse)\\n glLightfv(GL_LIGHT1, GL_SPECULAR, lightb_specular)\\n\\n # Constant attenuation (for distance, etc.)\\n # Only works for fixed light locations! Otherwise disabled\\n glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\\n glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\\n glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n # Create a spotlight effect (none at the moment)\\n if red_light:\\n glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 45.0)\\n glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 0.0)\\n glLightfv(GL_LIGHT1, GL_SPOT_DIRECTION, light_direction)\\n else:\\n glLightf(GL_LIGHT1, GL_SPOT_CUTOFF, 180.0)\\n glLightf(GL_LIGHT1, GL_SPOT_EXPONENT, 0.0)\\n\\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\\n # Try GL_TRUE - but then watch what happens when light is low\\n\\n glEnable(GL_LIGHT1)\\n\\n # This part draws a SELF-COLORED sphere (in spot where light is!)\\n glPushMatrix()\\n glTranslatef(lx, ly, lz)\\n glDisable(GL_LIGHTING)\\n glColor3f(brightness, 0, 0)\\n glutSolidSphere(0.5, 20, 20)\\n glEnable(GL_LIGHTING)\\n glPopMatrix()\",\n \"def closest_on_screen_point_optim(trajectory, viewpoint, yaw, gaze_on_screen):\\n \\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \\n \\n #pprint(traj_angles)\\n\\n dist, idx = closest_node_tree(traj_angles, gaze_on_screen)\\n ml_screen_ref = traj_angles[idx] \\n\\n return(idx, ml_screen_ref)\",\n \"def get_light(self, light, text=False):\\n if not self.have_light(light):\\n return None\\n if text:\\n return text_switch[self.light_status[light]]\\n return self.light_status[light]\",\n \"def planes_with_light_profiles(tracer):\\n # NOTE: Find all planes with light profiles\\n # NOTE:\\n # # image = tracer.galaxies[1].profile_image_from_grid(grid=grid)\\n # # plt.figure()\\n # # plt.imshow(image.in_2d)\\n # # plt.show()\\n #\\n # # asd = list(map(lambda plane: plane.has_light_profile, tracer.planes))\\n # # print(asd)\\n # #print(tracer.planes)\\n #\\n # #print(tracer.has_light_profile)\\n # #print(list(map(lambda plane: plane.has_light_profile, tracer.planes)))\\n # #print(tracer.galaxies_with_light_profile)\\n #\\n # #print(tracer.planes[1].galaxies_with_light_profile)\\n #\\n # galaxies = tracer.planes[1].galaxies_with_light_profile\\n # galaxy = galaxies[0]\\n #\\n # galaxy_light_profiles = galaxy.light_profiles\\n #\\n # image_0 = galaxy_light_profiles[0].profile_image_from_grid(grid=grid)\\n # image_0_in_2d = image_0.in_2d\\n #\\n # image_1 = galaxy_light_profiles[1].profile_image_from_grid(grid=grid)\\n # image_1_in_2d = image_1.in_2d\",\n \"def closest_battery(self, old_battery, house):\\r\\n batteries = self.child.batteries\\r\\n nearest_battery = None\\r\\n shortest_distance = 0\\r\\n\\r\\n for battery in batteries:\\r\\n distance = abs(batteries.get(battery).x_cor - house.x_cor) + abs(batteries.get(battery).y_cor - house.y_cor)\\r\\n\\r\\n if shortest_distance == 0:\\r\\n shortest_distance = distance\\r\\n nearest_battery = batteries.get(battery)\\r\\n else:\\r\\n if distance < shortest_distance:\\r\\n shortest_distance = distance\\r\\n nearest_battery = batteries.get(battery)\\r\\n return nearest_battery\",\n \"def light_row(row):\\n def filter_row(col, rw):\\n \\\"\\\"\\\"For a given pixel position, turn on if it matches our row\\n \\\"\\\"\\\"\\n return rw == row\\n light(MAX_BRIGHTNESS, filter_row)\",\n \"def localize_pixel(img_pos,camera : Camera,lidar : Lidar, scan : LaserScan) -> tuple:\\n\\n # ---OBJ--\\n # x r1 /\\\\ r2 x\\n # / \\\\\\n #cam_ray / \\\\ average_ray\\n # / \\\\\\n # / \\\\\\n # CAM ----> LID\\n # \\n\\n # has to be 2d\\n assert (img_pos.size == 2)\\n\\n cam_ray = camera.get_ray_through_image(img_pos)\\n\\n cam_ray_robot = camera.get_ray_in_robot_frame(cam_ray)\\n\\n cam_ray_lidar = lidar.get_ray_in_lidar_frame(cam_ray_robot)\\n\\n # flatten camera ray\\n cam_ray_lidar_flat = lidar.get_ray_projection(cam_ray_lidar)\\n\\n # figure out which lidar rays correspond to the camera ray\\n (ray1,ray2) = lidar.get_corresponding_lidar_rays(cam_ray_lidar_flat,scan)\\n\\n # if no rays found corresponding to scan data\\n if ray1 is None or ray2 is None:\\n return (None,None)\\n\\n # get the normal to the lidar hit\\n intersection_normal = lidar.get_normal_to_plane(ray1,ray2)\\n\\n # get the distance data in horizontal plane, from lidar to object\\n lidar_to_target_length = lidar.get_camera_ray_length(cam_ray_lidar_flat,ray1,ray2)\\n\\n # get the vector from camera to lidar (flattened to lidar plane)\\n # i.e. origin of lidar frame in camera frame\\n lidar_to_cam_vec = cam_ray_lidar_flat.origin\\n cam_to_lidar_flat = Ray(lidar_to_cam_vec,-lidar_to_cam_vec,np.linalg.norm(lidar_to_cam_vec))\\n \\n # now workout the lidar to object ray, i.e. interpolate between ray1's and ray2's tips\\n lidar_to_object_flat = interpolated_ray(ray1,ray2,0.5,lidar_to_target_length)\\n\\n # now finally workout the vector from camera to object (flattened)\\n # this lets us access the true z-distance in the camera\\n cam_to_object_flat = lidar_to_object_flat.get_vec() + cam_to_lidar_flat.get_vec()\\n \\n cam_to_object_flat_length = np.linalg.norm(cam_to_object_flat)\\n\\n # angle from horizontal on camera ray\\n cam_ray_theta = angle_between(cam_ray_lidar.get_vec(),cam_to_object_flat)\\n\\n # length of original camera ray (knowing the length of its projection)\\n # will fail if ray is pointing straight up or down\\n cam_ray_robot.length = cam_to_object_flat_length / math.cos(cam_ray_theta)\\n\\n\\n object_robot = cam_ray_robot.get_vec()+cam_ray_robot.origin\\n\\n return (object_robot,intersection_normal)\",\n \"def nearest(self, location, exclude=[]):\\n r = numpy.fromiter(\\n (t.distance(location) for t in self._thermals), dtype=float)\\n idx = numpy.argmin(r)\\n\\n idx = 0\\n sort_idx = numpy.argsort(r)\\n while self._thermals[sort_idx[idx]].id in exclude:\\n idx += 1\\n return (self._thermals[sort_idx[idx]], sort_idx[idx])\\n\\n include = numpy.ones((len(self._thermals),), dtype=bool)\\n include[exclude] = False\\n\\n idx = numpy.arange(len(self._thermals))[include]\\n sub_idx = idx[numpy.argmin(r[include])]\\n return (self._thermals[sub_idx], sub_idx)\",\n \"def handle_colordetection(self):\\n self.robot.sensormap.tank_drive.stop()\\n if self.robot.sensormap.cs_l.color in self.colors and self.robot.sensormap.cs_l.color not in self.detected:\\n self.detected.add(self.robot.sensormap.cs_l.color)\\n elif self.robot.sensormap.cs_r.color in self.colors and self.robot.sensormap.cs_r.color not in self.detected:\\n self.detected.add(self.robot.sensormap.cs_r.color)\\n elif self.robot.sensormap.cs_m.color in self.colors and self.robot.sensormap.cs_m.color not in self.detected:\\n self.detected.add(self.robot.sensormap.cs_m.color)\",\n \"def whatsgreen2(image):\\n green = image.hueDistance(color= Color('green'), minvalue=40).binarize()\\n return green\",\n \"def calculateLighting(x,y,z, xnormal, ynormal, znormal):\\n dummy = 0\\n clr = dislin.getlit(x,y,z,xn,yn,zn,dummy)\",\n \"def get_light(name):\\n if name not in _cache:\\n get_lights() # do nothing with response\\n\\n if name in _cache:\\n return _cache[name]\\n else:\\n return None\",\n \"def __get_light_state(self, light):\\n rospy.logdebug(\\\"TLDetector.__get_light_state\\\")\\n if not self.__has_image:\\n self.__prev_light_loc = None\\n return False\\n\\n cv_image = self.__bridge.imgmsg_to_cv2(self.__camera_image, \\\"bgr8\\\")\\n\\n rospy.logdebug(\\\"TLDetector: classifying light\\\")\\n return self.__light_classifier.get_classification(cv_image)\",\n \"def _get_twilight(self, datetime_today, lon, lat, alt):\\r\\n\\r\\n dusk = self._astral.dusk_utc(datetime_today, lat, lon,\\r\\n observer_elevation=alt,\\r\\n depression=self.twilight_alt)\\r\\n\\r\\n dawn = self._astral.dawn_utc(datetime_today + _delta_dt, lat, lon,\\r\\n observer_elevation=alt,\\r\\n depression=self.twilight_alt)\\r\\n\\r\\n return dusk, dawn\",\n \"def testOccultedLightSource(self):\\n torch = objects.Thing(store=self.store, name=u\\\"torch\\\")\\n objects.LightSource.createFor(torch, candelas=80)\\n\\n c = objects.Container.createFor(self.observer, capacity=1000)\\n\\n torch.moveTo(self.observer)\\n c.closed = True\\n\\n found = visibles(self.observer.idea)\\n self.assertDarkRoom(found[0])\\n self.assertEquals(len(found), 1)\",\n \"def _apply_laser(self, color):\\n path = self.get_laser_path(color)\\n if path[-1].type is LaserPathType.hit:\\n square = self.get(path[-1].position.x, path[-1].position.y)\\n if (square.piece.type is PieceType.anubis and square.piece.orientation is Orientation.delta(path[-1].direction,-180)) \\\\\\n or square.piece.type is PieceType.sphinx:\\n # Hit but not destroyed\\n pass\\n else:\\n piece = self.remove_piece(path[-1].position)\\n return path, piece\\n return path, None\",\n \"def get_light_state(self):\\n\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n\\n #Get classification\\n tl_image_rgb, color_index = self.light_classifier.get_classification(cv_image)\\n tl_cv_image = cv2.cvtColor(tl_image_rgb, cv2.COLOR_RGB2BGR)\\n try:\\n self.tl_detected_image_pub.publish(self.bridge.cv2_to_imgmsg(tl_cv_image, \\\"bgr8\\\"))\\n except CvBridgeError as e:\\n print(e)\",\n \"def detect_bridge():\\n # Initialize color ranges for detection\\n color_range = [Color(\\\"Brug\\\", [0, 0, 0], [0, 255, 107]),\\n Color(\\\"Gat\\\", [0, 0, 0], [0, 0, 255]),\\n Color(\\\"Rand\\\", [0, 0, 185], [0, 0, 255]),\\n Color(\\\"White-ish\\\", [0, 0, 68], [180, 98, 255])]\\n\\n cam = Recognize(color_range)\\n cam.run()\",\n \"def filter_lane_color(image):\\n \\n YELLOW_HSV_LOWER = np.array([20, 100, 100])\\n YELLOW_HSV_UPPER = np.array([40, 255, 255])\\n \\n WHITE_HSV_LOWER = np.array([0, 0, 220])\\n WHITE_HSV_UPPER = np.array([255, 255, 255])\\n \\n image_wk = np.copy(image) # working copy\\n image_hsv = cv2.cvtColor(image_wk, cv2.COLOR_RGB2HSV) # RGB -> HSV\\n \\n yellow_mask = cv2.inRange(image_hsv, YELLOW_HSV_LOWER, YELLOW_HSV_UPPER)\\n white_mask = cv2.inRange(image_hsv, WHITE_HSV_LOWER, WHITE_HSV_UPPER)\\n both_mask = yellow_mask + white_mask\\n \\n image_wk = grayscale(image_wk) # RGB -> GRAY\\n image_wk = cv2.bitwise_or(image_wk, both_mask) # GRAY + yellow/white mask\\n \\n # Output grayscale road image with enhanced yellow/white areas\\n return image_wk\",\n \"def locate_tracker(self, debug):\\n\\n # tmp_image =\\n # tmp_image = cv2.GaussianBlur(self.frame, (11, 11), 0) # Experiment with this\\n\\n hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV) # Convert to HSV Color Space. This is temporary for testing using colored objects)\\n\\n mask = cv2.inRange(hsv, self.hueLower, self.hueUpper)\\n\\n try:\\n mask = cv2.inRange(hsv, self.hueLower2, self.hueUpper2) + mask\\n except AttributeError:\\n pass\\n\\n mask = cv2.erode(mask, None, iterations=2)\\n mask = cv2.dilate(mask, None, iterations=2)\\n\\n if debug:\\n tmpMask = imutils.resize(mask, width=1000, height=1000)\\n cv2.imshow(\\\"mask\\\", tmpMask)\\n\\n\\n # find contours in the mask and initialize the current (x, y) center of the object\\n cnts = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)[-2]\\n center = None\\n\\n # only proceed if at least one contour was found\\n if len(cnts) > 0:\\n # find the largest contour in the mask, then use\\n # it to compute the minimum enclosing circle and\\n # centroid\\n c = max(cnts, key=cv2.contourArea)\\n\\n ((x, y), radius) = cv2.minEnclosingCircle(c)\\n M = cv2.moments(c)\\n center = (int(M[\\\"m10\\\"] / M[\\\"m00\\\"]), int(M[\\\"m01\\\"] / M[\\\"m00\\\"]))\\n\\n # only proceed if the radius meets a minimum size\\n # if radius > 10:\\n # # draw the circle and centroid on the frame,\\n # # then update the list of tracked points\\n # cv2.circle(frame, (int(x), int(y)), int(radius),\\n # (0, 255, 255), 2)\\n # cv2.circle(frame, center, 5, (0, 0, 255), -1)\\n if debug:\\n cv2.drawContours(self.frame, c, -1, (0, 255, 0), 20)\\n return center, radius\\n # update the points queue\\n cv2.imshow(\\\"mask\\\", imutils.resize(mask, width=1000, height=1000))\\n cv2.imshow(\\\"frame\\\", imutils.resize(self.frame, width=1000, height=1000))\\n cv2.waitKey(0)\\n cv2.destroyAllWindows()\\n raise OpenCVError(\\\"Could not find tracker!\\\")\\n\\n # return (1, 1), 1\",\n \"def bridge_problem3(here):\\r\\n\\r\\n def all_over(state):\\r\\n here, _ = state\\r\\n return not here or here == set([\\\"light\\\"])\\r\\n\\r\\n start = (frozenset(here) | frozenset([\\\"light\\\"]), frozenset())\\r\\n return lowest_cost_search(start, bsuccessors2, all_over, bcost)\",\n \"def closest_on_screen_point(trajectory, viewpoint, yaw, gaze_on_screen):\\n\\n traj_angles = dp.world_to_angles_through_screen(trajectory, viewpoint, yaw) \\n #pprint(traj_angles)\\n\\n #onscreen_idx, dists, *_ = find_closest_index(traj_angles, gaze_on_screen)\\n #idx = closest_node(traj_angles, gaze_on_screen)\\n idx = find_closest_index(traj_angles, gaze_on_screen)\\n # print(idx)\\n\\n #traj_ref = trajectory[idx, :]\\n screen_ref = traj_angles[idx, :]\\n world_ref = trajectory[idx, :]\\n\\n path_dist = ab_path_length(trajectory, viewpoint, world_ref)\\n path_dist /= 8.0 #time headway\\n\\n #plot_traj(screen_ref, gaze_on_screen, traj_angles)\\n\\n return(idx, screen_ref, world_ref, path_dist)#, traj_angles)\",\n \"def find_dark_states(excited_state, ground_states):\",\n \"def get_light_state(self, light):\\n if self.use_classifier: \\n if(not self.has_image):\\n return None\\n\\n cv_image = self.bridge.imgmsg_to_cv2(self.camera_image, \\\"bgr8\\\")\\n\\n #Get classification\\n return self.light_classifier.get_classification(cv_image) \\n \\n else:\\n # For testing, just return the ground-truth light state, directly coming from simulator\\n return light.state\",\n \"def place_headlamp_light():\\n\\n lx = 1.0\\n ly = light_height\\n lz = 2.0\\n #light_position = [lx, ly, lz, 1.0]\\n light_position = [0.0, 0.0, 0.0, 1]\\n light_ambient = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_diffuse = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_specular = [ 1*brightness, 1*brightness, 1*brightness, 1.0 ]\\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\\n # glViewport(0, 0, win_width, win_height)\\n # glMatrixMode(GL_PROJECTION)\\n # glLoadIdentity()\\n # gluPerspective(40.0, float(win_width) / float(win_height), 0.01, 100.0)\\n #\\n # glMatrixMode(GL_MODELVIEW)\\n # glLoadIdentity()\\n # glPushMatrix()\\n glLightfv(GL_LIGHT4, GL_POSITION, light_position)\\n\\n\\n\\n #glLightfv(GL_LIGHT4, GL_POSITION, (GLfloat * 4)(0.0, 0.0, 0.0, 1))\\n glLightfv(GL_LIGHT4, GL_AMBIENT, light_ambient)\\n glLightfv(GL_LIGHT4, GL_DIFFUSE, light_diffuse)\\n glLightfv(GL_LIGHT4, GL_SPECULAR, light_specular)\\n\\n # Constant attenuation (for distance, etc.)\\n # Only works for fixed light locations! Otherwise disabled\\n # glLightf(GL_LIGHT1, GL_CONSTANT_ATTENUATION, 2.0)\\n # glLightf(GL_LIGHT1, GL_LINEAR_ATTENUATION, 0.0)\\n # glLightf(GL_LIGHT1, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n glLightf(GL_LIGHT4, GL_CONSTANT_ATTENUATION, 3.0)\\n glLightf(GL_LIGHT4, GL_LINEAR_ATTENUATION, 0.0)\\n glLightf(GL_LIGHT4, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n # Create a spotlight effect (none at the moment)\\n if headlamp_is_on:\\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 30.0)\\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\\n glLightfv(GL_LIGHT4, GL_SPOT_DIRECTION, light_direction)\\n else:\\n glLightf(GL_LIGHT4, GL_SPOT_CUTOFF, 180.0)\\n glLightf(GL_LIGHT4, GL_SPOT_EXPONENT, 0.0)\\n\\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\\n # Try GL_TRUE - but then watch what happens when light is low\\n\\n glEnable(GL_LIGHT4)\\n\\n # This part draws a SELF-COLORED sphere (in spot where light is!)\\n glPushMatrix()\\n glTranslatef(lx, ly, lz)\\n glDisable(GL_LIGHTING)\\n glColor3f(brightness, brightness, brightness)\\n glutSolidSphere(0.5, 20, 20)\\n glEnable(GL_LIGHTING)\\n glPopMatrix()\",\n \"def traffic_cb(self, msg):\\n prev_red_light_waypoint = self.red_light_waypoint\\n self.red_light_waypoint = msg.data if msg.data >= 0 else None\\n if prev_red_light_waypoint != self.red_light_waypoint:\\n if debugging:\\n rospy.loginfo(\\\"TrafficLight changed: %s\\\", str(self.red_light_waypoint))\\n if publish_on_light_change:\\n self.update_and_publish() # Refresh if next traffic light has changed\",\n \"def color_for_temp(temp):\\n color = None\\n for temp_ceil in sorted(color_map.iterkeys()):\\n color = color_map[temp_ceil]\\n if(temp < temp_ceil):\\n break\\n return adjust_color(color)\",\n \"def main():\\n # color = rb.Color.BLUE.value\\n # move_to_color(color)\\n infared_sensor()\\n\\n # WHITE/RED does not work same with the BLUE/GREEN going down\",\n \"def match(self, color: Color) -> ColorPoint:\\n results = self.tree.search_nn(color.hsl)\\n if not results:\\n raise KeyError('No match found for color: {}'.format(color))\\n return results[0].data\",\n \"def test_find_tfl_lights(image_path, json_path=None, fig_num=None):\\n image = np.array(Image.open(image_path))\\n\\n if json_path is None:\\n objects = None\\n else:\\n gt_data = json.load(open(json_path))\\n what = ['traffic light']\\n objects = [o for o in gt_data['objects'] if o['label'] in what]\\n\\n find_tfl_lights(image)\",\n \"def light_circles():\\n global frame_1, frame_2\\n x_circle_center = int(camera_width/11)\\n y_circle_center = int(camera_hight/9)\\n circle_radius = int(camera_width*.07)\\n cv2.circle(\\n frame_1, (x_circle_center, (circle_radius+(4*circle_radius))),\\n circle_radius, green_color, thickness=thick_1_a)\\n cv2.circle(\\n frame_1, (x_circle_center, (circle_radius+(2*circle_radius))),\\n circle_radius, yellow_color, thickness=thick_1_b)\\n cv2.circle(\\n frame_1, (x_circle_center, circle_radius),\\n circle_radius, red_color, thickness=thick_1_c)\\n cv2.circle(\\n frame_2, (x_circle_center, (circle_radius+(4*circle_radius))),\\n circle_radius, green_color, thickness=thick_2_a)\\n cv2.circle(\\n frame_2, (x_circle_center, (circle_radius+(2*circle_radius))),\\n circle_radius, yellow_color, thickness=thick_2_b)\\n cv2.circle(\\n frame_2, (x_circle_center, circle_radius),\\n circle_radius, red_color, thickness=thick_2_c)\",\n \"def place_green_light():\\n glMatrixMode(GL_MODELVIEW)\\n lx = 5.0\\n ly = light_height\\n lz = 3.0\\n light_position = [lx, ly, lz, 1.0]\\n lightg_ambient = [0, 1.0, 0, 1] # green\\n lightb_diffuse = [0.4, 0.4, 0.6, 1] # blue\\n lightb_specular = [0.0, 0, 0.8, 1] # blue\\n light_direction = [1.0, -1.0, 1.0, 0.0] # Light points down\\n\\n # For Light 2 (green), set position, ambient, diffuse, and specular values\\n glLightfv(GL_LIGHT2, GL_POSITION, light_position)\\n glLightfv(GL_LIGHT2, GL_AMBIENT, lightg_ambient)\\n glLightfv(GL_LIGHT2, GL_DIFFUSE, lightb_diffuse)\\n glLightfv(GL_LIGHT2, GL_SPECULAR, lightb_specular)\\n\\n glLightf(GL_LIGHT2, GL_CONSTANT_ATTENUATION, 3.0)\\n glLightf(GL_LIGHT2, GL_LINEAR_ATTENUATION, 0.0)\\n glLightf(GL_LIGHT2, GL_QUADRATIC_ATTENUATION, 0.0)\\n\\n # Create a spotlight effect (none at the moment)\\n if green_light:\\n glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 45.0)\\n glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, 0.0)\\n glLightfv(GL_LIGHT2, GL_SPOT_DIRECTION, light_direction)\\n else:\\n glLightf(GL_LIGHT2, GL_SPOT_CUTOFF, 180.0)\\n glLightf(GL_LIGHT2, GL_SPOT_EXPONENT, 0.0)\\n\\n glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, use_lv)\\n glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE)\\n # Try GL_TRUE - but then watch what happens when light is low\\n\\n\\n glEnable(GL_LIGHT2)\\n\\n # This part draws a SELF-COLORED sphere (in spot where light is!)\\n glPushMatrix()\\n glTranslatef(lx, ly, lz)\\n glDisable(GL_LIGHTING)\\n glColor3f(0, brightness, 0)\\n glutSolidSphere(0.5, 20, 20)\\n glEnable(GL_LIGHTING)\\n glPopMatrix()\",\n \"def gl_lighting():\\n for viewer in nuke.allNodes('Viewer'):\\n val = int(viewer.knob('gl_lighting').getValue())\\n viewer.knob('gl_lighting').setValue(not val)\",\n \"def getFar(self):\\n return self.light.node().getLens().getFar()\",\n \"def get_traffic_lights_obstacles(traffic_lights, depth_frame, segmented_frame,\\n town_name):\\n camera_transform = depth_frame.camera_setup.get_transform()\\n # Iterate over all the traffic lights, and figure out which ones are\\n # facing us and are visible in the camera view.\\n detected = []\\n for light in traffic_lights:\\n if not light.is_traffic_light_visible(camera_transform, town_name):\\n continue\\n detected.extend(\\n light.get_all_detected_traffic_light_boxes(\\n town_name, depth_frame, segmented_frame.as_numpy_array()))\\n return detected\",\n \"def on_road(self):\\n for obj in self.model.grid[self.pos[0]][self.pos[1]]:\\n if obj.agent_type == \\\"road\\\":\\n return obj\",\n \"def _get_light_state(self, light):\\n if(not self.has_image):\\n return False\\n\\n #\\n # we want to convert the image from internal ROS format to\\n # CV2 GBR8 format because we trained our classifier model using GBR8 images.\\n # The original raining images were in PNG and JPG format and in folders\\n # that make it look like they are RGB, but we must remember that the training\\n # loads the images using cv2.imread() which loads the images into BGR8\\n # format, NOT RGB8!\\n #\\n cv2_image_bgr = self.bridge.imgmsg_to_cv2(self.camera_image_msg, \\\"bgr8\\\")\\n\\n #\\n #Get classification\\n #\\n return self.light_classifier.get_classification(cv2_image_bgr)\",\n \"def get_colour(self):\\n \\n distorted = []\\n if piCameraFound:\\n # Use piCamera\\n \\n #frame = self.capture_generator.next()\\n #distorted = frame.array\\n self.cam.capture(self.rawCapture, format=\\\"bgr\\\", use_video_port=True)\\n distorted = self.rawCapture.array\\n \\n # clear the stream in preparation for the next frame\\n self.rawCapture.truncate(0)\\n \\n else: # Use OpenCV\\n retval, distorted = self.cam.read() # Read frame\\n\\n if not retval: # Error\\n print \\\"Camera.get_colour: Could not read next frame\\\";\\n exit(-1);\\n \\n \\n #colour = cv2.remap(distorted, self.mapx, self.mapy, cv2.CV_INTER_LINEAR)\\n #colour = cv2.remap(distorted, self.mapx, self.mapy, cv2.INTER_LINEAR)\\n \\n # Skip this part because it is slow\\n #colour = cv2.undistort(distorted, self.intrinsic_matrix, self.distortion_coeffs)\\n colour = distorted\\n return colour, distorted\",\n \"def find_reddest_pixel(img):\\n # HINTS/ADVICE-------------\\n # Use a nested for loop here.\\n #\\n # BE CAREFUL DOING ARITHMETIC WITH UNSIGNED INTEGERS: \\n # >>> a = np.array([2], dtype='uint8')\\n # >>> b = np.array([3], dtype='uint8')\\n # >>> a - b\\n # array([255], dtype=uint8)\\n #\\n # Reminder:\\n # numpy arrays have a \\\"shape\\\" attribute that stores the layout:\\n # img.shape[0] - rows\\n # img.shape[1] - columns\\n # img.shape[2] - color channels\\n\\n max_redness = 0\\n max_x = 0\\n max_y = 0\\n \\n img = np.array(img, dtype = 'int32')\\n for r in range(img.shape[0]):\\n for c in range(img.shape[1]):\\n red = img[r, c, 2]\\n green = img[r, c, 1]\\n blue = img[r, c, 0] \\n redness = (red - green) + (red - blue)\\n\\n if redness > max_redness:\\n max_redness = redness\\n max_x = c\\n max_y = r\\n \\n return (max_x, max_y)\",\n \"def get_lights(bridge):\\n\\n target_names = [\\n \\\"Console Lamp\\\",\\n \\\"Bedroom Table Lamp\\\",\\n \\\"Kitchen light\\\",\\n ]\\n\\n targets = [light for light in bridge.lights if light.name in target_names]\\n\\n if len(targets) != len(target_names):\\n print(\\\"%s: not found ... %s\\\" % (target_names, targets))\\n exit(1)\\n\\n return targets\",\n \"def check_location_confidence(self):\\n\\t\\t## not the best way of doing things, but since the number of targets is fairly small its not a big deal\\n\\t\\tepsilon_pixels = .05 * self.horizontal_resolution #arbitrary confidence factor\\n\\t\\tepsilon_meters = .08\\n\\t\\tpixel_distances = []\\n\\t\\tactual_distances = []\\n\\t\\tnum_observed = 0\\n\\t\\tfor ti in self.targs:\\n\\t\\t\\tif ti.props_are_set:\\n\\t\\t\\t\\tfor tj in self.targs:\\n\\t\\t\\t\\t\\tif tj.props_are_set: \\n\\t\\t\\t\\t\\t\\tpixel_dist = np.linalg.norm(tj.position_camera - ti.position_camera)\\n\\t\\t\\t\\t\\t\\tactual_dist = np.abs(tj.d_cam_image - ti.d_cam_image)\\n\\t\\t\\t\\t\\t\\tif pixel_dist == 0:\\n\\t\\t\\t\\t\\t\\t\\tpixel_dist = 10000 #ignore two of the same points\\n\\t\\t\\t\\t\\t\\t\\tactual_dist = 10000\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(pixel_dist)\\t\\n\\t\\t\\t\\t\\t\\tactual_distances.append(actual_dist)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tfor _ in self.targs:\\n\\t\\t\\t\\t\\tpixel_distances.append(10000)\\n\\t\\t\\t\\t\\tactual_distances.append(10000)\\n\\t\\tmin_ind_pixel = np.argmin(pixel_distances)\\n\\t\\tmin_ind_actual = np.argmin(actual_distances)\\n\\t\\t#min_ind is encoded in base (num_targets); decode it to find the closest two points\\n\\t\\tbest_guys = [self.targs[min_ind_pixel/len(self.targs)],self.targs[min_ind_pixel%len(self.targs)]]\\n\\t\\tif pixel_distances[min_ind_pixel] > epsilon_pixels or actual_distances[min_ind_actual] > epsilon_meters:\\n\\t\\t\\t#measurements are not trustworthy, return nothing\\n\\t\\t\\treturn None\\n\\n\\t\\treturn best_guys\",\n \"def get_freenet_coordinates(self, location):\\n # TODO(ionel): This method assumes that the location has the\\n # same orientation as the lanes (i.e., it will always return a\\n # positive d).\\n loc = to_carla_location(location)\\n waypoint = self._map.get_waypoint(loc,\\n project_to_road=False,\\n lane_type=carla.LaneType.Any)\\n current_lane_w = waypoint\\n d0_location = None\\n while True:\\n # Keep on moving left until we're outside the road or on the\\n # oposite lane.\\n left_lane_w = current_lane_w.get_left_lane()\\n if (left_lane_w.lane_type != carla.LaneType.Driving or\\n (current_lane_w.transform.rotation.yaw -\\n left_lane_w.transform.rotation.yaw) > 170):\\n # If the left lane is drivable then we've reached the left hand\\n # side of a one way road. Alternatively, if the lane is rotated\\n # then the lane is on the other side of the road.\\n d0_location = current_lane_w\\n half_lane = carla.Location(\\n 0, - current_lane_w.lane_width / 2.0, 0)\\n d0_location = current_lane_w.transform.transform(half_lane)\\n break\\n current_lane_w = left_lane_w\\n\\n # TODO(ionel): Handle the case when the road id changes -> s resets.\\n # TODO(ionel): Handle case when the center lane is bidirectional.\\n return waypoint.s, self.__get_distance(location, d0_location)\",\n \"def __lightness(self, color):\\n hsv = color.toHsv()\\n return hsv.valueF()\",\n \"def get_pixel_obs(self):\\n delta = self.side / (self.pixel_side - 1)\\n bd1 = -self.side / 2\\n bd2 = self.side / 2 + delta\\n x, y = np.meshgrid(np.arange(bd1, bd2, delta), np.arange(bd2, bd1, -delta))\\n if self.robot.sensor.lower() == \\\"rgb\\\":\\n obs1, obs2, obs3 = np.zeros(x.shape), np.zeros(x.shape), np.zeros(x.shape)\\n # Color humans:\\n for human in self.humans:\\n robot_distance = np.sqrt(\\n (human.px - self.robot.px) ** 2 + (human.py - self.robot.py) ** 2\\n )\\n if robot_distance < self.robot.horizon:\\n obs1[\\n np.nonzero((x - human.px) ** 2 + (y - human.py) ** 2 <= human.radius ** 2)\\n ] = 1\\n # Color goal:\\n obs2[\\n np.nonzero(\\n (x - self.robot.gx) ** 2 + (y - self.robot.gy) ** 2 <= self.goal_radius ** 2\\n )\\n ] = 1\\n # Color robot:\\n obs3[\\n np.nonzero(\\n (x - self.robot.px) ** 2 + (y - self.robot.py) ** 2 <= self.robot.radius ** 2\\n )\\n ] = 1\\n obs = np.concatenate(\\n (np.expand_dims(obs1, 0), np.expand_dims(obs2, 0), np.expand_dims(obs3, 0)), axis=0\\n )\\n return np.float32(np.expand_dims(obs, 0))\\n elif self.robot.sensor.lower() == \\\"gray\\\":\\n obs = np.zeros(x.shape)\\n # Color humans:\\n for human in self.humans:\\n robot_distance = np.sqrt(\\n (human.px - self.robot.px) ** 2 + (human.py - self.robot.py) ** 2\\n )\\n if robot_distance < self.robot.horizon:\\n obs[\\n np.nonzero((x - human.px) ** 2 + (y - human.py) ** 2 <= human.radius ** 2)\\n ] = (1.0 / 3)\\n # Color goal:\\n obs[\\n np.nonzero(\\n (x - self.robot.gx) ** 2 + (y - self.robot.gy) ** 2 <= self.goal_radius ** 2\\n )\\n ] = (2.0 / 3)\\n # Color robot:\\n obs[\\n np.nonzero(\\n (x - self.robot.px) ** 2 + (y - self.robot.py) ** 2 <= self.robot.radius ** 2\\n )\\n ] = 1.0\\n return np.float32(np.expand_dims(np.expand_dims(obs, 0), 0))\\n else:\\n raise ValueError(\\\"Robot sensor incompatible with pixel observation.\\\")\",\n \"def get_rgb_light():\\n return list(light.rgb())\",\n \"def watershed(img):\\n\\ttmp = img.copy()\\n\\tgray = cv2.cvtColor(tmp, cv2.COLOR_BGR2GRAY)\\n\\tret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)\\n\\tkernel = np.ones((3,3), np.uint8)\\n\\topening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)\\n\\tsure_bg = cv2.dilate(opening, kernel, iterations=3)\\n\\tdist_transform = cv2.distanceTransform(opening, cv2.cv.CV_DIST_L2, 5)\\n\\tret, sure_fg = cv2.threshold(dist_transform, 0.7*dist_transform.max(), 255, 0)\\n\\tsure_fg = np.uint8(sure_fg)\\n\\tunknown = cv2.subtract(sure_bg, sure_fg)\\n\\tret, markers = cv2.connectedComponents(sure_fg) #IS THIS REALLY NOT IMPLEMENTED IN PYTHON?\\n\\tmarkers = markers+1\\n\\tmarkers[unknown==255] = 0\\n\\tmarkers = cv2.watershed(tmp, markers)\\n\\ttmp[markers == -1] = [255,0,0]\\n\\treturn tmp\",\n \"def track_closest_aircraft(latitude, longitude, elevation, host, port, q):\\n try:\\n d = Dump1090(host, port)\\n q.put(True)\\n except IOError as exc:\\n q.put(exc)\\n return\\n\\n target = None\\n target_distance = None\\n aad = AzimuthAltitudeDistance(latitude, longitude, elevation)\\n\\n try:\\n for aircraft in d.updates():\\n lat, lng = aircraft.position\\n azimuth, altitude, distance = aad.calculate(\\n lat,\\n lng,\\n aircraft.altitude\\n )\\n\\n # if we don't have a target we do now\\n # or target is old, then use this new aircraft\\n # or new aircraft isn't the target, but it is closer, so we switch!\\n if (target is None or target.age > 60 or\\n (target.icao != aircraft.icao and distance < target_distance)):\\n target = aircraft\\n\\n # if we aren't the target at this point then bail\\n if target.icao != aircraft.icao:\\n continue\\n\\n target = aircraft\\n target_distance = distance\\n q.put((target, azimuth, altitude, distance))\\n except KeyboardInterrupt:\\n pass\",\n \"def apply_laser(self, color):\\n if self.winner is not None:\\n raise RuntimeError(\\\"Game is already complete \\\" + str(self.winner.value) + \\\" won\\\")\\n results = {}\\n path, piece = self._apply_laser(color)\\n\\n if piece is not None:\\n results[\\\"destroyed\\\"] = piece\\n if piece.type is PieceType.pharaoh:\\n self.winner = TeamColor.opposite_color(piece.color)\\n results[\\\"winner\\\"] = self.winner\\n\\n results[\\\"path\\\"] = path\\n return results\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.706805","0.7047184","0.6819055","0.6764632","0.67316353","0.6700383","0.65447426","0.6457697","0.64285344","0.63972515","0.62802887","0.6241258","0.6087701","0.6074844","0.6063886","0.6034228","0.60252565","0.5981899","0.59716964","0.59051466","0.58939105","0.586088","0.58605397","0.5826346","0.58177155","0.5778377","0.576794","0.5765606","0.57586575","0.5741861","0.57115144","0.5693699","0.5648955","0.56416404","0.56294346","0.56225806","0.5609153","0.5604332","0.5600137","0.5593355","0.55929136","0.5580408","0.55729204","0.55698687","0.55648226","0.55448437","0.55372953","0.55356264","0.55314344","0.5522071","0.5510198","0.5370947","0.5361152","0.53536904","0.5349645","0.5344136","0.5335991","0.5318803","0.5313472","0.53110266","0.5304813","0.52869225","0.52841717","0.5268925","0.5251942","0.52518004","0.5237995","0.52356297","0.52323616","0.52311414","0.5217933","0.5203228","0.51839066","0.5179089","0.5177889","0.5172494","0.516964","0.5167221","0.5163718","0.5163628","0.5160716","0.51592207","0.51532525","0.51353455","0.5123129","0.51230246","0.51120496","0.5083954","0.5070307","0.5062443","0.50610787","0.5054416","0.50525284","0.50515026","0.5044183","0.5042788","0.50418735","0.5040931","0.5038793","0.5026881"],"string":"[\n \"0.706805\",\n \"0.7047184\",\n \"0.6819055\",\n \"0.6764632\",\n \"0.67316353\",\n \"0.6700383\",\n \"0.65447426\",\n \"0.6457697\",\n \"0.64285344\",\n \"0.63972515\",\n \"0.62802887\",\n \"0.6241258\",\n \"0.6087701\",\n \"0.6074844\",\n \"0.6063886\",\n \"0.6034228\",\n \"0.60252565\",\n \"0.5981899\",\n \"0.59716964\",\n \"0.59051466\",\n \"0.58939105\",\n \"0.586088\",\n \"0.58605397\",\n \"0.5826346\",\n \"0.58177155\",\n \"0.5778377\",\n \"0.576794\",\n \"0.5765606\",\n \"0.57586575\",\n \"0.5741861\",\n \"0.57115144\",\n \"0.5693699\",\n \"0.5648955\",\n \"0.56416404\",\n \"0.56294346\",\n \"0.56225806\",\n \"0.5609153\",\n \"0.5604332\",\n \"0.5600137\",\n \"0.5593355\",\n \"0.55929136\",\n \"0.5580408\",\n \"0.55729204\",\n \"0.55698687\",\n \"0.55648226\",\n \"0.55448437\",\n \"0.55372953\",\n \"0.55356264\",\n \"0.55314344\",\n \"0.5522071\",\n \"0.5510198\",\n \"0.5370947\",\n \"0.5361152\",\n \"0.53536904\",\n \"0.5349645\",\n \"0.5344136\",\n \"0.5335991\",\n \"0.5318803\",\n \"0.5313472\",\n \"0.53110266\",\n \"0.5304813\",\n \"0.52869225\",\n \"0.52841717\",\n \"0.5268925\",\n \"0.5251942\",\n \"0.52518004\",\n \"0.5237995\",\n \"0.52356297\",\n \"0.52323616\",\n \"0.52311414\",\n \"0.5217933\",\n \"0.5203228\",\n \"0.51839066\",\n \"0.5179089\",\n \"0.5177889\",\n \"0.5172494\",\n \"0.516964\",\n \"0.5167221\",\n \"0.5163718\",\n \"0.5163628\",\n \"0.5160716\",\n \"0.51592207\",\n \"0.51532525\",\n \"0.51353455\",\n \"0.5123129\",\n \"0.51230246\",\n \"0.51120496\",\n \"0.5083954\",\n \"0.5070307\",\n \"0.5062443\",\n \"0.50610787\",\n \"0.5054416\",\n \"0.50525284\",\n \"0.50515026\",\n \"0.5044183\",\n \"0.5042788\",\n \"0.50418735\",\n \"0.5040931\",\n \"0.5038793\",\n \"0.5026881\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6203305"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":80590,"cells":{"query":{"kind":"string","value":"Handles putio.get_items request with better error handling. Since the putio API will hand back HTTP exception all the time this function will allow them to happen without crashing your script. If there are no items in a directory we return an empty list. Return A list of Item objects (from putio class...) or an empty list if there are no items to return."},"document":{"kind":"string","value":"def get_items(self, parent=None, id_Number=None):\r\n\r\n sigkill = 0\r\n\r\n while 1:\r\n try:\r\n value = self.API.get_items(parent_id=parent, id=id_Number)\r\n return value\r\n except putio.PutioError as err:\r\n if str(err) == \"You have no items to show.\":\r\n print(\"Empty Directory...\")\r\n return []\r\n print(\"Warning: Fail to make putio request. Trying again.\")\r\n print(\"Debug: \" + str(err))\r\n sigkill += 1\r\n if sigkill >= 3:\r\n print(\"ERROR: Request failed too many times. Giving up!\")\r\n break\r\n time.sleep(15)\r\n pass"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_items():\n return requester.perform_request(Uri.items)","def test_get_all_item(self, app, item):\n res = app.store_items.get_all_items(\n header=item.header,\n type_response=ItemsResponse,\n )\n assert res.status_code == 200","async def get_items(\n request: Request,\n response: Response,\n db: SAConnection = Depends(get_postgresql_connection)\n):\n if db is None:\n response.status_code = 503\n return ResponseModel(result='Service unavailable')\n q = items.select()\n result = await db.fetch(query=q)\n items_list = [Item(**item) for item in result]\n for item in items_list:\n await request.app.extra['cache'].set_cache_item(item=item)\n return items_list","async def get_items(self, resource: str, *, params: dict = None):\r\n resp = await self.request(\"get\", self._api_base + resource, params, None)\r\n items = resp.get(\"items\", [])\r\n next_link = Api._get_next_link(resp)\r\n while next_link:\r\n resp = await self.request(\"get\", next_link, params, None)\r\n items.extend(resp.get(\"items\", []))\r\n next_link = Api._get_next_link(resp)\r\n return items","def get_all_items():\n try:\n return get_json(get_data())\n except ValueError as e:\n print(e)\n except TypeError as e:\n print(e)","def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KeyToPathArgs']]]]:\n return pulumi.get(self, \"items\")","def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KeyToPathArgs']]]]:\n return pulumi.get(self, \"items\")","def getAllItems(self):\r\n\r\n control = []\r\n\r\n for folder in self.get_items():\r\n control.append(folder.id)\r\n\r\n while len(control) > 0:\r\n try:\r\n for item in self.get_items(parent=control.pop()):\r\n print(\"Getting content for: \" + item.name)\r\n if item.type == \"folder\":\r\n control.insert(0,item.id)\r\n else:\r\n self.contents[item.id] = {\r\n 'name': item.name, 'parentID': item.parent_id,\r\n 'size': item.size, 'uri': item.download_url\r\n }\r\n except putio.PutioError as err:\r\n print(\"Can't get content for Directory\")\r\n pass\r\n return self.contents","def DirItems():\n return diritems","def get_game_items(self, **kwargs):\n url = self.__build_url(urls.GET_GAME_ITEMS, language=self.language, **kwargs)\n req = self.executor(url)\n if self.logger:\n self.logger.info('URL: {0}'.format(url))\n if not self.__check_http_err(req.status_code):\n return response.build(req, url, self.raw_mode)","def getAllItemsList():\n return Gw2Spidy._request('all-items', 'all')['results']","def getItems(self): \n if self.itemCount > 0:\n \n site = getSite()\n \n \n # Make string path relative to the site root\n # E.g. string path \"news\" becomes \"/yoursiteid/news\"\n site_path = site.getPhysicalPath();\n \n path = \"/\".join(site_path) + \"/\" + self.path \n \n types = [self.itemPortalType]\n \n items = []\n \n #if self.itemPortalType2 != None:\n # types.append(self.itemPortalType2) \n \n #print \"Querying by:\" + type + \" \" + path\n content_by_type = self.context.portal_catalog(path={ \"query\": path, \"depth\" :9 }, \n portal_type=self.itemPortalType, \n sort_on=\"created\", \n sort_order=\"reverse\")[0:self.itemCount]\n\n content_by_type = list(content_by_type)\n \n if self.itemPortalType2 != None:\n content_by_type2 = self.context.portal_catalog(path={ \"query\": path, \"depth\" :9 }, \n portal_type=self.itemPortalType2, \n sort_on=\"created\", \n sort_order=\"reverse\")[0:self.itemCount]\n\n content_by_type += list(content_by_type2)\n\n \n items += [ brain.getObject() for brain in content_by_type ]\n else:\n items = []\n \n #if self.title == \"Daily deals\":\n # import pdb ; pdb.set_trace()\n \n # XXX: custom hack for deals\n def is_expired_deal(i):\n \"\"\"\n \"\"\"\n if hasattr(i, \"validUntil\"):\n now = datetime.datetime.utcnow()\n if now > i.validUntil:\n return True\n \n return False\n \n items = [ i for i in items if not is_expired_deal(i) ]\n \n return items","def get_all_items(self):\n return self.api.state['items']","def get_files_in_folder(client, folder_id):\n\n try:\n items = client.folder(folder_id=folder_id).get_items()\n for item in items:\n print(item.name, item.id)\n return items\n except Exception as e:\n print(f\"An error has occurred: {e}\")","def test_get_item_list(self):\n resp = self.app.get('/items')\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\n data = json.loads(resp.data)\n self.assertEqual(len(data), 3)","def list_hnd(self, request, **kwargs):\n prefix = request.POST.get(\"prefix\", \"\")\n marker = request.POST.get(\"marker\", \"\")\n delimiter = request.POST.get(\"delimiter\", \"\")\n\n max_keys = int(request.POST.get(\"max_keys\", 1000))\n max_keys = max((1, max_keys)) # >= 1\n max_keys = min((1000, max_keys)) # <= 1000\n\n bucket = store.get_bucket()\n\n # prefix \"prefix\" with user dir\n eff_prefix = store.prefix_with_user_dir(request.user, prefix)\n\n # get list iterator from s3\n file_iter = bucket.list(prefix=eff_prefix, delimiter=delimiter,\n marker=marker, headers=None,\n encoding_type=None)\n\n # convert to list, try to get +1 item to be able\n # to determine if the results are truncated\n files = [key.key.split(\"/\", 1)[1]\n for key in itertools.islice(file_iter, 0, max_keys+1)]\n\n # if max_keys is less then there are more results\n # -> truncated = True\n truncated = len(files) > max_keys\n if truncated:\n # return 1 item less\n files = files[:-1]\n\n return self.create_response(request, {\n \"files\": files,\n \"truncated\": truncated\n })","def getItems(self): \n items = []\n if self.itemCount > 0:\n \n site = getSite()\n \n \n # Make string path relative to the site root\n # E.g. string path \"news\" becomes \"/yoursiteid/news\"\n site_path = site.getPhysicalPath();\n \n path = \"/\".join(site_path) + \"/\" + self.path \n \n #if self.itemPortalType2 != None:\n # types.append(self.itemPortalType2) \n \n #print \"Querying by:\" + type + \" \" + path\n content_by_type = self.context.portal_catalog(path={ \"query\": path, \"depth\" :9 }, \n sort_on=\"created\", \n sort_order=\"reverse\")[0:self.itemCount]\n\n \n items += [ brain.getObject() for brain in content_by_type ]\n\n return items","def get_all_items(unit) -> list:\n items = []\n for item in unit.items:\n if item.multi_item:\n for subitem in item.subitems:\n items.append(subitem)\n else:\n items.append(item)\n return items","def get(self):\n result = self.session.get(urljoin(self.base_url, self.directory))\n if result.ok:\n data = result.json()\n\n if self.raw:\n return data\n\n if not self.query[\"item\"]:\n return data[\"ids\"]\n else:\n if self.query[\"filter\"] == \"links\":\n return data[\"links\"]\n else:\n return data.get(\"entry\", None)\n else:\n raise RuntimeError(\"Malformed Request\")","def getItems(self):\n fname = 'getItems'\n actionId = self._db.addAction('WebCrawler')\n actionId_ex = self._db.addAction('extractor')\n\n if not os.path.exists(self._haystackPath):\n self._haystackPath = os.path.expanduser(self._haystackPath)\n\n if not os.path.exists(self._haystackPath):\n self._haystackPath = os.path.abspath(self._haystackPath)\n\n print('\\t{0} [{1}]'.format(fname, self._haystackPath))\n\n for (pathStr, dirs, files) in os.walk(self._haystackPath):\n head, tail = os.path.split(pathStr)\n for fileStr in files:\n fileDTCheck = ''\n filePath = os.path.join(pathStr,fileStr)\n\n # get the file date...\n fileDT = datetime.datetime.fromtimestamp(os.path.getmtime(filePath)).replace(microsecond=0)\n fileSize = os.path.getsize(filePath)\n fileName, fileExt = os.path.splitext(filePath)\n\n # save the item to the database\n itemId = self._db.addItem(self._engine_id, \"file://%s\" % filePath, fileDT)\n \n # now check the data for this item...\n itemList = self._db.getItemDataAll(itemId) \n isMatch = False\n for item in itemList:\n if item[0] == 'FileDate':\n # we have a date string...\n fileDTCheck = datetime.datetime.strptime(item[1], \"%Y-%m-%d %H:%M:%S\")\n if fileDTCheck == fileDT:\n # the same time, no changes needed\n isMatch = True\n \n if isMatch:\n # get next item as this is already exists\n continue\n \n # print(the details)\n print(fileDTCheck, fileDT)\n print('>>\\t%s\\t%s\\t%s' % (fname, head, tail))\n \n # set the datetime and other details\n self._db.addItemData(itemId, 'Haystack', tail, 0)\n self._db.addItemData(itemId, 'FileName', fileName, 0)\n self._db.addItemData(itemId, 'FileExt', fileExt, 0)\n self._db.addItemData(itemId, 'FileDate', fileDT, 0)\n self._db.addItemData(itemId, 'FileSize', fileSize, 0)\n\n # now to process the file...\n # this will extract out metadata and add to the itemData table the value pairs.\n pattern = re.compile(r'^.*[.](?P<ext>htm|html)$')\n pattPNG = re.compile(r'^.*[.](?P<ext>mp.|mpeg|avi|swf|jpg|jpeg|png)$')\n pattTAR = re.compile(r'^.*[.](?P<ext>tar\\.gz|tar\\.bz2|\\.zip|\\.tar|\\.7z)$')\n\n m = pattern.match(filePath)\n if not m:\n m = pattPNG.match(filePath)\n\n if not m:\n m = pattTAR.match(filePath)\n\n if not m:\n self.getContents(itemId, filePath, tail)\n self._db.updateItem(self._engine_id, itemId, actionId_ex, datetime.datetime.now())\n\n else:\n # we have a file extension...\n if m.group('ext').startswith('.htm'):\n # add this as an event to be processed by the html link reader...\n self._db.addItemEvent(self._engine_id, actionId, itemId)\n\n if self._db:\n self._db.commit_db()","def get_cch_items(cch_url):\n\t#'subtree=false' produces a flat list of all items\n\tall_items_url = cch_url + 'data/item?subtree=false&showDisabled=true'\n\teprint(\"retrieving CCH items from {}\".format(all_items_url))\n\tall_items_response = requests.get(all_items_url)\n\titems = handle_cch_items_response(all_items_response)\n\treturn items","def getAllItems(self):\n data = self._client.Item.filter(\n int(self.app_id), {\n 'limit': 500,\n# 'filters':[{\n# \"key\":\"96943879\", #En este pedazo se está filtrando sobre un campo, se quiere coger sólo a los\n# \"values\":[1],\n# }],\n },\n )[\"items\"]\n fields = [self.makeDict(item) for item in data]\n return fields","def getItemList(self):\r\n raise AbstractError\r\n return []","def test_get_bucketlist_items(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n\n self.assertEqual(resp_item.status_code, 200)\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp_item.status_code, 200)","def FullDirItems():\n return fulldiritems","def get_items(self):\n return self.item_list","def get_item(url: str, headers: Dict[str, str], **param) -> List[Dict[str, Any]]:\n response = req_get(url, headers=headers, params=param)\n return serialize_response(response)","def all_items_handler():\n items = getAllItems()\n return jsonify(items=[i.serialize for i in items])","def find_items():\n check50.exists(\"item.py\")\n try:\n check50.run(run_command).stdin(\"in\").stdout(room_3_items)\n except check50.Failure as error:\n raise check50.Failure(\"Could not find items upon first entering room.\\n\" +\n \" Remember to seperate multiple items by a single newline\\n\" +\n f\" {error}\")\n # Check for look command\n try:\n check = check50.run(run_command)\n moves = [\"IN\", \"OUT\", \"IN\", \"LOOK\"]\n\n for move in moves:\n check.stdout(\"> \")\n check.stdin(move, prompt=False)\n\n check.stdout(\"KEYS: a set of keys\")\n except check50.Failure as error:\n raise check50.Failure(f\"Could not find items when using LOOK.\\n {error}\")","async def fetch_file_list(client, bucket) -> List:\n # pylint: disable=invalid-name\n PG_HOSTNAME = config('PG_HOSTNAME')\n PG_DATABASE = config('PG_DATABASE')\n folder = f'backup/{PG_HOSTNAME}_{PG_DATABASE}'\n result = await client.list_objects_v2(Bucket=bucket, Prefix=folder)\n contents = result.get('Contents', None)\n file_list = list([])\n if contents:\n for content in contents:\n file_list.append(content.get('Key'))\n return file_list","def get_items(self, keyword='', linked=True, unlinked=True):\n page = 1\n show_on_page = 50\n request_items = self.request_channel_items(\n page, show_linked=linked, show_unlinked=unlinked,\n show_on_page=show_on_page, keyword=keyword)\n items = request_items\n while len(request_items) == show_on_page:\n page += 1\n request_items = self.request_channel_items(\n page, keyword=keyword, show_linked=linked,\n show_unlinked=unlinked)\n items = items + request_items\n return items","def get(self, *args, **kwargs):\n if not args and set(kwargs) in ({\"id\"}, {\"id\", \"changekey\"}):\n # We allow calling get(id=..., changekey=...) to get a single item, but only if exactly these two\n # kwargs are present.\n account = self.folder_collection.account\n item_id = self._id_field.field.clean(kwargs[\"id\"], version=account.version)\n changekey = self._changekey_field.field.clean(kwargs.get(\"changekey\"), version=account.version)\n # The folders we're querying may not support all fields\n if self.only_fields is None:\n only_fields = {FieldPath(field=f) for f in self.folder_collection.allowed_item_fields()}\n else:\n only_fields = self.only_fields\n items = list(account.fetch(ids=[(item_id, changekey)], only_fields=only_fields))\n else:\n new_qs = self.filter(*args, **kwargs)\n items = list(new_qs.__iter__())\n if not items:\n raise DoesNotExist()\n if len(items) != 1:\n raise MultipleObjectsReturned()\n return items[0]","def get_items(self) -> list:\r\n return self._items","def get_items(self):\n\n items = []\n\n params = self.request.query_params\n\n if 'items[]' in params:\n items = params.getlist('items[]', [])\n elif 'item' in params:\n items = [params.get('item', None)]\n\n if type(items) not in [list, tuple]:\n items = [items]\n\n valid_ids = []\n\n for item in items:\n try:\n valid_ids.append(int(item))\n except (ValueError):\n pass\n\n # List of StockItems which match provided values\n valid_items = StockItem.objects.filter(pk__in=valid_ids)\n\n return valid_items","def get_items_from_response(self, response):\n raise NotImplementedError","def get_items(self) -> list:\n if self._cached_items is None:\n self._cached_items = list(self.items.all())\n return self._cached_items","def boxSearch(client):\n\tfiles = []\n\titems_iter = client.folder(folder_id=0).get_items(limit=100, offset=0)\n\tfor x in items_iter:\n\t\tfiles.append(x)\n\treturn files","def get_items(self):\n\n if not self.ITEM_MODEL:\n raise NotImplementedError(f\"ITEM_MODEL attribute not defined for {__class__}\")\n\n ids = []\n\n # Construct a list of possible query parameter value options\n # e.g. if self.ITEM_KEY = 'order' -> ['order', 'order[]', 'orders', 'orders[]']\n for k in [self.ITEM_KEY + x for x in ['', '[]', 's', 's[]']]:\n if ids := self.request.query_params.getlist(k, []):\n # Return the first list of matches\n break\n\n # Next we must validated each provided object ID\n valid_ids = []\n\n for id in ids:\n try:\n valid_ids.append(int(id))\n except ValueError:\n pass\n\n # Filter queryset by matching ID values\n return self.ITEM_MODEL.objects.filter(pk__in=valid_ids)","def handle_cch_items_response(response):\n\tif 200 != response.status_code:\n\t\traise Exception('Could not retrieve CCH Items. Got status code {}'.format(response.status_code))\n\telse:\n\t\tthe_json = response.json()\n\t\tcch_items = the_json['items']\n\t\treturn cch_items","def get_items(self):\n return self.item_ids","def _parse_items(path: str) -> list[EditorItem]:\n items: list[EditorItem] = []\n with filesystem[path].open_str() as f:\n tok = Tokenizer(f, path)\n for tok_type, tok_value in tok:\n if tok_type is Token.STRING:\n if tok_value.casefold() != 'item':\n raise tok.error('Unknown item option \"{}\"!', tok_value)\n items.append(EditorItem.parse_one(tok, pak_id))\n elif tok_type is not Token.NEWLINE:\n raise tok.error(tok_type)\n return items","def get_items(self):\n return []","def test_get_all_items(test_client):\n\n response = test_client.get(BASE_URL)\n\n data = json.loads(response.get_data())\n\n assert response.status_code == 200\n assert len(data['items']) == 3","def get_all(self,empty=True):\n with self.lock:\n items = self.items\n if empty: self.items = []\n return items","def get_items_not_in_stock():\n try:\n return get_items_arent_on_stock(), 200\n except:\n return \"An error ocurred\", 404","def get_items(self):\n return self.items","def get_items(path, only=None):\n path = os.path.expanduser(path)\n ps = [os.path.join(path, n)\n for n in os.listdir(path)\n if not n.startswith('.') and len(n) == 4]\n ps = [p for p in ps if os.path.isdir(p)]\n if only is not None:\n ps = [p for p in ps if nmrex.utils.fname(p) in only]\n return ps","async def read_items(commons: dict = Depends(common_parameters)):\n return commons","def items(self) -> List[InlineResponse200Items]:\n return self._items","def get_items_from_dir(path):\n items = os.listdir(path)\n items.sort()\n return items","def getItemBuyListings(itemId, allPages = False):\n return Gw2Spidy._paginatedRequest(allPages, 'listings', str(itemId), 'buy')","def test_get_bucketlist_items(self):\r\n email = \"test@test.com\"\r\n _pword = \"test\"\r\n user = User.query.filter_by(email=email).first()\r\n bucketlist = BucketList.query.filter_by(user_id=user.id, id=1).first()\r\n items_no = len(bucketlist.bucketlist_items)\r\n headers = self.authentication_headers(email=email, password=_pword)\r\n response = self.client.get(\r\n '/api/v1/bucketlist/1/items/',\r\n content_type=\"application/json\",\r\n headers=headers,\r\n follow_redirects=True\r\n )\r\n result = json.loads(response.data.decode('utf-8'))\r\n self.assertEqual(len(result), items_no)","def _update_items(self):\n\n self._item_list = []\n for f in os.listdir(self._folder):\n # Skip text files\n # -> It is important that we don't delete the list file if the user puts it here!\n ext = os.path.splitext(f)[1]\n if ext not in ['.csv', 'txt']:\n self._item_list.append(f)","def getItems(request, marketGroupID):\n if not request.is_ajax():\n raise Http404\n\n try:\n marketGroupID = int(marketGroupID)\n except ValueError:\n raise Http404\n\n items = cache.get(\"items_%d\" % marketGroupID)\n\n if items is None:\n # List wasn't in cache, let's get it from the database.\n try:\n marketGroup = MarketGroup.objects.get(pk=marketGroupID)\n except MarketGroup.DoesNotExist:\n raise Http404\n\n itemQuery = Item.objects.filter(marketGroupID = marketGroup,\n published=True).order_by(\"typeName\")\n # Augment with CPU, PG and slot info.\n items = getCPUandPGandSlot(itemQuery)\n\n # Store the list in cache.\n cache.set(\"items_%d\" % marketGroupID, items)\n\n return render_to_response(\"items.html\", locals())","def fetch_items(self):\n if self.items is None:\n rows = self.sqldb.execute(TodoManager.select_sql).fetchall()\n self.items = [TodoItem._make(row) for row in rows]\n return self.items","def get_menu_items(self):\n url = self.build_url(\"menus/\")\n res = get(url)\n if res.ok:\n return [x[\"item_name\"] for x in res.json()]\n return None","def allItemsByType(self, itemType):\n if itemType.value not in self.__inventory__:\n return []\n return self.__inventory__[itemType.value]","def query_items(self, items_params):\n username, password, api_key, max_items_to_return = SettingsOps.get_settings()\n items_runnable = ItemRunnable(username, password, api_key, items_params)\n items_runnable.item_object.task_complete.connect(self.on_new_items)\n self.init_progress_bar()\n self.search_thread_pool.start(items_runnable)","def get_all(self, start_at, limit, order=None):\n result = []\n objects = []\n if limit == 0:\n objects = self.items[start_at:]\n else:\n objects = self.items[start_at:(start_at + limit)]\n for item in objects:\n result.append(FileDict(item))\n return result","async def get_item_data(self, ref, db):\n # If items_url is empty, treat ref as URL\n url = self.items_url.format(ref) or ref\n response = await self.asession.get(url)\n\n if response.status_code == 404:\n return self.log.debug(f\"Item {ref} doesn't exist\")\n\n try:\n # Raise for other response failures\n response.raise_for_status()\n\n # Add item to the db\n self.process_item_data(db, ref, response)\n\n self.log.debug(f'Got item {ref}')\n except Exception:\n e = traceback.format_exc()\n self.log.error(f'{e} (item {ref}, status {response.status_code})')","def getItemsOfType(typeId):\n return Gw2Spidy._request('all-items', str(typeId))['results']","def get(self, user):\n search = True if self.request.args.get('q') else False\n limit = int(self.request.args.get('limit')) if self.request.args.get('limit') else 20\n page = int(self.request.args.get('page')) if self.request.args.get('page') else 1\n bucketlists = user.bucketlists.paginate(page, limit, True).items\n bucketlists = user.bucketlists.filter(Bucketlist.name.contains(self.request.args.get('q'))) if self.request.args.get('q') else bucketlists\n\n bucketlists = [\n {'id': bucketlist.id,\n 'name': bucketlist.name,\n 'items': [\n {'id': item.id,\n 'name': item.description,\n 'date_created': str(item.date_created),\n 'date_modified': str(item.date_modified),\n 'done': str(item.is_done)\n } for item in bucketlist.items\n ],\n 'date_created': str(bucketlist.date_created),\n 'date_modified': str(bucketlist.date_modified),\n 'created_by': bucketlist.created_by\n } for bucketlist in bucketlists\n ]\n\n # if empty retutn no bucketlists added\n if not bucketlists:\n return \"You have no avialable bucketlists\", 200\n\n return bucketlists, 200","def get_collection_items(client, collection_id):\n\n try:\n items = client.collection(collection_id=collection_id).get_items()\n for item in items:\n print('{item.type.capitalize()} \"{item.name}\" is in the collection')\n\n except Exception as e:\n print(f\"An error has occurred: {e}\")\n return None","def get_out(self):\r\n\t\tlogger.debug(\"Getting items checked out.\")\r\n\t\t\r\n\t\treturn db.items_out()","def items(query=None, user=LOGGED_IN_USER, username=USER):\n library = Library.objects.get()\n items = Item.objects.all()\n query_json = '[]'\n\n if query:\n from query import execute_query, parse_query\n parsed = parse_query(query)\n items = execute_query(items, parsed)\n # this json representation of the query that was just used to filter\n # the items will be passed back to the template as a json string\n # so the front end can render the query widget. A string representation\n # is not passed because there is no way to parse LQL in javascript (yet).\n query_json = jsonify(parsed)\n\n items = items.all()\n all_keys = []\n return {\n 'parsed_query_json': query_json,\n 'library_items': items,\n 'items_count': len(items),\n 'keys': all_keys,\n }","def do_list_items(self, arg):\n try:\n cprint (\"These are your items: \\n\", 'blue')\n my_items = arg[\"<all_items>\"]\n choice = arg[\"--choice\"]\n if choice == \"name\":\n my_items_str = \" \".join(my_items)\n print(my_items_str)\n elif choice == \"id\":\n my_items_str = int(\" \".join(my_items))\n print (my_items_str)\n app.ToDoApp.to_view_items(my_items_str)\n \n\n\n \n except ValueError as e:\n cprint((e), 'red')","def ListFiles(s3):\n response = s3.list_objects(Bucket='mynewbucket123')\n for content in response.get('Contents', []):\n yield content.get('Key')","async def get_files_for_filter_menu(language: str):\n try:\n file_filter_query_result = get_db().AQLQuery(\n query=menu_queries.QUERY_FILES_FOR_CATEGORY,\n batchSize=10000,\n bindVars={\"language\": language},\n )\n return {\"filteritems\": file_filter_query_result.result}\n\n except DocumentNotFoundError as error:\n print(error)\n raise HTTPException(status_code=404, detail=\"Item not found\") from error\n except AQLQueryError as error:\n print(\"AQLQueryError: \", error)\n raise HTTPException(status_code=400, detail=error.errors) from error\n except KeyError as error:\n print(\"KeyError: \", error)\n raise HTTPException(status_code=400) from error","def get_file_list(\n self,\n file_regex = r'.*'):\n s3Contents = []\n #Use list_objects_v2 via kwargs since there could be\n #more than 1000 objects (single return limit)\n kwargs = {'Bucket': self.bucket, 'Prefix':self.key}\n while True:\n try:\n resp = self.s3.list_objects_v2(**kwargs)\n except:\n resp = None\n self.logger.error('Unable to reach s3 bucket')\n sys.exit(1)\n if resp.get(\"Contents\"):\n try:\n f_regex = re.compile(file_regex)\n #python 3.8+ required for walrus operator\n s3Contents += [f['Key'] for f in resp['Contents'] if (match := re.search(f_regex, f['Key']))]\n except Exception as e:\n self.logger.exception(e)\n self.logger.error('failed to filter s3 folder. Bucket: %s and location: %s',\n self.bucket,\n self.key)\n sys.exit(1)\n try:\n kwargs['ContinuationToken'] = resp['NextContinuationToken']\n except KeyError:\n break\n if not s3Contents:\n self.logger.warning(\n 'No files were returned from s3 bucket: %s and location: %s filtering by %s',\n self.bucket,\n self.key,\n file_regex)\n return s3Contents","def get_items_for_catalog(catalog_id):\n pass","def get_objects(self, bucket, s3_client=None):\n\n try:\n all_objects = s3_client.list_objects_v2(Bucket=bucket)\n except botocore.exceptions.EndpointConnectionError:\n logging.error(\"Couldn't connect to an S3 endpoint. If you're using an S3 compatible provider other than AWS, remember to set --s3-endpoint-url\")\n sys.exit(1)\n\n if 'Contents' in all_objects.keys():\n all_objects = [ k['Key'] for k in [ obj for obj in all_objects['Contents'] ]] # pylint: disable=unnecessary-comprehension\n else:\n all_objects = []\n\n return all_objects","def listExclusiveItems(appStore):\n appStores = ('Xbox', 'Amazon', 'iOS', 'Google Play')\n if appStore not in appStores:\n Exception(f\"No valid app store was provided. Valid choices are {appStores}.\")\n else:\n url = f\"https://catalog.roblox.com/v1/exclusive-items/{appStore}/bundles\"\n r = requests.get(url)\n j = json.loads(r.text)\n return j['data']","def get_all_items(model, type):\n if(type == \"office\"):\n return model.get_all_offices()\n elif(type == \"party\"):\n return model.get_all_parties()\n return []","def test_get_items_page(self, mock_requests_get):\n result = resources.get_items_page(1, \"a\", 1)\n\n assert result.total == 97\n\n item = result.items[0]\n assert item.id == 1\n assert item.name == \"Thing\"\n assert item.description == \"A thing\"\n\n assert item.current.price == 100\n assert item.today.price == 110\n\n assert item.members is True\n\n item = result.items[1]\n\n assert item.current.price == 11300\n assert item.today.price == 24400000\n\n assert item.members is False\n\n item = result.items[2]\n\n assert item.current.price == 1800000000\n assert item.today.price == 43657","def list_files():\n try:\n return jsonify(os.listdir(env(\"FILES_DIRECTORY\"))), 200\n except:\n return {\"msg\": \"Não há arquivos a serem listados.\"}, 404","async def get(self):\n identifier = self.data[\"id\"]\n item = self.core.item_manager.items.get(identifier)\n if not item:\n return self.error(\n ERROR_ITEM_NOT_FOUND,\n f\"No item found with identifier {identifier}\", status_code=404)\n\n return self.json(data=list(item.actions.keys()))","def get_directory_items(self, req, folder_path, folders_only):\n\t\titems = []\n\t\t\n\t\tdirectory_path = os.path.join(self.get_selected_root(req), folder_path)\n\t\tfor item in os.listdir(directory_path):\n\t\t\tif(item.startswith('.')):\n\t\t\t\tcontinue\n\t\t\tfull_path = os.path.join(directory_path, item)\n\t\t\tfinfo = os.stat(full_path)\n\t\t\tif(stat.S_ISREG(finfo.st_mode)):\n\t\t\t\titems.append(tags.Tag('File')(name=item, size=(finfo.st_size // 1024)))\n\t\t\telse:\n\t\t\t\titems.append(tags.Tag('Folder')(name=item))\n\t\t\n\t\titems.sort(lambda a, b: cmp(a.attributes['name'].lower(), b.attributes['name'].lower()))\n\t\t\n\t\tcontent = tags.Tag('Folders')[''.join([str(t) for t in items if t.tag == 'Folder'])]\n\t\tif(not folders_only):\n\t\t\tfile_string = ''.join([str(t) for t in items if t.tag == 'File'])\n\t\t\tif(file_string):\n\t\t\t\tcontent += tags.Tag('Files')[file_string]\n\t\t\n\t\treturn content","def equip_items(self):\n # TODO: Assuming first server is good - need to make fallback logic\n return self.session.get_any(\"{base}{request_url}\".format(base=self.servers[0],\n request_url=F\"/Destiny2/Actions/Items/EquipItems/\"))","def get_all(self, item_name):\n item = {}\n try:\n item = self.glpi.get_all(item_name)\n except Exception as e:\n item = \"{ \\\"error_message\\\": \\\"%s\\\" }\" % e\n\n return item","def folder_by_name(self, context, params):\n\n token = util.get_access_token(context['headers'])\n response, code = OnedriveApi.search(token, params['name'])\n\n if code == 400:\n return response\n\n result = []\n\n for item in response['value']:\n if item.get('folder'):\n item_data = self.get_item_data(item)\n result.append(item_data)\n\n return result","def get_item_list(cls):\n if Item.__item_list is None:\n Item.__item_list = []\n return Item.__item_list","def get_items(self):\n return (item for item in self.items)","def getitem(itemID):\n\n return harvest(GET_ITEM_URL, itemID)","def test_vault_get_all_vault_items(self):\n pass","def todo_items(self, todo_list_id):\n\n self.endpoint = '{0}/{1}/todo_items.json'.format(self.endpoint, todo_list_id)\n\n request = self.get(self.construct_url())\n\n if request.status_code == 200:\n return json.loads(request.content)\n\n raise BasecampAPIError(json.loads(request.content).get('error'))","def getItemSellListings(itemId, allPages = False):\n return Gw2Spidy._paginatedRequest(allPages, 'listings', str(itemId), 'sell')","def _get_items_in_file(self, filename):\n\t\treturn_list = []\n\t\t\t\t\n\t\tfor k in self.data.keys():\n\t\t\tfor item in self[k]:\n\t\t\t\tif item['meta']['filename'] == filename:\n\t\t\t\t\treturn_list.append(item)\n\t\treturn return_list","def list(self, prefix=\"\"):\n try:\n list_rep = self.client.listdir(self.bucket + \"/\" + prefix)\n for i in list_rep:\n # Remove preceding bucket name and potential leading slash from returned key value\n i = i.replace(self.bucket, \"\").replace('tar', 'wsp.sz')\n if i[0] == '/': i = i[1:]\n yield i\n except pyhdfs.HdfsFileNotFoundException:\n pass","def get_items(self):\n return self.order_items","def items(self) -> List[Item]:\n return self._items","def disco_get_items(self,node,iq):\n to=iq.get_to()\n if to and to!=self.jid:\n return iq.make_error_response(\"recipient-unavailable\")\n if not node and self.disco_items:\n return self.disco_items\n return None","def retrieve_all_files(service):\r\n result = []\r\n page_token = None\r\n while True:\r\n try:\r\n param = {}\r\n if page_token:\r\n param['pageToken'] = page_token\r\n files = service.files().list(**param).execute()\r\n\r\n result.extend(files['items'])\r\n page_token = files.get('nextPageToken')\r\n if not page_token:\r\n break\r\n except errors.HttpError, error:\r\n print 'An error occurred: %s' % error\r\n break\r\n return result","def getItems(docs):\n keys = []\n for d in docs:\n if d.teilenummer:\n t_index = d.t_index or \"\"\n keys.append((d.teilenummer, t_index))\n items = []\n if keys:\n items = getObjectsByAttributePair(u\"teile_stamm\", u\"teilenummer\", u\"t_index\", keys, Item)\n return items","def retrieve_all_files(service):\n\n result = []\n page_token = None\n while True:\n try:\n param = {}\n if page_token:\n param['pageToken'] = page_token\n files = service.files().list(**param).execute()\n\n result.extend(files['files'])\n page_token = files.get('nextPageToken')\n if not page_token:\n break\n except errors.HttpError as error:\n print('An error occurred: %s' % error)\n break\n\n return result","def get_playlist_items(self):\n results = self.API.playlist(self.playlist_uri)\n return results[\"tracks\"][\"items\"]","def items(self) -> List:\n pass","def items(self):\n return self._get_storage().items()","def items(request, pk):\n\n if Item.objects.filter(category_id=pk).exists(): # Checks if product_category exists with given id.\n all_items = Item.objects.filter(category_id=pk)\n else:\n return Response(messages.ITEMS_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\n if request.method == 'GET':\n item_serializer = ItemSerializer(all_items, many=True)\n return Response(item_serializer.data[::-1], status=status.HTTP_200_OK)","def test_get_bucketlist_item_id(self):\n resp = self.client.post('/bucketlists',\n data=json.dumps(self.bucketlist),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n resp_item = self.client.post('/bucketlistitems/1/items',\n data=json.dumps(\n {\"name\": \"visit the busy surburbs.\"}),\n content_type=\"application/json\", headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\n \"Authorization\": self.token\n })\n self.assertEqual(resp.status_code, 201)","def get_items(self, uri):\n validation.check_uri(uri)\n\n uri_scheme = urllib.parse.urlparse(uri).scheme\n backend = self.backends.with_playlists.get(uri_scheme, None)\n\n if not backend:\n return None\n\n with _backend_error_handling(backend):\n items = backend.playlists.get_items(uri).get()\n items is None or validation.check_instances(items, Ref)\n return items\n\n return None"],"string":"[\n \"def get_items():\\n return requester.perform_request(Uri.items)\",\n \"def test_get_all_item(self, app, item):\\n res = app.store_items.get_all_items(\\n header=item.header,\\n type_response=ItemsResponse,\\n )\\n assert res.status_code == 200\",\n \"async def get_items(\\n request: Request,\\n response: Response,\\n db: SAConnection = Depends(get_postgresql_connection)\\n):\\n if db is None:\\n response.status_code = 503\\n return ResponseModel(result='Service unavailable')\\n q = items.select()\\n result = await db.fetch(query=q)\\n items_list = [Item(**item) for item in result]\\n for item in items_list:\\n await request.app.extra['cache'].set_cache_item(item=item)\\n return items_list\",\n \"async def get_items(self, resource: str, *, params: dict = None):\\r\\n resp = await self.request(\\\"get\\\", self._api_base + resource, params, None)\\r\\n items = resp.get(\\\"items\\\", [])\\r\\n next_link = Api._get_next_link(resp)\\r\\n while next_link:\\r\\n resp = await self.request(\\\"get\\\", next_link, params, None)\\r\\n items.extend(resp.get(\\\"items\\\", []))\\r\\n next_link = Api._get_next_link(resp)\\r\\n return items\",\n \"def get_all_items():\\n try:\\n return get_json(get_data())\\n except ValueError as e:\\n print(e)\\n except TypeError as e:\\n print(e)\",\n \"def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KeyToPathArgs']]]]:\\n return pulumi.get(self, \\\"items\\\")\",\n \"def items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KeyToPathArgs']]]]:\\n return pulumi.get(self, \\\"items\\\")\",\n \"def getAllItems(self):\\r\\n\\r\\n control = []\\r\\n\\r\\n for folder in self.get_items():\\r\\n control.append(folder.id)\\r\\n\\r\\n while len(control) > 0:\\r\\n try:\\r\\n for item in self.get_items(parent=control.pop()):\\r\\n print(\\\"Getting content for: \\\" + item.name)\\r\\n if item.type == \\\"folder\\\":\\r\\n control.insert(0,item.id)\\r\\n else:\\r\\n self.contents[item.id] = {\\r\\n 'name': item.name, 'parentID': item.parent_id,\\r\\n 'size': item.size, 'uri': item.download_url\\r\\n }\\r\\n except putio.PutioError as err:\\r\\n print(\\\"Can't get content for Directory\\\")\\r\\n pass\\r\\n return self.contents\",\n \"def DirItems():\\n return diritems\",\n \"def get_game_items(self, **kwargs):\\n url = self.__build_url(urls.GET_GAME_ITEMS, language=self.language, **kwargs)\\n req = self.executor(url)\\n if self.logger:\\n self.logger.info('URL: {0}'.format(url))\\n if not self.__check_http_err(req.status_code):\\n return response.build(req, url, self.raw_mode)\",\n \"def getAllItemsList():\\n return Gw2Spidy._request('all-items', 'all')['results']\",\n \"def getItems(self): \\n if self.itemCount > 0:\\n \\n site = getSite()\\n \\n \\n # Make string path relative to the site root\\n # E.g. string path \\\"news\\\" becomes \\\"/yoursiteid/news\\\"\\n site_path = site.getPhysicalPath();\\n \\n path = \\\"/\\\".join(site_path) + \\\"/\\\" + self.path \\n \\n types = [self.itemPortalType]\\n \\n items = []\\n \\n #if self.itemPortalType2 != None:\\n # types.append(self.itemPortalType2) \\n \\n #print \\\"Querying by:\\\" + type + \\\" \\\" + path\\n content_by_type = self.context.portal_catalog(path={ \\\"query\\\": path, \\\"depth\\\" :9 }, \\n portal_type=self.itemPortalType, \\n sort_on=\\\"created\\\", \\n sort_order=\\\"reverse\\\")[0:self.itemCount]\\n\\n content_by_type = list(content_by_type)\\n \\n if self.itemPortalType2 != None:\\n content_by_type2 = self.context.portal_catalog(path={ \\\"query\\\": path, \\\"depth\\\" :9 }, \\n portal_type=self.itemPortalType2, \\n sort_on=\\\"created\\\", \\n sort_order=\\\"reverse\\\")[0:self.itemCount]\\n\\n content_by_type += list(content_by_type2)\\n\\n \\n items += [ brain.getObject() for brain in content_by_type ]\\n else:\\n items = []\\n \\n #if self.title == \\\"Daily deals\\\":\\n # import pdb ; pdb.set_trace()\\n \\n # XXX: custom hack for deals\\n def is_expired_deal(i):\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n if hasattr(i, \\\"validUntil\\\"):\\n now = datetime.datetime.utcnow()\\n if now > i.validUntil:\\n return True\\n \\n return False\\n \\n items = [ i for i in items if not is_expired_deal(i) ]\\n \\n return items\",\n \"def get_all_items(self):\\n return self.api.state['items']\",\n \"def get_files_in_folder(client, folder_id):\\n\\n try:\\n items = client.folder(folder_id=folder_id).get_items()\\n for item in items:\\n print(item.name, item.id)\\n return items\\n except Exception as e:\\n print(f\\\"An error has occurred: {e}\\\")\",\n \"def test_get_item_list(self):\\n resp = self.app.get('/items')\\n self.assertEqual(resp.status_code, status.HTTP_200_OK)\\n data = json.loads(resp.data)\\n self.assertEqual(len(data), 3)\",\n \"def list_hnd(self, request, **kwargs):\\n prefix = request.POST.get(\\\"prefix\\\", \\\"\\\")\\n marker = request.POST.get(\\\"marker\\\", \\\"\\\")\\n delimiter = request.POST.get(\\\"delimiter\\\", \\\"\\\")\\n\\n max_keys = int(request.POST.get(\\\"max_keys\\\", 1000))\\n max_keys = max((1, max_keys)) # >= 1\\n max_keys = min((1000, max_keys)) # <= 1000\\n\\n bucket = store.get_bucket()\\n\\n # prefix \\\"prefix\\\" with user dir\\n eff_prefix = store.prefix_with_user_dir(request.user, prefix)\\n\\n # get list iterator from s3\\n file_iter = bucket.list(prefix=eff_prefix, delimiter=delimiter,\\n marker=marker, headers=None,\\n encoding_type=None)\\n\\n # convert to list, try to get +1 item to be able\\n # to determine if the results are truncated\\n files = [key.key.split(\\\"/\\\", 1)[1]\\n for key in itertools.islice(file_iter, 0, max_keys+1)]\\n\\n # if max_keys is less then there are more results\\n # -> truncated = True\\n truncated = len(files) > max_keys\\n if truncated:\\n # return 1 item less\\n files = files[:-1]\\n\\n return self.create_response(request, {\\n \\\"files\\\": files,\\n \\\"truncated\\\": truncated\\n })\",\n \"def getItems(self): \\n items = []\\n if self.itemCount > 0:\\n \\n site = getSite()\\n \\n \\n # Make string path relative to the site root\\n # E.g. string path \\\"news\\\" becomes \\\"/yoursiteid/news\\\"\\n site_path = site.getPhysicalPath();\\n \\n path = \\\"/\\\".join(site_path) + \\\"/\\\" + self.path \\n \\n #if self.itemPortalType2 != None:\\n # types.append(self.itemPortalType2) \\n \\n #print \\\"Querying by:\\\" + type + \\\" \\\" + path\\n content_by_type = self.context.portal_catalog(path={ \\\"query\\\": path, \\\"depth\\\" :9 }, \\n sort_on=\\\"created\\\", \\n sort_order=\\\"reverse\\\")[0:self.itemCount]\\n\\n \\n items += [ brain.getObject() for brain in content_by_type ]\\n\\n return items\",\n \"def get_all_items(unit) -> list:\\n items = []\\n for item in unit.items:\\n if item.multi_item:\\n for subitem in item.subitems:\\n items.append(subitem)\\n else:\\n items.append(item)\\n return items\",\n \"def get(self):\\n result = self.session.get(urljoin(self.base_url, self.directory))\\n if result.ok:\\n data = result.json()\\n\\n if self.raw:\\n return data\\n\\n if not self.query[\\\"item\\\"]:\\n return data[\\\"ids\\\"]\\n else:\\n if self.query[\\\"filter\\\"] == \\\"links\\\":\\n return data[\\\"links\\\"]\\n else:\\n return data.get(\\\"entry\\\", None)\\n else:\\n raise RuntimeError(\\\"Malformed Request\\\")\",\n \"def getItems(self):\\n fname = 'getItems'\\n actionId = self._db.addAction('WebCrawler')\\n actionId_ex = self._db.addAction('extractor')\\n\\n if not os.path.exists(self._haystackPath):\\n self._haystackPath = os.path.expanduser(self._haystackPath)\\n\\n if not os.path.exists(self._haystackPath):\\n self._haystackPath = os.path.abspath(self._haystackPath)\\n\\n print('\\\\t{0} [{1}]'.format(fname, self._haystackPath))\\n\\n for (pathStr, dirs, files) in os.walk(self._haystackPath):\\n head, tail = os.path.split(pathStr)\\n for fileStr in files:\\n fileDTCheck = ''\\n filePath = os.path.join(pathStr,fileStr)\\n\\n # get the file date...\\n fileDT = datetime.datetime.fromtimestamp(os.path.getmtime(filePath)).replace(microsecond=0)\\n fileSize = os.path.getsize(filePath)\\n fileName, fileExt = os.path.splitext(filePath)\\n\\n # save the item to the database\\n itemId = self._db.addItem(self._engine_id, \\\"file://%s\\\" % filePath, fileDT)\\n \\n # now check the data for this item...\\n itemList = self._db.getItemDataAll(itemId) \\n isMatch = False\\n for item in itemList:\\n if item[0] == 'FileDate':\\n # we have a date string...\\n fileDTCheck = datetime.datetime.strptime(item[1], \\\"%Y-%m-%d %H:%M:%S\\\")\\n if fileDTCheck == fileDT:\\n # the same time, no changes needed\\n isMatch = True\\n \\n if isMatch:\\n # get next item as this is already exists\\n continue\\n \\n # print(the details)\\n print(fileDTCheck, fileDT)\\n print('>>\\\\t%s\\\\t%s\\\\t%s' % (fname, head, tail))\\n \\n # set the datetime and other details\\n self._db.addItemData(itemId, 'Haystack', tail, 0)\\n self._db.addItemData(itemId, 'FileName', fileName, 0)\\n self._db.addItemData(itemId, 'FileExt', fileExt, 0)\\n self._db.addItemData(itemId, 'FileDate', fileDT, 0)\\n self._db.addItemData(itemId, 'FileSize', fileSize, 0)\\n\\n # now to process the file...\\n # this will extract out metadata and add to the itemData table the value pairs.\\n pattern = re.compile(r'^.*[.](?P<ext>htm|html)$')\\n pattPNG = re.compile(r'^.*[.](?P<ext>mp.|mpeg|avi|swf|jpg|jpeg|png)$')\\n pattTAR = re.compile(r'^.*[.](?P<ext>tar\\\\.gz|tar\\\\.bz2|\\\\.zip|\\\\.tar|\\\\.7z)$')\\n\\n m = pattern.match(filePath)\\n if not m:\\n m = pattPNG.match(filePath)\\n\\n if not m:\\n m = pattTAR.match(filePath)\\n\\n if not m:\\n self.getContents(itemId, filePath, tail)\\n self._db.updateItem(self._engine_id, itemId, actionId_ex, datetime.datetime.now())\\n\\n else:\\n # we have a file extension...\\n if m.group('ext').startswith('.htm'):\\n # add this as an event to be processed by the html link reader...\\n self._db.addItemEvent(self._engine_id, actionId, itemId)\\n\\n if self._db:\\n self._db.commit_db()\",\n \"def get_cch_items(cch_url):\\n\\t#'subtree=false' produces a flat list of all items\\n\\tall_items_url = cch_url + 'data/item?subtree=false&showDisabled=true'\\n\\teprint(\\\"retrieving CCH items from {}\\\".format(all_items_url))\\n\\tall_items_response = requests.get(all_items_url)\\n\\titems = handle_cch_items_response(all_items_response)\\n\\treturn items\",\n \"def getAllItems(self):\\n data = self._client.Item.filter(\\n int(self.app_id), {\\n 'limit': 500,\\n# 'filters':[{\\n# \\\"key\\\":\\\"96943879\\\", #En este pedazo se está filtrando sobre un campo, se quiere coger sólo a los\\n# \\\"values\\\":[1],\\n# }],\\n },\\n )[\\\"items\\\"]\\n fields = [self.makeDict(item) for item in data]\\n return fields\",\n \"def getItemList(self):\\r\\n raise AbstractError\\r\\n return []\",\n \"def test_get_bucketlist_items(self):\\n resp = self.client.post('/bucketlists',\\n data=json.dumps(self.bucketlist),\\n content_type=\\\"application/json\\\", headers={\\n \\\"Authorization\\\": self.token\\n })\\n self.assertEqual(resp.status_code, 201)\\n\\n resp_item = self.client.post('/bucketlistitems/1/items',\\n data=json.dumps(\\n {\\\"name\\\": \\\"visit the busy surburbs.\\\"}),\\n content_type=\\\"application/json\\\", headers={\\n \\\"Authorization\\\": self.token\\n })\\n\\n self.assertEqual(resp_item.status_code, 200)\\n resp_item = self.client.get('/bucketlistitems/1/items', headers={\\n \\\"Authorization\\\": self.token\\n })\\n self.assertEqual(resp_item.status_code, 200)\",\n \"def FullDirItems():\\n return fulldiritems\",\n \"def get_items(self):\\n return self.item_list\",\n \"def get_item(url: str, headers: Dict[str, str], **param) -> List[Dict[str, Any]]:\\n response = req_get(url, headers=headers, params=param)\\n return serialize_response(response)\",\n \"def all_items_handler():\\n items = getAllItems()\\n return jsonify(items=[i.serialize for i in items])\",\n \"def find_items():\\n check50.exists(\\\"item.py\\\")\\n try:\\n check50.run(run_command).stdin(\\\"in\\\").stdout(room_3_items)\\n except check50.Failure as error:\\n raise check50.Failure(\\\"Could not find items upon first entering room.\\\\n\\\" +\\n \\\" Remember to seperate multiple items by a single newline\\\\n\\\" +\\n f\\\" {error}\\\")\\n # Check for look command\\n try:\\n check = check50.run(run_command)\\n moves = [\\\"IN\\\", \\\"OUT\\\", \\\"IN\\\", \\\"LOOK\\\"]\\n\\n for move in moves:\\n check.stdout(\\\"> \\\")\\n check.stdin(move, prompt=False)\\n\\n check.stdout(\\\"KEYS: a set of keys\\\")\\n except check50.Failure as error:\\n raise check50.Failure(f\\\"Could not find items when using LOOK.\\\\n {error}\\\")\",\n \"async def fetch_file_list(client, bucket) -> List:\\n # pylint: disable=invalid-name\\n PG_HOSTNAME = config('PG_HOSTNAME')\\n PG_DATABASE = config('PG_DATABASE')\\n folder = f'backup/{PG_HOSTNAME}_{PG_DATABASE}'\\n result = await client.list_objects_v2(Bucket=bucket, Prefix=folder)\\n contents = result.get('Contents', None)\\n file_list = list([])\\n if contents:\\n for content in contents:\\n file_list.append(content.get('Key'))\\n return file_list\",\n \"def get_items(self, keyword='', linked=True, unlinked=True):\\n page = 1\\n show_on_page = 50\\n request_items = self.request_channel_items(\\n page, show_linked=linked, show_unlinked=unlinked,\\n show_on_page=show_on_page, keyword=keyword)\\n items = request_items\\n while len(request_items) == show_on_page:\\n page += 1\\n request_items = self.request_channel_items(\\n page, keyword=keyword, show_linked=linked,\\n show_unlinked=unlinked)\\n items = items + request_items\\n return items\",\n \"def get(self, *args, **kwargs):\\n if not args and set(kwargs) in ({\\\"id\\\"}, {\\\"id\\\", \\\"changekey\\\"}):\\n # We allow calling get(id=..., changekey=...) to get a single item, but only if exactly these two\\n # kwargs are present.\\n account = self.folder_collection.account\\n item_id = self._id_field.field.clean(kwargs[\\\"id\\\"], version=account.version)\\n changekey = self._changekey_field.field.clean(kwargs.get(\\\"changekey\\\"), version=account.version)\\n # The folders we're querying may not support all fields\\n if self.only_fields is None:\\n only_fields = {FieldPath(field=f) for f in self.folder_collection.allowed_item_fields()}\\n else:\\n only_fields = self.only_fields\\n items = list(account.fetch(ids=[(item_id, changekey)], only_fields=only_fields))\\n else:\\n new_qs = self.filter(*args, **kwargs)\\n items = list(new_qs.__iter__())\\n if not items:\\n raise DoesNotExist()\\n if len(items) != 1:\\n raise MultipleObjectsReturned()\\n return items[0]\",\n \"def get_items(self) -> list:\\r\\n return self._items\",\n \"def get_items(self):\\n\\n items = []\\n\\n params = self.request.query_params\\n\\n if 'items[]' in params:\\n items = params.getlist('items[]', [])\\n elif 'item' in params:\\n items = [params.get('item', None)]\\n\\n if type(items) not in [list, tuple]:\\n items = [items]\\n\\n valid_ids = []\\n\\n for item in items:\\n try:\\n valid_ids.append(int(item))\\n except (ValueError):\\n pass\\n\\n # List of StockItems which match provided values\\n valid_items = StockItem.objects.filter(pk__in=valid_ids)\\n\\n return valid_items\",\n \"def get_items_from_response(self, response):\\n raise NotImplementedError\",\n \"def get_items(self) -> list:\\n if self._cached_items is None:\\n self._cached_items = list(self.items.all())\\n return self._cached_items\",\n \"def boxSearch(client):\\n\\tfiles = []\\n\\titems_iter = client.folder(folder_id=0).get_items(limit=100, offset=0)\\n\\tfor x in items_iter:\\n\\t\\tfiles.append(x)\\n\\treturn files\",\n \"def get_items(self):\\n\\n if not self.ITEM_MODEL:\\n raise NotImplementedError(f\\\"ITEM_MODEL attribute not defined for {__class__}\\\")\\n\\n ids = []\\n\\n # Construct a list of possible query parameter value options\\n # e.g. if self.ITEM_KEY = 'order' -> ['order', 'order[]', 'orders', 'orders[]']\\n for k in [self.ITEM_KEY + x for x in ['', '[]', 's', 's[]']]:\\n if ids := self.request.query_params.getlist(k, []):\\n # Return the first list of matches\\n break\\n\\n # Next we must validated each provided object ID\\n valid_ids = []\\n\\n for id in ids:\\n try:\\n valid_ids.append(int(id))\\n except ValueError:\\n pass\\n\\n # Filter queryset by matching ID values\\n return self.ITEM_MODEL.objects.filter(pk__in=valid_ids)\",\n \"def handle_cch_items_response(response):\\n\\tif 200 != response.status_code:\\n\\t\\traise Exception('Could not retrieve CCH Items. Got status code {}'.format(response.status_code))\\n\\telse:\\n\\t\\tthe_json = response.json()\\n\\t\\tcch_items = the_json['items']\\n\\t\\treturn cch_items\",\n \"def get_items(self):\\n return self.item_ids\",\n \"def _parse_items(path: str) -> list[EditorItem]:\\n items: list[EditorItem] = []\\n with filesystem[path].open_str() as f:\\n tok = Tokenizer(f, path)\\n for tok_type, tok_value in tok:\\n if tok_type is Token.STRING:\\n if tok_value.casefold() != 'item':\\n raise tok.error('Unknown item option \\\"{}\\\"!', tok_value)\\n items.append(EditorItem.parse_one(tok, pak_id))\\n elif tok_type is not Token.NEWLINE:\\n raise tok.error(tok_type)\\n return items\",\n \"def get_items(self):\\n return []\",\n \"def test_get_all_items(test_client):\\n\\n response = test_client.get(BASE_URL)\\n\\n data = json.loads(response.get_data())\\n\\n assert response.status_code == 200\\n assert len(data['items']) == 3\",\n \"def get_all(self,empty=True):\\n with self.lock:\\n items = self.items\\n if empty: self.items = []\\n return items\",\n \"def get_items_not_in_stock():\\n try:\\n return get_items_arent_on_stock(), 200\\n except:\\n return \\\"An error ocurred\\\", 404\",\n \"def get_items(self):\\n return self.items\",\n \"def get_items(path, only=None):\\n path = os.path.expanduser(path)\\n ps = [os.path.join(path, n)\\n for n in os.listdir(path)\\n if not n.startswith('.') and len(n) == 4]\\n ps = [p for p in ps if os.path.isdir(p)]\\n if only is not None:\\n ps = [p for p in ps if nmrex.utils.fname(p) in only]\\n return ps\",\n \"async def read_items(commons: dict = Depends(common_parameters)):\\n return commons\",\n \"def items(self) -> List[InlineResponse200Items]:\\n return self._items\",\n \"def get_items_from_dir(path):\\n items = os.listdir(path)\\n items.sort()\\n return items\",\n \"def getItemBuyListings(itemId, allPages = False):\\n return Gw2Spidy._paginatedRequest(allPages, 'listings', str(itemId), 'buy')\",\n \"def test_get_bucketlist_items(self):\\r\\n email = \\\"test@test.com\\\"\\r\\n _pword = \\\"test\\\"\\r\\n user = User.query.filter_by(email=email).first()\\r\\n bucketlist = BucketList.query.filter_by(user_id=user.id, id=1).first()\\r\\n items_no = len(bucketlist.bucketlist_items)\\r\\n headers = self.authentication_headers(email=email, password=_pword)\\r\\n response = self.client.get(\\r\\n '/api/v1/bucketlist/1/items/',\\r\\n content_type=\\\"application/json\\\",\\r\\n headers=headers,\\r\\n follow_redirects=True\\r\\n )\\r\\n result = json.loads(response.data.decode('utf-8'))\\r\\n self.assertEqual(len(result), items_no)\",\n \"def _update_items(self):\\n\\n self._item_list = []\\n for f in os.listdir(self._folder):\\n # Skip text files\\n # -> It is important that we don't delete the list file if the user puts it here!\\n ext = os.path.splitext(f)[1]\\n if ext not in ['.csv', 'txt']:\\n self._item_list.append(f)\",\n \"def getItems(request, marketGroupID):\\n if not request.is_ajax():\\n raise Http404\\n\\n try:\\n marketGroupID = int(marketGroupID)\\n except ValueError:\\n raise Http404\\n\\n items = cache.get(\\\"items_%d\\\" % marketGroupID)\\n\\n if items is None:\\n # List wasn't in cache, let's get it from the database.\\n try:\\n marketGroup = MarketGroup.objects.get(pk=marketGroupID)\\n except MarketGroup.DoesNotExist:\\n raise Http404\\n\\n itemQuery = Item.objects.filter(marketGroupID = marketGroup,\\n published=True).order_by(\\\"typeName\\\")\\n # Augment with CPU, PG and slot info.\\n items = getCPUandPGandSlot(itemQuery)\\n\\n # Store the list in cache.\\n cache.set(\\\"items_%d\\\" % marketGroupID, items)\\n\\n return render_to_response(\\\"items.html\\\", locals())\",\n \"def fetch_items(self):\\n if self.items is None:\\n rows = self.sqldb.execute(TodoManager.select_sql).fetchall()\\n self.items = [TodoItem._make(row) for row in rows]\\n return self.items\",\n \"def get_menu_items(self):\\n url = self.build_url(\\\"menus/\\\")\\n res = get(url)\\n if res.ok:\\n return [x[\\\"item_name\\\"] for x in res.json()]\\n return None\",\n \"def allItemsByType(self, itemType):\\n if itemType.value not in self.__inventory__:\\n return []\\n return self.__inventory__[itemType.value]\",\n \"def query_items(self, items_params):\\n username, password, api_key, max_items_to_return = SettingsOps.get_settings()\\n items_runnable = ItemRunnable(username, password, api_key, items_params)\\n items_runnable.item_object.task_complete.connect(self.on_new_items)\\n self.init_progress_bar()\\n self.search_thread_pool.start(items_runnable)\",\n \"def get_all(self, start_at, limit, order=None):\\n result = []\\n objects = []\\n if limit == 0:\\n objects = self.items[start_at:]\\n else:\\n objects = self.items[start_at:(start_at + limit)]\\n for item in objects:\\n result.append(FileDict(item))\\n return result\",\n \"async def get_item_data(self, ref, db):\\n # If items_url is empty, treat ref as URL\\n url = self.items_url.format(ref) or ref\\n response = await self.asession.get(url)\\n\\n if response.status_code == 404:\\n return self.log.debug(f\\\"Item {ref} doesn't exist\\\")\\n\\n try:\\n # Raise for other response failures\\n response.raise_for_status()\\n\\n # Add item to the db\\n self.process_item_data(db, ref, response)\\n\\n self.log.debug(f'Got item {ref}')\\n except Exception:\\n e = traceback.format_exc()\\n self.log.error(f'{e} (item {ref}, status {response.status_code})')\",\n \"def getItemsOfType(typeId):\\n return Gw2Spidy._request('all-items', str(typeId))['results']\",\n \"def get(self, user):\\n search = True if self.request.args.get('q') else False\\n limit = int(self.request.args.get('limit')) if self.request.args.get('limit') else 20\\n page = int(self.request.args.get('page')) if self.request.args.get('page') else 1\\n bucketlists = user.bucketlists.paginate(page, limit, True).items\\n bucketlists = user.bucketlists.filter(Bucketlist.name.contains(self.request.args.get('q'))) if self.request.args.get('q') else bucketlists\\n\\n bucketlists = [\\n {'id': bucketlist.id,\\n 'name': bucketlist.name,\\n 'items': [\\n {'id': item.id,\\n 'name': item.description,\\n 'date_created': str(item.date_created),\\n 'date_modified': str(item.date_modified),\\n 'done': str(item.is_done)\\n } for item in bucketlist.items\\n ],\\n 'date_created': str(bucketlist.date_created),\\n 'date_modified': str(bucketlist.date_modified),\\n 'created_by': bucketlist.created_by\\n } for bucketlist in bucketlists\\n ]\\n\\n # if empty retutn no bucketlists added\\n if not bucketlists:\\n return \\\"You have no avialable bucketlists\\\", 200\\n\\n return bucketlists, 200\",\n \"def get_collection_items(client, collection_id):\\n\\n try:\\n items = client.collection(collection_id=collection_id).get_items()\\n for item in items:\\n print('{item.type.capitalize()} \\\"{item.name}\\\" is in the collection')\\n\\n except Exception as e:\\n print(f\\\"An error has occurred: {e}\\\")\\n return None\",\n \"def get_out(self):\\r\\n\\t\\tlogger.debug(\\\"Getting items checked out.\\\")\\r\\n\\t\\t\\r\\n\\t\\treturn db.items_out()\",\n \"def items(query=None, user=LOGGED_IN_USER, username=USER):\\n library = Library.objects.get()\\n items = Item.objects.all()\\n query_json = '[]'\\n\\n if query:\\n from query import execute_query, parse_query\\n parsed = parse_query(query)\\n items = execute_query(items, parsed)\\n # this json representation of the query that was just used to filter\\n # the items will be passed back to the template as a json string\\n # so the front end can render the query widget. A string representation\\n # is not passed because there is no way to parse LQL in javascript (yet).\\n query_json = jsonify(parsed)\\n\\n items = items.all()\\n all_keys = []\\n return {\\n 'parsed_query_json': query_json,\\n 'library_items': items,\\n 'items_count': len(items),\\n 'keys': all_keys,\\n }\",\n \"def do_list_items(self, arg):\\n try:\\n cprint (\\\"These are your items: \\\\n\\\", 'blue')\\n my_items = arg[\\\"<all_items>\\\"]\\n choice = arg[\\\"--choice\\\"]\\n if choice == \\\"name\\\":\\n my_items_str = \\\" \\\".join(my_items)\\n print(my_items_str)\\n elif choice == \\\"id\\\":\\n my_items_str = int(\\\" \\\".join(my_items))\\n print (my_items_str)\\n app.ToDoApp.to_view_items(my_items_str)\\n \\n\\n\\n \\n except ValueError as e:\\n cprint((e), 'red')\",\n \"def ListFiles(s3):\\n response = s3.list_objects(Bucket='mynewbucket123')\\n for content in response.get('Contents', []):\\n yield content.get('Key')\",\n \"async def get_files_for_filter_menu(language: str):\\n try:\\n file_filter_query_result = get_db().AQLQuery(\\n query=menu_queries.QUERY_FILES_FOR_CATEGORY,\\n batchSize=10000,\\n bindVars={\\\"language\\\": language},\\n )\\n return {\\\"filteritems\\\": file_filter_query_result.result}\\n\\n except DocumentNotFoundError as error:\\n print(error)\\n raise HTTPException(status_code=404, detail=\\\"Item not found\\\") from error\\n except AQLQueryError as error:\\n print(\\\"AQLQueryError: \\\", error)\\n raise HTTPException(status_code=400, detail=error.errors) from error\\n except KeyError as error:\\n print(\\\"KeyError: \\\", error)\\n raise HTTPException(status_code=400) from error\",\n \"def get_file_list(\\n self,\\n file_regex = r'.*'):\\n s3Contents = []\\n #Use list_objects_v2 via kwargs since there could be\\n #more than 1000 objects (single return limit)\\n kwargs = {'Bucket': self.bucket, 'Prefix':self.key}\\n while True:\\n try:\\n resp = self.s3.list_objects_v2(**kwargs)\\n except:\\n resp = None\\n self.logger.error('Unable to reach s3 bucket')\\n sys.exit(1)\\n if resp.get(\\\"Contents\\\"):\\n try:\\n f_regex = re.compile(file_regex)\\n #python 3.8+ required for walrus operator\\n s3Contents += [f['Key'] for f in resp['Contents'] if (match := re.search(f_regex, f['Key']))]\\n except Exception as e:\\n self.logger.exception(e)\\n self.logger.error('failed to filter s3 folder. Bucket: %s and location: %s',\\n self.bucket,\\n self.key)\\n sys.exit(1)\\n try:\\n kwargs['ContinuationToken'] = resp['NextContinuationToken']\\n except KeyError:\\n break\\n if not s3Contents:\\n self.logger.warning(\\n 'No files were returned from s3 bucket: %s and location: %s filtering by %s',\\n self.bucket,\\n self.key,\\n file_regex)\\n return s3Contents\",\n \"def get_items_for_catalog(catalog_id):\\n pass\",\n \"def get_objects(self, bucket, s3_client=None):\\n\\n try:\\n all_objects = s3_client.list_objects_v2(Bucket=bucket)\\n except botocore.exceptions.EndpointConnectionError:\\n logging.error(\\\"Couldn't connect to an S3 endpoint. If you're using an S3 compatible provider other than AWS, remember to set --s3-endpoint-url\\\")\\n sys.exit(1)\\n\\n if 'Contents' in all_objects.keys():\\n all_objects = [ k['Key'] for k in [ obj for obj in all_objects['Contents'] ]] # pylint: disable=unnecessary-comprehension\\n else:\\n all_objects = []\\n\\n return all_objects\",\n \"def listExclusiveItems(appStore):\\n appStores = ('Xbox', 'Amazon', 'iOS', 'Google Play')\\n if appStore not in appStores:\\n Exception(f\\\"No valid app store was provided. Valid choices are {appStores}.\\\")\\n else:\\n url = f\\\"https://catalog.roblox.com/v1/exclusive-items/{appStore}/bundles\\\"\\n r = requests.get(url)\\n j = json.loads(r.text)\\n return j['data']\",\n \"def get_all_items(model, type):\\n if(type == \\\"office\\\"):\\n return model.get_all_offices()\\n elif(type == \\\"party\\\"):\\n return model.get_all_parties()\\n return []\",\n \"def test_get_items_page(self, mock_requests_get):\\n result = resources.get_items_page(1, \\\"a\\\", 1)\\n\\n assert result.total == 97\\n\\n item = result.items[0]\\n assert item.id == 1\\n assert item.name == \\\"Thing\\\"\\n assert item.description == \\\"A thing\\\"\\n\\n assert item.current.price == 100\\n assert item.today.price == 110\\n\\n assert item.members is True\\n\\n item = result.items[1]\\n\\n assert item.current.price == 11300\\n assert item.today.price == 24400000\\n\\n assert item.members is False\\n\\n item = result.items[2]\\n\\n assert item.current.price == 1800000000\\n assert item.today.price == 43657\",\n \"def list_files():\\n try:\\n return jsonify(os.listdir(env(\\\"FILES_DIRECTORY\\\"))), 200\\n except:\\n return {\\\"msg\\\": \\\"Não há arquivos a serem listados.\\\"}, 404\",\n \"async def get(self):\\n identifier = self.data[\\\"id\\\"]\\n item = self.core.item_manager.items.get(identifier)\\n if not item:\\n return self.error(\\n ERROR_ITEM_NOT_FOUND,\\n f\\\"No item found with identifier {identifier}\\\", status_code=404)\\n\\n return self.json(data=list(item.actions.keys()))\",\n \"def get_directory_items(self, req, folder_path, folders_only):\\n\\t\\titems = []\\n\\t\\t\\n\\t\\tdirectory_path = os.path.join(self.get_selected_root(req), folder_path)\\n\\t\\tfor item in os.listdir(directory_path):\\n\\t\\t\\tif(item.startswith('.')):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\tfull_path = os.path.join(directory_path, item)\\n\\t\\t\\tfinfo = os.stat(full_path)\\n\\t\\t\\tif(stat.S_ISREG(finfo.st_mode)):\\n\\t\\t\\t\\titems.append(tags.Tag('File')(name=item, size=(finfo.st_size // 1024)))\\n\\t\\t\\telse:\\n\\t\\t\\t\\titems.append(tags.Tag('Folder')(name=item))\\n\\t\\t\\n\\t\\titems.sort(lambda a, b: cmp(a.attributes['name'].lower(), b.attributes['name'].lower()))\\n\\t\\t\\n\\t\\tcontent = tags.Tag('Folders')[''.join([str(t) for t in items if t.tag == 'Folder'])]\\n\\t\\tif(not folders_only):\\n\\t\\t\\tfile_string = ''.join([str(t) for t in items if t.tag == 'File'])\\n\\t\\t\\tif(file_string):\\n\\t\\t\\t\\tcontent += tags.Tag('Files')[file_string]\\n\\t\\t\\n\\t\\treturn content\",\n \"def equip_items(self):\\n # TODO: Assuming first server is good - need to make fallback logic\\n return self.session.get_any(\\\"{base}{request_url}\\\".format(base=self.servers[0],\\n request_url=F\\\"/Destiny2/Actions/Items/EquipItems/\\\"))\",\n \"def get_all(self, item_name):\\n item = {}\\n try:\\n item = self.glpi.get_all(item_name)\\n except Exception as e:\\n item = \\\"{ \\\\\\\"error_message\\\\\\\": \\\\\\\"%s\\\\\\\" }\\\" % e\\n\\n return item\",\n \"def folder_by_name(self, context, params):\\n\\n token = util.get_access_token(context['headers'])\\n response, code = OnedriveApi.search(token, params['name'])\\n\\n if code == 400:\\n return response\\n\\n result = []\\n\\n for item in response['value']:\\n if item.get('folder'):\\n item_data = self.get_item_data(item)\\n result.append(item_data)\\n\\n return result\",\n \"def get_item_list(cls):\\n if Item.__item_list is None:\\n Item.__item_list = []\\n return Item.__item_list\",\n \"def get_items(self):\\n return (item for item in self.items)\",\n \"def getitem(itemID):\\n\\n return harvest(GET_ITEM_URL, itemID)\",\n \"def test_vault_get_all_vault_items(self):\\n pass\",\n \"def todo_items(self, todo_list_id):\\n\\n self.endpoint = '{0}/{1}/todo_items.json'.format(self.endpoint, todo_list_id)\\n\\n request = self.get(self.construct_url())\\n\\n if request.status_code == 200:\\n return json.loads(request.content)\\n\\n raise BasecampAPIError(json.loads(request.content).get('error'))\",\n \"def getItemSellListings(itemId, allPages = False):\\n return Gw2Spidy._paginatedRequest(allPages, 'listings', str(itemId), 'sell')\",\n \"def _get_items_in_file(self, filename):\\n\\t\\treturn_list = []\\n\\t\\t\\t\\t\\n\\t\\tfor k in self.data.keys():\\n\\t\\t\\tfor item in self[k]:\\n\\t\\t\\t\\tif item['meta']['filename'] == filename:\\n\\t\\t\\t\\t\\treturn_list.append(item)\\n\\t\\treturn return_list\",\n \"def list(self, prefix=\\\"\\\"):\\n try:\\n list_rep = self.client.listdir(self.bucket + \\\"/\\\" + prefix)\\n for i in list_rep:\\n # Remove preceding bucket name and potential leading slash from returned key value\\n i = i.replace(self.bucket, \\\"\\\").replace('tar', 'wsp.sz')\\n if i[0] == '/': i = i[1:]\\n yield i\\n except pyhdfs.HdfsFileNotFoundException:\\n pass\",\n \"def get_items(self):\\n return self.order_items\",\n \"def items(self) -> List[Item]:\\n return self._items\",\n \"def disco_get_items(self,node,iq):\\n to=iq.get_to()\\n if to and to!=self.jid:\\n return iq.make_error_response(\\\"recipient-unavailable\\\")\\n if not node and self.disco_items:\\n return self.disco_items\\n return None\",\n \"def retrieve_all_files(service):\\r\\n result = []\\r\\n page_token = None\\r\\n while True:\\r\\n try:\\r\\n param = {}\\r\\n if page_token:\\r\\n param['pageToken'] = page_token\\r\\n files = service.files().list(**param).execute()\\r\\n\\r\\n result.extend(files['items'])\\r\\n page_token = files.get('nextPageToken')\\r\\n if not page_token:\\r\\n break\\r\\n except errors.HttpError, error:\\r\\n print 'An error occurred: %s' % error\\r\\n break\\r\\n return result\",\n \"def getItems(docs):\\n keys = []\\n for d in docs:\\n if d.teilenummer:\\n t_index = d.t_index or \\\"\\\"\\n keys.append((d.teilenummer, t_index))\\n items = []\\n if keys:\\n items = getObjectsByAttributePair(u\\\"teile_stamm\\\", u\\\"teilenummer\\\", u\\\"t_index\\\", keys, Item)\\n return items\",\n \"def retrieve_all_files(service):\\n\\n result = []\\n page_token = None\\n while True:\\n try:\\n param = {}\\n if page_token:\\n param['pageToken'] = page_token\\n files = service.files().list(**param).execute()\\n\\n result.extend(files['files'])\\n page_token = files.get('nextPageToken')\\n if not page_token:\\n break\\n except errors.HttpError as error:\\n print('An error occurred: %s' % error)\\n break\\n\\n return result\",\n \"def get_playlist_items(self):\\n results = self.API.playlist(self.playlist_uri)\\n return results[\\\"tracks\\\"][\\\"items\\\"]\",\n \"def items(self) -> List:\\n pass\",\n \"def items(self):\\n return self._get_storage().items()\",\n \"def items(request, pk):\\n\\n if Item.objects.filter(category_id=pk).exists(): # Checks if product_category exists with given id.\\n all_items = Item.objects.filter(category_id=pk)\\n else:\\n return Response(messages.ITEMS_DOES_NOT_EXIST, status=status.HTTP_404_NOT_FOUND)\\n if request.method == 'GET':\\n item_serializer = ItemSerializer(all_items, many=True)\\n return Response(item_serializer.data[::-1], status=status.HTTP_200_OK)\",\n \"def test_get_bucketlist_item_id(self):\\n resp = self.client.post('/bucketlists',\\n data=json.dumps(self.bucketlist),\\n content_type=\\\"application/json\\\", headers={\\n \\\"Authorization\\\": self.token\\n })\\n self.assertEqual(resp.status_code, 201)\\n resp_item = self.client.post('/bucketlistitems/1/items',\\n data=json.dumps(\\n {\\\"name\\\": \\\"visit the busy surburbs.\\\"}),\\n content_type=\\\"application/json\\\", headers={\\n \\\"Authorization\\\": self.token\\n })\\n self.assertEqual(resp.status_code, 201)\\n get_item = self.client.get('/bucketlistitems/1/items/1', headers={\\n \\\"Authorization\\\": self.token\\n })\\n self.assertEqual(resp.status_code, 201)\",\n \"def get_items(self, uri):\\n validation.check_uri(uri)\\n\\n uri_scheme = urllib.parse.urlparse(uri).scheme\\n backend = self.backends.with_playlists.get(uri_scheme, None)\\n\\n if not backend:\\n return None\\n\\n with _backend_error_handling(backend):\\n items = backend.playlists.get_items(uri).get()\\n items is None or validation.check_instances(items, Ref)\\n return items\\n\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7251653","0.62557507","0.61749214","0.61535305","0.60895795","0.60632527","0.60632527","0.6048731","0.5943761","0.5902527","0.58333397","0.5765952","0.5759044","0.5714463","0.5705385","0.56921226","0.56823844","0.5629779","0.56284565","0.56101763","0.5602424","0.5586271","0.5575947","0.55738974","0.5572214","0.55601877","0.55019975","0.54393137","0.5428818","0.54167616","0.5407168","0.5387581","0.5362177","0.5358282","0.53573084","0.53427744","0.5325471","0.5323655","0.52970153","0.5295022","0.5292356","0.5289676","0.5275625","0.5268551","0.52683216","0.52353173","0.52352464","0.5230103","0.5229682","0.5217699","0.520931","0.52035147","0.5200263","0.519525","0.5178269","0.5173905","0.51704","0.51466495","0.5140137","0.5113755","0.51121914","0.5110839","0.5109228","0.5099653","0.5099209","0.50982803","0.50920403","0.5084824","0.50813025","0.50786597","0.5077325","0.5071963","0.5052934","0.50496584","0.5037355","0.5031221","0.502794","0.5026785","0.5017619","0.50172216","0.50171787","0.50150114","0.49929267","0.49827746","0.498274","0.49822137","0.49777868","0.4965907","0.49652833","0.49572513","0.49561274","0.49530756","0.4949929","0.49413523","0.49393168","0.49279326","0.49170235","0.4916091","0.49149764","0.49135163"],"string":"[\n \"0.7251653\",\n \"0.62557507\",\n \"0.61749214\",\n \"0.61535305\",\n \"0.60895795\",\n \"0.60632527\",\n \"0.60632527\",\n \"0.6048731\",\n \"0.5943761\",\n \"0.5902527\",\n \"0.58333397\",\n \"0.5765952\",\n \"0.5759044\",\n \"0.5714463\",\n \"0.5705385\",\n \"0.56921226\",\n \"0.56823844\",\n \"0.5629779\",\n \"0.56284565\",\n \"0.56101763\",\n \"0.5602424\",\n \"0.5586271\",\n \"0.5575947\",\n \"0.55738974\",\n \"0.5572214\",\n \"0.55601877\",\n \"0.55019975\",\n \"0.54393137\",\n \"0.5428818\",\n \"0.54167616\",\n \"0.5407168\",\n \"0.5387581\",\n \"0.5362177\",\n \"0.5358282\",\n \"0.53573084\",\n \"0.53427744\",\n \"0.5325471\",\n \"0.5323655\",\n \"0.52970153\",\n \"0.5295022\",\n \"0.5292356\",\n \"0.5289676\",\n \"0.5275625\",\n \"0.5268551\",\n \"0.52683216\",\n \"0.52353173\",\n \"0.52352464\",\n \"0.5230103\",\n \"0.5229682\",\n \"0.5217699\",\n \"0.520931\",\n \"0.52035147\",\n \"0.5200263\",\n \"0.519525\",\n \"0.5178269\",\n \"0.5173905\",\n \"0.51704\",\n \"0.51466495\",\n \"0.5140137\",\n \"0.5113755\",\n \"0.51121914\",\n \"0.5110839\",\n \"0.5109228\",\n \"0.5099653\",\n \"0.5099209\",\n \"0.50982803\",\n \"0.50920403\",\n \"0.5084824\",\n \"0.50813025\",\n \"0.50786597\",\n \"0.5077325\",\n \"0.5071963\",\n \"0.5052934\",\n \"0.50496584\",\n \"0.5037355\",\n \"0.5031221\",\n \"0.502794\",\n \"0.5026785\",\n \"0.5017619\",\n \"0.50172216\",\n \"0.50171787\",\n \"0.50150114\",\n \"0.49929267\",\n \"0.49827746\",\n \"0.498274\",\n \"0.49822137\",\n \"0.49777868\",\n \"0.4965907\",\n \"0.49652833\",\n \"0.49572513\",\n \"0.49561274\",\n \"0.49530756\",\n \"0.4949929\",\n \"0.49413523\",\n \"0.49393168\",\n \"0.49279326\",\n \"0.49170235\",\n \"0.4916091\",\n \"0.49149764\",\n \"0.49135163\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6713535"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":80591,"cells":{"query":{"kind":"string","value":"Get entire put.io account and and save it to a dict called contents. This function will iterate over your entire put.io account and download all files. It saves the following attribuites to the"},"document":{"kind":"string","value":"def getAllItems(self):\r\n\r\n control = []\r\n\r\n for folder in self.get_items():\r\n control.append(folder.id)\r\n\r\n while len(control) > 0:\r\n try:\r\n for item in self.get_items(parent=control.pop()):\r\n print(\"Getting content for: \" + item.name)\r\n if item.type == \"folder\":\r\n control.insert(0,item.id)\r\n else:\r\n self.contents[item.id] = {\r\n 'name': item.name, 'parentID': item.parent_id,\r\n 'size': item.size, 'uri': item.download_url\r\n }\r\n except putio.PutioError as err:\r\n print(\"Can't get content for Directory\")\r\n pass\r\n return self.contents"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def download_output_files(self):\n bucket_list = self.bucket.list(\"output/part\")\n for bucket_entry in bucket_list:\n key_string = str(bucket_entry.key)\n # check if file exists locally, if not: download it\n if not os.path.exists(key_string):\n bucket_entry.get_contents_to_filename(\"../\" + key_string)\n else:\n print \"output file already exists, please delete\"","def download_files(self):","def download_all(): #@save\n for name in DATA_HUB:\n download(name)","def download_all(generate=False, reset=False, max_workers=5):\n\n logger.info('starting download for all properties')\n\n for row in db.con['gsc_properties'].all():\n download(row['account_name'], row['gsc_property'], reset=reset)\n\n logger.info('finished download for all properties')","def download_output(hpo_id, bucket):\n objs = hpo_ls(hpo_id, bucket)\n for obj in objs:\n scan_obj(obj)","def save_current_contents(url,update_file):\n r=requests.get(url)\n save_file=update_file+'.original'\n json.dump(r.json(), open(save_file,'w'))\n\n print \"\\nSaved contents of: \\n\\n\\t%s \\n\\nto \\n\\n\\t%s\\n\" % (url,save_file)","def download_keys(file, bucket, user_keys = None ,verbose = False):\n if user_keys is None:\n \t\t\t\ts3 = boto3.client('s3')\n else:\n s3 = boto3.client('s3', \n aws_access_key_id = user_keys[\"AWS_ACCESS_KEY_ID\"], \n aws_secret_access_key = user_keys[\"AWS_SECRET_ACCESS_KEY\"], \n region_name = user_keys[\"REGION_NAME\"]\n ) \n \n keys = get_s3_keys(bucket, user_keys = None)\n create_dirs(keys, file)\n \n for i,key in enumerate(keys):\n if verbose:\n print(key)\n try:\n # download as local file\n s3.download_file(bucket, key, os.path.join(file,key))\n except:\n \t\t\t\traise\n return print(\"{} files were downloaded!\".format(i))","def fetchPutIOFile(self, fileID=None, fileDir=None):\r\n\r\n sigkill = 0\r\n\r\n if fileID == None or fileDir == None:\r\n raise ValueError('You must send a putio item id and file path.')\r\n\r\n if not fileID in self.contents:\r\n self.getItem(fileID)\r\n\r\n fileName = self.contents[fileID]['name']\r\n\r\n print(\"Downloading file: \" + fileName)\r\n while 1:\r\n try:\r\n resp, data = self.h.request(self.contents[fileID]['uri'])\r\n if resp.status >= 400:\r\n print(\"We couldn't downlaod the file: \" + fileName)\r\n print(resp)\r\n else:\r\n with open(fileDir, 'wb') as file:\r\n file.write(data)\r\n break\r\n except httplib2.HttpLib2Error or httplib2.socket.error as err:\r\n print(\"Warning we had a httplib2 error... Trying again.\")\r\n print(str(err))\r\n if sigkill <= 3:\r\n sigkill += 1\r\n pass\r\n else:\r\n print(\"ERROR: We failed to fetch item 3 items. Fuck this.\")","def export_accounts(self):\n print('=== Exporting all account data...')\n\n for account in self.client.tenant.accounts:\n print('- Exporting account:', account.email)\n\n json = {\n 'id': self.get_id(account),\n 'href': account.href,\n 'username': account.username,\n 'email': account.email,\n 'fullName': account.full_name,\n 'givenName': account.given_name,\n 'middleName': account.middle_name,\n 'surname': account.surname,\n 'status': account.status,\n 'createdAt': account.created_at.isoformat(),\n 'modifiedAt': account.modified_at.isoformat(),\n 'customData': self.get_custom_data(account),\n 'groups': [],\n 'apiKeys': [],\n 'directory': {\n 'id': self.get_id(account.directory),\n 'href': account.directory.href,\n 'name': account.directory.name,\n 'description': account.directory.description,\n 'status': account.directory.status,\n 'createdAt': account.directory.created_at.isoformat(),\n 'modifiedAt': account.directory.modified_at.isoformat(),\n },\n }\n\n for api_key in account.api_keys:\n json['apiKeys'].append({\n 'href': api_key.href,\n 'id': api_key.id,\n 'secret': api_key.secret,\n #'createdAt': api_key.created_at.isoformat(),\n #'modifiedAt': api_key.modified_at.isoformat(),\n })\n\n for group in account.groups:\n json['groups'].append({\n 'id': self.get_id(group),\n 'href': group.href,\n 'name': group.name,\n 'description': group.description,\n 'status': group.status,\n 'createdAt': group.created_at.isoformat(),\n 'modifiedAt': group.modified_at.isoformat(),\n })\n\n tenant = self.get_id(self.client.tenant)\n self.write('%s/%s/accounts/%s' % (self.location, tenant, json['id']), json)\n\n print('=== Done!\\n')","def download_files(\n self, mcg_obj, awscli_pod, bucket_to_read, result_folder, s3_creds=None\n ):\n ns_bucket_path = f\"s3://{bucket_to_read}\"\n\n if s3_creds:\n # Read data directly from target bucket (uls) to result dir\n sync_object_directory(\n awscli_pod,\n ns_bucket_path,\n result_folder,\n signed_request_creds=s3_creds,\n )\n else:\n # Read data from NS bucket to result dir\n sync_object_directory(awscli_pod, ns_bucket_path, result_folder, mcg_obj)","def download_meta(self):\n for f in self._manager.remote.list_contents(\".yml\"):\n self._manager.remote.download(f)","def download_features():\r\n\twith open('places.json') as f:\r\n\t\tplaces = json.load(f)\r\n\r\n\tfor place in places.values():\r\n\t\tr = get_url('http://www.caiusjcr.org.uk/roomCaius/index.php?location={}'.format(place['name'].replace(' ', '%20')), allow_redirects=False)\r\n\r\n\t\twith open('dump/features/place-{}.html'.format(place['name']), 'w') as f:\r\n\t\t\tf.write(r.encode('utf8'))\r\n\r\n\t\tprint place['name']","def _write(self):\n raw_data = {'file_version': 1}\n raw_creds = []\n raw_data['data'] = raw_creds\n for (cred_key, cred) in self._data.items():\n raw_key = dict(cred_key)\n raw_cred = json.loads(cred.to_json())\n raw_creds.append({'key': raw_key, 'credential': raw_cred})\n self._locked_json_write(raw_data)","def download_key_files(request):\n\n workpath = os.path.dirname(os.path.abspath(__file__)) # Returns the Path your .py file is in\n path = os.path.join(workpath, './static/BioC/linking.key')\n path1 = os.path.join(workpath, './static/BioC/mention.key')\n ment = request.GET.get('type_key',None)\n if ment == 'mentions':\n path = open(path1, 'r')\n return HttpResponse(path, content_type='text/plain')\n elif ment == 'linking':\n path1 = open(path, 'r')\n return HttpResponse(path1, content_type='text/plain')","def download_json(self):\n # create directories for threads and images if they don't exist\n if not self.path.is_dir():\n self.path.mkdir(parents=True)\n if not self.images_path.is_dir():\n self.images_path.mkdir(parents=True)\n\n # open file, send request and write data to a file\n with self.file.open('w') as json_file:\n try:\n json_data = json.dumps(requests.get(self.endpoint).json())\n json_file.write(json_data)\n except json.JSONDecodeError as error:\n print(\"Error fetching json: \", error)","def fetch_pwc():\n for url in [\n \"https://production-media.paperswithcode.com/about/papers-with-abstracts.json.gz\",\n \"https://production-media.paperswithcode.com/about/links-between-papers-and-code.json.gz\",\n \"https://production-media.paperswithcode.com/about/evaluation-tables.json.gz\",\n \"https://production-media.paperswithcode.com/about/methods.json.gz\",\n \"https://production-media.paperswithcode.com/about/datasets.json.gz\",\n ]:\n logging.info(f\"Fetching and saving url {url}\")\n fetch_save(url)","def download_blob():\n r1 = requests.get(url + '/dog.json')\n dicta = r1.json()\n dictb = {}\n for i in range(len(dicta)):\n try:\n dictb[dicta[i]['category']].append(dicta[i]['name'])\n except KeyError:\n dictb[dicta[i]['category']] = []\n jdata = json.dumps(dictb)\n response = requests.put(url + '/category.json', jdata)","def download(self):\n\n with open(self.dataset_path) as dataset_file:\n dataset = json.load(dataset_file)\n\n path = \"\".join([POST_HIT_PATH, dataset[\"dataset\"][\"data_path\"]])\n if not os.path.exists(path):\n os.makedirs(path)\n\n protocole = dataset[\"dataset\"][\"protocole\"]\n\n download_links = []\n\n for resource in dataset[\"dataset\"][\"resources\"]:\n file_path = \"\".join([path, resource[\"filename\"]])\n\n #Check if the the download link has not been used before (One download link for all)\n if resource[\"download_link\"] not in download_links:\n \n print(\"DOWNLOADING : {}\".format(resource[\"filename\"]))\n f = urllib.request.urlopen(resource[\"download_link\"])\n data = f.read()\n with open(file_path, \"wb\") as donwload_file:\n donwload_file.write(data)\n\n download_links.append(resource[\"download_link\"])\n\n \n #Extract all files from the tar archives if necessary\n if tarfile.is_tarfile(file_path):\n tf = tarfile.open(file_path)\n tf.exractall()","def download(self, account, code):\n\n url = Spider.BASE_URL + \"/p/%s/?taken-by=%s\" % (code, account)\n r = self.session.get(url)\n content_match = re.search(r\"<script.*?>\\s*?window._sharedData\\s*?=\\s*?({.*}).*?</script>\", r.text,\n re.MULTILINE)\n data = json.loads(content_match.group(1))\n media = data['entry_data']['PostPage'][0]['graphql']['shortcode_media']\n download_urls = []\n if media['__typename'] == 'GraphVideo': # video\n download_urls.append(media[\"video_url\"])\n if media['__typename'] == 'GraphImage': # image\n download_urls.append(media[\"display_url\"])\n if media['__typename'] == 'GraphSidecar': # slide\n nodes = media['edge_sidecar_to_children']['edges']\n for node in nodes:\n node = node['node']\n if node['is_video']:\n download_urls.append(node['video_url'])\n else:\n download_urls.append(node['display_url'])\n\n actual_download_dir = os.path.join(download_dir, account)\n if not os.path.isdir(actual_download_dir):\n os.mkdir(actual_download_dir)\n for url in download_urls:\n filename = os.path.join(actual_download_dir, url.split('/')[-1].split('?')[0])\n temp_name = filename + '.tmp'\n if os.path.isfile(filename):\n if self.spider.auto_stop:\n print('file', filename, \"already exists, exiting......\")\n sys.exit()\n print('file', filename, \"already exists, skipping\")\n else:\n print('downloading %s:' % filename)\n r = self.session.get(url, stream=True)\n content_length = int(r.headers['content-length'])\n curr = 0\n with open(temp_name, 'wb') as f:\n for chunk in r.iter_content(chunk_size=1024):\n f.write(chunk)\n curr += 1024\n progress(curr, content_length)\n os.rename(temp_name, filename)\n self.spider.item_count += 1","async def download_files(self, download_path):\n\n async with vt.Client(self.apikey) as client:\n while True:\n file_hash = await self.queue.get()\n file_path = os.path.join(download_path, file_hash)\n with open(file_path, \"wb\") as f:\n await client.download_file_async(file_hash, f)\n self.queue.task_done()","def download_files(self) -> None:\n\n for name, url in self.files.items():\n print(f\"Download {name.split('/')[-1]}\")\n wget.download(url, os.path.join(\"data\", name))","def download_json(self):\n # make the path dir if it doesn't exist\n if not self.path.is_dir():\n self.path.mkdir(parents=True)\n\n # open a file, send a request for the json and write to the file\n with self.file.open('w') as json_file:\n try:\n json_data = json.dumps(requests.get(self.endpoint).json())\n json_file.write(json_data)\n except json.JSONDecodeError as error:\n print(\"Error fetching json: \", error)","def download_all(self):\r\n # Fetch website list\r\n self.fetch_website_list()\r\n\r\n for website in self.website_list:\r\n self.download(website['id'])","def download_all(self, to: str = None) -> Generator:\n\n for filename in self.list_files():\n yield (self.download(filename, to))","def data_pull_s3(self):\n year = self.month_year[0]\n month = self.month_year[1]\n self.s3 = boto3.resource('s3',aws_access_key_id=self.creds_data['key_id'],\n aws_secret_access_key=self.creds_data['key_access'])\n bucket = self.s3.Bucket('himatdata')\n home = os.getcwd()\n file_path = os.path.join(*[home, 'Trmm/', self.output_folder, year + '_' + month])\n print(file_path)\n if not os.path.exists(file_path):\n os.makedirs(file_path)\n for obj in bucket.objects.filter(Delimiter='', Prefix='Trmm/{}{}_{}'.format(self.output_folder, year, month)):\n if obj.key.endswith('.nc4'):\n bucket.download_file(obj.key,os.path.join(os.path.join(home, obj.key)))\n logging.info(\"Done with Year Month: %s\", month_year)","def download_keypair ( s3_infra_conn, aws_account_type, region_name, keypair_type ) :\n keypair_name = get_keypair_name( aws_account_type, region_name, keypair_type )\n keypair_bucket = get_admin_bucket_name( region_name = region_name )\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\n bucket_name = keypair_bucket,\n key_name = get_keypair_keypath( aws_account_type ) + get_keypair_keyname( keypair_name ),\n stored_filename = keypair_name )","def download(all):\n print(\"Downloading\")","def ExportToJson(self, filepath):\n accountinfo = json.dumps({DataConnection.accountName : self._accountName , \n DataConnection.accountKey : self._accountKey, \n DataConnection.accountKind : self._accountKind})\n encryptedinfo = Secrets._encryptContents(accountinfo)\n filehandle = open(filepath, 'wb')\n filehandle.write(encryptedinfo)\n print(\"Account info has been stored to '%s'\" % filepath)\n return True","def read_file(user_id, path):\n full_path = s3_path + f\"/users/{user_id}/\" + path\n list_of_files = bucket.objects.filter(Prefix=full_path)\n story_dict = {}\n for obj in list_of_files:\n key = obj.key\n body = obj.get()['Body'].read()\n last_part = key.split(\"/\")[-1]\n story_dict[last_part] = body.decode(\"utf-8\")\n return story_dict","def download_all_files(self):\n self.server_handler.get_sensor_data_from_server()","def fetch_save(url):\n\n name = url.split(\"/\")[-1]\n response = requests.get(url, stream=True)\n if response.status_code == 200:\n with open(f\"{DATA_PATH}/{name}\", \"wb\") as f:\n f.write(response.raw.read())\n else:\n logging.info(f\"Failed {url} download\")","def download(bucket, key):\n validate_bucket_name(bucket)\n validate_key_name(key)\n client = get_client()\n\n # do a buffered download\n bytes_io = io.BytesIO()\n client.download_fileobj(bucket, key, bytes_io)\n\n # hope that stuff is not too big, and just return content\n return bytes_io.getvalue()","def take_auth_data():\n home = str(Path.home())\n path_to_keys = '/Documents/twitter/keys/'\n\n files = [f for f in listdir(home+path_to_keys) if '.DS' not in f]\n\n tokens = []\n for f in files:\n with open(home+path_to_keys+f, 'r') as lines:\n ln = lines.readline().replace(\" \", \"\")\n tokens.append(ln)\n\n auth_data = dict(zip(files, tokens))\n return auth_data","def main():\n store = file.Storage('token.json')\n creds = store.get()\n if not creds or creds.invalid:\n flow = client.flow_from_clientsecrets('credentials.json', SCOPES)\n creds = tools.run_flow(flow, store)\n service = build('drive', 'v2', http=creds.authorize(Http()))\n files_list = print_files_in_folder(service,'1Xy6wJozhJwLcsKKfNYASxDxBBbEHZoNy')\n if len(files_list) > 0:\n download_files(service,files_list)\n else:\n print \"No files to download\"\n\n # Call the Drive v3 API\n # results = service.files().list(q=\"mimeType='application/vnd.google-apps.folder' and 'AviPics' in parents\",\n # pageSize=10, fields=\"nextPageToken, files(id, name)\").execute()\n # results = service.children.list(folderId='1Xy6wJozhJwLcsKKfNYASxDxBBbEHZoNy')\n # items = results.get('files', [])\n\n # if not items:\n # print('No files found.')\n # else:\n # print('Files:')\n # for item in items:\n # print('{0} ({1})'.format(item['name'], item['id']))","def download(self):\n #the link has some meta data in it that we need to get a hold of so we cant use metaData.getLink()\n data = None\n\n for link in self.metaData.jsonObj['links']:\n if link.get('rel') == \"content\":\n data = link\n\n assert data is not None\n\n response = self._adapter.getRequest(data['href'], self._baseHeader)\n return {\"filename\": data['title'], \"mime\": data['type'], \"binary\": response['Body'] }","def getAuthorizedKeysFiles(self, credentials):\n #pwent = self._userdb.getpwnam(credentials.username)\n #root = FilePath(pwent.pw_dir).child('.ssh')\n #files = ['authorized_keys', 'authorized_keys2']\n #return [root.child(f) for f in files]\n return self._files","def getKeys(name = None):\n if name == None:\n name = session.get('name')\n\n keys = hl.getUser(\"Name\",name)[\"Keys\"]\n hl.keyDistributeFlag(name)\n #If on a production server, use actual path\n if os.path.isdir(keys_dir):\n filename = keys_dir + keys + '.ovpn' \n\n #if not os.path.exists(filename):\n # hl.zipUserKeys(keys) \n\n return send_file(filename, as_attachment=True)\n #Else use relative dev path\n else:\n return send_file('static\\\\Test_client1.zip', as_attachment=True)","def fetch_file(index_file, filename):\n with open(index_file, 'r') as index, open(filename, 'w+') as download:\n print 'Fetching keys from ', KEYSERVER, ' to create ', filename\n fetched_file = ''\n index_length = len(index.readlines())\n index.seek(0) # because python is stupid\n counter = 0\n for key in index.readlines():\n print 'Fetching key ', counter, ' of ', index_length\n counter = counter + 1\n fetched_file = fetched_file + parse_key(key.rstrip('\\n'))\n print 'All keys have been downloaded'\n download.write(base64.b64decode(fetched_file))\n print 'File has been decoded and saved as ', filename","def download_models_and_data():\n\n for file in DATA_FILES:\n download_file(file[\"url\"], file[\"path\"])","def download_all_data(self) -> None:\n print(\"Download in progress.\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_CHARACTERS\"], \"nextcloud\")\n self.download_data(os.environ[\"NC_TOKEN_TRAIN_FRAGMENTS\"], \"nextcloud\")\n self.download_data(os.environ[\"HABBAKUK_URL\"], \"generic_url\")\n print(\"Download complete!\")","def download_from_blob():\n block_blob_service = BlockBlobService(account_name='project3twitter',\n account_key='<YOUR_ACCOUNT_KEY>')\n container_name = 'project3'\n block_blob_service.set_container_acl(container_name, public_access=PublicAccess.Container)\n\n # actual download\n block_blob_service.get_blob_to_path(container_name, 'word-count.txt', 'resource/word-count.txt')","def api_files():\n files = FileWrapper.get_files(g.user.id)\n return jsonify([f.serialize() for f in files])","def ListFiles(s3):\n response = s3.list_objects(Bucket='mynewbucket123')\n for content in response.get('Contents', []):\n yield content.get('Key')","def main():\n\n nfiles = asyncio.run(fetch_all())\n print(f\"{nfiles} file(s) saved\")","def save(cls, context):\n\n data = context.get_stored_dict()\n files = {}\n\n def save_in_file(file, key, value):\n if file in files.keys():\n files[file][key] = value\n else:\n files[file] = {key: value}\n\n for key, val in data.items():\n if context.extends is not None and key in context.key_origins:\n save_in_file(context.key_origins[key], key, val)\n else:\n save_in_file(context.profile, key, val)\n\n for profile, content in files.items():\n metadata.update_metadata(\n context.workspace,\n profile,\n 'config',\n content)","def main(transcribe_bucket_name, mp3_bucket_name):\n\n s3 = boto3.resource('s3')\n for bucket in s3.buckets.all():\n if bucket.name == transcribe_bucket_name:\n for key in bucket.objects.all():\n if key.key.endswith('.json'):\n r = {}\n # Get reference number\n reference = basename(key.key).replace('.json', '')\n r['ref'] = reference\n # Get URL\n location = boto3.client('s3') \\\n .get_bucket_location(\n Bucket=mp3_bucket_name)['LocationConstraint']\n base_url = join('https://s3-%s.amazonaws.com' % location,\n mp3_bucket_name)\n url = join(base_url, key.key.replace('.json', '.mp3'))\n r['url'] = url\n # Download json file\n try:\n s3.Bucket(transcribe_bucket_name) \\\n .download_file(key.key, key.key)\n except Exception as exception:\n return 1\n # Get text\n with open(key.key, 'r') as f:\n data = json.load(f)\n text = data['results']['transcripts'][0]['transcript']\n r['text'] = text\n # Get sentiment\n sentiment = get_sentiment(text)\n r['sentiment'] = sentiment\n # Check promotion\n promo = check_promo(text)\n r['promo'] = promo\n # Save to Gooogle Sheets\n values = [r['ref'], r['text'], r['promo'], r['sentiment'],\n r['url']]\n append_row(values)\n # Remove tmp json file from local machine\n remove(key.key)","def do_GET(self):\n f = self.send_head()\n if f:\n try:\n \n self.copyfile(f, self.wfile)\n finally:\n f.close()","def download_key_from_blob(self):\n source_blob_name = \"generated-keys/{}\".format(self.service_account_email)\n destination_name = self.service_account_email\n\n # generate destination folder and file if they do not yet exist\n Path(\"downloaded-key/\").mkdir(parents=True, exist_ok=True) # creates folder if not exists\n folder = Path(\"downloaded-key/\") # folder where all the newly generated keys go\n destination_file_name = folder / \"{}\".format(destination_name) # file named after service-account name\n destination_file_name.touch(exist_ok=True)\n\n # download the file and store it locally\n storage_client = storage.Client()\n bucket = storage_client.get_bucket(self.bucket_name)\n blob = bucket.blob(source_blob_name)\n blob.download_to_filename(destination_file_name)\n\n # prints source and destination indicating successful download\n print('Encrypted key downloaded to -----> \\n {}.'.format(\n source_blob_name,\n destination_file_name))\n\n return destination_file_name","def get_file_contents(self, key):\n f = open( os.path.join(self.file_path, '%s.xoj' % key))\n data = f.read()\n f.close()\n return data","def read_bucket_objects(bucket_name):\n s3 = boto3.resource('s3')\n bucket = s3.Bucket(bucket_name)\n for obj in bucket.objects.all():\n response = obj.get()\n body = response['Body'].read().decode('utf-8')\n print(body)","def pub_download(args, project=\"\", base_url=\"\", api_key=\"\"):\n project, base_url, api_key, updated = get_project_config(\n project=project, base_url=base_url, api_key=api_key)\n if updated:\n save_config()\n download_theme(args, base_url, api_key, prefix=project)","async def _download(self) -> None:\n\n # do request\n async with aiohttp.ClientSession() as session:\n async with session.get(self.url, auth=self._auth, timeout=self._timeout) as response:\n # check response\n if response.status == 200:\n # get data and return it\n self._buffer = await response.read()\n elif response.status == 401:\n log.error(\"Wrong credentials for downloading file.\")\n raise FileNotFoundError\n else:\n log.error(\"Could not download file from filecache.\")\n raise FileNotFoundError","def load_accounts():\n logger.info('Loading accounts...')\n with open(\"C:\\\\Users\\\\harun\\\\Desktop\\\\BigSwede-volume-bot\\\\keys.txt\") as f:\n for key in f:\n key = key.strip()\n address = web3.eth.account.from_key(key).address\n accounts.append((address, key))","def download_presentation(epObject, uc):\r\n fileDict = make_file_dict()\r\n fileDict = populate_file_dict(epObject, uc, fileDict)\r\n now = str(datetime.datetime.now().hour) + \\\r\n str(datetime.datetime.now().minute) + \\\r\n str(datetime.datetime.now().second)\r\n directoryName = epObject.Name.replace(\" \", \"\") + \"_presentation_\" + now\r\n os.mkdir(directoryName)\r\n os.chdir(directoryName)\r\n temp = tempfile.TemporaryFile()\r\n temp.write(urllib.request.urlopen(fileDict['pageUrls'][0]).read())\r\n temp.seek(0)\r\n update_page(temp, fileDict, \"index.html\", index=True)\r\n temp.close()\r\n os.mkdir(\"Pages\")\r\n os.chdir(\"Pages\")\r\n for (pageUrl, pageFileName) in zip(fileDict['pageUrls'][1:], \r\n fileDict['pageFileNames'][1:]):\r\n temp = tempfile.TemporaryFile()\r\n temp.write(urllib.request.urlopen(pageUrl).read())\r\n update_page(temp, fileDict, pageFileName)\r\n temp.close()\r\n os.chdir(\"../\")\r\n os.mkdir(\"Content\")\r\n os.chdir(\"Content\")\r\n for (fileUrl, fileId) in zip(fileDict['fileUrls'], fileDict['fileIds']):\r\n fileName = eportfolio.get_ep_object_properties(uc, fileId).\\\r\n FileName.strip()\r\n urllib.request.urlretrieve(fileUrl, fileName)\r\n os.chdir(\"../\")\r\n os.mkdir(\"Formatting\")\r\n os.chdir(\"Formatting\")\r\n for (cssUrl, cssFileName) in zip(fileDict['cssUrls'],\r\n fileDict['cssFileNames']):\r\n temp = tempfile.TemporaryFile()\r\n temp.write(urllib.request.urlopen(cssUrl).read())\r\n temp.seek(0)\r\n update_css_file(cssUrl, temp, cssFileName)\r\n temp.close()\r\n for imgUrl in fileDict['imgUrls']:\r\n fileName = imgUrl[imgUrl.rfind(\"/\"): ]\r\n if fileName.find(\"?\") > 0:\r\n fileName = fileName[: fileName.find(\"?\")]\r\n urllib.request.urlretrieve(imgUrl, fileName)\r\n os.chdir(\"../\")\r\n print(str(fileDict))\r\n return fileDict","def get_mail_docs_in_bucket():\n if BUCKET_ID not in settings.DOCUMENT_BUCKETS:\n raise ImproperlyConfigured(f'Bucket \"{BUCKET_ID}\" is missing in settings')\n\n config = settings.DOCUMENT_BUCKETS[BUCKET_ID]\n if 'bucket' not in config:\n raise ImproperlyConfigured(f'Bucket \"{BUCKET_ID}\" not configured properly in settings')\n\n name = config['bucket']\n if not name:\n raise ImproperlyConfigured(\n f'Bucket \"{BUCKET_ID}\" bucket value not configured properly in settings',\n )\n\n client = documents.get_s3_client_for_bucket(bucket_id=BUCKET_ID)\n\n paginator = client.get_paginator('list_objects')\n for page in paginator.paginate(Bucket=name):\n for doc in page.get('Contents') or []:\n key = doc['Key']\n with tempfile.TemporaryFile(mode='w+b') as f:\n client.download_fileobj(Bucket=name, Key=key, Fileobj=f)\n f.seek(0)\n content = f.read()\n yield {'source': key, 'content': content}","def _download(\n hostname,\n auth,\n infile,\n output_dir=\".\",\n show_progress=False,\n unpack_packages=True,\n delete_unpacked_packages=False,\n) -> Optional[Dict[str, Any]]:\n object_list = Manifest.load(Path(infile))\n if object_list is None:\n logger.critical(f\"Error loading {infile}\")\n return None\n try:\n auth.get_access_token()\n except Gen3AuthError:\n logger.critical(f\"Unable to authenticate your credentials with {hostname}\")\n return\n\n downloader = DownloadManager(\n hostname=hostname,\n auth=auth,\n download_list=object_list,\n show_progress=show_progress,\n )\n\n out_dir_path = ensure_dirpath_exists(Path(output_dir))\n return downloader.download(\n object_list,\n str(out_dir_path),\n show_progress=show_progress,\n unpack_packages=unpack_packages,\n delete_unpacked_packages=delete_unpacked_packages,\n )","def export_all_for_course(self, course_key, output_directory, assets_policy_file):\r\n policy = {}\r\n assets, __ = self.get_all_content_for_course(course_key)\r\n\r\n for asset in assets:\r\n asset_location = AssetLocation._from_deprecated_son(asset['_id'], course_key.run) # pylint: disable=protected-access\r\n self.export(asset_location, output_directory)\r\n for attr, value in asset.iteritems():\r\n if attr not in ['_id', 'md5', 'uploadDate', 'length', 'chunkSize']:\r\n policy.setdefault(asset_location.name, {})[attr] = value\r\n\r\n with open(assets_policy_file, 'w') as f:\r\n json.dump(policy, f)","def cloud_files(self, cloud_bucket_name: str, credentials: Mapping, files_to_upload: List, private: bool = True) -> Iterator[str]:","async def _get_data(self, ctx: Context):\n\n data = await self.config.user(ctx.author).all()\n\n data_json = json.dumps(data)\n\n file = text_to_file(data_json, filename=f\"{ctx.author.name.lower()}_brawlcord_data.json\")\n\n try:\n await ctx.author.send(file=file)\n except discord.Forbidden:\n await ctx.send(\"Unable to DM you.\")\n\n await ctx.send(\"Sent you the file!\")","def blobs(self):\n if not self._blobs:\n workspace = self.attributes.workspace\n # Instantiates a google client, & get all blobs in bucket\n storage_client = storage.Client(project=self._user_project)\n bucket = storage_client.bucket(workspace['bucketName'], user_project=self._user_project)\n # get subset of data\n _blobs = {}\n try:\n for b in bucket.list_blobs(fields='items(size, etag, crc32c, name, timeCreated),nextPageToken'):\n name = f\"gs://{workspace['bucketName']}/{b.name}\"\n # cache.put(name, {'size': b.size, 'etag': b.etag, 'crc32c': b.crc32c, 'time_created': b.time_created, 'name': name})\n _blobs[name] = AttrDict({'size': b.size, 'etag': b.etag, 'crc32c': b.crc32c, 'time_created': b.time_created, 'name': name})\n self._blobs = _blobs\n except Exception as e:\n print(f\"{self.id} {workspace['bucketName']} {e}\")\n self._blobs = _blobs\n return self._blobs","def read_url_all(url):\n\n\t\treturn write_file(read_url(url))","def download_file(self):\n files = self.s3_client.list_objects_v2(\n Bucket=settings.PRIVATE_DATA_BUCKET_NAME, Prefix=f\"{self.import_type}/\"\n )[\"Contents\"]\n\n latest_file_key = sorted(files, key=lambda f: f[\"LastModified\"])[0][\"Key\"]\n print(latest_file_key)\n file = Path(self.tmp_dir.name) / self.import_type / \"full.csv\"\n file.parent.mkdir(exist_ok=True, parents=True)\n self.file_path = file\n with file.open(\"wb\") as f:\n self.s3_client.download_fileobj(\n settings.PRIVATE_DATA_BUCKET_NAME, latest_file_key, f\n )","def download():\n toydata = requests.get(DATA_URL).json()\n return toydata","def json_file():\r\n urlretrieve(URL, PATH)\r\n return PATH","def json_file():\r\n urlretrieve(URL, PATH)\r\n return PATH","def download(self, key_name):\n #Flat structure for now\n fn = basename(key_name)\n\n key = self.bucket.get_key(key_name)\n md5 = key.etag[1 :-1]\n\n local_md5 = hashfile(fn, hashlib.md5())\n\n if not local_md5 == md5:\n key.get_contents_to_filename(fn)","def download_JSON(sets_to_reference):\n print(\"- Downloading data from MTGAJSON -\")\n for setname in tqdm(sets_to_reference) :\n r = requests.get('https://mtgjson.com/api/v5/'+ setname +'.json.zip')\n zipfile = ROOT_DIR + 'data/sets/' +setname +\".zip\"\n with open(zipfile, \"wb\") as data:\n data.write(r.content)\n with ZipFile(zipfile, 'r') as zipObj:\n # Extract all the contents of zip file in current directory\n zipObj.extractall(path=ROOT_DIR + 'data/sets/')\n ## If file exists, delete it ##\n if os.path.isfile(zipfile):\n os.remove(zipfile)\n else: ## Show an error ##\n print(\"Error: %s file not found\" % zipfile)","def fetch_zenodo(self):\n\n # retrieve content from URL\n try:\n logging.info(f\"Downloading example data from {self.url}\")\n r = requests.get(self.url, stream=True)\n with io.BytesIO() as stream:\n with tqdm.wrapattr(\n stream,\n 'write',\n file=sys.stdout,\n miniters=1,\n desc=self.url,\n total=int(r.headers.get('content-length', 0))\n ) as file:\n for chunk in r.iter_content(chunk_size=4096):\n file.write(chunk)\n with zipfile.ZipFile(stream) as zipped:\n # extract each file in the zipped dir to the project\n for f in zipped.namelist():\n logging.info(\"Unzipped: {}\".format(os.path.join(self.destination, f)))\n zipped.extract(f, self.destination)\n\n logging.info(\"Download and install complete.\")\n\n self.close_logger()\n\n except requests.exceptions.MissingSchema:\n msg = f\"Unable to download data from {self.url}\"\n logging.exception(msg)\n self.close_logger()\n raise","def get_data(keychain_file):\n\n keychain = Keychain(keychain_file)\n items = keychain.get_all()\n return items","def download_data(self, format = 'srt'):\n resp, content = httplib2.Http(\".cache\").request(self.url, \"GET\")\n suburl = json.loads(content)['url']\n resp, content = httplib2.Http(\".cache\").request(suburl, \"GET\")\n\n return content","def collect_data(url: str, channel: str, file_name: str):\n print(f\"Downloadng data : {channel}\")\n download(url)\n upload_to_s3(channel, file_name)\n print(f\"Finished downloadng data : {channel}\")","def read_and_save(res):\n fname = os.path.split(urlsplit(res.url).path)[-1]\n fpath = os.path.join(cfg.OUTPUT_DIR, fname)\n with open(fpath, 'wb') as f:\n for chunk in res.iter_content(cfg.CHUNK):\n f.write(chunk)","def list_bucket(self, bucket):\n self.response.write('Creating more files for listbucket...\\n')\n self.create_file(bucket + '/foo1')\n self.create_file(bucket + '/foo2')\n self.response.write('\\nListbucket result:\\n')\n\n page_size = 1\n stats = gcs.listbucket(bucket, max_keys=page_size)\n while True:\n count = 0\n for stat in stats:\n count += 1\n self.response.write(repr(stat))\n self.response.write('\\n')\n\n if count != page_size or count == 0:\n break\n last_filename = stat.filename[len(bucket) + 1:]\n stats = gcs.listbucket(bucket, max_keys=page_size, marker=last_filename)","def files():\n return get_cached(\"files.json\")","async def fetch_file_list(client, bucket) -> List:\n # pylint: disable=invalid-name\n PG_HOSTNAME = config('PG_HOSTNAME')\n PG_DATABASE = config('PG_DATABASE')\n folder = f'backup/{PG_HOSTNAME}_{PG_DATABASE}'\n result = await client.list_objects_v2(Bucket=bucket, Prefix=folder)\n contents = result.get('Contents', None)\n file_list = list([])\n if contents:\n for content in contents:\n file_list.append(content.get('Key'))\n return file_list","def download_archive(self):\n\n def time_convert(structure):\n \"\"\"\n :param structure: tuple representation of time\n :return: GitHub archive time\n \"\"\"\n \n \n join_number_to_zero = lambda number: (\"\" if number > 9 else \"0\") + str(number)\n\n return \"%s-%s-%s-%s\" % (\n structure.tm_year, join_number_to_zero(structure.tm_mon), join_number_to_zero(structure.tm_mday),\n structure.tm_hour)\n\n current_time = self.get_time()\n self.logger.debug(__name__ + \": \" + \"current time: \" + str(gmtime(current_time)))\n\n difference = -25200\n #timezone difference in seconds between GMT and west coast of USA\n\n downloading_time = int(timegm(self.config[\"last_connection_time\"])) + 3600\n self.logger.debug(__name__ + \": \" + \"downloading time: \" + str(gmtime(downloading_time)))\n\n if downloading_time > current_time - 7200:\n self.logger.info(__name__ + \": \" + \"unable to download file (time limiting).\")\n return\n\n downloading_time += difference\n\n json_file_name = self.download_file(time_convert(gmtime(downloading_time)))\n\n self.config[\"last_connection_time\"] = gmtime(downloading_time - difference)\n self.logger.debug(__name__ + \": \" + \"last_connection_time: \" + str(self.config[\"last_connection_time\"]))\n\n return json_file_name","def download (url):\n path, url = url\n r = requests.get (url, stream = True)\n content = r.text\n #print (content)\n with open (path + '.txt', 'w') as f:\n f.write (content)","def download_account_structure(ad_accounts: [adaccount.AdAccount]):\n db_name = Path('facebook-account-structure_{}.sqlite3'.format(OUTPUT_FILE_VERSION))\n filepath = ensure_data_directory(db_name)\n\n with sqlite3.connect(str(filepath)) as con:\n for ad_account in ad_accounts:\n for row in download_account_structure_per_account(ad_account):\n _upsert_account_structure(row, con)","def download_account_structure_per_account(ad_account: adaccount.AdAccount) \\\n -> Generator[List, None, None]:\n campaign_data = get_campaign_data(ad_account)\n ad_set_data = get_ad_set_data(ad_account)\n ad_data = get_ad_data(ad_account)\n\n for ad_id, ad in ad_data.items():\n ad_set_id = ad['ad_set_id']\n ad_set = ad_set_data[ad_set_id]\n campaign_id = ad_set['campaign_id']\n campaign = campaign_data[campaign_id]\n\n attributes = {**campaign['attributes'],\n **ad_set['attributes'],\n **ad['attributes']}\n\n row = [ad_id,\n ad['name'],\n ad_set_id,\n ad_set['name'],\n campaign_id,\n campaign['name'],\n ad_account['account_id'],\n ad_account['name'],\n json.dumps(attributes)]\n\n yield row","def download_file(client, file_id):\n\n file_content = client.file(file_id).content()\n print(file_content)","def __retrieve_from_bucket(fname):\n blob = BUCKET.blob(fname)\n json_data = json.loads(blob.download_as_string())\n return json_data","def download_files_in_drs_manifest(\n hostname,\n auth,\n infile,\n output_dir,\n show_progress=True,\n unpack_packages=True,\n delete_unpacked_packages=False,\n) -> None:\n _download(\n hostname,\n auth,\n infile,\n output_dir,\n show_progress,\n unpack_packages,\n delete_unpacked_packages,\n )","def get_file_contents(filename):\n try:\n with open(filename, 'r') as f:\n # It's assumed our file contains a single line,\n # with our API key\n return f.read().strip()\n except FileNotFoundError:\n print(\"'%s' file not found\" % filename)","async def get_entities(self, file=\"entities.json\"):\n g = Get(self.token)\n u = Utilities()\n\n api_link_dict = await u.get_api_root_response()\n entity_dict = {\"creation_time\": datetime.now(), \"data\": {}}\n\n for index, key in enumerate(api_link_dict):\n await g.get(key)\n entity_dict[\"data\"][key] = Get.entity_dict\n\n # Check if a file of the same name already exists\n try:\n open(file, \"x\")\n # Add a complain function/class to allow outputting warnings and errors to a log of some sort\n except:\n print(\"Warn: File already exists! Overwriting\")\n\n output = open(file, \"w\")\n json.dump(entity_dict, output, indent=2)\n output.close()","def list_bucket_files(project, bucket_name, referenced_files, verbose):\n if verbose:\n print(\"listing contents of bucket gs://\" + bucket_name)\n\n # set up storage client\n storage_client = storage.Client(project=project)\n\n # check if bucket exists\n try:\n bucket = storage_client.get_bucket(bucket_name)\n except:\n print(f'Bucket {bucket_name} does not exist!')\n exit(1)\n\n # Note: Client.list_bucket_files requires at least package version 1.17.0.\n blobs = storage_client.list_blobs(bucket_name)\n\n if verbose:\n print(\"finished listing bucket contents. processing files now in chunks of 1000.\")\n\n bucket_dict = dict()\n\n def extract_file_metadata(blob):\n blob_name = blob.name\n\n if blob_name.endswith('/'): # if this is a directory\n return None\n\n full_file_path = \"gs://\" + bucket_name + \"/\" + blob_name\n # support new submissions directory structure in Terra bucket\n submissions_dir = \"submissions\"\n if full_file_path.split('/', 4)[3] == submissions_dir:\n # new format is gs://bucket_id/submissions/submission_id/remaining_path\n submission_id = full_file_path.split('/', 5)[4]\n else:\n # old format is gs://bucket_id/submission_id/remaining_path\n # Splits the bucket file: \"gs://bucket_Id/submission_id/file_path\", by the '/' symbol\n # and stores values in a 5 length array: ['gs:', '' , 'bucket_Id', submission_id, file_path]\n # to extract the submission id from the 4th element (index 3) of the array\n submission_id = full_file_path.split('/', 4)[3]\n\n file_metadata = {\n \"file_name\": blob_name.split('/')[-1],\n \"file_path\": full_file_path,\n \"submission_id\": submission_id,\n \"size\": blob.size,\n \"is_in_data_table\": full_file_path in referenced_files,\n \"time_created\": blob.time_created\n }\n\n return file_metadata\n\n n_blobs = 0\n for page in blobs.pages: # iterating through pages is way faster than not\n if verbose:\n n_blobs += page.remaining\n print(f'...processing {n_blobs} blobs', end='\\r')\n for blob in page:\n file_metadata = extract_file_metadata(blob)\n if file_metadata:\n full_file_path = file_metadata['file_path']\n bucket_dict[full_file_path] = file_metadata\n\n if verbose:\n print(f'Found {len(bucket_dict)} files in bucket {bucket_name}')\n\n return bucket_dict","def downloadAll(self, force=False):\n if self.minutesSinceLastUpdate() == 0 and force == False:\n self.log(\"TOO SOON SINCE LAST DOWNLOAD!\")\n return\n for grabber in self.grabbers:\n self.downloadGrab(grabber[\"url\"], grabber[\"ID\"])+\"\\n\"","def download(url, bucket_id, key_prefix):\n\n baseFile = '_'.join(url.split('/')[-4:]) #os.path.basename(url)\n\n #move the file to a more uniq path\n os.umask(0002)\n temp_path = \"/tmp/\"\n file = os.path.join(temp_path,baseFile)\n bucket = conn.get_bucket(bucket_id)\n key = bucket.get_key(key_prefix + baseFile, validate=False)\n s3_exists = key.exists()\n file_exists = os.path.isfile(file)\n \n if not file_exists and s3_exists:\n sys.stderr.write(\"Downloading %s from S3\\n\"%url)\n key.get_contents_to_filename(file)\n sys.stderr.write(\"Downloaded %s from S3\\n\"%url)\n elif not file_exists and not s3_exists:\n sys.stderr.write(\"Downloading %s from the web\\n\"%url)\n try:\n req = urllib2.urlopen(url)\n total_size = int(req.info().getheader('Content-Length').strip())\n downloaded = 0\n CHUNK = 256 * 10240\n with open(file, 'wb') as fp:\n while True:\n chunk = req.read(CHUNK)\n downloaded += len(chunk)\n #print math.floor( (downloaded / total_size) * 100 )\n if not chunk: break\n fp.write(chunk)\n except urllib2.HTTPError, e:\n sys.stderr.write(\"HTTP Error: %s %s\\n\"%(e.code , url))\n return False\n except urllib2.URLError, e:\n sys.stderr.write(\"URL Error: %s %s\\n\"%(e.reason , url))\n return False\n sys.stderr.write(\"Downloaded %s from the web\\n\"%url)\n\n if not s3_exists:\n sys.stderr.write(\"Uploading %s to S3\\n\"%url)\n key.set_contents_from_filename(file)\n\n sys.stderr.write(\"File ready: %s\\n\"%url)\n return file","def convert_to_json(basepath, sendto):\n\n logger = logging.getLogger('WikiLog')\n\n k = bucket.new_key(basepath)\n\n filenames = []\n year = month = day = hrs = ''\n\n for key in bucket.list():\n thisfile = key.name.encode('utf-8')\n if 'projectviews' not in thisfile and 'sql' not in thisfile and '.gz' in thisfile and thisfile.startswith(basepath):\n # S3 key name is of the format kt-wiki/pageviews/2016/2016-06/pageviews-20160601-000000.gz\n # Split by / to get last element\n filenames.append(thisfile)\n logger.info(\"Processing file: {}\".format(thisfile))\n fname = thisfile.split('/')\n\n # Get content from filename and save to local\n # Split again to Grab year, month, day, hour value from filename\n key.get_contents_to_filename('/home/ubuntu/WikiView/data/' + fname[-1])\n fname1 = fname[-1]\n data_time = fname1[:-3].split('-')\n year, month, day, hrs = data_time[1][:4], data_time[1][4:6], data_time[1][-2:], data_time[-1]\n\n docname = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\n dictlist = []\n\n # save file from s3 to local, read, write to json, push json to s3\n with open(docname, 'w') as fp:\n #\n with gzip.open('/home/ubuntu/WikiView/data/'+fname[-1],'r') as fin:\n for line in fin:\n line = line.split(' ')\n doc = {}\n doc['ymdh'] = year + '-' + month + '-' + day + '-' + hrs\n try:\n # format: project, title, views, bytes ~ en Main_Page 242332 4737756101\n prj, title, vcount = line[0], line[1], line[2]\n doc['prj'] = prj\n doc['title'] = title\n doc['vcount'] = vcount\n json.dump(doc,fp)\n fp.write('\\n')\n except:\n logger.error('Error reading gzip file {} at line: {}'.format(thisfile, line))\n pass\n# sys.exc_clear()\n\n # Now, save the json file to \n key_name = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\n full_key_name = os.path.join(sendto, key_name)\n k = bucket.new_key(full_key_name)\n\n logger.info(\"Sending json file to S3: {}\".format(docname))\n k.set_contents_from_filename(key_name)\n\n # Remove temp file\n logger.info(\"Removing temp file: {} {}\".format('/home/ubuntu/WikiView/data/', fname[-1]))\n os.remove('/home/ubuntu/WikiView/data/'+fname[-1])\n logger.info(\"Removing temp file: {}\".format(key_name))\n os.remove(key_name)\n logger.info('Finished!!!')","def download_data(self):\r\n \r\n for file in self.__files:\r\n file_to_download = os.path.join(self.__folder, os.path.basename(file))\r\n if not os.path.isfile(file_to_download):\r\n self.__download_file(file)","async def async_download_object_manifest(\n commons_url,\n output_filename=\"object-manifest.csv\",\n num_processes=4,\n max_concurrent_requests=MAX_CONCURRENT_REQUESTS,\n):\n start_time = time.perf_counter()\n logging.info(f\"start time: {start_time}\")\n\n # ensure tmp directory exists and is empty\n os.makedirs(TMP_FOLDER, exist_ok=True)\n for file in os.listdir(TMP_FOLDER):\n file_path = os.path.join(TMP_FOLDER, file)\n if os.path.isfile(file_path):\n os.unlink(file_path)\n\n result = await _write_all_index_records_to_file(\n commons_url, output_filename, num_processes, max_concurrent_requests\n )\n\n end_time = time.perf_counter()\n logging.info(f\"end time: {end_time}\")\n logging.info(f\"run time: {end_time-start_time}\")","def downloadstackexchangefiles(configlist):\n for domainname in configlist:\n try:\n downloadurl = 'https://archive.org/download/stackexchange/'+domainname+'.stackexchange.com.7z'\n outputpath = '/Users/SG/Documents/DE2020/DataDirrectory/'+domainname+'.meta.stackexchange.7z'\n r=requests.get(downloadurl)\n if r == False:\n print('Response not received. Check your input.')\n continue\n #r = requests.get('https://archive.org/download/stackexchange/coffee.meta.stackexchange.com.7z')\n with open(outputpath,'wb') as f:\n for chunk in r.iter_content(chunk_size=8192):\n if chunk:\n f.write(chunk)\n print('Download finished for ',domainname)\n except Exception as e:\n print(e)\n return\n return","def s3_read_data(self):\n\n self.k.open()\n self.k.read()","def download_optional_inputs(flywheel_basedir, sub_dir, ses_dir, rootdir):\n print('Looking for manifest-defined anatomical files')\n t1_anat_dir = os.path.join(flywheel_basedir, 'input', 't1w_anatomy')\n if os.path.isdir(t1_anat_dir):\n t1_file = os.listdir(t1_anat_dir)\n if t1_file:\n t1_file = os.path.join(t1_anat_dir, t1_file[0])\n anat_dir = os.path.join(rootdir, sub_dir, ses_dir, 'anat')\n if not os.path.isdir(anat_dir):\n os.mkdir(anat_dir)\n dest_file = os.path.join(anat_dir, sub_dir + '_' + ses_dir + '_T1w.nii.gz')\n if os.path.exists(dest_file):\n print('Found downloaded T1 file - overwriting!')\n os.remove(dest_file)\n os.remove(dest_file.replace('.nii.gz', '.json'))\n shutil.copyfile(t1_file, dest_file)\n\n t2_anat_dir = os.path.join(flywheel_basedir, 'input', 't2w_anatomy')\n if os.path.isdir(t2_anat_dir):\n t2_file = os.listdir(t2_anat_dir)\n if t2_file:\n anat_dir = os.path.join(rootdir, sub_dir, ses_dir, 'anat')\n if not os.path.isdir(anat_dir):\n os.mkdir(anat_dir)\n t2_file = os.path.join(t2_anat_dir, t2_file[0])\n dest_file = os.path.join(anat_dir, sub_dir + '_' + ses_dir + '_T2w.nii.gz')\n if os.path.exists(dest_file):\n print('Found downloaded T2 file - overwriting!')\n os.remove(dest_file)\n os.remove(dest_file.replace('.nii.gz', '.json'))\n shutil.copyfile(t2_file, dest_file)","def fetch_the_data():\n subprocess.run([\"wget\", \"https://storage.googleapis.com/recipe-box/recipes_raw.zip\"])\n subprocess.run([\"unzip\", \"recipes_raw.zip\", \"-d\", RECIPES_DIRPATH])\n subprocess.run([\"rm\", \"recipes_raw.zip\"])","def do_GET(self):\n f = self.send_head()\n if f:\n try:\n self.copyfile(f, self.wfile)\n finally:\n f.close()","def download_hero_images(file_name, output_dir):\n with open(file_name,'r') as json_file:\n hero_json = json.load(json_file) \n try:\n os.mkdir(output_dir)\n except OSError:\n print (\"Failed to create directory %s\" % output_dir)\n return\n for hero in hero_json:\n print (\"Processing %s.\" % hero['name'])\n hero_dir = output_dir + '/' + str(hero['hero_id'])\n os.mkdir(hero_dir)\n urlr.urlretrieve(hero['img_url'], hero_dir + '/main.' + IMAGE_EXTENSION);\n urlr.urlretrieve(hero['portrait_img_url'], hero_dir + '/portrait.' + IMAGE_EXTENSION);\n\n for ability in hero['abilities']:\n ability_img = hero_dir + '/ability_' + str(ability['ability_id']) + '.' + IMAGE_EXTENSION\n urlr.urlretrieve(ability['img_url'], ability_img);","def __main():\n\n\n#Makes HTTP request to Google Drive API 'copy' method\n def copyFile(token, target_name):\n print(\"Access Token: \" + token)\n url_destino = \"https://www.googleapis.com/drive/v2/files/0AilPd9i9ydNTdFc4a2lvYmZnNkNzSU1kdVFZb0syN1E/copy\" \\\n \"?key=(YOUR_API_KEY provided by Google API Console)\"\n values = \"{'title': '%s'}\" % target_name\n data = values.encode('utf-8')\n request = urllib.request.Request(url_destino, data, method='POST')\n request.add_header(\"Authorization\", \"Bearer \" + token)\n request.add_header(\"Content-Length\", len(data))\n request.add_header(\"Content-Type\", \"application/json\")\n print(request.header_items())\n f = urllib.request.urlopen(request)\n print(f.read())\n\n#Makes HTTP request to Google Drive API 'list' files method\n def listFiles(token):\n print(\"Access Token: \" + token)\n url_destino = \"https://www.googleapis.com/drive/v2/files?key=(YOUR_API_KEY provided by Google API Console)\"\n request = urllib.request.Request(url_destino)\n request.add_header(\"Authorization\", \"Bearer \" + token)\n f = urllib.request.urlopen(request)\n print(f.read())\n\n\n oauth2 = OAuth2()\n token = oauth2.getAccessToken()\n if token == None:\n print(\"Input the following URL into your browser and access it!\")\n print(oauth2.getUrlForAuthCode())\n code = input(\"Paste the code ---> \")\n token = oauth2.getAccessToken(code)\n\n\n try:\n listFiles(token)\n except urllib.error.HTTPError as e:\n if e.code == 401:\n token = oauth2.refreshAccessToken()\n listFiles(token)\n else:\n print(e.code)\n\n\n try:\n copyFile(token, 'HiperAgenda_Copiada_3')\n except urllib.error.HTTPError as e:\n if e.code == 401:\n token = oauth2.refreshAccessToken()\n copyFile(token, 'HiperAgenda_Copiada')\n else:\n print(e.code)","def download_finish(self, cloud_file):","def sync_submission_files(self):\n blobs = GoogleStorage().list_blobs_with_prefix(self.bucket_name, 'submissions')\n\n for blob in blobs:\n destination_file_name = os.path.join(os.environ['PROJ_HOME'], blob.name)\n\n # Check if the local file exist before download file\n if not os.path.isfile(destination_file_name):\n blob.download_to_filename(destination_file_name)\n print('Downloaded file {destination_file_name}'.format(destination_file_name=destination_file_name))","def download_entities(self, download_parameters, progress=None):\n\n result_file_path = self.download_file(download_parameters, progress)\n result_file_type = ResultFileType.full_download \\\n if download_parameters.last_sync_time_in_utc is None \\\n else ResultFileType.partial_download\n with BulkFileReader(\n file_path=result_file_path,\n result_file_type=result_file_type,\n file_type=download_parameters.file_type,\n ) as reader:\n for entity in reader:\n yield entity"],"string":"[\n \"def download_output_files(self):\\n bucket_list = self.bucket.list(\\\"output/part\\\")\\n for bucket_entry in bucket_list:\\n key_string = str(bucket_entry.key)\\n # check if file exists locally, if not: download it\\n if not os.path.exists(key_string):\\n bucket_entry.get_contents_to_filename(\\\"../\\\" + key_string)\\n else:\\n print \\\"output file already exists, please delete\\\"\",\n \"def download_files(self):\",\n \"def download_all(): #@save\\n for name in DATA_HUB:\\n download(name)\",\n \"def download_all(generate=False, reset=False, max_workers=5):\\n\\n logger.info('starting download for all properties')\\n\\n for row in db.con['gsc_properties'].all():\\n download(row['account_name'], row['gsc_property'], reset=reset)\\n\\n logger.info('finished download for all properties')\",\n \"def download_output(hpo_id, bucket):\\n objs = hpo_ls(hpo_id, bucket)\\n for obj in objs:\\n scan_obj(obj)\",\n \"def save_current_contents(url,update_file):\\n r=requests.get(url)\\n save_file=update_file+'.original'\\n json.dump(r.json(), open(save_file,'w'))\\n\\n print \\\"\\\\nSaved contents of: \\\\n\\\\n\\\\t%s \\\\n\\\\nto \\\\n\\\\n\\\\t%s\\\\n\\\" % (url,save_file)\",\n \"def download_keys(file, bucket, user_keys = None ,verbose = False):\\n if user_keys is None:\\n \\t\\t\\t\\ts3 = boto3.client('s3')\\n else:\\n s3 = boto3.client('s3', \\n aws_access_key_id = user_keys[\\\"AWS_ACCESS_KEY_ID\\\"], \\n aws_secret_access_key = user_keys[\\\"AWS_SECRET_ACCESS_KEY\\\"], \\n region_name = user_keys[\\\"REGION_NAME\\\"]\\n ) \\n \\n keys = get_s3_keys(bucket, user_keys = None)\\n create_dirs(keys, file)\\n \\n for i,key in enumerate(keys):\\n if verbose:\\n print(key)\\n try:\\n # download as local file\\n s3.download_file(bucket, key, os.path.join(file,key))\\n except:\\n \\t\\t\\t\\traise\\n return print(\\\"{} files were downloaded!\\\".format(i))\",\n \"def fetchPutIOFile(self, fileID=None, fileDir=None):\\r\\n\\r\\n sigkill = 0\\r\\n\\r\\n if fileID == None or fileDir == None:\\r\\n raise ValueError('You must send a putio item id and file path.')\\r\\n\\r\\n if not fileID in self.contents:\\r\\n self.getItem(fileID)\\r\\n\\r\\n fileName = self.contents[fileID]['name']\\r\\n\\r\\n print(\\\"Downloading file: \\\" + fileName)\\r\\n while 1:\\r\\n try:\\r\\n resp, data = self.h.request(self.contents[fileID]['uri'])\\r\\n if resp.status >= 400:\\r\\n print(\\\"We couldn't downlaod the file: \\\" + fileName)\\r\\n print(resp)\\r\\n else:\\r\\n with open(fileDir, 'wb') as file:\\r\\n file.write(data)\\r\\n break\\r\\n except httplib2.HttpLib2Error or httplib2.socket.error as err:\\r\\n print(\\\"Warning we had a httplib2 error... Trying again.\\\")\\r\\n print(str(err))\\r\\n if sigkill <= 3:\\r\\n sigkill += 1\\r\\n pass\\r\\n else:\\r\\n print(\\\"ERROR: We failed to fetch item 3 items. Fuck this.\\\")\",\n \"def export_accounts(self):\\n print('=== Exporting all account data...')\\n\\n for account in self.client.tenant.accounts:\\n print('- Exporting account:', account.email)\\n\\n json = {\\n 'id': self.get_id(account),\\n 'href': account.href,\\n 'username': account.username,\\n 'email': account.email,\\n 'fullName': account.full_name,\\n 'givenName': account.given_name,\\n 'middleName': account.middle_name,\\n 'surname': account.surname,\\n 'status': account.status,\\n 'createdAt': account.created_at.isoformat(),\\n 'modifiedAt': account.modified_at.isoformat(),\\n 'customData': self.get_custom_data(account),\\n 'groups': [],\\n 'apiKeys': [],\\n 'directory': {\\n 'id': self.get_id(account.directory),\\n 'href': account.directory.href,\\n 'name': account.directory.name,\\n 'description': account.directory.description,\\n 'status': account.directory.status,\\n 'createdAt': account.directory.created_at.isoformat(),\\n 'modifiedAt': account.directory.modified_at.isoformat(),\\n },\\n }\\n\\n for api_key in account.api_keys:\\n json['apiKeys'].append({\\n 'href': api_key.href,\\n 'id': api_key.id,\\n 'secret': api_key.secret,\\n #'createdAt': api_key.created_at.isoformat(),\\n #'modifiedAt': api_key.modified_at.isoformat(),\\n })\\n\\n for group in account.groups:\\n json['groups'].append({\\n 'id': self.get_id(group),\\n 'href': group.href,\\n 'name': group.name,\\n 'description': group.description,\\n 'status': group.status,\\n 'createdAt': group.created_at.isoformat(),\\n 'modifiedAt': group.modified_at.isoformat(),\\n })\\n\\n tenant = self.get_id(self.client.tenant)\\n self.write('%s/%s/accounts/%s' % (self.location, tenant, json['id']), json)\\n\\n print('=== Done!\\\\n')\",\n \"def download_files(\\n self, mcg_obj, awscli_pod, bucket_to_read, result_folder, s3_creds=None\\n ):\\n ns_bucket_path = f\\\"s3://{bucket_to_read}\\\"\\n\\n if s3_creds:\\n # Read data directly from target bucket (uls) to result dir\\n sync_object_directory(\\n awscli_pod,\\n ns_bucket_path,\\n result_folder,\\n signed_request_creds=s3_creds,\\n )\\n else:\\n # Read data from NS bucket to result dir\\n sync_object_directory(awscli_pod, ns_bucket_path, result_folder, mcg_obj)\",\n \"def download_meta(self):\\n for f in self._manager.remote.list_contents(\\\".yml\\\"):\\n self._manager.remote.download(f)\",\n \"def download_features():\\r\\n\\twith open('places.json') as f:\\r\\n\\t\\tplaces = json.load(f)\\r\\n\\r\\n\\tfor place in places.values():\\r\\n\\t\\tr = get_url('http://www.caiusjcr.org.uk/roomCaius/index.php?location={}'.format(place['name'].replace(' ', '%20')), allow_redirects=False)\\r\\n\\r\\n\\t\\twith open('dump/features/place-{}.html'.format(place['name']), 'w') as f:\\r\\n\\t\\t\\tf.write(r.encode('utf8'))\\r\\n\\r\\n\\t\\tprint place['name']\",\n \"def _write(self):\\n raw_data = {'file_version': 1}\\n raw_creds = []\\n raw_data['data'] = raw_creds\\n for (cred_key, cred) in self._data.items():\\n raw_key = dict(cred_key)\\n raw_cred = json.loads(cred.to_json())\\n raw_creds.append({'key': raw_key, 'credential': raw_cred})\\n self._locked_json_write(raw_data)\",\n \"def download_key_files(request):\\n\\n workpath = os.path.dirname(os.path.abspath(__file__)) # Returns the Path your .py file is in\\n path = os.path.join(workpath, './static/BioC/linking.key')\\n path1 = os.path.join(workpath, './static/BioC/mention.key')\\n ment = request.GET.get('type_key',None)\\n if ment == 'mentions':\\n path = open(path1, 'r')\\n return HttpResponse(path, content_type='text/plain')\\n elif ment == 'linking':\\n path1 = open(path, 'r')\\n return HttpResponse(path1, content_type='text/plain')\",\n \"def download_json(self):\\n # create directories for threads and images if they don't exist\\n if not self.path.is_dir():\\n self.path.mkdir(parents=True)\\n if not self.images_path.is_dir():\\n self.images_path.mkdir(parents=True)\\n\\n # open file, send request and write data to a file\\n with self.file.open('w') as json_file:\\n try:\\n json_data = json.dumps(requests.get(self.endpoint).json())\\n json_file.write(json_data)\\n except json.JSONDecodeError as error:\\n print(\\\"Error fetching json: \\\", error)\",\n \"def fetch_pwc():\\n for url in [\\n \\\"https://production-media.paperswithcode.com/about/papers-with-abstracts.json.gz\\\",\\n \\\"https://production-media.paperswithcode.com/about/links-between-papers-and-code.json.gz\\\",\\n \\\"https://production-media.paperswithcode.com/about/evaluation-tables.json.gz\\\",\\n \\\"https://production-media.paperswithcode.com/about/methods.json.gz\\\",\\n \\\"https://production-media.paperswithcode.com/about/datasets.json.gz\\\",\\n ]:\\n logging.info(f\\\"Fetching and saving url {url}\\\")\\n fetch_save(url)\",\n \"def download_blob():\\n r1 = requests.get(url + '/dog.json')\\n dicta = r1.json()\\n dictb = {}\\n for i in range(len(dicta)):\\n try:\\n dictb[dicta[i]['category']].append(dicta[i]['name'])\\n except KeyError:\\n dictb[dicta[i]['category']] = []\\n jdata = json.dumps(dictb)\\n response = requests.put(url + '/category.json', jdata)\",\n \"def download(self):\\n\\n with open(self.dataset_path) as dataset_file:\\n dataset = json.load(dataset_file)\\n\\n path = \\\"\\\".join([POST_HIT_PATH, dataset[\\\"dataset\\\"][\\\"data_path\\\"]])\\n if not os.path.exists(path):\\n os.makedirs(path)\\n\\n protocole = dataset[\\\"dataset\\\"][\\\"protocole\\\"]\\n\\n download_links = []\\n\\n for resource in dataset[\\\"dataset\\\"][\\\"resources\\\"]:\\n file_path = \\\"\\\".join([path, resource[\\\"filename\\\"]])\\n\\n #Check if the the download link has not been used before (One download link for all)\\n if resource[\\\"download_link\\\"] not in download_links:\\n \\n print(\\\"DOWNLOADING : {}\\\".format(resource[\\\"filename\\\"]))\\n f = urllib.request.urlopen(resource[\\\"download_link\\\"])\\n data = f.read()\\n with open(file_path, \\\"wb\\\") as donwload_file:\\n donwload_file.write(data)\\n\\n download_links.append(resource[\\\"download_link\\\"])\\n\\n \\n #Extract all files from the tar archives if necessary\\n if tarfile.is_tarfile(file_path):\\n tf = tarfile.open(file_path)\\n tf.exractall()\",\n \"def download(self, account, code):\\n\\n url = Spider.BASE_URL + \\\"/p/%s/?taken-by=%s\\\" % (code, account)\\n r = self.session.get(url)\\n content_match = re.search(r\\\"<script.*?>\\\\s*?window._sharedData\\\\s*?=\\\\s*?({.*}).*?</script>\\\", r.text,\\n re.MULTILINE)\\n data = json.loads(content_match.group(1))\\n media = data['entry_data']['PostPage'][0]['graphql']['shortcode_media']\\n download_urls = []\\n if media['__typename'] == 'GraphVideo': # video\\n download_urls.append(media[\\\"video_url\\\"])\\n if media['__typename'] == 'GraphImage': # image\\n download_urls.append(media[\\\"display_url\\\"])\\n if media['__typename'] == 'GraphSidecar': # slide\\n nodes = media['edge_sidecar_to_children']['edges']\\n for node in nodes:\\n node = node['node']\\n if node['is_video']:\\n download_urls.append(node['video_url'])\\n else:\\n download_urls.append(node['display_url'])\\n\\n actual_download_dir = os.path.join(download_dir, account)\\n if not os.path.isdir(actual_download_dir):\\n os.mkdir(actual_download_dir)\\n for url in download_urls:\\n filename = os.path.join(actual_download_dir, url.split('/')[-1].split('?')[0])\\n temp_name = filename + '.tmp'\\n if os.path.isfile(filename):\\n if self.spider.auto_stop:\\n print('file', filename, \\\"already exists, exiting......\\\")\\n sys.exit()\\n print('file', filename, \\\"already exists, skipping\\\")\\n else:\\n print('downloading %s:' % filename)\\n r = self.session.get(url, stream=True)\\n content_length = int(r.headers['content-length'])\\n curr = 0\\n with open(temp_name, 'wb') as f:\\n for chunk in r.iter_content(chunk_size=1024):\\n f.write(chunk)\\n curr += 1024\\n progress(curr, content_length)\\n os.rename(temp_name, filename)\\n self.spider.item_count += 1\",\n \"async def download_files(self, download_path):\\n\\n async with vt.Client(self.apikey) as client:\\n while True:\\n file_hash = await self.queue.get()\\n file_path = os.path.join(download_path, file_hash)\\n with open(file_path, \\\"wb\\\") as f:\\n await client.download_file_async(file_hash, f)\\n self.queue.task_done()\",\n \"def download_files(self) -> None:\\n\\n for name, url in self.files.items():\\n print(f\\\"Download {name.split('/')[-1]}\\\")\\n wget.download(url, os.path.join(\\\"data\\\", name))\",\n \"def download_json(self):\\n # make the path dir if it doesn't exist\\n if not self.path.is_dir():\\n self.path.mkdir(parents=True)\\n\\n # open a file, send a request for the json and write to the file\\n with self.file.open('w') as json_file:\\n try:\\n json_data = json.dumps(requests.get(self.endpoint).json())\\n json_file.write(json_data)\\n except json.JSONDecodeError as error:\\n print(\\\"Error fetching json: \\\", error)\",\n \"def download_all(self):\\r\\n # Fetch website list\\r\\n self.fetch_website_list()\\r\\n\\r\\n for website in self.website_list:\\r\\n self.download(website['id'])\",\n \"def download_all(self, to: str = None) -> Generator:\\n\\n for filename in self.list_files():\\n yield (self.download(filename, to))\",\n \"def data_pull_s3(self):\\n year = self.month_year[0]\\n month = self.month_year[1]\\n self.s3 = boto3.resource('s3',aws_access_key_id=self.creds_data['key_id'],\\n aws_secret_access_key=self.creds_data['key_access'])\\n bucket = self.s3.Bucket('himatdata')\\n home = os.getcwd()\\n file_path = os.path.join(*[home, 'Trmm/', self.output_folder, year + '_' + month])\\n print(file_path)\\n if not os.path.exists(file_path):\\n os.makedirs(file_path)\\n for obj in bucket.objects.filter(Delimiter='', Prefix='Trmm/{}{}_{}'.format(self.output_folder, year, month)):\\n if obj.key.endswith('.nc4'):\\n bucket.download_file(obj.key,os.path.join(os.path.join(home, obj.key)))\\n logging.info(\\\"Done with Year Month: %s\\\", month_year)\",\n \"def download_keypair ( s3_infra_conn, aws_account_type, region_name, keypair_type ) :\\n keypair_name = get_keypair_name( aws_account_type, region_name, keypair_type )\\n keypair_bucket = get_admin_bucket_name( region_name = region_name )\\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\\n bucket_name = keypair_bucket,\\n key_name = get_keypair_keypath( aws_account_type ) + get_keypair_keyname( keypair_name ),\\n stored_filename = keypair_name )\",\n \"def download(all):\\n print(\\\"Downloading\\\")\",\n \"def ExportToJson(self, filepath):\\n accountinfo = json.dumps({DataConnection.accountName : self._accountName , \\n DataConnection.accountKey : self._accountKey, \\n DataConnection.accountKind : self._accountKind})\\n encryptedinfo = Secrets._encryptContents(accountinfo)\\n filehandle = open(filepath, 'wb')\\n filehandle.write(encryptedinfo)\\n print(\\\"Account info has been stored to '%s'\\\" % filepath)\\n return True\",\n \"def read_file(user_id, path):\\n full_path = s3_path + f\\\"/users/{user_id}/\\\" + path\\n list_of_files = bucket.objects.filter(Prefix=full_path)\\n story_dict = {}\\n for obj in list_of_files:\\n key = obj.key\\n body = obj.get()['Body'].read()\\n last_part = key.split(\\\"/\\\")[-1]\\n story_dict[last_part] = body.decode(\\\"utf-8\\\")\\n return story_dict\",\n \"def download_all_files(self):\\n self.server_handler.get_sensor_data_from_server()\",\n \"def fetch_save(url):\\n\\n name = url.split(\\\"/\\\")[-1]\\n response = requests.get(url, stream=True)\\n if response.status_code == 200:\\n with open(f\\\"{DATA_PATH}/{name}\\\", \\\"wb\\\") as f:\\n f.write(response.raw.read())\\n else:\\n logging.info(f\\\"Failed {url} download\\\")\",\n \"def download(bucket, key):\\n validate_bucket_name(bucket)\\n validate_key_name(key)\\n client = get_client()\\n\\n # do a buffered download\\n bytes_io = io.BytesIO()\\n client.download_fileobj(bucket, key, bytes_io)\\n\\n # hope that stuff is not too big, and just return content\\n return bytes_io.getvalue()\",\n \"def take_auth_data():\\n home = str(Path.home())\\n path_to_keys = '/Documents/twitter/keys/'\\n\\n files = [f for f in listdir(home+path_to_keys) if '.DS' not in f]\\n\\n tokens = []\\n for f in files:\\n with open(home+path_to_keys+f, 'r') as lines:\\n ln = lines.readline().replace(\\\" \\\", \\\"\\\")\\n tokens.append(ln)\\n\\n auth_data = dict(zip(files, tokens))\\n return auth_data\",\n \"def main():\\n store = file.Storage('token.json')\\n creds = store.get()\\n if not creds or creds.invalid:\\n flow = client.flow_from_clientsecrets('credentials.json', SCOPES)\\n creds = tools.run_flow(flow, store)\\n service = build('drive', 'v2', http=creds.authorize(Http()))\\n files_list = print_files_in_folder(service,'1Xy6wJozhJwLcsKKfNYASxDxBBbEHZoNy')\\n if len(files_list) > 0:\\n download_files(service,files_list)\\n else:\\n print \\\"No files to download\\\"\\n\\n # Call the Drive v3 API\\n # results = service.files().list(q=\\\"mimeType='application/vnd.google-apps.folder' and 'AviPics' in parents\\\",\\n # pageSize=10, fields=\\\"nextPageToken, files(id, name)\\\").execute()\\n # results = service.children.list(folderId='1Xy6wJozhJwLcsKKfNYASxDxBBbEHZoNy')\\n # items = results.get('files', [])\\n\\n # if not items:\\n # print('No files found.')\\n # else:\\n # print('Files:')\\n # for item in items:\\n # print('{0} ({1})'.format(item['name'], item['id']))\",\n \"def download(self):\\n #the link has some meta data in it that we need to get a hold of so we cant use metaData.getLink()\\n data = None\\n\\n for link in self.metaData.jsonObj['links']:\\n if link.get('rel') == \\\"content\\\":\\n data = link\\n\\n assert data is not None\\n\\n response = self._adapter.getRequest(data['href'], self._baseHeader)\\n return {\\\"filename\\\": data['title'], \\\"mime\\\": data['type'], \\\"binary\\\": response['Body'] }\",\n \"def getAuthorizedKeysFiles(self, credentials):\\n #pwent = self._userdb.getpwnam(credentials.username)\\n #root = FilePath(pwent.pw_dir).child('.ssh')\\n #files = ['authorized_keys', 'authorized_keys2']\\n #return [root.child(f) for f in files]\\n return self._files\",\n \"def getKeys(name = None):\\n if name == None:\\n name = session.get('name')\\n\\n keys = hl.getUser(\\\"Name\\\",name)[\\\"Keys\\\"]\\n hl.keyDistributeFlag(name)\\n #If on a production server, use actual path\\n if os.path.isdir(keys_dir):\\n filename = keys_dir + keys + '.ovpn' \\n\\n #if not os.path.exists(filename):\\n # hl.zipUserKeys(keys) \\n\\n return send_file(filename, as_attachment=True)\\n #Else use relative dev path\\n else:\\n return send_file('static\\\\\\\\Test_client1.zip', as_attachment=True)\",\n \"def fetch_file(index_file, filename):\\n with open(index_file, 'r') as index, open(filename, 'w+') as download:\\n print 'Fetching keys from ', KEYSERVER, ' to create ', filename\\n fetched_file = ''\\n index_length = len(index.readlines())\\n index.seek(0) # because python is stupid\\n counter = 0\\n for key in index.readlines():\\n print 'Fetching key ', counter, ' of ', index_length\\n counter = counter + 1\\n fetched_file = fetched_file + parse_key(key.rstrip('\\\\n'))\\n print 'All keys have been downloaded'\\n download.write(base64.b64decode(fetched_file))\\n print 'File has been decoded and saved as ', filename\",\n \"def download_models_and_data():\\n\\n for file in DATA_FILES:\\n download_file(file[\\\"url\\\"], file[\\\"path\\\"])\",\n \"def download_all_data(self) -> None:\\n print(\\\"Download in progress.\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_CHARACTERS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"NC_TOKEN_TRAIN_FRAGMENTS\\\"], \\\"nextcloud\\\")\\n self.download_data(os.environ[\\\"HABBAKUK_URL\\\"], \\\"generic_url\\\")\\n print(\\\"Download complete!\\\")\",\n \"def download_from_blob():\\n block_blob_service = BlockBlobService(account_name='project3twitter',\\n account_key='<YOUR_ACCOUNT_KEY>')\\n container_name = 'project3'\\n block_blob_service.set_container_acl(container_name, public_access=PublicAccess.Container)\\n\\n # actual download\\n block_blob_service.get_blob_to_path(container_name, 'word-count.txt', 'resource/word-count.txt')\",\n \"def api_files():\\n files = FileWrapper.get_files(g.user.id)\\n return jsonify([f.serialize() for f in files])\",\n \"def ListFiles(s3):\\n response = s3.list_objects(Bucket='mynewbucket123')\\n for content in response.get('Contents', []):\\n yield content.get('Key')\",\n \"def main():\\n\\n nfiles = asyncio.run(fetch_all())\\n print(f\\\"{nfiles} file(s) saved\\\")\",\n \"def save(cls, context):\\n\\n data = context.get_stored_dict()\\n files = {}\\n\\n def save_in_file(file, key, value):\\n if file in files.keys():\\n files[file][key] = value\\n else:\\n files[file] = {key: value}\\n\\n for key, val in data.items():\\n if context.extends is not None and key in context.key_origins:\\n save_in_file(context.key_origins[key], key, val)\\n else:\\n save_in_file(context.profile, key, val)\\n\\n for profile, content in files.items():\\n metadata.update_metadata(\\n context.workspace,\\n profile,\\n 'config',\\n content)\",\n \"def main(transcribe_bucket_name, mp3_bucket_name):\\n\\n s3 = boto3.resource('s3')\\n for bucket in s3.buckets.all():\\n if bucket.name == transcribe_bucket_name:\\n for key in bucket.objects.all():\\n if key.key.endswith('.json'):\\n r = {}\\n # Get reference number\\n reference = basename(key.key).replace('.json', '')\\n r['ref'] = reference\\n # Get URL\\n location = boto3.client('s3') \\\\\\n .get_bucket_location(\\n Bucket=mp3_bucket_name)['LocationConstraint']\\n base_url = join('https://s3-%s.amazonaws.com' % location,\\n mp3_bucket_name)\\n url = join(base_url, key.key.replace('.json', '.mp3'))\\n r['url'] = url\\n # Download json file\\n try:\\n s3.Bucket(transcribe_bucket_name) \\\\\\n .download_file(key.key, key.key)\\n except Exception as exception:\\n return 1\\n # Get text\\n with open(key.key, 'r') as f:\\n data = json.load(f)\\n text = data['results']['transcripts'][0]['transcript']\\n r['text'] = text\\n # Get sentiment\\n sentiment = get_sentiment(text)\\n r['sentiment'] = sentiment\\n # Check promotion\\n promo = check_promo(text)\\n r['promo'] = promo\\n # Save to Gooogle Sheets\\n values = [r['ref'], r['text'], r['promo'], r['sentiment'],\\n r['url']]\\n append_row(values)\\n # Remove tmp json file from local machine\\n remove(key.key)\",\n \"def do_GET(self):\\n f = self.send_head()\\n if f:\\n try:\\n \\n self.copyfile(f, self.wfile)\\n finally:\\n f.close()\",\n \"def download_key_from_blob(self):\\n source_blob_name = \\\"generated-keys/{}\\\".format(self.service_account_email)\\n destination_name = self.service_account_email\\n\\n # generate destination folder and file if they do not yet exist\\n Path(\\\"downloaded-key/\\\").mkdir(parents=True, exist_ok=True) # creates folder if not exists\\n folder = Path(\\\"downloaded-key/\\\") # folder where all the newly generated keys go\\n destination_file_name = folder / \\\"{}\\\".format(destination_name) # file named after service-account name\\n destination_file_name.touch(exist_ok=True)\\n\\n # download the file and store it locally\\n storage_client = storage.Client()\\n bucket = storage_client.get_bucket(self.bucket_name)\\n blob = bucket.blob(source_blob_name)\\n blob.download_to_filename(destination_file_name)\\n\\n # prints source and destination indicating successful download\\n print('Encrypted key downloaded to -----> \\\\n {}.'.format(\\n source_blob_name,\\n destination_file_name))\\n\\n return destination_file_name\",\n \"def get_file_contents(self, key):\\n f = open( os.path.join(self.file_path, '%s.xoj' % key))\\n data = f.read()\\n f.close()\\n return data\",\n \"def read_bucket_objects(bucket_name):\\n s3 = boto3.resource('s3')\\n bucket = s3.Bucket(bucket_name)\\n for obj in bucket.objects.all():\\n response = obj.get()\\n body = response['Body'].read().decode('utf-8')\\n print(body)\",\n \"def pub_download(args, project=\\\"\\\", base_url=\\\"\\\", api_key=\\\"\\\"):\\n project, base_url, api_key, updated = get_project_config(\\n project=project, base_url=base_url, api_key=api_key)\\n if updated:\\n save_config()\\n download_theme(args, base_url, api_key, prefix=project)\",\n \"async def _download(self) -> None:\\n\\n # do request\\n async with aiohttp.ClientSession() as session:\\n async with session.get(self.url, auth=self._auth, timeout=self._timeout) as response:\\n # check response\\n if response.status == 200:\\n # get data and return it\\n self._buffer = await response.read()\\n elif response.status == 401:\\n log.error(\\\"Wrong credentials for downloading file.\\\")\\n raise FileNotFoundError\\n else:\\n log.error(\\\"Could not download file from filecache.\\\")\\n raise FileNotFoundError\",\n \"def load_accounts():\\n logger.info('Loading accounts...')\\n with open(\\\"C:\\\\\\\\Users\\\\\\\\harun\\\\\\\\Desktop\\\\\\\\BigSwede-volume-bot\\\\\\\\keys.txt\\\") as f:\\n for key in f:\\n key = key.strip()\\n address = web3.eth.account.from_key(key).address\\n accounts.append((address, key))\",\n \"def download_presentation(epObject, uc):\\r\\n fileDict = make_file_dict()\\r\\n fileDict = populate_file_dict(epObject, uc, fileDict)\\r\\n now = str(datetime.datetime.now().hour) + \\\\\\r\\n str(datetime.datetime.now().minute) + \\\\\\r\\n str(datetime.datetime.now().second)\\r\\n directoryName = epObject.Name.replace(\\\" \\\", \\\"\\\") + \\\"_presentation_\\\" + now\\r\\n os.mkdir(directoryName)\\r\\n os.chdir(directoryName)\\r\\n temp = tempfile.TemporaryFile()\\r\\n temp.write(urllib.request.urlopen(fileDict['pageUrls'][0]).read())\\r\\n temp.seek(0)\\r\\n update_page(temp, fileDict, \\\"index.html\\\", index=True)\\r\\n temp.close()\\r\\n os.mkdir(\\\"Pages\\\")\\r\\n os.chdir(\\\"Pages\\\")\\r\\n for (pageUrl, pageFileName) in zip(fileDict['pageUrls'][1:], \\r\\n fileDict['pageFileNames'][1:]):\\r\\n temp = tempfile.TemporaryFile()\\r\\n temp.write(urllib.request.urlopen(pageUrl).read())\\r\\n update_page(temp, fileDict, pageFileName)\\r\\n temp.close()\\r\\n os.chdir(\\\"../\\\")\\r\\n os.mkdir(\\\"Content\\\")\\r\\n os.chdir(\\\"Content\\\")\\r\\n for (fileUrl, fileId) in zip(fileDict['fileUrls'], fileDict['fileIds']):\\r\\n fileName = eportfolio.get_ep_object_properties(uc, fileId).\\\\\\r\\n FileName.strip()\\r\\n urllib.request.urlretrieve(fileUrl, fileName)\\r\\n os.chdir(\\\"../\\\")\\r\\n os.mkdir(\\\"Formatting\\\")\\r\\n os.chdir(\\\"Formatting\\\")\\r\\n for (cssUrl, cssFileName) in zip(fileDict['cssUrls'],\\r\\n fileDict['cssFileNames']):\\r\\n temp = tempfile.TemporaryFile()\\r\\n temp.write(urllib.request.urlopen(cssUrl).read())\\r\\n temp.seek(0)\\r\\n update_css_file(cssUrl, temp, cssFileName)\\r\\n temp.close()\\r\\n for imgUrl in fileDict['imgUrls']:\\r\\n fileName = imgUrl[imgUrl.rfind(\\\"/\\\"): ]\\r\\n if fileName.find(\\\"?\\\") > 0:\\r\\n fileName = fileName[: fileName.find(\\\"?\\\")]\\r\\n urllib.request.urlretrieve(imgUrl, fileName)\\r\\n os.chdir(\\\"../\\\")\\r\\n print(str(fileDict))\\r\\n return fileDict\",\n \"def get_mail_docs_in_bucket():\\n if BUCKET_ID not in settings.DOCUMENT_BUCKETS:\\n raise ImproperlyConfigured(f'Bucket \\\"{BUCKET_ID}\\\" is missing in settings')\\n\\n config = settings.DOCUMENT_BUCKETS[BUCKET_ID]\\n if 'bucket' not in config:\\n raise ImproperlyConfigured(f'Bucket \\\"{BUCKET_ID}\\\" not configured properly in settings')\\n\\n name = config['bucket']\\n if not name:\\n raise ImproperlyConfigured(\\n f'Bucket \\\"{BUCKET_ID}\\\" bucket value not configured properly in settings',\\n )\\n\\n client = documents.get_s3_client_for_bucket(bucket_id=BUCKET_ID)\\n\\n paginator = client.get_paginator('list_objects')\\n for page in paginator.paginate(Bucket=name):\\n for doc in page.get('Contents') or []:\\n key = doc['Key']\\n with tempfile.TemporaryFile(mode='w+b') as f:\\n client.download_fileobj(Bucket=name, Key=key, Fileobj=f)\\n f.seek(0)\\n content = f.read()\\n yield {'source': key, 'content': content}\",\n \"def _download(\\n hostname,\\n auth,\\n infile,\\n output_dir=\\\".\\\",\\n show_progress=False,\\n unpack_packages=True,\\n delete_unpacked_packages=False,\\n) -> Optional[Dict[str, Any]]:\\n object_list = Manifest.load(Path(infile))\\n if object_list is None:\\n logger.critical(f\\\"Error loading {infile}\\\")\\n return None\\n try:\\n auth.get_access_token()\\n except Gen3AuthError:\\n logger.critical(f\\\"Unable to authenticate your credentials with {hostname}\\\")\\n return\\n\\n downloader = DownloadManager(\\n hostname=hostname,\\n auth=auth,\\n download_list=object_list,\\n show_progress=show_progress,\\n )\\n\\n out_dir_path = ensure_dirpath_exists(Path(output_dir))\\n return downloader.download(\\n object_list,\\n str(out_dir_path),\\n show_progress=show_progress,\\n unpack_packages=unpack_packages,\\n delete_unpacked_packages=delete_unpacked_packages,\\n )\",\n \"def export_all_for_course(self, course_key, output_directory, assets_policy_file):\\r\\n policy = {}\\r\\n assets, __ = self.get_all_content_for_course(course_key)\\r\\n\\r\\n for asset in assets:\\r\\n asset_location = AssetLocation._from_deprecated_son(asset['_id'], course_key.run) # pylint: disable=protected-access\\r\\n self.export(asset_location, output_directory)\\r\\n for attr, value in asset.iteritems():\\r\\n if attr not in ['_id', 'md5', 'uploadDate', 'length', 'chunkSize']:\\r\\n policy.setdefault(asset_location.name, {})[attr] = value\\r\\n\\r\\n with open(assets_policy_file, 'w') as f:\\r\\n json.dump(policy, f)\",\n \"def cloud_files(self, cloud_bucket_name: str, credentials: Mapping, files_to_upload: List, private: bool = True) -> Iterator[str]:\",\n \"async def _get_data(self, ctx: Context):\\n\\n data = await self.config.user(ctx.author).all()\\n\\n data_json = json.dumps(data)\\n\\n file = text_to_file(data_json, filename=f\\\"{ctx.author.name.lower()}_brawlcord_data.json\\\")\\n\\n try:\\n await ctx.author.send(file=file)\\n except discord.Forbidden:\\n await ctx.send(\\\"Unable to DM you.\\\")\\n\\n await ctx.send(\\\"Sent you the file!\\\")\",\n \"def blobs(self):\\n if not self._blobs:\\n workspace = self.attributes.workspace\\n # Instantiates a google client, & get all blobs in bucket\\n storage_client = storage.Client(project=self._user_project)\\n bucket = storage_client.bucket(workspace['bucketName'], user_project=self._user_project)\\n # get subset of data\\n _blobs = {}\\n try:\\n for b in bucket.list_blobs(fields='items(size, etag, crc32c, name, timeCreated),nextPageToken'):\\n name = f\\\"gs://{workspace['bucketName']}/{b.name}\\\"\\n # cache.put(name, {'size': b.size, 'etag': b.etag, 'crc32c': b.crc32c, 'time_created': b.time_created, 'name': name})\\n _blobs[name] = AttrDict({'size': b.size, 'etag': b.etag, 'crc32c': b.crc32c, 'time_created': b.time_created, 'name': name})\\n self._blobs = _blobs\\n except Exception as e:\\n print(f\\\"{self.id} {workspace['bucketName']} {e}\\\")\\n self._blobs = _blobs\\n return self._blobs\",\n \"def read_url_all(url):\\n\\n\\t\\treturn write_file(read_url(url))\",\n \"def download_file(self):\\n files = self.s3_client.list_objects_v2(\\n Bucket=settings.PRIVATE_DATA_BUCKET_NAME, Prefix=f\\\"{self.import_type}/\\\"\\n )[\\\"Contents\\\"]\\n\\n latest_file_key = sorted(files, key=lambda f: f[\\\"LastModified\\\"])[0][\\\"Key\\\"]\\n print(latest_file_key)\\n file = Path(self.tmp_dir.name) / self.import_type / \\\"full.csv\\\"\\n file.parent.mkdir(exist_ok=True, parents=True)\\n self.file_path = file\\n with file.open(\\\"wb\\\") as f:\\n self.s3_client.download_fileobj(\\n settings.PRIVATE_DATA_BUCKET_NAME, latest_file_key, f\\n )\",\n \"def download():\\n toydata = requests.get(DATA_URL).json()\\n return toydata\",\n \"def json_file():\\r\\n urlretrieve(URL, PATH)\\r\\n return PATH\",\n \"def json_file():\\r\\n urlretrieve(URL, PATH)\\r\\n return PATH\",\n \"def download(self, key_name):\\n #Flat structure for now\\n fn = basename(key_name)\\n\\n key = self.bucket.get_key(key_name)\\n md5 = key.etag[1 :-1]\\n\\n local_md5 = hashfile(fn, hashlib.md5())\\n\\n if not local_md5 == md5:\\n key.get_contents_to_filename(fn)\",\n \"def download_JSON(sets_to_reference):\\n print(\\\"- Downloading data from MTGAJSON -\\\")\\n for setname in tqdm(sets_to_reference) :\\n r = requests.get('https://mtgjson.com/api/v5/'+ setname +'.json.zip')\\n zipfile = ROOT_DIR + 'data/sets/' +setname +\\\".zip\\\"\\n with open(zipfile, \\\"wb\\\") as data:\\n data.write(r.content)\\n with ZipFile(zipfile, 'r') as zipObj:\\n # Extract all the contents of zip file in current directory\\n zipObj.extractall(path=ROOT_DIR + 'data/sets/')\\n ## If file exists, delete it ##\\n if os.path.isfile(zipfile):\\n os.remove(zipfile)\\n else: ## Show an error ##\\n print(\\\"Error: %s file not found\\\" % zipfile)\",\n \"def fetch_zenodo(self):\\n\\n # retrieve content from URL\\n try:\\n logging.info(f\\\"Downloading example data from {self.url}\\\")\\n r = requests.get(self.url, stream=True)\\n with io.BytesIO() as stream:\\n with tqdm.wrapattr(\\n stream,\\n 'write',\\n file=sys.stdout,\\n miniters=1,\\n desc=self.url,\\n total=int(r.headers.get('content-length', 0))\\n ) as file:\\n for chunk in r.iter_content(chunk_size=4096):\\n file.write(chunk)\\n with zipfile.ZipFile(stream) as zipped:\\n # extract each file in the zipped dir to the project\\n for f in zipped.namelist():\\n logging.info(\\\"Unzipped: {}\\\".format(os.path.join(self.destination, f)))\\n zipped.extract(f, self.destination)\\n\\n logging.info(\\\"Download and install complete.\\\")\\n\\n self.close_logger()\\n\\n except requests.exceptions.MissingSchema:\\n msg = f\\\"Unable to download data from {self.url}\\\"\\n logging.exception(msg)\\n self.close_logger()\\n raise\",\n \"def get_data(keychain_file):\\n\\n keychain = Keychain(keychain_file)\\n items = keychain.get_all()\\n return items\",\n \"def download_data(self, format = 'srt'):\\n resp, content = httplib2.Http(\\\".cache\\\").request(self.url, \\\"GET\\\")\\n suburl = json.loads(content)['url']\\n resp, content = httplib2.Http(\\\".cache\\\").request(suburl, \\\"GET\\\")\\n\\n return content\",\n \"def collect_data(url: str, channel: str, file_name: str):\\n print(f\\\"Downloadng data : {channel}\\\")\\n download(url)\\n upload_to_s3(channel, file_name)\\n print(f\\\"Finished downloadng data : {channel}\\\")\",\n \"def read_and_save(res):\\n fname = os.path.split(urlsplit(res.url).path)[-1]\\n fpath = os.path.join(cfg.OUTPUT_DIR, fname)\\n with open(fpath, 'wb') as f:\\n for chunk in res.iter_content(cfg.CHUNK):\\n f.write(chunk)\",\n \"def list_bucket(self, bucket):\\n self.response.write('Creating more files for listbucket...\\\\n')\\n self.create_file(bucket + '/foo1')\\n self.create_file(bucket + '/foo2')\\n self.response.write('\\\\nListbucket result:\\\\n')\\n\\n page_size = 1\\n stats = gcs.listbucket(bucket, max_keys=page_size)\\n while True:\\n count = 0\\n for stat in stats:\\n count += 1\\n self.response.write(repr(stat))\\n self.response.write('\\\\n')\\n\\n if count != page_size or count == 0:\\n break\\n last_filename = stat.filename[len(bucket) + 1:]\\n stats = gcs.listbucket(bucket, max_keys=page_size, marker=last_filename)\",\n \"def files():\\n return get_cached(\\\"files.json\\\")\",\n \"async def fetch_file_list(client, bucket) -> List:\\n # pylint: disable=invalid-name\\n PG_HOSTNAME = config('PG_HOSTNAME')\\n PG_DATABASE = config('PG_DATABASE')\\n folder = f'backup/{PG_HOSTNAME}_{PG_DATABASE}'\\n result = await client.list_objects_v2(Bucket=bucket, Prefix=folder)\\n contents = result.get('Contents', None)\\n file_list = list([])\\n if contents:\\n for content in contents:\\n file_list.append(content.get('Key'))\\n return file_list\",\n \"def download_archive(self):\\n\\n def time_convert(structure):\\n \\\"\\\"\\\"\\n :param structure: tuple representation of time\\n :return: GitHub archive time\\n \\\"\\\"\\\"\\n \\n \\n join_number_to_zero = lambda number: (\\\"\\\" if number > 9 else \\\"0\\\") + str(number)\\n\\n return \\\"%s-%s-%s-%s\\\" % (\\n structure.tm_year, join_number_to_zero(structure.tm_mon), join_number_to_zero(structure.tm_mday),\\n structure.tm_hour)\\n\\n current_time = self.get_time()\\n self.logger.debug(__name__ + \\\": \\\" + \\\"current time: \\\" + str(gmtime(current_time)))\\n\\n difference = -25200\\n #timezone difference in seconds between GMT and west coast of USA\\n\\n downloading_time = int(timegm(self.config[\\\"last_connection_time\\\"])) + 3600\\n self.logger.debug(__name__ + \\\": \\\" + \\\"downloading time: \\\" + str(gmtime(downloading_time)))\\n\\n if downloading_time > current_time - 7200:\\n self.logger.info(__name__ + \\\": \\\" + \\\"unable to download file (time limiting).\\\")\\n return\\n\\n downloading_time += difference\\n\\n json_file_name = self.download_file(time_convert(gmtime(downloading_time)))\\n\\n self.config[\\\"last_connection_time\\\"] = gmtime(downloading_time - difference)\\n self.logger.debug(__name__ + \\\": \\\" + \\\"last_connection_time: \\\" + str(self.config[\\\"last_connection_time\\\"]))\\n\\n return json_file_name\",\n \"def download (url):\\n path, url = url\\n r = requests.get (url, stream = True)\\n content = r.text\\n #print (content)\\n with open (path + '.txt', 'w') as f:\\n f.write (content)\",\n \"def download_account_structure(ad_accounts: [adaccount.AdAccount]):\\n db_name = Path('facebook-account-structure_{}.sqlite3'.format(OUTPUT_FILE_VERSION))\\n filepath = ensure_data_directory(db_name)\\n\\n with sqlite3.connect(str(filepath)) as con:\\n for ad_account in ad_accounts:\\n for row in download_account_structure_per_account(ad_account):\\n _upsert_account_structure(row, con)\",\n \"def download_account_structure_per_account(ad_account: adaccount.AdAccount) \\\\\\n -> Generator[List, None, None]:\\n campaign_data = get_campaign_data(ad_account)\\n ad_set_data = get_ad_set_data(ad_account)\\n ad_data = get_ad_data(ad_account)\\n\\n for ad_id, ad in ad_data.items():\\n ad_set_id = ad['ad_set_id']\\n ad_set = ad_set_data[ad_set_id]\\n campaign_id = ad_set['campaign_id']\\n campaign = campaign_data[campaign_id]\\n\\n attributes = {**campaign['attributes'],\\n **ad_set['attributes'],\\n **ad['attributes']}\\n\\n row = [ad_id,\\n ad['name'],\\n ad_set_id,\\n ad_set['name'],\\n campaign_id,\\n campaign['name'],\\n ad_account['account_id'],\\n ad_account['name'],\\n json.dumps(attributes)]\\n\\n yield row\",\n \"def download_file(client, file_id):\\n\\n file_content = client.file(file_id).content()\\n print(file_content)\",\n \"def __retrieve_from_bucket(fname):\\n blob = BUCKET.blob(fname)\\n json_data = json.loads(blob.download_as_string())\\n return json_data\",\n \"def download_files_in_drs_manifest(\\n hostname,\\n auth,\\n infile,\\n output_dir,\\n show_progress=True,\\n unpack_packages=True,\\n delete_unpacked_packages=False,\\n) -> None:\\n _download(\\n hostname,\\n auth,\\n infile,\\n output_dir,\\n show_progress,\\n unpack_packages,\\n delete_unpacked_packages,\\n )\",\n \"def get_file_contents(filename):\\n try:\\n with open(filename, 'r') as f:\\n # It's assumed our file contains a single line,\\n # with our API key\\n return f.read().strip()\\n except FileNotFoundError:\\n print(\\\"'%s' file not found\\\" % filename)\",\n \"async def get_entities(self, file=\\\"entities.json\\\"):\\n g = Get(self.token)\\n u = Utilities()\\n\\n api_link_dict = await u.get_api_root_response()\\n entity_dict = {\\\"creation_time\\\": datetime.now(), \\\"data\\\": {}}\\n\\n for index, key in enumerate(api_link_dict):\\n await g.get(key)\\n entity_dict[\\\"data\\\"][key] = Get.entity_dict\\n\\n # Check if a file of the same name already exists\\n try:\\n open(file, \\\"x\\\")\\n # Add a complain function/class to allow outputting warnings and errors to a log of some sort\\n except:\\n print(\\\"Warn: File already exists! Overwriting\\\")\\n\\n output = open(file, \\\"w\\\")\\n json.dump(entity_dict, output, indent=2)\\n output.close()\",\n \"def list_bucket_files(project, bucket_name, referenced_files, verbose):\\n if verbose:\\n print(\\\"listing contents of bucket gs://\\\" + bucket_name)\\n\\n # set up storage client\\n storage_client = storage.Client(project=project)\\n\\n # check if bucket exists\\n try:\\n bucket = storage_client.get_bucket(bucket_name)\\n except:\\n print(f'Bucket {bucket_name} does not exist!')\\n exit(1)\\n\\n # Note: Client.list_bucket_files requires at least package version 1.17.0.\\n blobs = storage_client.list_blobs(bucket_name)\\n\\n if verbose:\\n print(\\\"finished listing bucket contents. processing files now in chunks of 1000.\\\")\\n\\n bucket_dict = dict()\\n\\n def extract_file_metadata(blob):\\n blob_name = blob.name\\n\\n if blob_name.endswith('/'): # if this is a directory\\n return None\\n\\n full_file_path = \\\"gs://\\\" + bucket_name + \\\"/\\\" + blob_name\\n # support new submissions directory structure in Terra bucket\\n submissions_dir = \\\"submissions\\\"\\n if full_file_path.split('/', 4)[3] == submissions_dir:\\n # new format is gs://bucket_id/submissions/submission_id/remaining_path\\n submission_id = full_file_path.split('/', 5)[4]\\n else:\\n # old format is gs://bucket_id/submission_id/remaining_path\\n # Splits the bucket file: \\\"gs://bucket_Id/submission_id/file_path\\\", by the '/' symbol\\n # and stores values in a 5 length array: ['gs:', '' , 'bucket_Id', submission_id, file_path]\\n # to extract the submission id from the 4th element (index 3) of the array\\n submission_id = full_file_path.split('/', 4)[3]\\n\\n file_metadata = {\\n \\\"file_name\\\": blob_name.split('/')[-1],\\n \\\"file_path\\\": full_file_path,\\n \\\"submission_id\\\": submission_id,\\n \\\"size\\\": blob.size,\\n \\\"is_in_data_table\\\": full_file_path in referenced_files,\\n \\\"time_created\\\": blob.time_created\\n }\\n\\n return file_metadata\\n\\n n_blobs = 0\\n for page in blobs.pages: # iterating through pages is way faster than not\\n if verbose:\\n n_blobs += page.remaining\\n print(f'...processing {n_blobs} blobs', end='\\\\r')\\n for blob in page:\\n file_metadata = extract_file_metadata(blob)\\n if file_metadata:\\n full_file_path = file_metadata['file_path']\\n bucket_dict[full_file_path] = file_metadata\\n\\n if verbose:\\n print(f'Found {len(bucket_dict)} files in bucket {bucket_name}')\\n\\n return bucket_dict\",\n \"def downloadAll(self, force=False):\\n if self.minutesSinceLastUpdate() == 0 and force == False:\\n self.log(\\\"TOO SOON SINCE LAST DOWNLOAD!\\\")\\n return\\n for grabber in self.grabbers:\\n self.downloadGrab(grabber[\\\"url\\\"], grabber[\\\"ID\\\"])+\\\"\\\\n\\\"\",\n \"def download(url, bucket_id, key_prefix):\\n\\n baseFile = '_'.join(url.split('/')[-4:]) #os.path.basename(url)\\n\\n #move the file to a more uniq path\\n os.umask(0002)\\n temp_path = \\\"/tmp/\\\"\\n file = os.path.join(temp_path,baseFile)\\n bucket = conn.get_bucket(bucket_id)\\n key = bucket.get_key(key_prefix + baseFile, validate=False)\\n s3_exists = key.exists()\\n file_exists = os.path.isfile(file)\\n \\n if not file_exists and s3_exists:\\n sys.stderr.write(\\\"Downloading %s from S3\\\\n\\\"%url)\\n key.get_contents_to_filename(file)\\n sys.stderr.write(\\\"Downloaded %s from S3\\\\n\\\"%url)\\n elif not file_exists and not s3_exists:\\n sys.stderr.write(\\\"Downloading %s from the web\\\\n\\\"%url)\\n try:\\n req = urllib2.urlopen(url)\\n total_size = int(req.info().getheader('Content-Length').strip())\\n downloaded = 0\\n CHUNK = 256 * 10240\\n with open(file, 'wb') as fp:\\n while True:\\n chunk = req.read(CHUNK)\\n downloaded += len(chunk)\\n #print math.floor( (downloaded / total_size) * 100 )\\n if not chunk: break\\n fp.write(chunk)\\n except urllib2.HTTPError, e:\\n sys.stderr.write(\\\"HTTP Error: %s %s\\\\n\\\"%(e.code , url))\\n return False\\n except urllib2.URLError, e:\\n sys.stderr.write(\\\"URL Error: %s %s\\\\n\\\"%(e.reason , url))\\n return False\\n sys.stderr.write(\\\"Downloaded %s from the web\\\\n\\\"%url)\\n\\n if not s3_exists:\\n sys.stderr.write(\\\"Uploading %s to S3\\\\n\\\"%url)\\n key.set_contents_from_filename(file)\\n\\n sys.stderr.write(\\\"File ready: %s\\\\n\\\"%url)\\n return file\",\n \"def convert_to_json(basepath, sendto):\\n\\n logger = logging.getLogger('WikiLog')\\n\\n k = bucket.new_key(basepath)\\n\\n filenames = []\\n year = month = day = hrs = ''\\n\\n for key in bucket.list():\\n thisfile = key.name.encode('utf-8')\\n if 'projectviews' not in thisfile and 'sql' not in thisfile and '.gz' in thisfile and thisfile.startswith(basepath):\\n # S3 key name is of the format kt-wiki/pageviews/2016/2016-06/pageviews-20160601-000000.gz\\n # Split by / to get last element\\n filenames.append(thisfile)\\n logger.info(\\\"Processing file: {}\\\".format(thisfile))\\n fname = thisfile.split('/')\\n\\n # Get content from filename and save to local\\n # Split again to Grab year, month, day, hour value from filename\\n key.get_contents_to_filename('/home/ubuntu/WikiView/data/' + fname[-1])\\n fname1 = fname[-1]\\n data_time = fname1[:-3].split('-')\\n year, month, day, hrs = data_time[1][:4], data_time[1][4:6], data_time[1][-2:], data_time[-1]\\n\\n docname = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\\n dictlist = []\\n\\n # save file from s3 to local, read, write to json, push json to s3\\n with open(docname, 'w') as fp:\\n #\\n with gzip.open('/home/ubuntu/WikiView/data/'+fname[-1],'r') as fin:\\n for line in fin:\\n line = line.split(' ')\\n doc = {}\\n doc['ymdh'] = year + '-' + month + '-' + day + '-' + hrs\\n try:\\n # format: project, title, views, bytes ~ en Main_Page 242332 4737756101\\n prj, title, vcount = line[0], line[1], line[2]\\n doc['prj'] = prj\\n doc['title'] = title\\n doc['vcount'] = vcount\\n json.dump(doc,fp)\\n fp.write('\\\\n')\\n except:\\n logger.error('Error reading gzip file {} at line: {}'.format(thisfile, line))\\n pass\\n# sys.exc_clear()\\n\\n # Now, save the json file to \\n key_name = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\\n full_key_name = os.path.join(sendto, key_name)\\n k = bucket.new_key(full_key_name)\\n\\n logger.info(\\\"Sending json file to S3: {}\\\".format(docname))\\n k.set_contents_from_filename(key_name)\\n\\n # Remove temp file\\n logger.info(\\\"Removing temp file: {} {}\\\".format('/home/ubuntu/WikiView/data/', fname[-1]))\\n os.remove('/home/ubuntu/WikiView/data/'+fname[-1])\\n logger.info(\\\"Removing temp file: {}\\\".format(key_name))\\n os.remove(key_name)\\n logger.info('Finished!!!')\",\n \"def download_data(self):\\r\\n \\r\\n for file in self.__files:\\r\\n file_to_download = os.path.join(self.__folder, os.path.basename(file))\\r\\n if not os.path.isfile(file_to_download):\\r\\n self.__download_file(file)\",\n \"async def async_download_object_manifest(\\n commons_url,\\n output_filename=\\\"object-manifest.csv\\\",\\n num_processes=4,\\n max_concurrent_requests=MAX_CONCURRENT_REQUESTS,\\n):\\n start_time = time.perf_counter()\\n logging.info(f\\\"start time: {start_time}\\\")\\n\\n # ensure tmp directory exists and is empty\\n os.makedirs(TMP_FOLDER, exist_ok=True)\\n for file in os.listdir(TMP_FOLDER):\\n file_path = os.path.join(TMP_FOLDER, file)\\n if os.path.isfile(file_path):\\n os.unlink(file_path)\\n\\n result = await _write_all_index_records_to_file(\\n commons_url, output_filename, num_processes, max_concurrent_requests\\n )\\n\\n end_time = time.perf_counter()\\n logging.info(f\\\"end time: {end_time}\\\")\\n logging.info(f\\\"run time: {end_time-start_time}\\\")\",\n \"def downloadstackexchangefiles(configlist):\\n for domainname in configlist:\\n try:\\n downloadurl = 'https://archive.org/download/stackexchange/'+domainname+'.stackexchange.com.7z'\\n outputpath = '/Users/SG/Documents/DE2020/DataDirrectory/'+domainname+'.meta.stackexchange.7z'\\n r=requests.get(downloadurl)\\n if r == False:\\n print('Response not received. Check your input.')\\n continue\\n #r = requests.get('https://archive.org/download/stackexchange/coffee.meta.stackexchange.com.7z')\\n with open(outputpath,'wb') as f:\\n for chunk in r.iter_content(chunk_size=8192):\\n if chunk:\\n f.write(chunk)\\n print('Download finished for ',domainname)\\n except Exception as e:\\n print(e)\\n return\\n return\",\n \"def s3_read_data(self):\\n\\n self.k.open()\\n self.k.read()\",\n \"def download_optional_inputs(flywheel_basedir, sub_dir, ses_dir, rootdir):\\n print('Looking for manifest-defined anatomical files')\\n t1_anat_dir = os.path.join(flywheel_basedir, 'input', 't1w_anatomy')\\n if os.path.isdir(t1_anat_dir):\\n t1_file = os.listdir(t1_anat_dir)\\n if t1_file:\\n t1_file = os.path.join(t1_anat_dir, t1_file[0])\\n anat_dir = os.path.join(rootdir, sub_dir, ses_dir, 'anat')\\n if not os.path.isdir(anat_dir):\\n os.mkdir(anat_dir)\\n dest_file = os.path.join(anat_dir, sub_dir + '_' + ses_dir + '_T1w.nii.gz')\\n if os.path.exists(dest_file):\\n print('Found downloaded T1 file - overwriting!')\\n os.remove(dest_file)\\n os.remove(dest_file.replace('.nii.gz', '.json'))\\n shutil.copyfile(t1_file, dest_file)\\n\\n t2_anat_dir = os.path.join(flywheel_basedir, 'input', 't2w_anatomy')\\n if os.path.isdir(t2_anat_dir):\\n t2_file = os.listdir(t2_anat_dir)\\n if t2_file:\\n anat_dir = os.path.join(rootdir, sub_dir, ses_dir, 'anat')\\n if not os.path.isdir(anat_dir):\\n os.mkdir(anat_dir)\\n t2_file = os.path.join(t2_anat_dir, t2_file[0])\\n dest_file = os.path.join(anat_dir, sub_dir + '_' + ses_dir + '_T2w.nii.gz')\\n if os.path.exists(dest_file):\\n print('Found downloaded T2 file - overwriting!')\\n os.remove(dest_file)\\n os.remove(dest_file.replace('.nii.gz', '.json'))\\n shutil.copyfile(t2_file, dest_file)\",\n \"def fetch_the_data():\\n subprocess.run([\\\"wget\\\", \\\"https://storage.googleapis.com/recipe-box/recipes_raw.zip\\\"])\\n subprocess.run([\\\"unzip\\\", \\\"recipes_raw.zip\\\", \\\"-d\\\", RECIPES_DIRPATH])\\n subprocess.run([\\\"rm\\\", \\\"recipes_raw.zip\\\"])\",\n \"def do_GET(self):\\n f = self.send_head()\\n if f:\\n try:\\n self.copyfile(f, self.wfile)\\n finally:\\n f.close()\",\n \"def download_hero_images(file_name, output_dir):\\n with open(file_name,'r') as json_file:\\n hero_json = json.load(json_file) \\n try:\\n os.mkdir(output_dir)\\n except OSError:\\n print (\\\"Failed to create directory %s\\\" % output_dir)\\n return\\n for hero in hero_json:\\n print (\\\"Processing %s.\\\" % hero['name'])\\n hero_dir = output_dir + '/' + str(hero['hero_id'])\\n os.mkdir(hero_dir)\\n urlr.urlretrieve(hero['img_url'], hero_dir + '/main.' + IMAGE_EXTENSION);\\n urlr.urlretrieve(hero['portrait_img_url'], hero_dir + '/portrait.' + IMAGE_EXTENSION);\\n\\n for ability in hero['abilities']:\\n ability_img = hero_dir + '/ability_' + str(ability['ability_id']) + '.' + IMAGE_EXTENSION\\n urlr.urlretrieve(ability['img_url'], ability_img);\",\n \"def __main():\\n\\n\\n#Makes HTTP request to Google Drive API 'copy' method\\n def copyFile(token, target_name):\\n print(\\\"Access Token: \\\" + token)\\n url_destino = \\\"https://www.googleapis.com/drive/v2/files/0AilPd9i9ydNTdFc4a2lvYmZnNkNzSU1kdVFZb0syN1E/copy\\\" \\\\\\n \\\"?key=(YOUR_API_KEY provided by Google API Console)\\\"\\n values = \\\"{'title': '%s'}\\\" % target_name\\n data = values.encode('utf-8')\\n request = urllib.request.Request(url_destino, data, method='POST')\\n request.add_header(\\\"Authorization\\\", \\\"Bearer \\\" + token)\\n request.add_header(\\\"Content-Length\\\", len(data))\\n request.add_header(\\\"Content-Type\\\", \\\"application/json\\\")\\n print(request.header_items())\\n f = urllib.request.urlopen(request)\\n print(f.read())\\n\\n#Makes HTTP request to Google Drive API 'list' files method\\n def listFiles(token):\\n print(\\\"Access Token: \\\" + token)\\n url_destino = \\\"https://www.googleapis.com/drive/v2/files?key=(YOUR_API_KEY provided by Google API Console)\\\"\\n request = urllib.request.Request(url_destino)\\n request.add_header(\\\"Authorization\\\", \\\"Bearer \\\" + token)\\n f = urllib.request.urlopen(request)\\n print(f.read())\\n\\n\\n oauth2 = OAuth2()\\n token = oauth2.getAccessToken()\\n if token == None:\\n print(\\\"Input the following URL into your browser and access it!\\\")\\n print(oauth2.getUrlForAuthCode())\\n code = input(\\\"Paste the code ---> \\\")\\n token = oauth2.getAccessToken(code)\\n\\n\\n try:\\n listFiles(token)\\n except urllib.error.HTTPError as e:\\n if e.code == 401:\\n token = oauth2.refreshAccessToken()\\n listFiles(token)\\n else:\\n print(e.code)\\n\\n\\n try:\\n copyFile(token, 'HiperAgenda_Copiada_3')\\n except urllib.error.HTTPError as e:\\n if e.code == 401:\\n token = oauth2.refreshAccessToken()\\n copyFile(token, 'HiperAgenda_Copiada')\\n else:\\n print(e.code)\",\n \"def download_finish(self, cloud_file):\",\n \"def sync_submission_files(self):\\n blobs = GoogleStorage().list_blobs_with_prefix(self.bucket_name, 'submissions')\\n\\n for blob in blobs:\\n destination_file_name = os.path.join(os.environ['PROJ_HOME'], blob.name)\\n\\n # Check if the local file exist before download file\\n if not os.path.isfile(destination_file_name):\\n blob.download_to_filename(destination_file_name)\\n print('Downloaded file {destination_file_name}'.format(destination_file_name=destination_file_name))\",\n \"def download_entities(self, download_parameters, progress=None):\\n\\n result_file_path = self.download_file(download_parameters, progress)\\n result_file_type = ResultFileType.full_download \\\\\\n if download_parameters.last_sync_time_in_utc is None \\\\\\n else ResultFileType.partial_download\\n with BulkFileReader(\\n file_path=result_file_path,\\n result_file_type=result_file_type,\\n file_type=download_parameters.file_type,\\n ) as reader:\\n for entity in reader:\\n yield entity\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5624332","0.5565257","0.5325051","0.5309067","0.53066105","0.5221628","0.51972795","0.51733166","0.5163463","0.512532","0.5081053","0.50756407","0.507155","0.5058799","0.5047412","0.5042756","0.49936804","0.498855","0.49836323","0.49819744","0.49795422","0.49542502","0.49347362","0.49321923","0.4928288","0.4928005","0.4917908","0.4915324","0.4909932","0.4906578","0.49051493","0.49021652","0.48916","0.4889866","0.48839355","0.48768377","0.4874515","0.48665646","0.48458073","0.4843235","0.48376033","0.48304626","0.48208374","0.48204324","0.48188218","0.48129705","0.48104453","0.4809921","0.4803572","0.4802228","0.48013422","0.4799882","0.47935614","0.47927374","0.47917098","0.47816592","0.4780743","0.47767955","0.47758096","0.47694704","0.47634384","0.47618914","0.47572416","0.47539365","0.47539365","0.47533065","0.4749528","0.47482252","0.47379225","0.47363928","0.47334078","0.47294196","0.47255886","0.47132352","0.47076732","0.4694142","0.46863896","0.4683207","0.46824622","0.46696973","0.46672797","0.4667111","0.4665121","0.46638831","0.46596816","0.4652879","0.4652372","0.46500507","0.4648062","0.46415985","0.46343815","0.46313214","0.4626819","0.4621626","0.46170625","0.4616138","0.46136868","0.46133247","0.4612551","0.4609786"],"string":"[\n \"0.5624332\",\n \"0.5565257\",\n \"0.5325051\",\n \"0.5309067\",\n \"0.53066105\",\n \"0.5221628\",\n \"0.51972795\",\n \"0.51733166\",\n \"0.5163463\",\n \"0.512532\",\n \"0.5081053\",\n \"0.50756407\",\n \"0.507155\",\n \"0.5058799\",\n \"0.5047412\",\n \"0.5042756\",\n \"0.49936804\",\n \"0.498855\",\n \"0.49836323\",\n \"0.49819744\",\n \"0.49795422\",\n \"0.49542502\",\n \"0.49347362\",\n \"0.49321923\",\n \"0.4928288\",\n \"0.4928005\",\n \"0.4917908\",\n \"0.4915324\",\n \"0.4909932\",\n \"0.4906578\",\n \"0.49051493\",\n \"0.49021652\",\n \"0.48916\",\n \"0.4889866\",\n \"0.48839355\",\n \"0.48768377\",\n \"0.4874515\",\n \"0.48665646\",\n \"0.48458073\",\n \"0.4843235\",\n \"0.48376033\",\n \"0.48304626\",\n \"0.48208374\",\n \"0.48204324\",\n \"0.48188218\",\n \"0.48129705\",\n \"0.48104453\",\n \"0.4809921\",\n \"0.4803572\",\n \"0.4802228\",\n \"0.48013422\",\n \"0.4799882\",\n \"0.47935614\",\n \"0.47927374\",\n \"0.47917098\",\n \"0.47816592\",\n \"0.4780743\",\n \"0.47767955\",\n \"0.47758096\",\n \"0.47694704\",\n \"0.47634384\",\n \"0.47618914\",\n \"0.47572416\",\n \"0.47539365\",\n \"0.47539365\",\n \"0.47533065\",\n \"0.4749528\",\n \"0.47482252\",\n \"0.47379225\",\n \"0.47363928\",\n \"0.47334078\",\n \"0.47294196\",\n \"0.47255886\",\n \"0.47132352\",\n \"0.47076732\",\n \"0.4694142\",\n \"0.46863896\",\n \"0.4683207\",\n \"0.46824622\",\n \"0.46696973\",\n \"0.46672797\",\n \"0.4667111\",\n \"0.4665121\",\n \"0.46638831\",\n \"0.46596816\",\n \"0.4652879\",\n \"0.4652372\",\n \"0.46500507\",\n \"0.4648062\",\n \"0.46415985\",\n \"0.46343815\",\n \"0.46313214\",\n \"0.4626819\",\n \"0.4621626\",\n \"0.46170625\",\n \"0.4616138\",\n \"0.46136868\",\n \"0.46133247\",\n \"0.4612551\",\n \"0.4609786\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.47829255"},"document_rank":{"kind":"string","value":"55"}}},{"rowIdx":80592,"cells":{"query":{"kind":"string","value":"Figures out the full path to a file on Put.io itemID equals the id of the file which you want to determine the path. returns a string that contains the path of the file /foo/bar.txt"},"document":{"kind":"string","value":"def putioPath(self, itemID=None):\r\n\r\n path = self.get_items(id_Number=itemID)[0].name\r\n\r\n while 1:\r\n itemID = self.get_items(id_Number=itemID)[0].parent_id\r\n if itemID == \"0\":\r\n break\r\n else:\r\n path = self.get_items(id_Number=itemID)[0].name + \"/\" + path\r\n\r\n #path = path.replace('\\\\\\\\','/')\r\n return self.dlLocation + path"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def fetchPutIOFile(self, fileID=None, fileDir=None):\r\n\r\n sigkill = 0\r\n\r\n if fileID == None or fileDir == None:\r\n raise ValueError('You must send a putio item id and file path.')\r\n\r\n if not fileID in self.contents:\r\n self.getItem(fileID)\r\n\r\n fileName = self.contents[fileID]['name']\r\n\r\n print(\"Downloading file: \" + fileName)\r\n while 1:\r\n try:\r\n resp, data = self.h.request(self.contents[fileID]['uri'])\r\n if resp.status >= 400:\r\n print(\"We couldn't downlaod the file: \" + fileName)\r\n print(resp)\r\n else:\r\n with open(fileDir, 'wb') as file:\r\n file.write(data)\r\n break\r\n except httplib2.HttpLib2Error or httplib2.socket.error as err:\r\n print(\"Warning we had a httplib2 error... Trying again.\")\r\n print(str(err))\r\n if sigkill <= 3:\r\n sigkill += 1\r\n pass\r\n else:\r\n print(\"ERROR: We failed to fetch item 3 items. Fuck this.\")","def item_upload_to(instance, filename):\n import os\n file_root, file_ext = os.path.splitext(filename)\n date = datetime.now().strftime(\"%Y%m%d\")\n random_name = generate_random_string() + file_ext\n classname = instance.__class__.__name__.lower()\n filename = \"%s_%s\" % (date, random_name)\n\n if classname == 'relatedimage':\n return '/'.join([classname, instance.content_type.name, filename])\n return '/'.join([classname, filename])","def get_items_path() -> Path:\n return Path(os.path.join(Path(os.path.realpath(__file__)).parent, \"items.csv\"))","def test_convert_id_to_path(self):\n backend = BackendS3(**self.config)\n filename = 'demo-test.tar.gz'\n id = utils.generate_id(filename)\n parts = backend.id_to_path(id)\n self.assertEquals(6, len(parts))\n self.assertEquals(filename, parts[5])","def svn_client_commit_item_t_path_get(svn_client_commit_item_t_self): # real signature unknown; restored from __doc__\n return \"\"","def __getitem__(self, item):\n if item == 'path':\n return str(self.path)\n elif item == 'type':\n return str(self.kind)\n elif item == 'absolute_directory':\n return str(self.path)\n raise NotImplementedError()","def item_ref_path(item: Union[BaseField, Config]) -> str:\n return item._ref_path","def _fetch_parent_item(file_id, client, dest):\n target_file = client.getResource('file', file_id)\n item = client.getResource('item', target_file['itemId'])\n dest = os.path.join(dest, client.transformFilename(item['name']))\n target_path = dest\n\n for file in client.listFile(item['_id']):\n path = os.path.join(dest, client.transformFilename(file['name']))\n client.downloadFile(file['_id'], path)\n\n if file['_id'] == target_file['_id']:\n target_path = path\n\n return target_path","def path(self, f):\n\t\treturn os.path.join(self.directory, f)","def get_id_path():\n\n root = os.path.dirname(os.path.abspath(__file__))[:-5]\n id_path = os.path.join(root, \"client\\\\files\\\\id.txt\")\n\n return id_path","def svn_client_commit_item2_t_path_get(svn_client_commit_item2_t_self): # real signature unknown; restored from __doc__\n return \"\"","def get_upload_path(instance, filename):\n \n return \"user_{username}/{goal}/{file}\".format(id=instance.user.username, \n goal=instance.name.slug, file=filename)","def file_path(self) -> global___Expression:","def get_item(dataobj_id):\n file = get_by_id(dataobj_id)\n if file:\n data = frontmatter.load(file)\n data[\"fullpath\"] = str(file)\n data[\"dir\"] = str(file.parent.relative_to(get_data_dir()))\n # replace . for root items to ''\n if data[\"dir\"] == \".\":\n data[\"dir\"] = \"\"\n return data\n return None","def file_location(self, file: str) -> str:\n return os.path.join(str(self.id), file)","def get_file_path(instance, filename):\n\text = filename.split('.')[-1]\n\tfilename = '%s.%s' % (uuid.uuid4(), ext)\n\treturn os.path.join('upload', filename)","def path_and_filename(instance, filename=None):\n \n # Note that filename parameter is set by the file upload form\n # thus we have to make sure the function is defined accordingly.\n # we role our own naming / numbering scheme below and ignore the uploaded file's name\n file_path = 'keyfiles/keyfile_id_{0}'.format(instance.id)\n if os.path.isfile(file_path):\n os.remove(file_path)\n return file_path","def svn_client_commit_item3_t_path_get(svn_client_commit_item3_t_self): # real signature unknown; restored from __doc__\n return \"\"","def filenameAsPath(self, app):\n return app.recordingsPath.child(self.filename).path","def _filename(self, key):\n return os.path.join(self.root, key[:2], key)","def recipe_image_file_path(instance, filename):\n # Return the extention of the file name\n ext = filename.split('.')[-1]\n # Create a new name using the uuid\n filename = f'{uuid.uuid4()}.{ext}'\n\n # A relable method that allowed us to join 2 strings into a vaild path\n return os.path.join('uploads/recipe/', filename)","def get_upload_path(instance, filename):\n \n userpath = \"{name}/{file}\".format(name=instance.user.username, file=filename)\n mainpath = os.path.join(\"infocomp\",userpath)\n return mainpath","def resource_path(self, resource):\n # type: (Text) -> Text\n # This deliberately raises FileNotFoundError instead of\n # NotImplementedError so that if this method is accidentally called,\n # it'll still do the right thing.\n raise FileNotFoundError","def _tf_idf_path(id):\n return os.path.join(os.path.dirname(__file__), './tf_idfs/{0}.json'.format(id))","def get_itemid(filename):\n return os.path.splitext(os.path.basename(filename))[0]","def path_for(objectid):","def path_and_rename(instance, filename):\n\n upload_to = 'things'\n ext = filename.split('.')[-1]\n # get filename\n if instance.pk:\n filename = '{}.{}'.format(instance.pk, ext)\n else:\n # set filename as random string\n filename = '{}.{}'.format(datetime.now(), ext)\n # return the whole path to the file\n return os.path.join(upload_to, filename)","def get_file_path(obj):\n return PATH + obj.strftime('%d-%B-%Y-comments.txt')","def _filename(task_id):\n return \"{}.json\".format(task_id)","def get_upload_to(instance, filename):\n\n if instance.rating_decision:\n return 'issuers/%s/rating_decision/%s/%s'\\\n % (\n instance.issuer.lei,\n instance.rating_decision.id,\n filename)\n else:\n return 'issuers/%s/%s' % (instance.issuer.lei, filename)","def get_upload_path(instance, filename):\n return os.path.join(getattr(settings, \"FILEBROWSER_DIRECTORY\"), str(instance.project.short_name.lower()), filename)","def path_to(self, course_id, filename):\r\n return os.path.join(self.root_path, urllib.quote(course_id.to_deprecated_string(), safe=''), filename)","def resource_path(self, resource):\n return str(self.path.joinpath(resource))","def resource_path(self, resource):\n return str(self.path.joinpath(resource))","def _file_url(self, fid):\n base = self.tq.threatq_host + '/files/'\n return base + str(fid) + '/details'","def file_path(instance, filename):\n hashcode = hash(filename)\n mask = 255 # bitmask\n # use the first and second bytes of the hash code represented as\n # zero-padded hex numbers as directory names\n # provides 256 * 256 = 65536 of possible directory combinations\n dir1 = \"{:0>2x}\".format(hashcode & mask)\n dir2 = \"{:0>2x}\".format((hashcode >> 8) & mask)\n # Galaxy doesn't process names with parentheses in them\n filename = re.sub('[()]', '_', filename)\n return os.path.join(dir1, dir2, filename)","def content_file_name(instance, filename):\r\n return '/'.join([str(instance.app.publisher.id), str(instance.app.id), filename])","def recipe_image_file_path(instance, filename):\n\n ext = filename.split('.')[-1]\n filename = f'{uuid.uuid4()}.{ext}'\n\n return os.path.join('uploads/recipe/', filename)","def id2path(sid):\n\n wav_file_path = os.path.join(\n dpath.IA, # Directory of IA mp3 files.\n '{0:d}.mp3'.format(sid) # Named by SALAMI ID number.\n )\n\n # Make sure it exists first\n if os.path.exists(wav_file_path):\n return wav_file_path\n else:\n return None","def product_image_file_path(instance, filename):\n ext = os.path.splitext(filename)[1]\n filename = f'{uuid.uuid4()}{ext}'\n\n return os.path.join('uploads', 'product', filename)","def file_path(self, request, response=None, info=None):\n url = request.url\n media_guid = hashlib.sha1(to_bytes(url)).hexdigest()\n media_ext = os.path.splitext(url)[1]\n if not media_ext.isalnum():\n media_ext = os.path.splitext(urlparse(url).path)[1]\n return \"full/%s%s\" % (media_guid, media_ext)","def abspath(self, fileid):\n # Find the directory, relative from the corpus root.\n name = fileid.split('.')[0]\n category = fileid.split('_')[0]\n # Create the pickle file extension\n basename = name + '.pickle'\n\n # Return the path to the file relative to the target.\n return os.path.normpath(os.path.join(self.target, category, basename))","def meta_files_from_item(cls, rel_item_path: pl.Path) -> tt.PathGen:\n pass","def base_filename_for_feed_item(feed_item):\n return \"{}_{}\".format(\n int(to_epoch(feed_item.upload_time)),\n feed_item.video_id\n )","def getFilePath(self, filename):\n idx = self._soundfiles.index(filename)\n return \"{}/{}\".format(self._soundpaths[idx], filename)","def get_content_path(content):","def file_path(self):\n return self.lib.file_path","def FilePath(self) -> str:","def _get_file_name(id):\n client = Client(DRS_URL)\n c = client.client\n\n # assume id will be NA18537\n response = c.GetDataObject(data_object_id=id).result()\n return response['data_object'][\"name\"]","def full_file_path_f(self, *args, **kwargs):\n return '%s/%s' % (self.location_f(*args, **kwargs), self.key_f(*args, **kwargs))","def get_path(self):\n try:\n return self._file.path\n except AttributeError:\n return os.path.abspath(self._file.name)","def song_directory_path(instance, filename):\n return f\"music/songs/{instance.id}_{instance.name}_{filename}\"","def relative_path(self, item):\n if hasattr(item, 'path'):\n return self.path.relative_path(item.path)\n else:\n return self.path.relative_path(item)","def roompost_image_file_path(instance, filename):\n ext = filename.split('.')[-1]\n filename = f'{uuid.uuid4()}.{ext}'\n\n return os.path.join('uploads/post/', filename)","def path(self):\n return self.file_path()","def get_path(self, path_id):\n\t\tpass","def get_file_path(self,filename):\n return Path(self.resource_path,filename)","def get_item_image(itemID):\n\n for i in os.listdir(\"./resources/items\"):\n if i[:-4] == str(itemID):\n return \"./resources/items/{0}.png\".format(itemID)\n\n with open('./data/items.json', 'r') as f:\n for item in json.load(f):\n if item['id'] == itemID:\n with open(\"./resources/items/{0}.png\".format(itemID), 'wb') as f:\n f.write(requests.get(item['icon']).content)\n return \"./resources/items/{0}.png\".format(itemID)\n\n return \"No image found\"","def upload_location(instance, filename):\n new_id = randint(0, 1000)\n return \"%s/%s\" % (new_id, filename)","def format_path(file: str) -> str:\n return os.path.abspath([file.replace('/', os.path.sep)][0])","def filepath(self):\n return self._filepath.path","def get_path_for_item(item):\n query = item['original_query']\n if isinstance(query, dict):\n if 'grlc' in query:\n del query['grlc']\n query = \"\\n\" + json.dumps(query, indent=2) + \"\\n\"\n\n description = item['description']\n description += '\\n\\n```\\n{}\\n```'.format(query)\n description += '\\n\\nSPARQL transformation:\\n```json\\n{}```'.format(\n item['transform']) if 'transform' in item else ''\n\n item_path = {\n item['method']: {\n 'tags': item['tags'],\n 'summary': item['summary'],\n 'description': description,\n 'produces': ['text/csv', 'application/json', 'text/html'],\n 'parameters': item['params'] if 'params' in item else None,\n 'responses': {\n '200': {\n 'description': 'Query response',\n 'schema': {\n 'type': 'array',\n 'items': {\n 'type': 'object',\n 'properties': item['item_properties'] if 'item_properties' in item else None\n },\n }\n },\n 'default': {\n 'description': 'Unexpected error',\n 'schema': {\n '$ref': '#/definitions/Message'\n }\n }\n }\n }\n }\n return item_path","def fpath(self):\n return os.path.join(self.path, self.name)","def get_upload_path(instance: 'FileUpload', filename: str) -> str:\n if not instance.name:\n instance.name = filename # set original filename\n\n filename = '{name}.{ext}'.format(name=uuid4().hex,\n ext=filename.split('.')[-1])\n current_dt = now()\n return '/'.join([\n 'uploaded_files',\n str(current_dt.year),\n str(current_dt.month),\n str(current_dt.day),\n filename,\n ])","def path(self):\n return self.get_upload_set().path(self.filename)","def url_for(filename):\n return \"{}{}\".format(S3_LOCATION, filename)","def getFile():\n return P4_FILE_SEARCH.sub( P4_FILE_REPLACE_STRING, \"$File$\")","def save_image(fileitem):\n\tdocument_root = os.environ[\"DOCUMENT_ROOT\"]\n\tfn = os.path.basename(fileitem.filename)\n\tfull_path = document_root + UPLOAD_DIR + fn\n\topen(full_path, 'wb').write(fileitem.file.read())\n\treturn full_path","def get_attachment_upload_dir(instance, filename):\n return f\"{tasks}/{attachments}/{str(instance.task.id)}/{filename}\"","def path(self) -> str:\n return pulumi.get(self, \"path\")","def path(self) -> str:\n return pulumi.get(self, \"path\")","def item_id_to_name(itemID):\n\n with open('/data/items.json', 'r') as f:\n for item in json.load(f):\n if item['id'] == itemID:\n return item['name']","def get_fpath(self, sid):\n\n\t\treturn os.path.join(self.cm.get_booknlp_dirpath(sid), 'characters.json')","def _get_resource_path(filename, path=Path.TEST):\n return os.path.normpath(os.path.join(path.value, filename))","def get_static_path(path, aid, filename):\n return os.path.join(path, aid, os.path.basename(filename))","def service_image_file_path(instance, filename):\n ext = filename.split('.')[-1]\n filename = f'{uuid.uuid4()}.{ext}'\n\n return os.path.join('uploads/services/', filename)","def file_name(id, title, kind=\"src\"):\n fn_template = conf.template_source_file_name\n if kind == \"tst\":\n fn_template = conf.template_test_file_name\n\n return fn_template.format(id=id, title=title.replace(\"-\", \"_\"))","def _get_filepath(self) -> str:\n return os.path.join(\n os.sep.join(\n [\n self.period.value,\n 'activities',\n f'activities_{self._dt_string}.json'\n ]\n )\n )","def id_to_relative_raw_path(self, id):\n return osp.join(self.id_to_base_id(id) + '.ply')","def abspath(self, fileid):\n # Find the directory, relative from the corpus root.\n parent = os.path.relpath(\n os.path.dirname(self.corpus.abspath(fileid)), self.corpus.root\n )\n\n # Compute the name parts to reconstruct\n basename = os.path.basename(fileid)\n name, ext = os.path.splitext(basename)\n\n # Create the pickle file extension\n basename = name + '.pickle'\n\n # Return the path to the file relative to the target.\n return os.path.normpath(os.path.join(self.target, parent, basename))","def abspath(self, fileid):\n # Find the directory, relative from the corpus root.\n parent = os.path.relpath(\n os.path.dirname(self.corpus.abspath(fileid)), self.corpus.root\n )\n\n # Compute the name parts to reconstruct\n basename = os.path.basename(fileid)\n name, ext = os.path.splitext(basename)\n\n # Create the pickle file extension\n basename = name + '.pickle'\n\n # Return the path to the file relative to the target.\n return os.path.normpath(os.path.join(self.target, parent, basename))","def file_path(self):\n return self._obs_file()","def _get_input_filepath(self, game_id: int) -> str:\n with self._db_connection as connection:\n with connection.cursor() as cursor:\n cursor.execute('SELECT sgf_content FROM games WHERE id=%s', (game_id,))\n if cursor.rowcount == 0:\n raise GameNotFoundError()\n sgf_content, = cursor.fetchone()\n file_descriptor, filepath = tempfile.mkstemp('.sgf')\n with open(file_descriptor, 'wb') as file:\n file.write(sgf_content)\n return filepath","def item_name_from_id(item_id):\n return items[\"data\"][str(item_id)][\"name\"]","def get_api_file_url(file_id):\n api_url = get_api_url()\n return f\"{api_url}/files/{file_id}\"","def get_file_path(filename: str):\n return TEMP_DIR.joinpath(filename)","def getFile(self, stamp):\n name = escapeForPath(str(stamp))\n return os.path.join(self.path, name)","def image_upload_path(instance, filename):\n return \"adverts/{}/{}\".format(instance.uuid, filename)","def _unique_path(user_id, filename, category='images'):\n ext = os.path.splitext(filename)[-1]\n new_filename = '{}{}'.format(uuid.uuid4(), ext)\n return os.path.join(category, str(user_id), new_filename)","def get_file_path(self):\n return self._file_path","def tfile_path(filename):\n here = os.path.dirname(__file__)\n return '{0}/static/files/{1}'.format(here, filename)","def transcript_path_for_id(transcript_id):\n if transcript_id is int:\n transcript_id = \"%05d\" % transcript_id\n prefix_folder = str(transcript_id)[:3]\n return join(config.FISHER_ROOT, 'data', 'trans', prefix_folder, 'fe_03_%s.txt' % transcript_id)","def _get_file_by_id(id):\n query = \"\"\"SELECT * FROM files WHERE id = (:id) LIMIT 1\"\"\"\n param_obj = {'id': id}\n return _execute(query, param_obj)","def _file_storage_path(self, sha1, filename):\n # pylint: disable=no-member\n path = (\n '{loc.org}/{loc.course}/{loc.block_type}/{loc.block_id}/'\n '{student_id}/{sha1}{ext}'.format(\n\t\tstudent_id = self.xmodule_runtime.anonymous_student_id,\n loc=self.location,\n sha1=sha1,\n ext=os.path.splitext(filename)[1]\n )\n )\n return path","def filepath(self):\n return self.file.path","def _path(self):\n return self._table_path+\"flow/%s/\" % self._id","def get_api_file_content_url(file_id):\n return f\"{get_api_file_url(file_id)}/content\"","def _file_path(self, file: str) -> str:\n return os.path.abspath(f\"tests/resources/{file}\")","def upload_to(instance, filename):\n return upload_image_path(filename, 'products')","def path(self, args):\n dir_path = self.dir_path_(*args)\n return os.path.join(dir_path, self.file_name)"],"string":"[\n \"def fetchPutIOFile(self, fileID=None, fileDir=None):\\r\\n\\r\\n sigkill = 0\\r\\n\\r\\n if fileID == None or fileDir == None:\\r\\n raise ValueError('You must send a putio item id and file path.')\\r\\n\\r\\n if not fileID in self.contents:\\r\\n self.getItem(fileID)\\r\\n\\r\\n fileName = self.contents[fileID]['name']\\r\\n\\r\\n print(\\\"Downloading file: \\\" + fileName)\\r\\n while 1:\\r\\n try:\\r\\n resp, data = self.h.request(self.contents[fileID]['uri'])\\r\\n if resp.status >= 400:\\r\\n print(\\\"We couldn't downlaod the file: \\\" + fileName)\\r\\n print(resp)\\r\\n else:\\r\\n with open(fileDir, 'wb') as file:\\r\\n file.write(data)\\r\\n break\\r\\n except httplib2.HttpLib2Error or httplib2.socket.error as err:\\r\\n print(\\\"Warning we had a httplib2 error... Trying again.\\\")\\r\\n print(str(err))\\r\\n if sigkill <= 3:\\r\\n sigkill += 1\\r\\n pass\\r\\n else:\\r\\n print(\\\"ERROR: We failed to fetch item 3 items. Fuck this.\\\")\",\n \"def item_upload_to(instance, filename):\\n import os\\n file_root, file_ext = os.path.splitext(filename)\\n date = datetime.now().strftime(\\\"%Y%m%d\\\")\\n random_name = generate_random_string() + file_ext\\n classname = instance.__class__.__name__.lower()\\n filename = \\\"%s_%s\\\" % (date, random_name)\\n\\n if classname == 'relatedimage':\\n return '/'.join([classname, instance.content_type.name, filename])\\n return '/'.join([classname, filename])\",\n \"def get_items_path() -> Path:\\n return Path(os.path.join(Path(os.path.realpath(__file__)).parent, \\\"items.csv\\\"))\",\n \"def test_convert_id_to_path(self):\\n backend = BackendS3(**self.config)\\n filename = 'demo-test.tar.gz'\\n id = utils.generate_id(filename)\\n parts = backend.id_to_path(id)\\n self.assertEquals(6, len(parts))\\n self.assertEquals(filename, parts[5])\",\n \"def svn_client_commit_item_t_path_get(svn_client_commit_item_t_self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def __getitem__(self, item):\\n if item == 'path':\\n return str(self.path)\\n elif item == 'type':\\n return str(self.kind)\\n elif item == 'absolute_directory':\\n return str(self.path)\\n raise NotImplementedError()\",\n \"def item_ref_path(item: Union[BaseField, Config]) -> str:\\n return item._ref_path\",\n \"def _fetch_parent_item(file_id, client, dest):\\n target_file = client.getResource('file', file_id)\\n item = client.getResource('item', target_file['itemId'])\\n dest = os.path.join(dest, client.transformFilename(item['name']))\\n target_path = dest\\n\\n for file in client.listFile(item['_id']):\\n path = os.path.join(dest, client.transformFilename(file['name']))\\n client.downloadFile(file['_id'], path)\\n\\n if file['_id'] == target_file['_id']:\\n target_path = path\\n\\n return target_path\",\n \"def path(self, f):\\n\\t\\treturn os.path.join(self.directory, f)\",\n \"def get_id_path():\\n\\n root = os.path.dirname(os.path.abspath(__file__))[:-5]\\n id_path = os.path.join(root, \\\"client\\\\\\\\files\\\\\\\\id.txt\\\")\\n\\n return id_path\",\n \"def svn_client_commit_item2_t_path_get(svn_client_commit_item2_t_self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def get_upload_path(instance, filename):\\n \\n return \\\"user_{username}/{goal}/{file}\\\".format(id=instance.user.username, \\n goal=instance.name.slug, file=filename)\",\n \"def file_path(self) -> global___Expression:\",\n \"def get_item(dataobj_id):\\n file = get_by_id(dataobj_id)\\n if file:\\n data = frontmatter.load(file)\\n data[\\\"fullpath\\\"] = str(file)\\n data[\\\"dir\\\"] = str(file.parent.relative_to(get_data_dir()))\\n # replace . for root items to ''\\n if data[\\\"dir\\\"] == \\\".\\\":\\n data[\\\"dir\\\"] = \\\"\\\"\\n return data\\n return None\",\n \"def file_location(self, file: str) -> str:\\n return os.path.join(str(self.id), file)\",\n \"def get_file_path(instance, filename):\\n\\text = filename.split('.')[-1]\\n\\tfilename = '%s.%s' % (uuid.uuid4(), ext)\\n\\treturn os.path.join('upload', filename)\",\n \"def path_and_filename(instance, filename=None):\\n \\n # Note that filename parameter is set by the file upload form\\n # thus we have to make sure the function is defined accordingly.\\n # we role our own naming / numbering scheme below and ignore the uploaded file's name\\n file_path = 'keyfiles/keyfile_id_{0}'.format(instance.id)\\n if os.path.isfile(file_path):\\n os.remove(file_path)\\n return file_path\",\n \"def svn_client_commit_item3_t_path_get(svn_client_commit_item3_t_self): # real signature unknown; restored from __doc__\\n return \\\"\\\"\",\n \"def filenameAsPath(self, app):\\n return app.recordingsPath.child(self.filename).path\",\n \"def _filename(self, key):\\n return os.path.join(self.root, key[:2], key)\",\n \"def recipe_image_file_path(instance, filename):\\n # Return the extention of the file name\\n ext = filename.split('.')[-1]\\n # Create a new name using the uuid\\n filename = f'{uuid.uuid4()}.{ext}'\\n\\n # A relable method that allowed us to join 2 strings into a vaild path\\n return os.path.join('uploads/recipe/', filename)\",\n \"def get_upload_path(instance, filename):\\n \\n userpath = \\\"{name}/{file}\\\".format(name=instance.user.username, file=filename)\\n mainpath = os.path.join(\\\"infocomp\\\",userpath)\\n return mainpath\",\n \"def resource_path(self, resource):\\n # type: (Text) -> Text\\n # This deliberately raises FileNotFoundError instead of\\n # NotImplementedError so that if this method is accidentally called,\\n # it'll still do the right thing.\\n raise FileNotFoundError\",\n \"def _tf_idf_path(id):\\n return os.path.join(os.path.dirname(__file__), './tf_idfs/{0}.json'.format(id))\",\n \"def get_itemid(filename):\\n return os.path.splitext(os.path.basename(filename))[0]\",\n \"def path_for(objectid):\",\n \"def path_and_rename(instance, filename):\\n\\n upload_to = 'things'\\n ext = filename.split('.')[-1]\\n # get filename\\n if instance.pk:\\n filename = '{}.{}'.format(instance.pk, ext)\\n else:\\n # set filename as random string\\n filename = '{}.{}'.format(datetime.now(), ext)\\n # return the whole path to the file\\n return os.path.join(upload_to, filename)\",\n \"def get_file_path(obj):\\n return PATH + obj.strftime('%d-%B-%Y-comments.txt')\",\n \"def _filename(task_id):\\n return \\\"{}.json\\\".format(task_id)\",\n \"def get_upload_to(instance, filename):\\n\\n if instance.rating_decision:\\n return 'issuers/%s/rating_decision/%s/%s'\\\\\\n % (\\n instance.issuer.lei,\\n instance.rating_decision.id,\\n filename)\\n else:\\n return 'issuers/%s/%s' % (instance.issuer.lei, filename)\",\n \"def get_upload_path(instance, filename):\\n return os.path.join(getattr(settings, \\\"FILEBROWSER_DIRECTORY\\\"), str(instance.project.short_name.lower()), filename)\",\n \"def path_to(self, course_id, filename):\\r\\n return os.path.join(self.root_path, urllib.quote(course_id.to_deprecated_string(), safe=''), filename)\",\n \"def resource_path(self, resource):\\n return str(self.path.joinpath(resource))\",\n \"def resource_path(self, resource):\\n return str(self.path.joinpath(resource))\",\n \"def _file_url(self, fid):\\n base = self.tq.threatq_host + '/files/'\\n return base + str(fid) + '/details'\",\n \"def file_path(instance, filename):\\n hashcode = hash(filename)\\n mask = 255 # bitmask\\n # use the first and second bytes of the hash code represented as\\n # zero-padded hex numbers as directory names\\n # provides 256 * 256 = 65536 of possible directory combinations\\n dir1 = \\\"{:0>2x}\\\".format(hashcode & mask)\\n dir2 = \\\"{:0>2x}\\\".format((hashcode >> 8) & mask)\\n # Galaxy doesn't process names with parentheses in them\\n filename = re.sub('[()]', '_', filename)\\n return os.path.join(dir1, dir2, filename)\",\n \"def content_file_name(instance, filename):\\r\\n return '/'.join([str(instance.app.publisher.id), str(instance.app.id), filename])\",\n \"def recipe_image_file_path(instance, filename):\\n\\n ext = filename.split('.')[-1]\\n filename = f'{uuid.uuid4()}.{ext}'\\n\\n return os.path.join('uploads/recipe/', filename)\",\n \"def id2path(sid):\\n\\n wav_file_path = os.path.join(\\n dpath.IA, # Directory of IA mp3 files.\\n '{0:d}.mp3'.format(sid) # Named by SALAMI ID number.\\n )\\n\\n # Make sure it exists first\\n if os.path.exists(wav_file_path):\\n return wav_file_path\\n else:\\n return None\",\n \"def product_image_file_path(instance, filename):\\n ext = os.path.splitext(filename)[1]\\n filename = f'{uuid.uuid4()}{ext}'\\n\\n return os.path.join('uploads', 'product', filename)\",\n \"def file_path(self, request, response=None, info=None):\\n url = request.url\\n media_guid = hashlib.sha1(to_bytes(url)).hexdigest()\\n media_ext = os.path.splitext(url)[1]\\n if not media_ext.isalnum():\\n media_ext = os.path.splitext(urlparse(url).path)[1]\\n return \\\"full/%s%s\\\" % (media_guid, media_ext)\",\n \"def abspath(self, fileid):\\n # Find the directory, relative from the corpus root.\\n name = fileid.split('.')[0]\\n category = fileid.split('_')[0]\\n # Create the pickle file extension\\n basename = name + '.pickle'\\n\\n # Return the path to the file relative to the target.\\n return os.path.normpath(os.path.join(self.target, category, basename))\",\n \"def meta_files_from_item(cls, rel_item_path: pl.Path) -> tt.PathGen:\\n pass\",\n \"def base_filename_for_feed_item(feed_item):\\n return \\\"{}_{}\\\".format(\\n int(to_epoch(feed_item.upload_time)),\\n feed_item.video_id\\n )\",\n \"def getFilePath(self, filename):\\n idx = self._soundfiles.index(filename)\\n return \\\"{}/{}\\\".format(self._soundpaths[idx], filename)\",\n \"def get_content_path(content):\",\n \"def file_path(self):\\n return self.lib.file_path\",\n \"def FilePath(self) -> str:\",\n \"def _get_file_name(id):\\n client = Client(DRS_URL)\\n c = client.client\\n\\n # assume id will be NA18537\\n response = c.GetDataObject(data_object_id=id).result()\\n return response['data_object'][\\\"name\\\"]\",\n \"def full_file_path_f(self, *args, **kwargs):\\n return '%s/%s' % (self.location_f(*args, **kwargs), self.key_f(*args, **kwargs))\",\n \"def get_path(self):\\n try:\\n return self._file.path\\n except AttributeError:\\n return os.path.abspath(self._file.name)\",\n \"def song_directory_path(instance, filename):\\n return f\\\"music/songs/{instance.id}_{instance.name}_{filename}\\\"\",\n \"def relative_path(self, item):\\n if hasattr(item, 'path'):\\n return self.path.relative_path(item.path)\\n else:\\n return self.path.relative_path(item)\",\n \"def roompost_image_file_path(instance, filename):\\n ext = filename.split('.')[-1]\\n filename = f'{uuid.uuid4()}.{ext}'\\n\\n return os.path.join('uploads/post/', filename)\",\n \"def path(self):\\n return self.file_path()\",\n \"def get_path(self, path_id):\\n\\t\\tpass\",\n \"def get_file_path(self,filename):\\n return Path(self.resource_path,filename)\",\n \"def get_item_image(itemID):\\n\\n for i in os.listdir(\\\"./resources/items\\\"):\\n if i[:-4] == str(itemID):\\n return \\\"./resources/items/{0}.png\\\".format(itemID)\\n\\n with open('./data/items.json', 'r') as f:\\n for item in json.load(f):\\n if item['id'] == itemID:\\n with open(\\\"./resources/items/{0}.png\\\".format(itemID), 'wb') as f:\\n f.write(requests.get(item['icon']).content)\\n return \\\"./resources/items/{0}.png\\\".format(itemID)\\n\\n return \\\"No image found\\\"\",\n \"def upload_location(instance, filename):\\n new_id = randint(0, 1000)\\n return \\\"%s/%s\\\" % (new_id, filename)\",\n \"def format_path(file: str) -> str:\\n return os.path.abspath([file.replace('/', os.path.sep)][0])\",\n \"def filepath(self):\\n return self._filepath.path\",\n \"def get_path_for_item(item):\\n query = item['original_query']\\n if isinstance(query, dict):\\n if 'grlc' in query:\\n del query['grlc']\\n query = \\\"\\\\n\\\" + json.dumps(query, indent=2) + \\\"\\\\n\\\"\\n\\n description = item['description']\\n description += '\\\\n\\\\n```\\\\n{}\\\\n```'.format(query)\\n description += '\\\\n\\\\nSPARQL transformation:\\\\n```json\\\\n{}```'.format(\\n item['transform']) if 'transform' in item else ''\\n\\n item_path = {\\n item['method']: {\\n 'tags': item['tags'],\\n 'summary': item['summary'],\\n 'description': description,\\n 'produces': ['text/csv', 'application/json', 'text/html'],\\n 'parameters': item['params'] if 'params' in item else None,\\n 'responses': {\\n '200': {\\n 'description': 'Query response',\\n 'schema': {\\n 'type': 'array',\\n 'items': {\\n 'type': 'object',\\n 'properties': item['item_properties'] if 'item_properties' in item else None\\n },\\n }\\n },\\n 'default': {\\n 'description': 'Unexpected error',\\n 'schema': {\\n '$ref': '#/definitions/Message'\\n }\\n }\\n }\\n }\\n }\\n return item_path\",\n \"def fpath(self):\\n return os.path.join(self.path, self.name)\",\n \"def get_upload_path(instance: 'FileUpload', filename: str) -> str:\\n if not instance.name:\\n instance.name = filename # set original filename\\n\\n filename = '{name}.{ext}'.format(name=uuid4().hex,\\n ext=filename.split('.')[-1])\\n current_dt = now()\\n return '/'.join([\\n 'uploaded_files',\\n str(current_dt.year),\\n str(current_dt.month),\\n str(current_dt.day),\\n filename,\\n ])\",\n \"def path(self):\\n return self.get_upload_set().path(self.filename)\",\n \"def url_for(filename):\\n return \\\"{}{}\\\".format(S3_LOCATION, filename)\",\n \"def getFile():\\n return P4_FILE_SEARCH.sub( P4_FILE_REPLACE_STRING, \\\"$File$\\\")\",\n \"def save_image(fileitem):\\n\\tdocument_root = os.environ[\\\"DOCUMENT_ROOT\\\"]\\n\\tfn = os.path.basename(fileitem.filename)\\n\\tfull_path = document_root + UPLOAD_DIR + fn\\n\\topen(full_path, 'wb').write(fileitem.file.read())\\n\\treturn full_path\",\n \"def get_attachment_upload_dir(instance, filename):\\n return f\\\"{tasks}/{attachments}/{str(instance.task.id)}/{filename}\\\"\",\n \"def path(self) -> str:\\n return pulumi.get(self, \\\"path\\\")\",\n \"def path(self) -> str:\\n return pulumi.get(self, \\\"path\\\")\",\n \"def item_id_to_name(itemID):\\n\\n with open('/data/items.json', 'r') as f:\\n for item in json.load(f):\\n if item['id'] == itemID:\\n return item['name']\",\n \"def get_fpath(self, sid):\\n\\n\\t\\treturn os.path.join(self.cm.get_booknlp_dirpath(sid), 'characters.json')\",\n \"def _get_resource_path(filename, path=Path.TEST):\\n return os.path.normpath(os.path.join(path.value, filename))\",\n \"def get_static_path(path, aid, filename):\\n return os.path.join(path, aid, os.path.basename(filename))\",\n \"def service_image_file_path(instance, filename):\\n ext = filename.split('.')[-1]\\n filename = f'{uuid.uuid4()}.{ext}'\\n\\n return os.path.join('uploads/services/', filename)\",\n \"def file_name(id, title, kind=\\\"src\\\"):\\n fn_template = conf.template_source_file_name\\n if kind == \\\"tst\\\":\\n fn_template = conf.template_test_file_name\\n\\n return fn_template.format(id=id, title=title.replace(\\\"-\\\", \\\"_\\\"))\",\n \"def _get_filepath(self) -> str:\\n return os.path.join(\\n os.sep.join(\\n [\\n self.period.value,\\n 'activities',\\n f'activities_{self._dt_string}.json'\\n ]\\n )\\n )\",\n \"def id_to_relative_raw_path(self, id):\\n return osp.join(self.id_to_base_id(id) + '.ply')\",\n \"def abspath(self, fileid):\\n # Find the directory, relative from the corpus root.\\n parent = os.path.relpath(\\n os.path.dirname(self.corpus.abspath(fileid)), self.corpus.root\\n )\\n\\n # Compute the name parts to reconstruct\\n basename = os.path.basename(fileid)\\n name, ext = os.path.splitext(basename)\\n\\n # Create the pickle file extension\\n basename = name + '.pickle'\\n\\n # Return the path to the file relative to the target.\\n return os.path.normpath(os.path.join(self.target, parent, basename))\",\n \"def abspath(self, fileid):\\n # Find the directory, relative from the corpus root.\\n parent = os.path.relpath(\\n os.path.dirname(self.corpus.abspath(fileid)), self.corpus.root\\n )\\n\\n # Compute the name parts to reconstruct\\n basename = os.path.basename(fileid)\\n name, ext = os.path.splitext(basename)\\n\\n # Create the pickle file extension\\n basename = name + '.pickle'\\n\\n # Return the path to the file relative to the target.\\n return os.path.normpath(os.path.join(self.target, parent, basename))\",\n \"def file_path(self):\\n return self._obs_file()\",\n \"def _get_input_filepath(self, game_id: int) -> str:\\n with self._db_connection as connection:\\n with connection.cursor() as cursor:\\n cursor.execute('SELECT sgf_content FROM games WHERE id=%s', (game_id,))\\n if cursor.rowcount == 0:\\n raise GameNotFoundError()\\n sgf_content, = cursor.fetchone()\\n file_descriptor, filepath = tempfile.mkstemp('.sgf')\\n with open(file_descriptor, 'wb') as file:\\n file.write(sgf_content)\\n return filepath\",\n \"def item_name_from_id(item_id):\\n return items[\\\"data\\\"][str(item_id)][\\\"name\\\"]\",\n \"def get_api_file_url(file_id):\\n api_url = get_api_url()\\n return f\\\"{api_url}/files/{file_id}\\\"\",\n \"def get_file_path(filename: str):\\n return TEMP_DIR.joinpath(filename)\",\n \"def getFile(self, stamp):\\n name = escapeForPath(str(stamp))\\n return os.path.join(self.path, name)\",\n \"def image_upload_path(instance, filename):\\n return \\\"adverts/{}/{}\\\".format(instance.uuid, filename)\",\n \"def _unique_path(user_id, filename, category='images'):\\n ext = os.path.splitext(filename)[-1]\\n new_filename = '{}{}'.format(uuid.uuid4(), ext)\\n return os.path.join(category, str(user_id), new_filename)\",\n \"def get_file_path(self):\\n return self._file_path\",\n \"def tfile_path(filename):\\n here = os.path.dirname(__file__)\\n return '{0}/static/files/{1}'.format(here, filename)\",\n \"def transcript_path_for_id(transcript_id):\\n if transcript_id is int:\\n transcript_id = \\\"%05d\\\" % transcript_id\\n prefix_folder = str(transcript_id)[:3]\\n return join(config.FISHER_ROOT, 'data', 'trans', prefix_folder, 'fe_03_%s.txt' % transcript_id)\",\n \"def _get_file_by_id(id):\\n query = \\\"\\\"\\\"SELECT * FROM files WHERE id = (:id) LIMIT 1\\\"\\\"\\\"\\n param_obj = {'id': id}\\n return _execute(query, param_obj)\",\n \"def _file_storage_path(self, sha1, filename):\\n # pylint: disable=no-member\\n path = (\\n '{loc.org}/{loc.course}/{loc.block_type}/{loc.block_id}/'\\n '{student_id}/{sha1}{ext}'.format(\\n\\t\\tstudent_id = self.xmodule_runtime.anonymous_student_id,\\n loc=self.location,\\n sha1=sha1,\\n ext=os.path.splitext(filename)[1]\\n )\\n )\\n return path\",\n \"def filepath(self):\\n return self.file.path\",\n \"def _path(self):\\n return self._table_path+\\\"flow/%s/\\\" % self._id\",\n \"def get_api_file_content_url(file_id):\\n return f\\\"{get_api_file_url(file_id)}/content\\\"\",\n \"def _file_path(self, file: str) -> str:\\n return os.path.abspath(f\\\"tests/resources/{file}\\\")\",\n \"def upload_to(instance, filename):\\n return upload_image_path(filename, 'products')\",\n \"def path(self, args):\\n dir_path = self.dir_path_(*args)\\n return os.path.join(dir_path, self.file_name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65508145","0.6093909","0.605057","0.60210365","0.59997284","0.5959347","0.5940371","0.59336776","0.59185827","0.5912623","0.5863045","0.58628094","0.58371645","0.5830468","0.5817235","0.579462","0.5781786","0.5779269","0.5740309","0.5699368","0.5698278","0.5675912","0.56758964","0.56728435","0.56591356","0.5634577","0.5628783","0.5611127","0.5607594","0.56037116","0.55923754","0.5586332","0.557863","0.557863","0.5576686","0.55292714","0.5510627","0.54913527","0.54840636","0.5474762","0.54649305","0.5460743","0.5460724","0.54555106","0.5448358","0.5435008","0.5432602","0.5432508","0.54295945","0.54261357","0.54154253","0.5404628","0.5397727","0.5394856","0.539245","0.5388381","0.5372442","0.5369687","0.53646606","0.5363602","0.5361961","0.5354735","0.53514034","0.5348071","0.53479314","0.53471684","0.53465736","0.533556","0.5333284","0.53325737","0.53325737","0.53298795","0.5326952","0.53081703","0.5305408","0.53053766","0.5301614","0.5289698","0.52849895","0.5283085","0.5283085","0.52757925","0.52741003","0.5266303","0.5265272","0.52635574","0.52509594","0.52489215","0.52453935","0.5237481","0.5236138","0.523453","0.52252656","0.5218459","0.5216596","0.52091724","0.5204298","0.52009344","0.52008003","0.5189891"],"string":"[\n \"0.65508145\",\n \"0.6093909\",\n \"0.605057\",\n \"0.60210365\",\n \"0.59997284\",\n \"0.5959347\",\n \"0.5940371\",\n \"0.59336776\",\n \"0.59185827\",\n \"0.5912623\",\n \"0.5863045\",\n \"0.58628094\",\n \"0.58371645\",\n \"0.5830468\",\n \"0.5817235\",\n \"0.579462\",\n \"0.5781786\",\n \"0.5779269\",\n \"0.5740309\",\n \"0.5699368\",\n \"0.5698278\",\n \"0.5675912\",\n \"0.56758964\",\n \"0.56728435\",\n \"0.56591356\",\n \"0.5634577\",\n \"0.5628783\",\n \"0.5611127\",\n \"0.5607594\",\n \"0.56037116\",\n \"0.55923754\",\n \"0.5586332\",\n \"0.557863\",\n \"0.557863\",\n \"0.5576686\",\n \"0.55292714\",\n \"0.5510627\",\n \"0.54913527\",\n \"0.54840636\",\n \"0.5474762\",\n \"0.54649305\",\n \"0.5460743\",\n \"0.5460724\",\n \"0.54555106\",\n \"0.5448358\",\n \"0.5435008\",\n \"0.5432602\",\n \"0.5432508\",\n \"0.54295945\",\n \"0.54261357\",\n \"0.54154253\",\n \"0.5404628\",\n \"0.5397727\",\n \"0.5394856\",\n \"0.539245\",\n \"0.5388381\",\n \"0.5372442\",\n \"0.5369687\",\n \"0.53646606\",\n \"0.5363602\",\n \"0.5361961\",\n \"0.5354735\",\n \"0.53514034\",\n \"0.5348071\",\n \"0.53479314\",\n \"0.53471684\",\n \"0.53465736\",\n \"0.533556\",\n \"0.5333284\",\n \"0.53325737\",\n \"0.53325737\",\n \"0.53298795\",\n \"0.5326952\",\n \"0.53081703\",\n \"0.5305408\",\n \"0.53053766\",\n \"0.5301614\",\n \"0.5289698\",\n \"0.52849895\",\n \"0.5283085\",\n \"0.5283085\",\n \"0.52757925\",\n \"0.52741003\",\n \"0.5266303\",\n \"0.5265272\",\n \"0.52635574\",\n \"0.52509594\",\n \"0.52489215\",\n \"0.52453935\",\n \"0.5237481\",\n \"0.5236138\",\n \"0.523453\",\n \"0.52252656\",\n \"0.5218459\",\n \"0.5216596\",\n \"0.52091724\",\n \"0.5204298\",\n \"0.52009344\",\n \"0.52008003\",\n \"0.5189891\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7573712"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80593,"cells":{"query":{"kind":"string","value":"Check whether local directory tree exists. Create if not."},"document":{"kind":"string","value":"def createLocalDirectory(self, file=None):\r\n\r\n if file == None:\r\n raise ValueError(\"Pass a file path!\")\r\n\r\n path, fileName = os.path.split(file)\r\n\r\n try:\r\n if not os.path.exists(path):\r\n os.makedirs(path)\r\n except OSError as err:\r\n print(\"ERROR: Could not create directory for file\")\r\n print(str(err))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_local_directory(dirpath: pathlib.Path):\n if dirpath.exists():\n return False\n\n # TODO: Debug and improve this in order to catch particular exceptions\n try:\n dirpath.mkdir(parents=True)\n except Exception as error:\n raise SrtUtilsException(\n f'Directory was not created: {dirpath}. Exception '\n f'occured ({error.__class__.__name__}): {error}'\n )\n\n return True","def _create_local_dir(file_path:str)->bool:\n try:\n directory = os.path.dirname(file_path)\n if directory == \"\":\n return True # nothing to create\n if not os.path.exists(directory):\n os.makedirs(directory)\n except Exception as exc:\n raise Error(\"Error {} occurred while creating local directory\".format(exc))\n \n return True","def dirChecking(dir):\n if not os.path.exists(dir):\n os.mkdir(dir)","def create_dir():\n if check_dir_exist():\n return False\n else:\n os.makedirs(path_structure)\n return True","def check_dir(path, create = True):\n if os.path.exists(path):\n if os.path.isdir(path):\n return path\n else:\n return False\n if create:\n msg = \"Creating directory: '%s'\" % (path)\n print msg\n log.info(msg)\n os.mkdir(path)\n else:\n return False","def check_if_dir_exists():\n if not os.path.exists(str(__CURRENT_DIRECTORY) + os.sep + \"..\" + os.sep + \"logs\"):\n try:\n os.mkdir(str(__CURRENT_DIRECTORY) + os.sep + \"..\" + os.sep + \"logs\")\n logger.debug(\"Dir for logs has been created\")\n except OSError:\n logger.debug(f\"Creation of the directory {str(__CURRENT_DIRECTORY) + os.sep + '..' + os.sep + 'logs'} failed\")\n\n if not os.path.exists(str(__CURRENT_DIRECTORY) + os.sep + \"..\" + os.sep + \"db\"):\n try:\n os.mkdir(str(__CURRENT_DIRECTORY) + os.sep + \"..\" + os.sep + \"db\")\n logger.debug(\"Dir for DB has been created\")\n except OSError:\n logger.debug(f\"Creation of the directory {str(__CURRENT_DIRECTORY) + os.sep + '..' + os.sep + 'db'} failed\")","def test_makedirs_exists(self, client, remote_temp_dir):\n\n dir_path = posixpath.join(remote_temp_dir, \"some\", \"nested\", \"dir\")\n\n with HdfsHook() as hook:\n hook.makedirs(dir_path, exist_ok=False)\n\n with pytest.raises(IOError):\n hook.makedirs(dir_path, exist_ok=False)\n\n hook.makedirs(dir_path, exist_ok=True)","def _check_path(path):\n os.system(\"if [ ! -d \" + path + \" ]; then mkdir -p \" + path + \"; fi\")","def _check_or_create_dir(directory):\n if not tf.gfile.Exists(directory):\n tf.gfile.MakeDirs(directory)","def dirCheck(dirPath):\n if not os.path.exists(dirPath):\n os.mkdir(dirPath)\n return dirPath","def test_ensure_dir_exists(self):\n pass","def check_dir(path):\n if not os.path.exists(path):\n os.makedirs(path)","def checkExistenceDir(path):\n path = os.path.abspath(path)\n if not os.path.isdir(path):\n logger.warning(\n \"Directory {} does not seem to exist, creating one.\".format(path)\n )\n os.mkdir(path)","def checking_path():\n path = Path(\"phonebook\")\n try:\n path.mkdir(parents=True, exist_ok=False)\n except FileExistsError:\n pass\n else:\n pass","def check_path(dir_path):\n if not os.path.exists(dir_path):\n os.mkdir(dir_path, 0755)","def check_dir_exist():\n if os.path.isdir(path_structure):\n return True\n else:\n return False","def exist_ok_makedirs (path, mode=0777):\n if not os.path.isdir (path):\n head, tail = os.path.split (path)\n if not tail:\n head, tail = os.path.split (head)\n if head and tail:\n exist_ok_makedirs (head, mode)\n exist_ok_mkdir (path, mode)","def check_dir(dir):\n if not os.path.exists(dir):\n print(\"[+] Creating directory for target..\")\n os.makedirs(dir)","def check_dir(path):\n \n if not os.path.exists(path):\n os.makedirs(path)\n print path","def test_make_sure_path_exists(tmp_path):\n existing_directory = tmp_path\n directory_to_create = Path(tmp_path, \"not_yet_created\")\n\n utils.make_sure_path_exists(existing_directory)\n utils.make_sure_path_exists(directory_to_create)\n\n # Ensure by base system methods.\n assert existing_directory.is_dir()\n assert existing_directory.exists()\n assert directory_to_create.is_dir()\n assert directory_to_create.exists()","def test_makedirs(self, client, remote_temp_dir):\n\n dir_path = posixpath.join(remote_temp_dir, \"some\", \"nested\", \"dir\")\n\n with HdfsHook() as hook:\n hook.makedirs(dir_path, mode=0o750)\n\n assert client.exists(dir_path)\n assert client.info(dir_path)[\"permissions\"] == 0o750","def checkDir(dirName=None):\r\n if not os.path.exists(dirName):\r\n os.makedirs(dirName)\r\n return 0","def CheckDir(dir):\n if not os.path.exists(dir):\n os.makedirs(dir)","def dir_exists(self, path):\n if not path:\n return True\n return False","def _check_dirs(self):\r\n for dir in [self.papers_dir,\r\n self.buffer_dir]:\r\n if not os.path.exists(dir):\r\n message = f'Dir not exists: {dir}. Making it.'\r\n logging.warning(message)\r\n os.mkdir(dir)","def make_dir(path):\n if os.path.exists(path):\n return False\n else:\n os.makedirs(path, exist_ok=True)\n return True","def exist_ok_mkdir (path, mode=0777):\n try:\n os.mkdir (path, mode)\n except OSError:\n if not os.path.isdir (path):\n raise","def checkDirExists(dirPath):\n if not MyFile.checkFileExists(dirPath):\n MyFile.makeDir(dirPath)","def MakeDir(path):\n if os.path.exists(path):\n return False\n else:\n os.makedirs(path)\n return True","def check_folder(directory):\n global path_checked\n if not os.path.exists(directory):\n os.makedirs(directory)\n else:\n path_checked = True","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else: raise","def test_mkdir_exists(self, client, remote_temp_dir):\n\n dir_path = posixpath.join(remote_temp_dir, \"subdir\")\n assert not client.exists(dir_path)\n\n with HdfsHook() as hook:\n hook.mkdir(dir_path, exist_ok=False)\n\n with pytest.raises(IOError):\n hook.mkdir(dir_path, exist_ok=False)\n\n hook.mkdir(dir_path, exist_ok=True)","def make_sure_path_exists(input_path: Union[Path, str], isfile: bool = False):\n input_path = Path(input_path)\n\n if isfile:\n directory = input_path.parent\n else:\n directory = input_path\n\n if directory.exists():\n return\n else:\n directory.mkdir(parents=True)","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def ifnotexistmkdir(directory):\n if not os.path.exists(directory):\n os.mkdir(directory)\n return Path(directory)","def mkdir_p(path):\r\n try:\r\n os.makedirs(path)\r\n except OSError as exc: # Python >2.5\r\n if exc.errno == errno.EEXIST and os.path.isdir(path):\r\n pass\r\n else:\r\n raise","def checkDirectory(path,logger):\n newPath = completePath(path)\n if not os.path.exists(newPath):\n os.makedirs(newPath)\n if (logger):\n print(\"Did not found required directories. Creating them...\")\n else:\n if (logger):\n print(\"Found the required directories!\")","def chkPath(fullPath: str) -> None:\n\n # Check if path already exist.\n p = os.path.split(fullPath)\n exists = os.path.exists(p[0])\n # If not then create it.\n if exists == False:\n try:\n os.makedirs(p[0])\n except:\n print(\"Failed to create requested path.\")","def create_folder_if_needed(path):\n if os.path.exists(path):\n print(\"{} dir exists\".format(path))\n else:\n print(\"{} dir does not exist. Creating dir.\".format(path))\n os.mkdir(path)","def dir_exists(dirname):\n global datapath\n current_dir = './' + dirname + '/'\n parent_dir = '../' + dirname + '/'\n grandparent_dir = '../../' + dirname + '/'\n if os.path.isdir(current_dir):\n datapath = current_dir\n elif os.path.isdir(parent_dir):\n datapath = parent_dir\n elif os.path.isdir(grandparent_dir):\n datapath = grandparent_dir\n else:\n response = raw_input(\"'{}' directory does not exist. \"\n \"Create it [Y/n]? \".format(dirname))\n if not response or response[0].lower() == 'y':\n directory = os.getcwd()\n if os.path.basename(directory) == 'caribou-data-collection':\n # E.g. /caribou-data-collection/scraper.py\n datapath = current_dir\n os.makedirs(datapath)\n print 'Created', datapath\n elif os.path.basename(directory) in COUNTRIES:\n # E.g. /caribou-data-collection/country/scraper.py\n datapath = parent_dir\n os.makedirs(datapath)\n print 'Created', datapath\n elif os.path.basename(os.path.dirname(directory)) in COUNTRIES:\n # E.g. /caribou-data-collection/country/region/scraper.py\n datapath = grandparent_dir\n os.makedirs(datapath)\n print 'Created', datapath\n else:\n raise RuntimeError('Directory not created. '\n 'Please switch to the caribou-data-collection'\n ' directory and try again.')\n else:\n return False\n return True","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError, e:\n if e.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def mkdir_p(self, path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def _mkdir_p(path):\n if not osp.exists(path):\n os.makedirs(path)","def mkdir_if_missing(d):\n if not os.path.exists(d):\n os.makedirs(d)","def check_dir(directory):\n if not os.path.exists(directory):\n os.makedirs(directory)","def _mkdir_if_not_exist(path):\n if not(os.path.isdir(path)):\n os.mkdir(path)\n else:\n _logger.info('Skipping existing directory %s' % path)","def ensure_folders_if(path, condition=True):\n if not os.path.exists(path) and condition:\n os.makedirs(path)","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def initialize(self):\n if not self.mount():\n return False\n if not self.gvfs.create_dir_p(self._base):\n self._error = \"could not mkdir %r\" % self._base\n return False\n return True","def _check_is_dir(self, path):\n if os.path.isdir(path) and os.path.exists(path):\n self.__save_dir = path\n else:\n print(f'No existing directory found. Creating new directory at {path}')\n os.mkdir(path)\n self.__save_dir = path","def mkdir_p(path):\n try:\n os.makedirs(path) # , exist_ok=True\n except OSError:\n pass","def test_existingRemoteDirectory(self):\n def _check(results):\n self.assertEqual(results[0], b'')\n self.assertEqual(results[1],\n b'remote error 11: mkdir failed')\n\n d = self.runScript('mkdir testMakeDirectory',\n 'mkdir testMakeDirectory')\n d.addCallback(_check)\n return d","def safeCreateDir(relPath):\n if not os.path.isdir(relPath):\n os.mkdir(relPath)","def mkdir_if_not_exists(path):\n if not os.path.exists(path):\n os.makedirs(path)","def check_path(path, verbose = False):\n if (not os.path.isdir(path)):\n if (verbose):\n log(LogType.SERVICE, 'No ' + path + '. Creating. . .')\n os.mkdir(path, 0o777)","def _check_directory(my_folder):\n if not os.path.exists(my_folder):\n os.makedirs(my_folder)","def mkdir_p(path):\n\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def maybe_makedirs(path_to_create):\n try: \n os.makedirs(path_to_create)\n except OSError:\n if not os.path.isdir(path_to_create):\n raise","def mkdir_p(path):\n # http://stackoverflow.com/questions/600268/mkdir-p-functionality-in-python\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST:\n pass\n else:\n raise","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno == errno.EEXIST and os.path.isdir(path):\n pass\n else:\n raise","def check_dir(dname):\n direc = os.path.dirname(dname)\n try:\n os.stat(direc)\n except:\n os.mkdir(direc)\n print \"Made directory %s....\" % dname\n return dname","def _directory(self):\n dir = self.target\n\n if not os.path.exists(dir):\n return os.makedirs(dir)\n return True","def assure_path_exists(self, path):\n\n dir = os.path.dirname(path)\n if not os.path.exists(dir):\n os.makedirs(dir)","def create_dir_if_necessary(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise","def verify_dir_helper(dir):\n if not os.path.exists(dir):\n print(\"Creating cache directory at {}\".format(dir))\n os.makedirs(dir)","def _ensure_directory(self, dirname):\n if not os.path.exists(dirname):\n os.makedirs(dirname)","def mkdir_p(path):\n try:\n os.makedirs(path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST:\n pass\n else: raise","def make_sure_path_exists(path):\n try: os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST: raise","def safeMkDir(pth):\n try: os.mkdir(pth)\n except OSError: print 'directory %s already exists ?!'%pth","def make_sure_path_exists(path):\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno != errno.EEXIST:\n raise","def mkdir_p(path):\n path = expand_path(path)\n try:\n os.makedirs(path)\n except OSError as exception:\n if exception.errno == errno.EEXIST and os.path.isdir(path):\n return 'pre-existing: ' + path\n else:\n raise\n return 'new: ' + path","def EnsureDirExists(path):\n try:\n os.makedirs(os.path.dirname(path))\n except OSError:\n pass","def _check_path(self, path):\n result = False\n if self._check_dir_exists(path):\n # ok, path is an existing file system object and a directory. But is it also writeable?\n if self._check_access(os.path.abspath(path), os.W_OK):\n # Perfect.\n result = True\n else:\n # hm, the path doesn't exist. but could we create it? let's find the last existing parent...\n parent = os.path.dirname(os.path.abspath(path))\n while not self._check_dir_exists(parent):\n parent = os.path.dirname(parent)\n if self._check_access(os.path.abspath(parent), os.W_OK):\n # good news, we could create the path\n result = True\n return result","def testLocalDirectory(self):\n d = self.runCommand('lmkdir %s/testLocalDirectory' % (self.testDir.path,))\n d.addCallback(self.assertEqual, b'')\n d.addCallback(lambda _: self.runCommand('rmdir testLocalDirectory'))\n d.addCallback(self.assertEqual, b'')\n return d","def maybe_makedirs(path_to_create):\n try:\n os.makedirs(path_to_create)\n except OSError:\n if not os.path.isdir(path_to_create):\n raise","def ensure_dir(d):\n\n if not os.path.exists(d):\n os.makedirs(d, exist_ok=True)\n\n return","def create_tree(file, rep):\n try:\n if file is not None:\n rep = rep + '/' + file[0:4] + '/' + file[4:6] + '/' + file[6:8]\n if not exists(rep):\n makedirs(rep)\n move(file, rep)\n else:\n if not exists(rep + '/' + file):\n move(file, rep)\n else:\n print('Already exists!')\n except OSError:\n print('Argh! I could not create the directory!')","def prepare_dir(path, empty=False):\n\n def create_dir(path):\n \"\"\"\n Creates a directory\n :param path: string\n :return: nothing\n \"\"\"\n try:\n os.makedirs(path)\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n\n if not os.path.exists(path):\n create_dir(path)","def ensure_dir(f):\n\td=os.path.dirname(f)\n\tif not os.path.exists(d):\n\t\tos.makedirs(d)","def ensure_directory(path):\n\tdir_path = os.path.dirname(path)\n\tif os.path.exists(dir_path):\n\t\treturn\n\tensure_directory(dir_path)\n\ttry:\n\t\tos.mkdir(dir_path)\n\texcept OSError as e:\n\t\t# Ignore if EEXISTS. This is needed to avoid a race if two getters run at once.\n\t\tif e.errno != errno.EEXIST:\n\t\t\traise","def check_make(folder_check):\n if not os.path.isdir(folder_check):\n os.mkdir(folder_check)","def _ensure_dir(dir_name):\n if not os.path.exists(dir_name):\n os.makedirs(dir_name)","def ensure_dir_exists(path):\n if not os.path.exists(path):\n os.makedirs(path)","def ensure_dir(path):\n\n \n try:\n os.makedirs(path)\n except (EnvironmentError) as e:\n if not(e.errno == errno.EEXIST and \n e.filename == path):\n raise\n return","def safeMkDir(pth ,verbose ) :\n try: os.mkdir(pth)\n except OSError:\n if verbose:\n print('directory %s already exists ?!'%pth)","def mkdir_p(start_path):\n try:\n os.makedirs(start_path)\n except OSError as exc: # Python >2.5\n if exc.errno == errno.EEXIST and os.path.isdir(start_path):\n pass","def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\n if os.path.isdir(pathToDir) and isCleanIfExists:\n shutil.rmtree(pathToDir)\n if not os.path.isdir(pathToDir):\n os.makedirs(pathToDir)","def _check_repository_directory(self):\n if not os.path.exists(self._repository_path):\n os.makedirs(self._repository_path)","def try_makedirs(name):\n try:\n if not path.exists(name):\n # Strange, but it may raise winerror 123\n makedirs(name)\n except OSError:\n return","def mkdir_p(path):\n if not os.path.exists(path):\n os.makedirs(path)","def create_dir(name):\n root_dir = get_data_dir()\n new_path = root_dir / name.strip(\"/\")\n if is_relative_to(new_path, root_dir):\n new_path.mkdir(parents=True, exist_ok=True)\n return str(new_path.relative_to(root_dir))\n return False","def check_file(path):\n if not os.path.exists(path):\n os.makedirs(path)","def check_create_dir(directory):\n if not os.path.isdir(directory):\n if os.path.isfile(directory):\n raise RuntimeError(\"Cannot create directory %s, already \"\n \"exists as a file object\" % directory)\n os.makedirs(directory)\n log.debug(\"Making dir %s\" % directory)","def test_mkdir(self, client, remote_temp_dir):\n\n dir_path = posixpath.join(remote_temp_dir, \"subdir\")\n assert not client.exists(dir_path)\n\n with HdfsHook() as hook:\n hook.mkdir(dir_path, mode=0o750)\n\n assert client.exists(dir_path)\n assert client.info(dir_path)[\"permissions\"] == 0o750","def create_directory_structure(path_main):\n\n if not path_main.exists():\n path_main.mkdir(parents=True)","def _assert_dir_already_exists(dirname):\n\n if not dirname:\n return\n\n assert os.path.isdir(dirname), dirname\n assert os.access(dirname, os.R_OK), dirname\n assert os.access(dirname, os.W_OK), dirname","def ensure_dir( dirName ):\r\n if not os.path.exists( dirName ):\r\n os.makedirs( dirName )","def make_dir_if_needed(path):\n\n if not os.path.exists(path):\n os.makedirs(path)\n return path"],"string":"[\n \"def create_local_directory(dirpath: pathlib.Path):\\n if dirpath.exists():\\n return False\\n\\n # TODO: Debug and improve this in order to catch particular exceptions\\n try:\\n dirpath.mkdir(parents=True)\\n except Exception as error:\\n raise SrtUtilsException(\\n f'Directory was not created: {dirpath}. Exception '\\n f'occured ({error.__class__.__name__}): {error}'\\n )\\n\\n return True\",\n \"def _create_local_dir(file_path:str)->bool:\\n try:\\n directory = os.path.dirname(file_path)\\n if directory == \\\"\\\":\\n return True # nothing to create\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n except Exception as exc:\\n raise Error(\\\"Error {} occurred while creating local directory\\\".format(exc))\\n \\n return True\",\n \"def dirChecking(dir):\\n if not os.path.exists(dir):\\n os.mkdir(dir)\",\n \"def create_dir():\\n if check_dir_exist():\\n return False\\n else:\\n os.makedirs(path_structure)\\n return True\",\n \"def check_dir(path, create = True):\\n if os.path.exists(path):\\n if os.path.isdir(path):\\n return path\\n else:\\n return False\\n if create:\\n msg = \\\"Creating directory: '%s'\\\" % (path)\\n print msg\\n log.info(msg)\\n os.mkdir(path)\\n else:\\n return False\",\n \"def check_if_dir_exists():\\n if not os.path.exists(str(__CURRENT_DIRECTORY) + os.sep + \\\"..\\\" + os.sep + \\\"logs\\\"):\\n try:\\n os.mkdir(str(__CURRENT_DIRECTORY) + os.sep + \\\"..\\\" + os.sep + \\\"logs\\\")\\n logger.debug(\\\"Dir for logs has been created\\\")\\n except OSError:\\n logger.debug(f\\\"Creation of the directory {str(__CURRENT_DIRECTORY) + os.sep + '..' + os.sep + 'logs'} failed\\\")\\n\\n if not os.path.exists(str(__CURRENT_DIRECTORY) + os.sep + \\\"..\\\" + os.sep + \\\"db\\\"):\\n try:\\n os.mkdir(str(__CURRENT_DIRECTORY) + os.sep + \\\"..\\\" + os.sep + \\\"db\\\")\\n logger.debug(\\\"Dir for DB has been created\\\")\\n except OSError:\\n logger.debug(f\\\"Creation of the directory {str(__CURRENT_DIRECTORY) + os.sep + '..' + os.sep + 'db'} failed\\\")\",\n \"def test_makedirs_exists(self, client, remote_temp_dir):\\n\\n dir_path = posixpath.join(remote_temp_dir, \\\"some\\\", \\\"nested\\\", \\\"dir\\\")\\n\\n with HdfsHook() as hook:\\n hook.makedirs(dir_path, exist_ok=False)\\n\\n with pytest.raises(IOError):\\n hook.makedirs(dir_path, exist_ok=False)\\n\\n hook.makedirs(dir_path, exist_ok=True)\",\n \"def _check_path(path):\\n os.system(\\\"if [ ! -d \\\" + path + \\\" ]; then mkdir -p \\\" + path + \\\"; fi\\\")\",\n \"def _check_or_create_dir(directory):\\n if not tf.gfile.Exists(directory):\\n tf.gfile.MakeDirs(directory)\",\n \"def dirCheck(dirPath):\\n if not os.path.exists(dirPath):\\n os.mkdir(dirPath)\\n return dirPath\",\n \"def test_ensure_dir_exists(self):\\n pass\",\n \"def check_dir(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def checkExistenceDir(path):\\n path = os.path.abspath(path)\\n if not os.path.isdir(path):\\n logger.warning(\\n \\\"Directory {} does not seem to exist, creating one.\\\".format(path)\\n )\\n os.mkdir(path)\",\n \"def checking_path():\\n path = Path(\\\"phonebook\\\")\\n try:\\n path.mkdir(parents=True, exist_ok=False)\\n except FileExistsError:\\n pass\\n else:\\n pass\",\n \"def check_path(dir_path):\\n if not os.path.exists(dir_path):\\n os.mkdir(dir_path, 0755)\",\n \"def check_dir_exist():\\n if os.path.isdir(path_structure):\\n return True\\n else:\\n return False\",\n \"def exist_ok_makedirs (path, mode=0777):\\n if not os.path.isdir (path):\\n head, tail = os.path.split (path)\\n if not tail:\\n head, tail = os.path.split (head)\\n if head and tail:\\n exist_ok_makedirs (head, mode)\\n exist_ok_mkdir (path, mode)\",\n \"def check_dir(dir):\\n if not os.path.exists(dir):\\n print(\\\"[+] Creating directory for target..\\\")\\n os.makedirs(dir)\",\n \"def check_dir(path):\\n \\n if not os.path.exists(path):\\n os.makedirs(path)\\n print path\",\n \"def test_make_sure_path_exists(tmp_path):\\n existing_directory = tmp_path\\n directory_to_create = Path(tmp_path, \\\"not_yet_created\\\")\\n\\n utils.make_sure_path_exists(existing_directory)\\n utils.make_sure_path_exists(directory_to_create)\\n\\n # Ensure by base system methods.\\n assert existing_directory.is_dir()\\n assert existing_directory.exists()\\n assert directory_to_create.is_dir()\\n assert directory_to_create.exists()\",\n \"def test_makedirs(self, client, remote_temp_dir):\\n\\n dir_path = posixpath.join(remote_temp_dir, \\\"some\\\", \\\"nested\\\", \\\"dir\\\")\\n\\n with HdfsHook() as hook:\\n hook.makedirs(dir_path, mode=0o750)\\n\\n assert client.exists(dir_path)\\n assert client.info(dir_path)[\\\"permissions\\\"] == 0o750\",\n \"def checkDir(dirName=None):\\r\\n if not os.path.exists(dirName):\\r\\n os.makedirs(dirName)\\r\\n return 0\",\n \"def CheckDir(dir):\\n if not os.path.exists(dir):\\n os.makedirs(dir)\",\n \"def dir_exists(self, path):\\n if not path:\\n return True\\n return False\",\n \"def _check_dirs(self):\\r\\n for dir in [self.papers_dir,\\r\\n self.buffer_dir]:\\r\\n if not os.path.exists(dir):\\r\\n message = f'Dir not exists: {dir}. Making it.'\\r\\n logging.warning(message)\\r\\n os.mkdir(dir)\",\n \"def make_dir(path):\\n if os.path.exists(path):\\n return False\\n else:\\n os.makedirs(path, exist_ok=True)\\n return True\",\n \"def exist_ok_mkdir (path, mode=0777):\\n try:\\n os.mkdir (path, mode)\\n except OSError:\\n if not os.path.isdir (path):\\n raise\",\n \"def checkDirExists(dirPath):\\n if not MyFile.checkFileExists(dirPath):\\n MyFile.makeDir(dirPath)\",\n \"def MakeDir(path):\\n if os.path.exists(path):\\n return False\\n else:\\n os.makedirs(path)\\n return True\",\n \"def check_folder(directory):\\n global path_checked\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n else:\\n path_checked = True\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else: raise\",\n \"def test_mkdir_exists(self, client, remote_temp_dir):\\n\\n dir_path = posixpath.join(remote_temp_dir, \\\"subdir\\\")\\n assert not client.exists(dir_path)\\n\\n with HdfsHook() as hook:\\n hook.mkdir(dir_path, exist_ok=False)\\n\\n with pytest.raises(IOError):\\n hook.mkdir(dir_path, exist_ok=False)\\n\\n hook.mkdir(dir_path, exist_ok=True)\",\n \"def make_sure_path_exists(input_path: Union[Path, str], isfile: bool = False):\\n input_path = Path(input_path)\\n\\n if isfile:\\n directory = input_path.parent\\n else:\\n directory = input_path\\n\\n if directory.exists():\\n return\\n else:\\n directory.mkdir(parents=True)\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def ifnotexistmkdir(directory):\\n if not os.path.exists(directory):\\n os.mkdir(directory)\\n return Path(directory)\",\n \"def mkdir_p(path):\\r\\n try:\\r\\n os.makedirs(path)\\r\\n except OSError as exc: # Python >2.5\\r\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\r\\n pass\\r\\n else:\\r\\n raise\",\n \"def checkDirectory(path,logger):\\n newPath = completePath(path)\\n if not os.path.exists(newPath):\\n os.makedirs(newPath)\\n if (logger):\\n print(\\\"Did not found required directories. Creating them...\\\")\\n else:\\n if (logger):\\n print(\\\"Found the required directories!\\\")\",\n \"def chkPath(fullPath: str) -> None:\\n\\n # Check if path already exist.\\n p = os.path.split(fullPath)\\n exists = os.path.exists(p[0])\\n # If not then create it.\\n if exists == False:\\n try:\\n os.makedirs(p[0])\\n except:\\n print(\\\"Failed to create requested path.\\\")\",\n \"def create_folder_if_needed(path):\\n if os.path.exists(path):\\n print(\\\"{} dir exists\\\".format(path))\\n else:\\n print(\\\"{} dir does not exist. Creating dir.\\\".format(path))\\n os.mkdir(path)\",\n \"def dir_exists(dirname):\\n global datapath\\n current_dir = './' + dirname + '/'\\n parent_dir = '../' + dirname + '/'\\n grandparent_dir = '../../' + dirname + '/'\\n if os.path.isdir(current_dir):\\n datapath = current_dir\\n elif os.path.isdir(parent_dir):\\n datapath = parent_dir\\n elif os.path.isdir(grandparent_dir):\\n datapath = grandparent_dir\\n else:\\n response = raw_input(\\\"'{}' directory does not exist. \\\"\\n \\\"Create it [Y/n]? \\\".format(dirname))\\n if not response or response[0].lower() == 'y':\\n directory = os.getcwd()\\n if os.path.basename(directory) == 'caribou-data-collection':\\n # E.g. /caribou-data-collection/scraper.py\\n datapath = current_dir\\n os.makedirs(datapath)\\n print 'Created', datapath\\n elif os.path.basename(directory) in COUNTRIES:\\n # E.g. /caribou-data-collection/country/scraper.py\\n datapath = parent_dir\\n os.makedirs(datapath)\\n print 'Created', datapath\\n elif os.path.basename(os.path.dirname(directory)) in COUNTRIES:\\n # E.g. /caribou-data-collection/country/region/scraper.py\\n datapath = grandparent_dir\\n os.makedirs(datapath)\\n print 'Created', datapath\\n else:\\n raise RuntimeError('Directory not created. '\\n 'Please switch to the caribou-data-collection'\\n ' directory and try again.')\\n else:\\n return False\\n return True\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError, e:\\n if e.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def mkdir_p(self, path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def _mkdir_p(path):\\n if not osp.exists(path):\\n os.makedirs(path)\",\n \"def mkdir_if_missing(d):\\n if not os.path.exists(d):\\n os.makedirs(d)\",\n \"def check_dir(directory):\\n if not os.path.exists(directory):\\n os.makedirs(directory)\",\n \"def _mkdir_if_not_exist(path):\\n if not(os.path.isdir(path)):\\n os.mkdir(path)\\n else:\\n _logger.info('Skipping existing directory %s' % path)\",\n \"def ensure_folders_if(path, condition=True):\\n if not os.path.exists(path) and condition:\\n os.makedirs(path)\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def initialize(self):\\n if not self.mount():\\n return False\\n if not self.gvfs.create_dir_p(self._base):\\n self._error = \\\"could not mkdir %r\\\" % self._base\\n return False\\n return True\",\n \"def _check_is_dir(self, path):\\n if os.path.isdir(path) and os.path.exists(path):\\n self.__save_dir = path\\n else:\\n print(f'No existing directory found. Creating new directory at {path}')\\n os.mkdir(path)\\n self.__save_dir = path\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path) # , exist_ok=True\\n except OSError:\\n pass\",\n \"def test_existingRemoteDirectory(self):\\n def _check(results):\\n self.assertEqual(results[0], b'')\\n self.assertEqual(results[1],\\n b'remote error 11: mkdir failed')\\n\\n d = self.runScript('mkdir testMakeDirectory',\\n 'mkdir testMakeDirectory')\\n d.addCallback(_check)\\n return d\",\n \"def safeCreateDir(relPath):\\n if not os.path.isdir(relPath):\\n os.mkdir(relPath)\",\n \"def mkdir_if_not_exists(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def check_path(path, verbose = False):\\n if (not os.path.isdir(path)):\\n if (verbose):\\n log(LogType.SERVICE, 'No ' + path + '. Creating. . .')\\n os.mkdir(path, 0o777)\",\n \"def _check_directory(my_folder):\\n if not os.path.exists(my_folder):\\n os.makedirs(my_folder)\",\n \"def mkdir_p(path):\\n\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def maybe_makedirs(path_to_create):\\n try: \\n os.makedirs(path_to_create)\\n except OSError:\\n if not os.path.isdir(path_to_create):\\n raise\",\n \"def mkdir_p(path):\\n # http://stackoverflow.com/questions/600268/mkdir-p-functionality-in-python\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST:\\n pass\\n else:\\n raise\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno == errno.EEXIST and os.path.isdir(path):\\n pass\\n else:\\n raise\",\n \"def check_dir(dname):\\n direc = os.path.dirname(dname)\\n try:\\n os.stat(direc)\\n except:\\n os.mkdir(direc)\\n print \\\"Made directory %s....\\\" % dname\\n return dname\",\n \"def _directory(self):\\n dir = self.target\\n\\n if not os.path.exists(dir):\\n return os.makedirs(dir)\\n return True\",\n \"def assure_path_exists(self, path):\\n\\n dir = os.path.dirname(path)\\n if not os.path.exists(dir):\\n os.makedirs(dir)\",\n \"def create_dir_if_necessary(path):\\n try:\\n os.makedirs(path)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n raise\",\n \"def verify_dir_helper(dir):\\n if not os.path.exists(dir):\\n print(\\\"Creating cache directory at {}\\\".format(dir))\\n os.makedirs(dir)\",\n \"def _ensure_directory(self, dirname):\\n if not os.path.exists(dirname):\\n os.makedirs(dirname)\",\n \"def mkdir_p(path):\\n try:\\n os.makedirs(path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST:\\n pass\\n else: raise\",\n \"def make_sure_path_exists(path):\\n try: os.makedirs(path)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST: raise\",\n \"def safeMkDir(pth):\\n try: os.mkdir(pth)\\n except OSError: print 'directory %s already exists ?!'%pth\",\n \"def make_sure_path_exists(path):\\n try:\\n os.makedirs(path)\\n except OSError as exception:\\n if exception.errno != errno.EEXIST:\\n raise\",\n \"def mkdir_p(path):\\n path = expand_path(path)\\n try:\\n os.makedirs(path)\\n except OSError as exception:\\n if exception.errno == errno.EEXIST and os.path.isdir(path):\\n return 'pre-existing: ' + path\\n else:\\n raise\\n return 'new: ' + path\",\n \"def EnsureDirExists(path):\\n try:\\n os.makedirs(os.path.dirname(path))\\n except OSError:\\n pass\",\n \"def _check_path(self, path):\\n result = False\\n if self._check_dir_exists(path):\\n # ok, path is an existing file system object and a directory. But is it also writeable?\\n if self._check_access(os.path.abspath(path), os.W_OK):\\n # Perfect.\\n result = True\\n else:\\n # hm, the path doesn't exist. but could we create it? let's find the last existing parent...\\n parent = os.path.dirname(os.path.abspath(path))\\n while not self._check_dir_exists(parent):\\n parent = os.path.dirname(parent)\\n if self._check_access(os.path.abspath(parent), os.W_OK):\\n # good news, we could create the path\\n result = True\\n return result\",\n \"def testLocalDirectory(self):\\n d = self.runCommand('lmkdir %s/testLocalDirectory' % (self.testDir.path,))\\n d.addCallback(self.assertEqual, b'')\\n d.addCallback(lambda _: self.runCommand('rmdir testLocalDirectory'))\\n d.addCallback(self.assertEqual, b'')\\n return d\",\n \"def maybe_makedirs(path_to_create):\\n try:\\n os.makedirs(path_to_create)\\n except OSError:\\n if not os.path.isdir(path_to_create):\\n raise\",\n \"def ensure_dir(d):\\n\\n if not os.path.exists(d):\\n os.makedirs(d, exist_ok=True)\\n\\n return\",\n \"def create_tree(file, rep):\\n try:\\n if file is not None:\\n rep = rep + '/' + file[0:4] + '/' + file[4:6] + '/' + file[6:8]\\n if not exists(rep):\\n makedirs(rep)\\n move(file, rep)\\n else:\\n if not exists(rep + '/' + file):\\n move(file, rep)\\n else:\\n print('Already exists!')\\n except OSError:\\n print('Argh! I could not create the directory!')\",\n \"def prepare_dir(path, empty=False):\\n\\n def create_dir(path):\\n \\\"\\\"\\\"\\n Creates a directory\\n :param path: string\\n :return: nothing\\n \\\"\\\"\\\"\\n try:\\n os.makedirs(path)\\n except OSError as exc:\\n if exc.errno != errno.EEXIST:\\n raise\\n\\n if not os.path.exists(path):\\n create_dir(path)\",\n \"def ensure_dir(f):\\n\\td=os.path.dirname(f)\\n\\tif not os.path.exists(d):\\n\\t\\tos.makedirs(d)\",\n \"def ensure_directory(path):\\n\\tdir_path = os.path.dirname(path)\\n\\tif os.path.exists(dir_path):\\n\\t\\treturn\\n\\tensure_directory(dir_path)\\n\\ttry:\\n\\t\\tos.mkdir(dir_path)\\n\\texcept OSError as e:\\n\\t\\t# Ignore if EEXISTS. This is needed to avoid a race if two getters run at once.\\n\\t\\tif e.errno != errno.EEXIST:\\n\\t\\t\\traise\",\n \"def check_make(folder_check):\\n if not os.path.isdir(folder_check):\\n os.mkdir(folder_check)\",\n \"def _ensure_dir(dir_name):\\n if not os.path.exists(dir_name):\\n os.makedirs(dir_name)\",\n \"def ensure_dir_exists(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def ensure_dir(path):\\n\\n \\n try:\\n os.makedirs(path)\\n except (EnvironmentError) as e:\\n if not(e.errno == errno.EEXIST and \\n e.filename == path):\\n raise\\n return\",\n \"def safeMkDir(pth ,verbose ) :\\n try: os.mkdir(pth)\\n except OSError:\\n if verbose:\\n print('directory %s already exists ?!'%pth)\",\n \"def mkdir_p(start_path):\\n try:\\n os.makedirs(start_path)\\n except OSError as exc: # Python >2.5\\n if exc.errno == errno.EEXIST and os.path.isdir(start_path):\\n pass\",\n \"def makeDirIfNotExists(pathToDir, isCleanIfExists=True):\\n if os.path.isdir(pathToDir) and isCleanIfExists:\\n shutil.rmtree(pathToDir)\\n if not os.path.isdir(pathToDir):\\n os.makedirs(pathToDir)\",\n \"def _check_repository_directory(self):\\n if not os.path.exists(self._repository_path):\\n os.makedirs(self._repository_path)\",\n \"def try_makedirs(name):\\n try:\\n if not path.exists(name):\\n # Strange, but it may raise winerror 123\\n makedirs(name)\\n except OSError:\\n return\",\n \"def mkdir_p(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def create_dir(name):\\n root_dir = get_data_dir()\\n new_path = root_dir / name.strip(\\\"/\\\")\\n if is_relative_to(new_path, root_dir):\\n new_path.mkdir(parents=True, exist_ok=True)\\n return str(new_path.relative_to(root_dir))\\n return False\",\n \"def check_file(path):\\n if not os.path.exists(path):\\n os.makedirs(path)\",\n \"def check_create_dir(directory):\\n if not os.path.isdir(directory):\\n if os.path.isfile(directory):\\n raise RuntimeError(\\\"Cannot create directory %s, already \\\"\\n \\\"exists as a file object\\\" % directory)\\n os.makedirs(directory)\\n log.debug(\\\"Making dir %s\\\" % directory)\",\n \"def test_mkdir(self, client, remote_temp_dir):\\n\\n dir_path = posixpath.join(remote_temp_dir, \\\"subdir\\\")\\n assert not client.exists(dir_path)\\n\\n with HdfsHook() as hook:\\n hook.mkdir(dir_path, mode=0o750)\\n\\n assert client.exists(dir_path)\\n assert client.info(dir_path)[\\\"permissions\\\"] == 0o750\",\n \"def create_directory_structure(path_main):\\n\\n if not path_main.exists():\\n path_main.mkdir(parents=True)\",\n \"def _assert_dir_already_exists(dirname):\\n\\n if not dirname:\\n return\\n\\n assert os.path.isdir(dirname), dirname\\n assert os.access(dirname, os.R_OK), dirname\\n assert os.access(dirname, os.W_OK), dirname\",\n \"def ensure_dir( dirName ):\\r\\n if not os.path.exists( dirName ):\\r\\n os.makedirs( dirName )\",\n \"def make_dir_if_needed(path):\\n\\n if not os.path.exists(path):\\n os.makedirs(path)\\n return path\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7586968","0.752541","0.72212356","0.7198572","0.7167625","0.70522654","0.7001844","0.69993913","0.69269073","0.6925842","0.6918411","0.6912752","0.6870089","0.68536395","0.685239","0.68481475","0.6830266","0.6827925","0.67800814","0.67182344","0.6705626","0.6705205","0.6695645","0.6695047","0.6684188","0.6673846","0.66738015","0.6655525","0.6638383","0.66330165","0.6625022","0.66246665","0.6616973","0.66152793","0.66152793","0.66132516","0.6582905","0.657664","0.6559081","0.65530634","0.654698","0.65424","0.65400666","0.6537633","0.6530321","0.65286183","0.6523918","0.65189165","0.64914274","0.64914274","0.64893645","0.64856374","0.64841783","0.6482567","0.64789957","0.64631206","0.6459638","0.6450145","0.6443436","0.6443072","0.64409894","0.6439598","0.64369583","0.6434226","0.6430848","0.64266175","0.6418647","0.64115936","0.6400973","0.6398205","0.63967425","0.63777477","0.6373837","0.6365863","0.6362797","0.6355234","0.63524884","0.634617","0.6343949","0.63405716","0.633212","0.63291705","0.6325613","0.6321341","0.6312824","0.6309915","0.63093394","0.63089013","0.63038963","0.63034475","0.6297766","0.6291246","0.6290901","0.6290173","0.62892866","0.6288223","0.6287227","0.6285549","0.6285217","0.62779486","0.6270701"],"string":"[\n \"0.7586968\",\n \"0.752541\",\n \"0.72212356\",\n \"0.7198572\",\n \"0.7167625\",\n \"0.70522654\",\n \"0.7001844\",\n \"0.69993913\",\n \"0.69269073\",\n \"0.6925842\",\n \"0.6918411\",\n \"0.6912752\",\n \"0.6870089\",\n \"0.68536395\",\n \"0.685239\",\n \"0.68481475\",\n \"0.6830266\",\n \"0.6827925\",\n \"0.67800814\",\n \"0.67182344\",\n \"0.6705626\",\n \"0.6705205\",\n \"0.6695645\",\n \"0.6695047\",\n \"0.6684188\",\n \"0.6673846\",\n \"0.66738015\",\n \"0.6655525\",\n \"0.6638383\",\n \"0.66330165\",\n \"0.6625022\",\n \"0.66246665\",\n \"0.6616973\",\n \"0.66152793\",\n \"0.66152793\",\n \"0.66132516\",\n \"0.6582905\",\n \"0.657664\",\n \"0.6559081\",\n \"0.65530634\",\n \"0.654698\",\n \"0.65424\",\n \"0.65400666\",\n \"0.6537633\",\n \"0.6530321\",\n \"0.65286183\",\n \"0.6523918\",\n \"0.65189165\",\n \"0.64914274\",\n \"0.64914274\",\n \"0.64893645\",\n \"0.64856374\",\n \"0.64841783\",\n \"0.6482567\",\n \"0.64789957\",\n \"0.64631206\",\n \"0.6459638\",\n \"0.6450145\",\n \"0.6443436\",\n \"0.6443072\",\n \"0.64409894\",\n \"0.6439598\",\n \"0.64369583\",\n \"0.6434226\",\n \"0.6430848\",\n \"0.64266175\",\n \"0.6418647\",\n \"0.64115936\",\n \"0.6400973\",\n \"0.6398205\",\n \"0.63967425\",\n \"0.63777477\",\n \"0.6373837\",\n \"0.6365863\",\n \"0.6362797\",\n \"0.6355234\",\n \"0.63524884\",\n \"0.634617\",\n \"0.6343949\",\n \"0.63405716\",\n \"0.633212\",\n \"0.63291705\",\n \"0.6325613\",\n \"0.6321341\",\n \"0.6312824\",\n \"0.6309915\",\n \"0.63093394\",\n \"0.63089013\",\n \"0.63038963\",\n \"0.63034475\",\n \"0.6297766\",\n \"0.6291246\",\n \"0.6290901\",\n \"0.6290173\",\n \"0.62892866\",\n \"0.6288223\",\n \"0.6287227\",\n \"0.6285549\",\n \"0.6285217\",\n \"0.62779486\",\n \"0.6270701\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80594,"cells":{"query":{"kind":"string","value":"We will fetch a file and store it locally. fileID is the file ID of the file you want to download from put.io fileDir The file name and local directory to save the file."},"document":{"kind":"string","value":"def fetchPutIOFile(self, fileID=None, fileDir=None):\r\n\r\n sigkill = 0\r\n\r\n if fileID == None or fileDir == None:\r\n raise ValueError('You must send a putio item id and file path.')\r\n\r\n if not fileID in self.contents:\r\n self.getItem(fileID)\r\n\r\n fileName = self.contents[fileID]['name']\r\n\r\n print(\"Downloading file: \" + fileName)\r\n while 1:\r\n try:\r\n resp, data = self.h.request(self.contents[fileID]['uri'])\r\n if resp.status >= 400:\r\n print(\"We couldn't downlaod the file: \" + fileName)\r\n print(resp)\r\n else:\r\n with open(fileDir, 'wb') as file:\r\n file.write(data)\r\n break\r\n except httplib2.HttpLib2Error or httplib2.socket.error as err:\r\n print(\"Warning we had a httplib2 error... Trying again.\")\r\n print(str(err))\r\n if sigkill <= 3:\r\n sigkill += 1\r\n pass\r\n else:\r\n print(\"ERROR: We failed to fetch item 3 items. Fuck this.\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_file(self, file_id, filename=''):\n method = 'getFile?' + 'file_id=' + str(file_id)\n res = requests.post(self.api_url + method, file_id)\n try:\n file_path = res.json()['result']['file_path']\n # Determine the fileName. Use modified file_path if none given.\n if not filename:\n filename = file_path[file_path.rfind('/') + 1:]\n except (KeyError, ValueError):\n return \"500 - Failed parsing the file link from API response.\"\n\n if not os.path.exists(self.dirDownloads):\n os.mkdir(self.dirDownloads)\n\n local_path = os.path.join(self.dirDownloads, filename)\n\n # Download file as stream.\n res = requests.get(self.file_url + file_path, stream=True)\n if res.status_code == 200:\n try:\n with open(local_path, 'wb') as f:\n for chunk in res:\n f.write(chunk)\n except IOError:\n pass\n return '200 - {} written.'.format(local_path)\n else:\n return '404 - Error accessing {}'.format(file_path)","def download_file(service, file_id, file_name=None):\n # Setup request for the file\n request = service.files().get_media(fileId=file_id, supportsAllDrives=True)\n # setup the file handler to recieve the byte stream\n fh = io.BytesIO()\n\n # the download utility \n downloader = MediaIoBaseDownload(fh, request, chunksize=204800)\n # continue to download until all bytes are recieved\n done = False\n while not done:\n status, done = downloader.next_chunk()\n\n # go to beginning of stream\n fh.seek(0)\n\n # get file name meta data to store file with same name, \n # only executed if user did not provide a file name to store the file locally\n if file_name == None:\n file_name_results = service.files().get(fileId=file_id,\n fields='name', \n supportsAllDrives=True).execute()\n file_name = file_name_results['name']\n # copy stream from file handler to local storage\n with open(file_name, 'wb') as f:\n shutil.copyfileobj(fh, f)\n \n return file_name","def _download_file(self, file_id, file_name, path):\n request = self.service.files().get_media(fileId=file_id)\n fh = io.FileIO(path + file_name, 'wb')\n downloader = MediaIoBaseDownload(fh, request)\n done = False\n print('Start download ' + file_name)\n while not done:\n status, done = downloader.next_chunk()\n print(\"Download %d%%.\" % int(status.progress() * 100))","def download_file(client, file_id):\n\n file_content = client.file(file_id).content()\n print(file_content)","def download_file(self, file_id):\n \n file = self.service.files().get(fileId=file_id).execute()\n file_name = file['name']\n print ('Name:', file_name)\n # print ('MIME type:', file['mimeType'])\n local_fd = open(file_name, \"wb\")\n request = self.service.files().get_media(fileId=file_id)\n media_request = http.MediaIoBaseDownload(local_fd, request)\n\n while True:\n try:\n download_progress, done = media_request.next_chunk()\n except errors.HttpError as error:\n print ('An error occurred:', error)\n return\n if download_progress:\n print ('Download Progress:', int(download_progress.progress() * 100))\n if done:\n print ('Download Complete')\n local_fd.close()\n return","def download(self, file_id: str, output_path: str) -> str:\n url = self.get_method_url('storage', 'download', file_id)\n response = self.request(\n url=url,\n method='GET'\n )\n file_name = search(\n r'\\\"(.*?)\\\"', response.headers['content-disposition']\n ).group(1)\n with open(f'{output_path}/{file_name}', 'wb') as file:\n file.write(response.content)\n\n return f'{output_path}/{file_name}'","def download_file(self, id, file_name, file_location):\n if not self.check_for_file():\n gd = GDrive()\n gd.download_file(id, file_name, file_location)","def getFile(self, filename):\n # define a callback to handle the retrieved blocks:\n def cb(block, fp):\n fp.write(block)\n # retrieve the contents of the file and save locally:\n basename = os.path.basename(filename)\n fp = open(basename, 'wb')\n self.ftp.retrbinary('retr ' + filename, lambda block: cb(block, fp))\n fp.close()","def __download_file(self, filename):\r\n \r\n respons = requests.get(self.__url + filename, stream=True)\r\n save_filename = os.path.join(self.__folder, os.path.basename(filename))\r\n with open(save_filename, 'wb') as output_file:\r\n for chunk in respons.iter_content(chunk_size=128):\r\n output_file.write(chunk)","def download_file(self, filename: str, save_dir: str) -> None:\n raise NotImplementedError()","def download_file(url: str, local_dir: str = '.', local_filename: str = '') -> str:\n os.makedirs(f'{local_dir}', exist_ok=True)\n local_filename = local_filename if local_filename else url.split('/')[-1]\n if os.path.exists(f'{local_dir}/{local_filename}'):\n print(\"{0}/{1} already exists. Skipping download.\".format(local_dir, local_filename))\n else:\n print(\"Downloading file from {0} to {1}/{2}.\".format(url, local_dir, local_filename))\n with requests.get(url, stream=True) as r:\n r.raise_for_status()\n with open(f'./{local_dir}/{local_filename}', 'wb') as f:\n for chunk in r.iter_content(chunk_size=128):\n f.write(chunk)\n print(\"Finished saving file from {0} to {1}/{2}.\".format(url, local_dir, local_filename))\n return f'{local_dir}/{local_filename}'","def download_file(fileid, save_path):\n authorize_google_drive()\n file_object = DRIVE.CreateFile({'id': fileid})\n file_object.GetContentFile(save_path)\n return True","def download_file(file_id, filename):\n # httplib2 library is not thread-safe, need a new http for each thread\n drive_service = discovery.build('drive', 'v3', http=get_http())\n request = drive_service.files().get_media(fileId=file_id)\n\n fh = io.FileIO(filename, 'wb')\n downloader = MediaIoBaseDownload(fh, request)\n\n done = False\n while done is False:\n try:\n status, done = downloader.next_chunk()\n except Exception as ex:\n print (\"User rate limit exceeded for %s\" % filename)\n return False\n print (\"Download %d%%.\" % int(status.progress() * 100))\n return True","def _get(self, remote_filename, local_path):\n\n with local_path.open('wb') as local_file:\n file_id = self.get_file_id(remote_filename)\n if file_id is None:\n raise BackendException(\n 'File \"%s\" cannot be downloaded: it does not exist' %\n remote_filename)\n\n response = self.http_client.get(\n self.content_url + '/nodes/' + file_id + '/content', stream=True)\n response.raise_for_status()\n for chunk in response.iter_content(chunk_size=DEFAULT_BUFFER_SIZE):\n if chunk:\n local_file.write(chunk)\n local_file.flush()","def fetch(file_url):\n\n tmp_file_handle = NamedTemporaryFile(delete=True)\n headers = {'User-Agent': 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'}\n\n # download file and save to temp object\n with requests.get(file_url, headers=headers, stream=True) as r:\n tmp_file_handle.write(r.content)\n\n tmp_file_handle.flush()\n\n return tmp_file_handle","def put(self, url, localfile):\n\n cachedir = self._cachedir(url)\n filename = localfile.name\n\n logger.debug(f\"Storing {localfile} in cache for {url}\")\n shutil.copy2(localfile, cachedir / filename)\n self._writefilename(cachedir, filename)","def fetch(args):\n storage, remote_path = split_storage(args.remote)\n\n local_path = args.local\n if local_path is None:\n _, local_path = os.path.split(remote_path)\n\n local_path_exists = os.path.exists(local_path)\n if local_path_exists and not args.force and not args.update:\n sys.exit(\"Local file %s already exists, not overwriting.\" % local_path)\n\n directory, _ = os.path.split(local_path)\n if directory:\n makedirs(directory, exist_ok=True)\n\n osf = _setup_osf(args)\n project = osf.project(args.project)\n\n store = project.storage(storage)\n for file_ in store.files:\n if norm_remote_path(file_.path) == remote_path:\n if local_path_exists and not args.force and args.update:\n if file_.hashes.get('md5') == checksum(local_path):\n print(\"Local file %s already matches remote.\" % local_path)\n break\n with open(local_path, 'wb') as fp:\n file_.write_to(fp)\n\n # only fetching one file so we are done\n break","def addfile(self, filename, mode):\n if mode == 'never':\n return filename\n http = False\n if filename.startswith('http'):\n filename, headers = urllib.urlretrieve(filename)\n http = True\n if not http and mode == 'http':\n return filename\n dst = os.path.join(self.path, \"files\", str(uuid.uuid4()))\n try:\n folder = os.path.join(self.path, \"files\")\n if not os.path.exists(folder):\n os.mkdir(folder)\n shutil.copyfile(filename, dst)\n dst = dst.replace(self.path, '')\n dst = \"collector://collections/\" + self.collection_id + \"/\" + dst\n\n except IOError as ioex:\n logging.exception(ioex)\n return None\n return dst","def fetch_and_cache(data_url, file, data_dir=\"data\", force=False):\n data_dir = Path(data_dir)\n data_dir.mkdir(exist_ok = True)\n file_path = data_dir / Path(file)\n if force and file_path.exists():\n file_path.unlink()\n if force or not file_path.exists():\n print('Downloading...', end=' ')\n resp = requests.get(data_url)\n with file_path.open('wb') as f:\n f.write(resp.content)\n print('Done!')\n last_modified_time = time.ctime(file_path.stat().st_mtime)\n else:\n last_modified_time = time.ctime(file_path.stat().st_mtime)\n print(\"Using cached version that was downloaded (UTC):\", last_modified_time)\n return file_path","def fetch_file(url, filename):\n from clinica.utils.exceptions import ClinicaException\n from urllib.request import Request, urlopen\n from urllib.error import URLError\n import shutil\n import ssl\n import os.path\n from clinica.utils.stream import cprint\n\n head_tail = os.path.split(filename)\n if not os.path.exists(head_tail[0]):\n cprint('Path to the file does not exist')\n cprint('Stop Clinica and handle this error')\n\n # Download the file from `url` and save it locally under `file_name`:\n cert = ssl.get_server_certificate((\"aramislab.paris.inria.fr\", 443))\n gcontext = ssl.SSLContext()\n req = Request(url)\n try:\n response = urlopen(req, context=gcontext)\n except URLError as e:\n if hasattr(e, 'reason'):\n cprint('We failed to reach a server.')\n cprint(['Reason: ' + e.reason])\n elif hasattr(e, 'code'):\n cprint('The server could not fulfill the request.')\n cprint(['Error code: ' + e.code])\n else:\n try:\n with open(filename, 'wb') as out_file:\n shutil.copyfileobj(response, out_file)\n except OSError as err:\n cprint(\"OS error: {0}\".format(err))","def putFile(filename, file = None, localFilename = None):\n if not file and not filename:\n print(\"Please pass a valid file or filename\")\n\n if filename and not file:\n file = open(filename, \"rb\")\n\n print(\"filename: {}, file: {}\".format(filename, file))\n r = requests.put(\"{host}/{filename}\".format(host = host, filename = filename), files = {\"file\": file})\n return (r.ok, r.status_code, r.text)","def download_file(service, file_id, local_fd):\n request = service.files().get_media(fileId=file_id)\n media_request = http.MediaIoBaseDownload(local_fd, request)\n \n while True:\n try:\n download_progress, done = media_request.next_chunk()\n except errors.HttpError as error:\n print('An error occurred: %s' % error)\n return\n if download_progress:\n print('Download Progress: %d%%' % int(download_progress.progress() * 100))\n if done:\n print('Download Complete')\n return","def fetch_and_cache_gdrive(gdrive_id, file, data_dir=\"data\", force=False):\n\n import requests\n from hashlib import md5\n from pathlib import Path\n\n data_dir = Path(data_dir)\n data_dir.mkdir(exist_ok=True)\n file_path = data_dir/Path(file)\n # If the file already exists and we want to force a download then\n # delete the file first so that the creation date is correct.\n if force and file_path.exists():\n file_path.unlink()\n if force or not file_path.exists():\n download_file_from_google_drive(gdrive_id, file_path)\n else:\n import time\n time_downloaded = time.ctime(file_path.stat().st_ctime)\n print(\"Using version already downloaded:\", time_downloaded)\n # Compute and print md5 hash of file, whether newly downloaded or not\n m5 = md5()\n m5.update(file_path.read_bytes())\n print(f\"MD5 hash of file: {m5.hexdigest()}\")\n return file_path","def store_file(self,client,url,orig_filename):\n # Get rep_path to copy file\n try:\n filename, headers=urllib.urlretrieve(url)\n except:\n # if we fail here returns a None object\n self.log('File retrieval error for file %s' % url)\n return ''\n\n # Fix filename encoding\n udata=orig_filename.decode(\"utf-8\")\n orig_filename=udata.encode(\"ascii\",\"ignore\")\n\n # Use ckanclient patch to upload file to storage\n url, msg=util.upload_file(client,filename,orig_filename)\n\n # Log error if True\n if msg is not '':\n #log.error('File upload error:\\n %s' % msg)\n self.log( 'File upload error:\\n %s' % msg)\n return None\n\n return url","async def download_file(\n location_id: LocationID,\n file_id: StorageFileID,\n user_id: UserID,\n link_type: LinkType = LinkType.PRESIGNED,\n):","def download_file(service, file_id, file_path):\n request = service.files().get_media(fileId=file_id)\n with open(file_path, mode='wb') as f:\n downloader = MediaIoBaseDownload(f, request)\n done = False\n while done is False:\n status, done = downloader.next_chunk()","def download(self, filename, localfolder=None):\n raise NotImplementedError(\"Implement this method in child class\")","def download_file(service, file_id, local_fd):\n request = service.files().get_media(fileId=file_id)\n media_request = MediaIoBaseDownload(local_fd, request)\n\n while True:\n try:\n download_progress, done = media_request.next_chunk()\n except errors.HttpError as error:\n print('An error occurred: %s' % error)\n return\n # if download_progress:\n # print('Download Progress: %d%%' % int(download_progress.progress() * 100))\n if done:\n print('Download Complete')\n return","def update(self, example_id):\n\n download_file(self._remote.get_url(example_id), self._cache.get_local_cache_folder())","def __getFile_httplib(self, _src, _dst):\n\n #-------------------- \n # Pre-download callbacks\n #-------------------- \n self.runEventCallbacks('downloadStarted', _src, -1)\n self.runEventCallbacks('downloading', _src, 0)\n\n\n\n #-------------------- \n # Download\n #-------------------- \n response = self.__httpsRequest('GET', _src)\n data = response.read() \n with open(_dst, 'wb') as f:\n f.write(data) \n\n\n\n #-------------------- \n # Post-download callbacks\n #-------------------- \n self.removeFromDownloadQueue(_src)\n self.runEventCallbacks('downloadFinished', _src)","def download(self, key, filename):\n self.resource.Bucket(self.bucket).download_file(key, filename)\n return filename","def make_file_public(self, file_id):\n\n # Check if file is already public\n response = self.client.api_call(\n f'files.info?'\n f'file={file_id}'\n )\n if response['ok'] and response['file']['public_url_shared'] is True:\n return response\n\n response = self.client.api_call(\n f'files.sharedPublicURL?'\n f'file={file_id}'\n )\n assert response['ok']\n\n return response","def getFile(self, _src, _dst):\n\n #--------------------\n # Reset total size of downloads for all files\n #-------------------------\n self.downloadTracker['totalDownloadSize']['bytes'] = 0\n self.downloadTracker['downloadedSize']['bytes'] = 0\n downloadFolders = []\n\n #-------------------------\n # Remove existing dst files from their local URI\n #-------------------------\n if os.path.exists(_dst):\n os.remove(_dst)\n self.__getFile_requests(_src, _dst)","def download_file(fileId, fileName):\n creds = authenticate()\n service = build('drive', 'v3', credentials=creds)\n\n request = service.files().get_media(fileId=fileId)\n\n # print(request)\n\n # Downloads the photo to local storage.\n fh = io.FileIO(temp_dir + fileName, mode='wb')\n downloader = MediaIoBaseDownload(fd=fh, request=request)\n\n\n done = False\n while done is False:\n status,done = downloader.next_chunk()\n # print(\"Download %d%%.\" % int(status.progress() * 100))\n\n fh.close()\n\n return fileName","def _download_file(self, artifact_path, local_path):\n full_path = self.base_artifact_path / artifact_path\n with self.managed_folder.get_file(str(full_path)) as remote_file:\n with open(local_path, \"wb\") as local_file:\n for line in remote_file:\n local_file.write(line)","def get_file(self, key, local_file):\n\t\t\n\t\ttry:\n\t\t\tfh = open(local_file, 'wb')\n\t\t\tfh.write(self.s3.get(self.bucket, key).object.data)\n\t\t\tfh.close()\n\t\texcept:\n\t\t\treturn False","def fetch_save(url):\n\n name = url.split(\"/\")[-1]\n response = requests.get(url, stream=True)\n if response.status_code == 200:\n with open(f\"{DATA_PATH}/{name}\", \"wb\") as f:\n f.write(response.raw.read())\n else:\n logging.info(f\"Failed {url} download\")","async def get_file(self, file_id: base.String) -> types.File:\n payload = generate_payload(**locals())\n result = await self.request(api.Methods.GET_FILE, payload)\n\n return types.File(**result)","def download_file(self):\n files = self.s3_client.list_objects_v2(\n Bucket=settings.PRIVATE_DATA_BUCKET_NAME, Prefix=f\"{self.import_type}/\"\n )[\"Contents\"]\n\n latest_file_key = sorted(files, key=lambda f: f[\"LastModified\"])[0][\"Key\"]\n print(latest_file_key)\n file = Path(self.tmp_dir.name) / self.import_type / \"full.csv\"\n file.parent.mkdir(exist_ok=True, parents=True)\n self.file_path = file\n with file.open(\"wb\") as f:\n self.s3_client.download_fileobj(\n settings.PRIVATE_DATA_BUCKET_NAME, latest_file_key, f\n )","def get_file(self, file_id):\n LOG.debug(\"Getting a file from mattermost\")\n url = '%s/api/v4/files/%s' % (self.server_url, file_id)\n LOG.debug(\"Sending: %s\", url)\n response = self._request(self._session.get, url)\n\n if response.status_code != 200:\n raise RuntimeError(\"Server unhappy. (%s)\", response)\n\n return response.content","def get_file(self, remote_path, local_path, storage_id=None):\n return self.get(remote_path, local_path, directory=False, storage_id=storage_id)","def download_file(self, remote_file):\n remote_file.download()","def _download_minio_file(file_name):\n minioClient = Minio(MINIO_END_POINT,\n access_key = MINIO_ACCESS_KEY,\n secret_key = MINIO_SECRET_KEY,\n secure = True)\n\n file_path = f\"{LOCAL_FILES_PATH}/{file_name}\" # path to download the file\n file_name_indexed = file_name + \".tbi\" # hard coded\n file_path_indexed = f\"{LOCAL_FILES_PATH}/{file_name_indexed}\" # path to download indexed file\n bucket = 'test'\n\n # Create the file\n try:\n f = open(file_path, \"x\")\n f.close()\n\n f = open(file_path_indexed, \"x\")\n f.close()\n except:\n # File already exists, do nothing\n pass\n\n # download the required file into file_path\n try:\n minioClient.fget_object(bucket, file_name, file_path)\n minioClient.fget_object(bucket, file_name_indexed, file_path_indexed)\n except ResponseError as err:\n print(err)","def fetch_and_extract(self, filename):\n # type: (Text) -> None\n\n with io.open(filename, 'wb') as f:\n self.bucket.download_fileobj(filename, f)\n with tarfile.open(filename, \"r:gz\") as tar:\n tar.extractall(self.data_dir)","def download_file():\n\n if 'POST' == request.method:\n file_id = request.form['file_id']\n else:\n file_id = request.args.get('file_id')\n\n # 1 ==> example_1.tgz\n file_path = file_manager.get_file_path_from_id(file_id)\n print \"serving file: \" + file_path\n return send_file(file_path, as_attachment=True)","def main(url, localfile):\n ph.download_file(url, localfile)","def download_and_save(url, file_name,file_extension):\n #make a request for the file\n response = requests.get(url, allow_redirects =True)\n\n #compose the file + extension\n file_to_be_saved = f\"{file_name}.{file_extension}\"\n \n #Create a new file with \"file_to_be_saved\" in the current directory\n # And save this file and print the directory with the OS module\n with open(file_to_be_saved, 'wb') as file:\n print(\"saving file.... \\n\")\n file.write(response.content)\n print('done....\\n')\n print('file saved as: ', file_to_be_saved )\n print('in: ', os.getcwd() )","def save_file(url, *, out_dir='sha_tmp/', out_name=None):\n exten_types = {'image/fits': '.fits',\n 'text/plain; charset=UTF-8': '.tbl',\n 'application/zip': '.zip',\n }\n # Make request\n response = requests.get(url, stream=True)\n response.raise_for_status()\n # Name file using ID at end\n if out_name is None:\n out_name = 'shaID_' + id_parse.findall(url)[0]\n # Determine extension\n exten = exten_types[response.headers['Content-Type']]\n # Check if path exists\n if not os.path.exists(out_dir):\n os.makedirs(out_dir)\n # Write file\n with open(out_dir + out_name + exten, 'wb') as f:\n for block in response.iter_content(1024):\n f.write(block)","def download_file(self, parsed_event, input_dir_path):","def get_file(self, file_name: str) -> BytesIO:\n fl = BytesIO()\n self.client.download_fileobj(self.bucket, file_name, fl)\n fl.seek(0)\n return fl","def download_file(self, bucket, key, download_dir, download_file=None, temp_dir=None):\n for argument in [(\"Bucket\", bucket), (\"Key\", key)]:\n if not isinstance(argument[1], six.string_types):\n raise ValueError('{} must be a string'.format(argument[0]))\n\n if not temp_dir:\n temp_dir = download_dir\n\n if not download_file:\n download_file = os.path.basename(key)\n\n create_directory_tree(temp_dir)\n create_directory_tree(download_dir)\n\n local_file_path = os.path.join(download_dir, download_file)\n\n # The file was already downloaded\n if os.path.isfile(local_file_path):\n return local_file_path\n\n # Avoid other instances to download the same file\n filelock_filepath = get_filelock_path(download_file)\n lock = filelock.FileLock(filelock_filepath)\n try:\n with lock.acquire(timeout=10):\n downloaded_file = self._download_parts(bucket, key, download_file, temp_dir)\n if downloaded_file is not None and downloaded_file != local_file_path:\n os.rename(downloaded_file, local_file_path)\n except filelock.Timeout:\n raise S3ResumableBloqued(\"Another instance is currently downloading {}\".format(\n local_file_path))\n\n return local_file_path","def _file_data(self, message, data, is_external=True):\n message.file = o.File(data)\n if data.get('is_starred'):\n message.is_starred = True\n\n if is_external:\n logging.debug(\"Found external file `%s'\", data['url_private'])\n message.file.url = data['url_private']\n else:\n logging.debug(\"Found internal file `%s'\",\n data['url_private_download'])\n priv_url = data['url_private_download']\n message.file.filepath = self.downloader.download(priv_url, 'file')\n self.session.add(message.file)","def save_file(self, name, file):\n fs = FileSystemStorage()\n filename = fs.save(name, file)\n return fs.path(filename), fs.url(filename)","def putFile(self, filename):\n basename = os.path.basename(filename)\n fp = open(filename, 'rb')\n self.ftp.storbinary('stor ' + basename, fp)\n fp.close();","def get_file(url, file_name=None):\n cache_dir = os.path.join(os.path.expanduser(\"~\"), \".jhML\")\n\n if file_name is None:\n file_name = url[url.rfind('/') + 1:]\n file_path = os.path.join(cache_dir, file_name)\n\n if not os.path.exists(cache_dir):\n os.mkdir(cache_dir)\n\n if os.path.exists(file_path):\n return file_path\n\n print(\"Downloading: \" + file_name)\n try:\n urllib.request.urlretrieve(url, file_path, show_progress)\n except (Exception, KeyboardInterrupt) as e:\n if os.path.exists(file_path):\n os.remove(file_path)\n raise\n print(\" Done\")\n\n return file_path","def fetch_file(self, path, content_type, response=settings.HTTP_OK):\n try:\n with open(path) as fp:\n self.fetch_content(fp.read(), content_type, response)\n except IOError:\n self.send_error(settings.HTTP_INTERNAL_SERVER_ERROR)","def download(filename):\n print \"Downloading\", filename\n file_content = urlopen(\n urljoin(URL_PATH, filename)\n )\n write_data_to_file(\n file_content.read(),\n os.path.join(\n '/tmp',\n filename\n )\n )","def download_file_from_icos(icos_obj, bucket: str, local_file_name: str, key: str) -> None:\r\n try:\r\n icos_obj.download_file(Bucket=bucket, Key=key, Filename=local_file_name)\r\n except Exception as e:\r\n print(Exception, e)\r\n else:\r\n print('File `{}` downloaded from ICOS and saved locally as `{}`.'.format(key, local_file_name))","async def download_file_by_id(self, file_id: base.String, destination=None,\n timeout: base.Integer = 30, chunk_size: base.Integer = 65536,\n seek: base.Boolean = True):\n file = await self.get_file(file_id)\n return await self.download_file(file_path=file.file_path, destination=destination, timeout=timeout,\n chunk_size=chunk_size, seek=seek)","def get_datafile(file_):\n\n if os.path.exists(file_):\n return file_\n else:\n\n # download file, then return file_ path\n\n (path_, fname) = os.path.split(file_)\n if path_ == '':\n path_ = '.' # relative to current path\n\n try:\n resp = urllib_request.urlopen(urljoin(DATA_SERVER, fname))\n except urllib_request.HTTPError as ex:\n ex.msg = (\"{0}. '{1}' not found on server or server is down\"\n .format(ex.msg, fname))\n raise ex\n\n # # progress bar\n # widgets = [fname + ': ',\n # pb.Percentage(),\n # ' ',\n # pb.Bar(),\n # ' ',\n # pb.ETA(),\n # ' ',\n # pb.FileTransferSpeed(),\n # ]\n\n # pbar = pb.ProgressBar(widgets=widgets,\n # maxval=int(resp.info().getheader('Content-Length'))\n # ).start()\n\n if not os.path.exists(path_):\n os.makedirs(path_)\n\n sz_read = 0\n with open(file_, 'wb') as fh:\n # while sz_read < resp.info().getheader('Content-Length')\n # goes into infinite recursion so break loop for len(data) == 0\n while True:\n data = resp.read(CHUNKSIZE)\n\n if len(data) == 0:\n break\n else:\n fh.write(data)\n sz_read += len(data)\n\n # if sz_read >= CHUNKSIZE:\n # pbar.update(CHUNKSIZE)\n\n # pbar.finish()\n return file_","def fetch(self, fname, processor=None, downloader=None, progressbar=False):\n self._assert_file_in_registry(fname)\n\n # Create the local data directory if it doesn't already exist\n make_local_storage(str(self.abspath))\n\n url = self.get_url(fname)\n full_path = self.abspath / fname\n known_hash = self.registry[fname]\n action, verb = download_action(full_path, known_hash)\n\n if action == \"update\" and not self.allow_updates:\n raise ValueError(\n f\"{fname} needs to update {full_path} but updates are disallowed.\"\n )\n\n if action in (\"download\", \"update\"):\n get_logger().info(\n \"%s file '%s' from '%s' to '%s'.\",\n verb,\n fname,\n url,\n str(self.abspath),\n )\n\n if downloader is None:\n downloader = choose_downloader(url, progressbar=progressbar)\n\n stream_download(\n url,\n full_path,\n known_hash,\n downloader,\n pooch=self,\n retry_if_failed=self.retry_if_failed,\n )\n\n if processor is not None:\n return processor(str(full_path), action, self)\n\n return str(full_path)","def dwnld_with_id(credentials, file_id, dst_pth):\n \n http = credentials.authorize(httplib2.Http())\n service = discovery.build('drive', 'v3', http=http)\n\n request = service.files().get_media(fileId=file_id)\n fh = io.FileIO( dst_pth, 'wb' )\n downloader = MediaIoBaseDownload(fh, request)\n done = False\n while done is False:\n status, done = downloader.next_chunk()\n print ( '{} Download {}%.'.format( file_id, int(status.progress() * 100) ) )","def download_file_endpoint(self, guid=None):\n if not isinstance(guid, str):\n raise Gen3Error(\"Please, supply GUID as string.\")\n\n download_url = \"{}/user/data/download/{}\".format(self._endpoint, guid)\n print(\"Downloading file from '{}'.\".format(download_url))\n\n try:\n # get the pre-signed URL\n res = requests.get(\n download_url, auth=self._auth_provider\n ) # get the presigned URL\n file_url = json.loads(res.content)[\"url\"]\n\n # extract the filename from the pre-signed url\n f_regex = re.compile(\n r\".*[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\\/(.*)\\?.*\"\n )\n fmatch = f_regex.match(res.text)\n if fmatch:\n file_name = fmatch.groups()[0]\n print(\"\\tSaving downloaded file as '{}'\".format(file_name))\n else:\n file_name = guid\n print(\n \"No matching filename in the response. Saving file with GUID as filename.\"\n )\n\n # get the file and write the contents to the file_name\n res_file = requests.get(file_url)\n open(\"./{}\".format(file_name), \"wb\").write(res_file.content)\n\n except Exception as e:\n print(\"\\tFile '{}' failed to download: {}\".format(file_name, e))\n\n return file_name","def fetch_file(self, location, output=None):\n\n self.log.debug(\"Fetching '%s' file...\" % location)\n\n if not output:\n output = tempfile.mktemp(\"-dogen\")\n \n self.log.debug(\"File will be saved as '%s'...\" % output)\n\n with open(output, 'wb') as f:\n f.write(requests.get(location, verify=self.ssl_verify).content)\n\n return output","async def _download(self) -> None:\n\n # do request\n async with aiohttp.ClientSession() as session:\n async with session.get(self.url, auth=self._auth, timeout=self._timeout) as response:\n # check response\n if response.status == 200:\n # get data and return it\n self._buffer = await response.read()\n elif response.status == 401:\n log.error(\"Wrong credentials for downloading file.\")\n raise FileNotFoundError\n else:\n log.error(\"Could not download file from filecache.\")\n raise FileNotFoundError","def fetch_file(index_file, filename):\n with open(index_file, 'r') as index, open(filename, 'w+') as download:\n print 'Fetching keys from ', KEYSERVER, ' to create ', filename\n fetched_file = ''\n index_length = len(index.readlines())\n index.seek(0) # because python is stupid\n counter = 0\n for key in index.readlines():\n print 'Fetching key ', counter, ' of ', index_length\n counter = counter + 1\n fetched_file = fetched_file + parse_key(key.rstrip('\\n'))\n print 'All keys have been downloaded'\n download.write(base64.b64decode(fetched_file))\n print 'File has been decoded and saved as ', filename","def create_file(filename,filename_on_drive):\r\n creds = None\r\n # The file token.pickle stores the user's access and refresh tokens, and is\r\n # created automatically when the authorization flow completes for the first\r\n # time.\r\n if os.path.exists('token.pickle'):\r\n with open('token.pickle', 'rb') as token:\r\n creds = pickle.load(token)\r\n # If there are no (valid) credentials available, let the user log in.\r\n if not creds or not creds.valid:\r\n if creds and creds.expired and creds.refresh_token:\r\n creds.refresh(Request())\r\n else:\r\n flow = InstalledAppFlow.from_client_secrets_file(\r\n 'credentials.json', SCOPES)\r\n creds = flow.run_local_server(port=0)\r\n # Save the credentials for the next run\r\n with open('token.pickle', 'wb') as token:\r\n pickle.dump(creds, token)\r\n\r\n service = build('drive', 'v3', credentials=creds)\r\n folder_id = \"1asVdT2WEOcCYkVqbaFlT_zs0r2hJ97Fb\"\r\n file_metadata = {'name': filename_on_drive,'parents': [folder_id]}\r\n media = MediaFileUpload(filename, mimetype='image/jpeg')\r\n file = service.files().create(body=file_metadata,\r\n media_body=media,\r\n fields='id').execute()\r\n print('File ID: %s' % file.get('id'))\r\n return file.get('id') \r\n #search_file(service)\r","def storage_ipfs_download_file(self, ipfs_cid, output_path=None):\n # Rquest: retrieve a file (the smiley_explorer.png file we uploaded earlier)\n # curl -X POST -H 'Content-Type: application/json' --data '{\"jsonrpc\":\"2.0\",\"method\":\"edgestore.GetFile\",\"params\":[{\"key\": \"0xbc0383809da9fb98c5755e3fa4f19f4ebc7e34308ab321246e4bb54e548fad04\"}],\"id\":1}' http://localhost:19888/rpc\n # Result\n # {\n # \"jsonrpc\": \"2.0\",\n # \"id\": 1,\n # \"result\": {\n # \"path\": \"../data/edgestore/playground/single-node-network/node/storage/file_cache/0xbc0383809da9fb98c5755e3fa4f19f4ebc7e34308ab321246e4bb54e548fad04/smiley_explorer.png\"\n # }\n # }\n\n request_data = {\"jsonrpc\":\"2.0\",\n \"method\":\"edgestore.GetFile\",\n \"params\":[{\"key\": ipfs_cid}],\n \"id\":1}\n res = httpx.post(\n self.ipfs_download_uri,\n headers={\"Content-Type\": \"application/json\"},\n data=json.dumps(request_data),\n timeout=None,\n )\n\n download_path = None\n content = res.json()\n result = content.get(\"result\", None)\n if result is None:\n return False, \"Failed to download file(result is none).\"\n else:\n download_path = result.get(\"path\", None)\n if download_path is None:\n return False, \"Failed to download file(path is none).\"\n else:\n download_path = os.path.join(self.store_home_dir, download_path)\n\n output_file_obj = None\n file_content = None\n try:\n if output_path is not None:\n shutil.copyfile(download_path, output_path)\n output_file_obj = open(output_path, \"rb\")\n except Exception as e:\n pass\n\n try:\n download_file_obj = open(download_path, \"rb\")\n file_content = download_file_obj.read()\n except Exception as e:\n pass\n\n return file_content, output_file_obj","def maybe_download(filename):\n\n if not tf.gfile.Exists(WORK_DIRECTORY):\n tf.gfile.MakeDirs(WORK_DIRECTORY)\n filepath = os.path.join(WORK_DIRECTORY, filename)\n if not tf.gfile.Exists(filepath):\n filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename, filepath)\n with tf.gfile.GFile(filepath) as f:\n size = f.Size()\n print('Successfully downloaded', filename, size, 'bytes.')\n return filepath","def _download_file(self, url, local_filepath, timeout=None, auth=None,\n continuation=True, cache=False, method=\"GET\",\n head_safe=False, **kwargs):\n\n if head_safe:\n response = self._session.request(\"HEAD\", url,\n timeout=timeout, stream=True,\n auth=auth, **kwargs)\n else:\n response = self._session.request(method, url,\n timeout=timeout, stream=True,\n auth=auth, **kwargs)\n\n response.raise_for_status()\n if 'content-length' in response.headers:\n length = int(response.headers['content-length'])\n if length == 0:\n log.warn('URL {0} has length=0'.format(url))\n else:\n length = None\n\n if ((os.path.exists(local_filepath)\n and ('Accept-Ranges' in response.headers)\n and continuation)):\n open_mode = 'ab'\n\n existing_file_length = os.stat(local_filepath).st_size\n if length is not None and existing_file_length >= length:\n # all done!\n log.info(\"Found cached file {0} with expected size {1}.\"\n .format(local_filepath, existing_file_length))\n return\n elif existing_file_length == 0:\n open_mode = 'wb'\n else:\n log.info(\"Continuing download of file {0}, with {1} bytes to \"\n \"go ({2}%)\".format(local_filepath,\n length - existing_file_length,\n (length-existing_file_length)/length*100))\n\n # bytes are indexed from 0:\n # https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#range-request-header\n end = \"{0}\".format(length-1) if length is not None else \"\"\n self._session.headers['Range'] = \"bytes={0}-{1}\".format(existing_file_length,\n end)\n\n response = self._session.request(method, url,\n timeout=timeout, stream=True,\n auth=auth, **kwargs)\n response.raise_for_status()\n del self._session.headers['Range']\n\n elif cache and os.path.exists(local_filepath):\n if length is not None:\n statinfo = os.stat(local_filepath)\n if statinfo.st_size != length:\n log.warning(f\"Found cached file {local_filepath} with size {statinfo.st_size} \"\n f\"that is different from expected size {length}\")\n open_mode = 'wb'\n else:\n log.info(\"Found cached file {0} with expected size {1}.\"\n .format(local_filepath, statinfo.st_size))\n response.close()\n return\n else:\n log.info(\"Found cached file {0}.\".format(local_filepath))\n response.close()\n return\n else:\n open_mode = 'wb'\n if head_safe:\n response = self._session.request(method, url,\n timeout=timeout, stream=True,\n auth=auth, **kwargs)\n response.raise_for_status()\n\n blocksize = astropy.utils.data.conf.download_block_size\n\n log.debug(f\"Downloading URL {url} to {local_filepath} with size {length} \"\n f\"by blocks of {blocksize}\")\n\n bytes_read = 0\n\n # Only show progress bar if logging level is INFO or lower.\n if log.getEffectiveLevel() <= 20:\n progress_stream = None # Astropy default\n else:\n progress_stream = io.StringIO()\n\n with ProgressBarOrSpinner(length, f'Downloading URL {url} to {local_filepath} ...',\n file=progress_stream) as pb:\n with open(local_filepath, open_mode) as f:\n for block in response.iter_content(blocksize):\n f.write(block)\n bytes_read += len(block)\n if length is not None:\n pb.update(bytes_read if bytes_read <= length else length)\n else:\n pb.update(bytes_read)\n response.close()\n return response","def download(self, file_id: str) -> bytes:\n file_data = {\"alt\": \"media\"}\n r = requests.get(\n f\"https://www.googleapis.com/drive/v3/files/{file_id}\",\n params=file_data, headers=self._auth_headers\n )\n if r.status_code in self._errors:\n raise ApiResponseException(\n r.status_code, r.json()[\"error\"][\"message\"])\n return r.content","def _download_file(file_url: str, file_path: str) -> str:\n if os.path.exists(file_path):\n return file_path\n op_desc = f\"Downloading {os.path.basename(file_path)}\"\n try:\n with requests.Session() as req_sess:\n req_res = req_sess.get(file_url, stream=True)\n total_length = int(req_res.headers.get(\"Content-Length\"))\n with tqdm.wrapattr(req_res.raw, \"read\", total=total_length, desc=op_desc) as raw:\n with open(file_path , \"wb\") as file:\n shutil.copyfileobj(raw,file)\n return file_path\n except Exception as network_error:\n if os.path.exists(file_path):\n os.remove(file_path)\n raise network_error","def upload_file(\n self, bucket_id: uplink.Path, filename: uplink.Path, file: uplink.Body\n ):\n pass","def download_result_file(run_id, file_id):\n print('download {} {}'.format(run_id, file_id))\n from robflask.service import service\n with service() as api:\n # Authentication of the user from the expected api_token in the header\n # will fail if no token is given or if the user is not logged in.\n fh = api.runs().get_result_file(run_id=run_id, file_id=file_id)\n return send_file(\n fh.open(),\n as_attachment=True,\n attachment_filename=fh.name,\n mimetype=fh.mime_type\n )","def to_file(self, filename):\n resp = urlopen(self.url)\n self.file_size = self._get_content_length(resp.headers)\n block_size = 8192\n self.bytes_read = 0\n with open(filename, 'wb') as f:\n while True:\n buf = resp.read(block_size)\n if not buf:\n break\n self.bytes_read += len(buf)\n f.write(buf)\n self._dl_progress_bar()\n if self.show_progress:\n print(' ✓')","def fetch_and_cache(data_url, file, data_dir=\"data\", force=False):\n\n import requests\n from hashlib import md5\n from pathlib import Path\n\n data_dir = Path(data_dir)\n data_dir.mkdir(exist_ok=True)\n file_path = data_dir/Path(file)\n # If the file already exists and we want to force a download then\n # delete the file first so that the creation date is correct.\n if force and file_path.exists():\n file_path.unlink()\n if force or not file_path.exists():\n resp = requests.get(data_url, stream=True)\n file_size = int(resp.headers.get('content-length', 0))\n step = 40\n chunk_size = file_size//step\n with file_path.open('wb') as f:\n for chunk in resp.iter_content(chunk_size): # write file in chunks\n f.write(chunk)\n step -= 1\n print('[' + '#'*(41 - step) + (step)*' ' + ']\\r', end='')\n print(f\"\\nDownloaded {data_url.split('/')[-1]}!\")\n else:\n import time\n time_downloaded = time.ctime(file_path.stat().st_ctime)\n print(\"Using version already downloaded:\", time_downloaded)\n # Compute and print md5 hash of file, whether newly downloaded or not\n m5 = md5()\n m5.update(file_path.read_bytes())\n print(f\"MD5 hash of file: {m5.hexdigest()}\")\n return file_path","def download_file(self, url, filename):\n r = requests.get(url, stream=True)\n r.raise_for_status()\n\n with open(filename, 'wb') as f:\n for chunk in r.iter_content():\n if chunk:\n f.write(chunk)\n f.flush()","async def _download_remote_file(\n self,\n server_name: str,\n media_id: str,\n ) -> dict:\n\n file_id = random_string(24)\n\n file_info = FileInfo(server_name=server_name, file_id=file_id)\n\n with self.media_storage.store_into_file(file_info) as (f, fname, finish):\n request_path = \"/\".join(\n (\"/_matrix/media/r0/download\", server_name, media_id)\n )\n try:\n length, headers = await self.client.get_file(\n server_name,\n request_path,\n output_stream=f,\n max_size=self.max_upload_size,\n args={\n # tell the remote server to 404 if it doesn't\n # recognise the server_name, to make sure we don't\n # end up with a routing loop.\n \"allow_remote\": \"false\"\n },\n )\n except RequestSendFailed as e:\n logger.warning(\n \"Request failed fetching remote media %s/%s: %r\",\n server_name,\n media_id,\n e,\n )\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n except HttpResponseException as e:\n logger.warning(\n \"HTTP error fetching remote media %s/%s: %s\",\n server_name,\n media_id,\n e.response,\n )\n if e.code == twisted.web.http.NOT_FOUND:\n raise e.to_synapse_error()\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n except SynapseError:\n logger.warning(\n \"Failed to fetch remote media %s/%s\", server_name, media_id\n )\n raise\n except NotRetryingDestination:\n logger.warning(\"Not retrying destination %r\", server_name)\n raise SynapseError(502, \"Failed to fetch remote media\")\n except Exception:\n logger.exception(\n \"Failed to fetch remote media %s/%s\", server_name, media_id\n )\n raise SynapseError(502, \"Failed to fetch remote media\")\n\n await finish()\n\n if b\"Content-Type\" in headers:\n media_type = headers[b\"Content-Type\"][0].decode(\"ascii\")\n else:\n media_type = \"application/octet-stream\"\n upload_name = get_filename_from_headers(headers)\n time_now_ms = self.clock.time_msec()\n\n # Multiple remote media download requests can race (when using\n # multiple media repos), so this may throw a violation constraint\n # exception. If it does we'll delete the newly downloaded file from\n # disk (as we're in the ctx manager).\n #\n # However: we've already called `finish()` so we may have also\n # written to the storage providers. This is preferable to the\n # alternative where we call `finish()` *after* this, where we could\n # end up having an entry in the DB but fail to write the files to\n # the storage providers.\n await self.store.store_cached_remote_media(\n origin=server_name,\n media_id=media_id,\n media_type=media_type,\n time_now_ms=self.clock.time_msec(),\n upload_name=upload_name,\n media_length=length,\n filesystem_id=file_id,\n )\n\n logger.info(\"Stored remote media in file %r\", fname)\n\n media_info = {\n \"media_type\": media_type,\n \"media_length\": length,\n \"upload_name\": upload_name,\n \"created_ts\": time_now_ms,\n \"filesystem_id\": file_id,\n }\n\n return media_info","def save(self,file,filename=None,max_size=None):\n \n \n if not file:\n self.success = False\n self.error_text = \"No file submitted\"\n return\n \n self.filename = filename\n \n blob_file = False\n # test if the file is actually a binary string\n if isinstance(file,bytes):\n blob_file = True\n \n if not self.filename:\n if blob_file:\n self.success = False\n self.error_text = \"No Filename provided\"\n return\n else:\n self.filename = file.filename\n \n if not self.filename:\n # no file Name\n self.success = False\n self.error_text = \"No file name specified\"\n return\n \n if not self.allowed_file(self.filename):\n self.success = False\n self.error_text = \"'{}' is not an allowed file type\".format(self.filename)\n return\n \n else:\n self.filename = secure_filename(self.filename).lower()\n destination = Path(self.resource_path,self.local_path)\n if not destination.exists():\n try:\n destination.mkdir(parents=True, exist_ok=True)\n except Exception as e:\n self.success = False\n self.error_text = \"Unable to create path for resources at '{}\".format(destination.as_posix())\n return\n \n # append a number to the file name if it already exists\n file_count = 0\n final_name = self.filename\n while (destination / final_name).exists():\n file_count += 1\n final_name = self.filename.split('.')[0] + \"\".join(str(file_count)) + '.' + self.filename.rsplit('.', 1)[1]\n \n self.filename = final_name\n self.saved_file_path = Path(self.local_path,final_name) # the abbreviated path\n try:\n if blob_file:\n # copy the data to disk\n with open(destination / self.filename,'wb') as f:\n f.write(file)\n else:\n file.save(destination / self.filename )\n \n \n except Exception as e:\n self.success = False\n self.error_text = str(e)\n \n if max_size:\n try:\n # create and save a thumbnail of the image\n im = Image.open(destination / self.filename )\n size = (im.height,im.width)\n if im.width > max_size or im.height > max_size:\n size = (max_size,max_size)\n im.thumbnail(size)\n im.save(destination / self.filename)\n im.close()\n \n except Exception as e:\n self.success = False\n self.error_text = str(e)","def t_getfile(self, link, filename, session):\n\n self.sema.acquire()\n\n filepath = os.path.join(os.getcwd() + '/Downloads/' + str(filename))\n os.makedirs(os.path.dirname(filepath), exist_ok=True)\n\n if not os.path.isfile(filepath):\n self.download_new_file(link, filepath, session)\n else:\n\n current_bytes = os.stat(filepath).st_size\n\n headers = requests.head(link).headers\n\n print(headers)\n if 'content-length' not in headers:\n print(f\"server doesn't support content-length for {link}\")\n self.sema.release()\n return\n\n total_bytes = int(requests.head(link).headers['content-length'])\n\n print(total_bytes)\n\n if current_bytes < total_bytes:\n #\n self.continue_file_download(link, filepath, session, current_bytes, total_bytes)\n print(f\"Current byte < total - remaining {total_bytes - current_bytes}\")\n else:\n print(f\"already done: {filename}\")\n\n self.sema.release()","def submit_download_mock(_self, _fetch_and_save, filename, dest_folder):\n # If filename == foo/bar/x_y_z_attr.dat, content == \"x_y_z_attr\"\n content = os.path.splitext(os.path.basename(filename))[0]\n if content.split(\"_\")[-1] == \"full\":\n content = {\"molecule\": content}\n qml.data.Dataset._write_file(content, os.path.join(dest_folder, filename))","def download_file_from_google_drive(file_id, root, filename=None, md5=None):\n # Based on https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url\n try:\n import requests\n except ImportError as e:\n print(\n 'To download from Google Drive, first install the requests library by running:')\n print('pip install requests --upgrade')\n raise e\n url = \"https://docs.google.com/uc?export=download\"\n\n root = os.path.expanduser(root)\n if not filename:\n filename = file_id\n fpath = os.path.join(root, filename)\n\n os.makedirs(root, exist_ok=True)\n\n if os.path.isfile(fpath) and check_integrity(fpath, md5):\n print('Using downloaded and verified file: ' + fpath)\n else:\n session = requests.Session()\n\n response = session.get(url, params={'id': file_id}, stream=True)\n token = _get_confirm_token(response)\n\n if token:\n params = {'id': file_id, 'confirm': token}\n response = session.get(url, params=params, stream=True)\n\n if _quota_exceeded(response):\n msg = (\n \"The daily quota of the file \" + filename + \" is exceeded and it \" +\n \"can't be downloaded. This is a limitation of Google Drive \" +\n \"and can only be overcome by trying again later.\"\n )\n raise RuntimeError(msg)\n\n _save_response_content(response, fpath)","def download_file(bucket, key, filename):\n validate_bucket_name(bucket)\n validate_key_name(key)\n client = get_client()\n\n client.download_file(bucket, key, filename)","def download_file(self, parsed_event, input_dir_path):\n file_download_path = \"\"\n url = f\"https://{self.oneprovider_host}/{self._CDMI_PATH}{parsed_event.object_key}\"\n get_logger().info(\"Downloading item from host '%s' with key '%s'\",\n self.oneprovider_host,\n parsed_event.object_key)\n response = requests.get(url, headers=self.headers)\n if response.status_code == 200:\n file_download_path = SysUtils.join_paths(input_dir_path, parsed_event.file_name)\n FileUtils.create_file_with_content(file_download_path, response.content, mode='wb')\n\n get_logger().info(\"Successful download of file '%s' with key '%s' in path '%s'\",\n parsed_event.file_name,\n parsed_event.object_key,\n file_download_path)\n else:\n get_logger().error(\"File '%s' download from Onedata host '%s' failed!\",\n parsed_event.file_name,\n self.oneprovider_host)\n return file_download_path","def fetch_and_extract(self, filename):\n # type: (Text) -> None\n\n blob = self.bucket.blob(filename)\n blob.download_to_filename(filename)\n\n with tarfile.open(filename, \"r:gz\") as tar:\n tar.extractall(self.data_dir)","def download(job_id, filename):\n client = connect()\n result = client.get_job_output(\n vaultName=VAULT_NAME,\n jobId=str(job_id))\n\n with open(filename) as f:\n f.write(result['Body'].read())\n print(\"File successfully downloaded.\")","def download_file_from_google_drive(file_id, dest_path, verbose=False):\n\n destination_directory = dirname(dest_path)\n if len(destination_directory) > 0 and not exists(destination_directory):\n makedirs(destination_directory)\n\n session = requests.Session()\n\n if verbose:\n print('Downloading file with Google ID {} into {}... '.format(file_id, dest_path), end='')\n stdout.flush()\n\n response = session.get(Constant.DOWNLOAD_URL, params={'id': file_id}, stream=True)\n\n token = get_confirm_token(response)\n if token:\n params = {'id': file_id, 'confirm': token}\n response = session.get(Constant.DOWNLOAD_URL, params=params, stream=True)\n\n save_response_content(response, dest_path)\n if verbose:\n print('Download completed.')","def persist_file(self, path, buf, info, meta=None, headers=None):\n headers = {\n \"Authorization\": \"UPYUN: {}:{}\".format(self.OPERATOR, self.SIGNATURE),\n \"Date\": format_date_time(int(time.time())),\n }\n url = \"http://v0.api.upyun.com:5000/{}/{}{}\".format(\n self.bucket, self.prefix, path)\n\n def upload():\n try:\n res = requests.put(url, headers=headers, data=buf)\n if res.status_code != 200:\n logger.info(\n \"failed to upload file %s to upyun, response code: %s, text:\\n%s\",\n path, res.status_code, res.text)\n else:\n logger.debug(\"uploaded file %s to upyun\", path)\n except Exception:\n logger.warn(\"upload file %s to upyun failed\",\n path, exc_info=True)\n return threads.deferToThread(upload)","def httpretrieve_save_file(url, filename, querydata=None, postdata=None, \\\r\n httpheaders=None, proxy=None, timeout=None):\r\n\r\n # Open the output file object and http file-like object.\r\n outfileobj = open(filename, 'w')\r\n httpobj = httpretrieve_open(url, querydata=querydata, postdata=postdata, \\\r\n httpheaders=httpheaders, proxy=proxy, timeout=timeout)\r\n\r\n # Repeatedly read from the file-like HTTP object into our file, until the\r\n # response is finished.\r\n responsechunkstr = None\r\n while responsechunkstr != '':\r\n responsechunkstr = httpobj.read(4096)\r\n outfileobj.write(responsechunkstr)\r\n\r\n outfileobj.close()\r\n httpobj.close()","def download_tmp_file(path, filename):\n try:\n _file = file(_path)\n wrapper = FileWrapper(_file)\n\n # use the same type for all files\n response = HttpResponse(wrapper, content_type='text/plain') \n response['Content-Disposition'] = \\\n 'attachment; filename=%s' % unicode(filename)\n response['Content-Length'] = os.path.getsize(_path)\n return response\n except Exception,e:\n logger.exception('could not find attached file object for id: %r', id)\n raise e","def get_piece_file(filename):\n \n if 'username'in session:\n \n s3_resource = boto3.resource('s3')\n bucket = s3_resource.Bucket(S3_BUCKET)\n \n file_obj = bucket.Object(filename).get()\n \n return Response(file_obj['Body'].read(),\n mimetype='text/plain',\n headers={'Content-Disposition': f'attachment;filename={filename}'}\n )\n \n flash('You need to be logged in to download files.', 'info')\n return redirect(url_for('login'))","def downloadFile()-> None:\n logging.info(f\"Downloading current data set {getTime()}\")\n with open(DATA_FILE,\"wb\") as f:\n f.write(get(\"https://covid.ourworldindata.org/data/owid-covid-data.csv\").text.encode())\n logging.info(f\"Finished Downloading current data set {getTime()}\")","def make_file_private(self, file_id):\n\n # Check if file is already private\n response = self.client.api_call(\n f'files.info?'\n f'file={file_id}'\n )\n if response['ok'] and response['file']['public_url_shared'] is False:\n return response\n\n response = self.client.api_call(\n f'files.revokePublicURL?'\n f'file={file_id}'\n )\n assert response['ok']\n\n return response","def get_file_download(self, bucket_id, file_id):\n\n \n path = '/storage/buckets/{bucketId}/files/{fileId}/download'\n params = {}\n if bucket_id is None:\n raise AppwriteException('Missing required parameter: \"bucket_id\"')\n\n if file_id is None:\n raise AppwriteException('Missing required parameter: \"file_id\"')\n\n path = path.replace('{bucketId}', bucket_id)\n path = path.replace('{fileId}', file_id)\n\n\n return self.client.call('get', path, {\n 'content-type': 'application/json',\n }, params)","def download(self, bucket_name, file_name, file_path):\n\n self.client.download_file(bucket_name, file_name, file_path)","def fetch(file):\n\tprint \"Fetching {0}...\".format(file.split(\"/\")[-1])\n\tsubprocess.call(\"wget {0} > /dev/null 2>&1\".format(file), shell=True)","def download_file(url, local_path):\n try:\n local_filename = normalizeFilenameToCommonDateFormat(url.split('/')[-1])\n \n destination_dir = local_path #os.path.join(local_path, os.path.splitext(os.path.basename(local_filename))[0])\n \n #if not os.path.exists(destination_dir):\n # os.makedirs(destination_dir)\n \n destination_file = os.path.join(destination_dir, local_filename)\n \n if not os.path.exists(destination_file):\n # NOTE the stream=True parameter \n r = requests.get(url, stream=True)\n with open(destination_file, 'wb') as f:\n for chunk in r.iter_content(chunk_size=1024): \n if chunk: # filter out keep-alive new chunks\n f.write(chunk)\n #f.flush() commented by recommendation from J.F.Sebastian\n # Sleep so that we aren't rude\n sleep(1)\n else:\n return destination_file + ' already '\n \n return destination_file\n except ValueError as err:\n return \"Skipping %s, not \" % (url.split('/')[-1])","def download_file(Bucket=None, Key=None, Filename=None, ExtraArgs=None, Callback=None, Config=None):\n pass","def unavoidable_download_method(self, target, name):\n # Get path to file\n file_path = os.path.join(self.work_dir, name)\n\n # Create necessary directories if not present\n self.mkdir_p(self.work_dir)\n\n # Check if file exists, download if not presente\n if not os.path.exists(file_path):\n try:\n subprocess.check_call(['curl', '-fs', self.input_urls[name], '-o', file_path])\n except subprocess.CalledProcessError:\n raise RuntimeError('\\nNecessary file could not be acquired: {}. Check input URL')\n except OSError:\n raise RuntimeError('Failed to find \"curl\". Install via \"apt-get install curl\"')\n\n assert os.path.exists(file_path)\n\n # Update FileStoreID\n target.updateGlobalFile(self.ids[name], file_path)\n\n return file_path","def save(self, filename: str):\n r = requests.get(self.raw_url, stream=True)\n if r.status_code == 404:\n raise Exception(f\"Document {self.key} does not exist\")\n r.raise_for_status()\n \n with open(filename, 'wb') as file:\n for chunk in r.iter_content(10 * 1024):\n file.write(chunk)"],"string":"[\n \"def get_file(self, file_id, filename=''):\\n method = 'getFile?' + 'file_id=' + str(file_id)\\n res = requests.post(self.api_url + method, file_id)\\n try:\\n file_path = res.json()['result']['file_path']\\n # Determine the fileName. Use modified file_path if none given.\\n if not filename:\\n filename = file_path[file_path.rfind('/') + 1:]\\n except (KeyError, ValueError):\\n return \\\"500 - Failed parsing the file link from API response.\\\"\\n\\n if not os.path.exists(self.dirDownloads):\\n os.mkdir(self.dirDownloads)\\n\\n local_path = os.path.join(self.dirDownloads, filename)\\n\\n # Download file as stream.\\n res = requests.get(self.file_url + file_path, stream=True)\\n if res.status_code == 200:\\n try:\\n with open(local_path, 'wb') as f:\\n for chunk in res:\\n f.write(chunk)\\n except IOError:\\n pass\\n return '200 - {} written.'.format(local_path)\\n else:\\n return '404 - Error accessing {}'.format(file_path)\",\n \"def download_file(service, file_id, file_name=None):\\n # Setup request for the file\\n request = service.files().get_media(fileId=file_id, supportsAllDrives=True)\\n # setup the file handler to recieve the byte stream\\n fh = io.BytesIO()\\n\\n # the download utility \\n downloader = MediaIoBaseDownload(fh, request, chunksize=204800)\\n # continue to download until all bytes are recieved\\n done = False\\n while not done:\\n status, done = downloader.next_chunk()\\n\\n # go to beginning of stream\\n fh.seek(0)\\n\\n # get file name meta data to store file with same name, \\n # only executed if user did not provide a file name to store the file locally\\n if file_name == None:\\n file_name_results = service.files().get(fileId=file_id,\\n fields='name', \\n supportsAllDrives=True).execute()\\n file_name = file_name_results['name']\\n # copy stream from file handler to local storage\\n with open(file_name, 'wb') as f:\\n shutil.copyfileobj(fh, f)\\n \\n return file_name\",\n \"def _download_file(self, file_id, file_name, path):\\n request = self.service.files().get_media(fileId=file_id)\\n fh = io.FileIO(path + file_name, 'wb')\\n downloader = MediaIoBaseDownload(fh, request)\\n done = False\\n print('Start download ' + file_name)\\n while not done:\\n status, done = downloader.next_chunk()\\n print(\\\"Download %d%%.\\\" % int(status.progress() * 100))\",\n \"def download_file(client, file_id):\\n\\n file_content = client.file(file_id).content()\\n print(file_content)\",\n \"def download_file(self, file_id):\\n \\n file = self.service.files().get(fileId=file_id).execute()\\n file_name = file['name']\\n print ('Name:', file_name)\\n # print ('MIME type:', file['mimeType'])\\n local_fd = open(file_name, \\\"wb\\\")\\n request = self.service.files().get_media(fileId=file_id)\\n media_request = http.MediaIoBaseDownload(local_fd, request)\\n\\n while True:\\n try:\\n download_progress, done = media_request.next_chunk()\\n except errors.HttpError as error:\\n print ('An error occurred:', error)\\n return\\n if download_progress:\\n print ('Download Progress:', int(download_progress.progress() * 100))\\n if done:\\n print ('Download Complete')\\n local_fd.close()\\n return\",\n \"def download(self, file_id: str, output_path: str) -> str:\\n url = self.get_method_url('storage', 'download', file_id)\\n response = self.request(\\n url=url,\\n method='GET'\\n )\\n file_name = search(\\n r'\\\\\\\"(.*?)\\\\\\\"', response.headers['content-disposition']\\n ).group(1)\\n with open(f'{output_path}/{file_name}', 'wb') as file:\\n file.write(response.content)\\n\\n return f'{output_path}/{file_name}'\",\n \"def download_file(self, id, file_name, file_location):\\n if not self.check_for_file():\\n gd = GDrive()\\n gd.download_file(id, file_name, file_location)\",\n \"def getFile(self, filename):\\n # define a callback to handle the retrieved blocks:\\n def cb(block, fp):\\n fp.write(block)\\n # retrieve the contents of the file and save locally:\\n basename = os.path.basename(filename)\\n fp = open(basename, 'wb')\\n self.ftp.retrbinary('retr ' + filename, lambda block: cb(block, fp))\\n fp.close()\",\n \"def __download_file(self, filename):\\r\\n \\r\\n respons = requests.get(self.__url + filename, stream=True)\\r\\n save_filename = os.path.join(self.__folder, os.path.basename(filename))\\r\\n with open(save_filename, 'wb') as output_file:\\r\\n for chunk in respons.iter_content(chunk_size=128):\\r\\n output_file.write(chunk)\",\n \"def download_file(self, filename: str, save_dir: str) -> None:\\n raise NotImplementedError()\",\n \"def download_file(url: str, local_dir: str = '.', local_filename: str = '') -> str:\\n os.makedirs(f'{local_dir}', exist_ok=True)\\n local_filename = local_filename if local_filename else url.split('/')[-1]\\n if os.path.exists(f'{local_dir}/{local_filename}'):\\n print(\\\"{0}/{1} already exists. Skipping download.\\\".format(local_dir, local_filename))\\n else:\\n print(\\\"Downloading file from {0} to {1}/{2}.\\\".format(url, local_dir, local_filename))\\n with requests.get(url, stream=True) as r:\\n r.raise_for_status()\\n with open(f'./{local_dir}/{local_filename}', 'wb') as f:\\n for chunk in r.iter_content(chunk_size=128):\\n f.write(chunk)\\n print(\\\"Finished saving file from {0} to {1}/{2}.\\\".format(url, local_dir, local_filename))\\n return f'{local_dir}/{local_filename}'\",\n \"def download_file(fileid, save_path):\\n authorize_google_drive()\\n file_object = DRIVE.CreateFile({'id': fileid})\\n file_object.GetContentFile(save_path)\\n return True\",\n \"def download_file(file_id, filename):\\n # httplib2 library is not thread-safe, need a new http for each thread\\n drive_service = discovery.build('drive', 'v3', http=get_http())\\n request = drive_service.files().get_media(fileId=file_id)\\n\\n fh = io.FileIO(filename, 'wb')\\n downloader = MediaIoBaseDownload(fh, request)\\n\\n done = False\\n while done is False:\\n try:\\n status, done = downloader.next_chunk()\\n except Exception as ex:\\n print (\\\"User rate limit exceeded for %s\\\" % filename)\\n return False\\n print (\\\"Download %d%%.\\\" % int(status.progress() * 100))\\n return True\",\n \"def _get(self, remote_filename, local_path):\\n\\n with local_path.open('wb') as local_file:\\n file_id = self.get_file_id(remote_filename)\\n if file_id is None:\\n raise BackendException(\\n 'File \\\"%s\\\" cannot be downloaded: it does not exist' %\\n remote_filename)\\n\\n response = self.http_client.get(\\n self.content_url + '/nodes/' + file_id + '/content', stream=True)\\n response.raise_for_status()\\n for chunk in response.iter_content(chunk_size=DEFAULT_BUFFER_SIZE):\\n if chunk:\\n local_file.write(chunk)\\n local_file.flush()\",\n \"def fetch(file_url):\\n\\n tmp_file_handle = NamedTemporaryFile(delete=True)\\n headers = {'User-Agent': 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36'}\\n\\n # download file and save to temp object\\n with requests.get(file_url, headers=headers, stream=True) as r:\\n tmp_file_handle.write(r.content)\\n\\n tmp_file_handle.flush()\\n\\n return tmp_file_handle\",\n \"def put(self, url, localfile):\\n\\n cachedir = self._cachedir(url)\\n filename = localfile.name\\n\\n logger.debug(f\\\"Storing {localfile} in cache for {url}\\\")\\n shutil.copy2(localfile, cachedir / filename)\\n self._writefilename(cachedir, filename)\",\n \"def fetch(args):\\n storage, remote_path = split_storage(args.remote)\\n\\n local_path = args.local\\n if local_path is None:\\n _, local_path = os.path.split(remote_path)\\n\\n local_path_exists = os.path.exists(local_path)\\n if local_path_exists and not args.force and not args.update:\\n sys.exit(\\\"Local file %s already exists, not overwriting.\\\" % local_path)\\n\\n directory, _ = os.path.split(local_path)\\n if directory:\\n makedirs(directory, exist_ok=True)\\n\\n osf = _setup_osf(args)\\n project = osf.project(args.project)\\n\\n store = project.storage(storage)\\n for file_ in store.files:\\n if norm_remote_path(file_.path) == remote_path:\\n if local_path_exists and not args.force and args.update:\\n if file_.hashes.get('md5') == checksum(local_path):\\n print(\\\"Local file %s already matches remote.\\\" % local_path)\\n break\\n with open(local_path, 'wb') as fp:\\n file_.write_to(fp)\\n\\n # only fetching one file so we are done\\n break\",\n \"def addfile(self, filename, mode):\\n if mode == 'never':\\n return filename\\n http = False\\n if filename.startswith('http'):\\n filename, headers = urllib.urlretrieve(filename)\\n http = True\\n if not http and mode == 'http':\\n return filename\\n dst = os.path.join(self.path, \\\"files\\\", str(uuid.uuid4()))\\n try:\\n folder = os.path.join(self.path, \\\"files\\\")\\n if not os.path.exists(folder):\\n os.mkdir(folder)\\n shutil.copyfile(filename, dst)\\n dst = dst.replace(self.path, '')\\n dst = \\\"collector://collections/\\\" + self.collection_id + \\\"/\\\" + dst\\n\\n except IOError as ioex:\\n logging.exception(ioex)\\n return None\\n return dst\",\n \"def fetch_and_cache(data_url, file, data_dir=\\\"data\\\", force=False):\\n data_dir = Path(data_dir)\\n data_dir.mkdir(exist_ok = True)\\n file_path = data_dir / Path(file)\\n if force and file_path.exists():\\n file_path.unlink()\\n if force or not file_path.exists():\\n print('Downloading...', end=' ')\\n resp = requests.get(data_url)\\n with file_path.open('wb') as f:\\n f.write(resp.content)\\n print('Done!')\\n last_modified_time = time.ctime(file_path.stat().st_mtime)\\n else:\\n last_modified_time = time.ctime(file_path.stat().st_mtime)\\n print(\\\"Using cached version that was downloaded (UTC):\\\", last_modified_time)\\n return file_path\",\n \"def fetch_file(url, filename):\\n from clinica.utils.exceptions import ClinicaException\\n from urllib.request import Request, urlopen\\n from urllib.error import URLError\\n import shutil\\n import ssl\\n import os.path\\n from clinica.utils.stream import cprint\\n\\n head_tail = os.path.split(filename)\\n if not os.path.exists(head_tail[0]):\\n cprint('Path to the file does not exist')\\n cprint('Stop Clinica and handle this error')\\n\\n # Download the file from `url` and save it locally under `file_name`:\\n cert = ssl.get_server_certificate((\\\"aramislab.paris.inria.fr\\\", 443))\\n gcontext = ssl.SSLContext()\\n req = Request(url)\\n try:\\n response = urlopen(req, context=gcontext)\\n except URLError as e:\\n if hasattr(e, 'reason'):\\n cprint('We failed to reach a server.')\\n cprint(['Reason: ' + e.reason])\\n elif hasattr(e, 'code'):\\n cprint('The server could not fulfill the request.')\\n cprint(['Error code: ' + e.code])\\n else:\\n try:\\n with open(filename, 'wb') as out_file:\\n shutil.copyfileobj(response, out_file)\\n except OSError as err:\\n cprint(\\\"OS error: {0}\\\".format(err))\",\n \"def putFile(filename, file = None, localFilename = None):\\n if not file and not filename:\\n print(\\\"Please pass a valid file or filename\\\")\\n\\n if filename and not file:\\n file = open(filename, \\\"rb\\\")\\n\\n print(\\\"filename: {}, file: {}\\\".format(filename, file))\\n r = requests.put(\\\"{host}/{filename}\\\".format(host = host, filename = filename), files = {\\\"file\\\": file})\\n return (r.ok, r.status_code, r.text)\",\n \"def download_file(service, file_id, local_fd):\\n request = service.files().get_media(fileId=file_id)\\n media_request = http.MediaIoBaseDownload(local_fd, request)\\n \\n while True:\\n try:\\n download_progress, done = media_request.next_chunk()\\n except errors.HttpError as error:\\n print('An error occurred: %s' % error)\\n return\\n if download_progress:\\n print('Download Progress: %d%%' % int(download_progress.progress() * 100))\\n if done:\\n print('Download Complete')\\n return\",\n \"def fetch_and_cache_gdrive(gdrive_id, file, data_dir=\\\"data\\\", force=False):\\n\\n import requests\\n from hashlib import md5\\n from pathlib import Path\\n\\n data_dir = Path(data_dir)\\n data_dir.mkdir(exist_ok=True)\\n file_path = data_dir/Path(file)\\n # If the file already exists and we want to force a download then\\n # delete the file first so that the creation date is correct.\\n if force and file_path.exists():\\n file_path.unlink()\\n if force or not file_path.exists():\\n download_file_from_google_drive(gdrive_id, file_path)\\n else:\\n import time\\n time_downloaded = time.ctime(file_path.stat().st_ctime)\\n print(\\\"Using version already downloaded:\\\", time_downloaded)\\n # Compute and print md5 hash of file, whether newly downloaded or not\\n m5 = md5()\\n m5.update(file_path.read_bytes())\\n print(f\\\"MD5 hash of file: {m5.hexdigest()}\\\")\\n return file_path\",\n \"def store_file(self,client,url,orig_filename):\\n # Get rep_path to copy file\\n try:\\n filename, headers=urllib.urlretrieve(url)\\n except:\\n # if we fail here returns a None object\\n self.log('File retrieval error for file %s' % url)\\n return ''\\n\\n # Fix filename encoding\\n udata=orig_filename.decode(\\\"utf-8\\\")\\n orig_filename=udata.encode(\\\"ascii\\\",\\\"ignore\\\")\\n\\n # Use ckanclient patch to upload file to storage\\n url, msg=util.upload_file(client,filename,orig_filename)\\n\\n # Log error if True\\n if msg is not '':\\n #log.error('File upload error:\\\\n %s' % msg)\\n self.log( 'File upload error:\\\\n %s' % msg)\\n return None\\n\\n return url\",\n \"async def download_file(\\n location_id: LocationID,\\n file_id: StorageFileID,\\n user_id: UserID,\\n link_type: LinkType = LinkType.PRESIGNED,\\n):\",\n \"def download_file(service, file_id, file_path):\\n request = service.files().get_media(fileId=file_id)\\n with open(file_path, mode='wb') as f:\\n downloader = MediaIoBaseDownload(f, request)\\n done = False\\n while done is False:\\n status, done = downloader.next_chunk()\",\n \"def download(self, filename, localfolder=None):\\n raise NotImplementedError(\\\"Implement this method in child class\\\")\",\n \"def download_file(service, file_id, local_fd):\\n request = service.files().get_media(fileId=file_id)\\n media_request = MediaIoBaseDownload(local_fd, request)\\n\\n while True:\\n try:\\n download_progress, done = media_request.next_chunk()\\n except errors.HttpError as error:\\n print('An error occurred: %s' % error)\\n return\\n # if download_progress:\\n # print('Download Progress: %d%%' % int(download_progress.progress() * 100))\\n if done:\\n print('Download Complete')\\n return\",\n \"def update(self, example_id):\\n\\n download_file(self._remote.get_url(example_id), self._cache.get_local_cache_folder())\",\n \"def __getFile_httplib(self, _src, _dst):\\n\\n #-------------------- \\n # Pre-download callbacks\\n #-------------------- \\n self.runEventCallbacks('downloadStarted', _src, -1)\\n self.runEventCallbacks('downloading', _src, 0)\\n\\n\\n\\n #-------------------- \\n # Download\\n #-------------------- \\n response = self.__httpsRequest('GET', _src)\\n data = response.read() \\n with open(_dst, 'wb') as f:\\n f.write(data) \\n\\n\\n\\n #-------------------- \\n # Post-download callbacks\\n #-------------------- \\n self.removeFromDownloadQueue(_src)\\n self.runEventCallbacks('downloadFinished', _src)\",\n \"def download(self, key, filename):\\n self.resource.Bucket(self.bucket).download_file(key, filename)\\n return filename\",\n \"def make_file_public(self, file_id):\\n\\n # Check if file is already public\\n response = self.client.api_call(\\n f'files.info?'\\n f'file={file_id}'\\n )\\n if response['ok'] and response['file']['public_url_shared'] is True:\\n return response\\n\\n response = self.client.api_call(\\n f'files.sharedPublicURL?'\\n f'file={file_id}'\\n )\\n assert response['ok']\\n\\n return response\",\n \"def getFile(self, _src, _dst):\\n\\n #--------------------\\n # Reset total size of downloads for all files\\n #-------------------------\\n self.downloadTracker['totalDownloadSize']['bytes'] = 0\\n self.downloadTracker['downloadedSize']['bytes'] = 0\\n downloadFolders = []\\n\\n #-------------------------\\n # Remove existing dst files from their local URI\\n #-------------------------\\n if os.path.exists(_dst):\\n os.remove(_dst)\\n self.__getFile_requests(_src, _dst)\",\n \"def download_file(fileId, fileName):\\n creds = authenticate()\\n service = build('drive', 'v3', credentials=creds)\\n\\n request = service.files().get_media(fileId=fileId)\\n\\n # print(request)\\n\\n # Downloads the photo to local storage.\\n fh = io.FileIO(temp_dir + fileName, mode='wb')\\n downloader = MediaIoBaseDownload(fd=fh, request=request)\\n\\n\\n done = False\\n while done is False:\\n status,done = downloader.next_chunk()\\n # print(\\\"Download %d%%.\\\" % int(status.progress() * 100))\\n\\n fh.close()\\n\\n return fileName\",\n \"def _download_file(self, artifact_path, local_path):\\n full_path = self.base_artifact_path / artifact_path\\n with self.managed_folder.get_file(str(full_path)) as remote_file:\\n with open(local_path, \\\"wb\\\") as local_file:\\n for line in remote_file:\\n local_file.write(line)\",\n \"def get_file(self, key, local_file):\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tfh = open(local_file, 'wb')\\n\\t\\t\\tfh.write(self.s3.get(self.bucket, key).object.data)\\n\\t\\t\\tfh.close()\\n\\t\\texcept:\\n\\t\\t\\treturn False\",\n \"def fetch_save(url):\\n\\n name = url.split(\\\"/\\\")[-1]\\n response = requests.get(url, stream=True)\\n if response.status_code == 200:\\n with open(f\\\"{DATA_PATH}/{name}\\\", \\\"wb\\\") as f:\\n f.write(response.raw.read())\\n else:\\n logging.info(f\\\"Failed {url} download\\\")\",\n \"async def get_file(self, file_id: base.String) -> types.File:\\n payload = generate_payload(**locals())\\n result = await self.request(api.Methods.GET_FILE, payload)\\n\\n return types.File(**result)\",\n \"def download_file(self):\\n files = self.s3_client.list_objects_v2(\\n Bucket=settings.PRIVATE_DATA_BUCKET_NAME, Prefix=f\\\"{self.import_type}/\\\"\\n )[\\\"Contents\\\"]\\n\\n latest_file_key = sorted(files, key=lambda f: f[\\\"LastModified\\\"])[0][\\\"Key\\\"]\\n print(latest_file_key)\\n file = Path(self.tmp_dir.name) / self.import_type / \\\"full.csv\\\"\\n file.parent.mkdir(exist_ok=True, parents=True)\\n self.file_path = file\\n with file.open(\\\"wb\\\") as f:\\n self.s3_client.download_fileobj(\\n settings.PRIVATE_DATA_BUCKET_NAME, latest_file_key, f\\n )\",\n \"def get_file(self, file_id):\\n LOG.debug(\\\"Getting a file from mattermost\\\")\\n url = '%s/api/v4/files/%s' % (self.server_url, file_id)\\n LOG.debug(\\\"Sending: %s\\\", url)\\n response = self._request(self._session.get, url)\\n\\n if response.status_code != 200:\\n raise RuntimeError(\\\"Server unhappy. (%s)\\\", response)\\n\\n return response.content\",\n \"def get_file(self, remote_path, local_path, storage_id=None):\\n return self.get(remote_path, local_path, directory=False, storage_id=storage_id)\",\n \"def download_file(self, remote_file):\\n remote_file.download()\",\n \"def _download_minio_file(file_name):\\n minioClient = Minio(MINIO_END_POINT,\\n access_key = MINIO_ACCESS_KEY,\\n secret_key = MINIO_SECRET_KEY,\\n secure = True)\\n\\n file_path = f\\\"{LOCAL_FILES_PATH}/{file_name}\\\" # path to download the file\\n file_name_indexed = file_name + \\\".tbi\\\" # hard coded\\n file_path_indexed = f\\\"{LOCAL_FILES_PATH}/{file_name_indexed}\\\" # path to download indexed file\\n bucket = 'test'\\n\\n # Create the file\\n try:\\n f = open(file_path, \\\"x\\\")\\n f.close()\\n\\n f = open(file_path_indexed, \\\"x\\\")\\n f.close()\\n except:\\n # File already exists, do nothing\\n pass\\n\\n # download the required file into file_path\\n try:\\n minioClient.fget_object(bucket, file_name, file_path)\\n minioClient.fget_object(bucket, file_name_indexed, file_path_indexed)\\n except ResponseError as err:\\n print(err)\",\n \"def fetch_and_extract(self, filename):\\n # type: (Text) -> None\\n\\n with io.open(filename, 'wb') as f:\\n self.bucket.download_fileobj(filename, f)\\n with tarfile.open(filename, \\\"r:gz\\\") as tar:\\n tar.extractall(self.data_dir)\",\n \"def download_file():\\n\\n if 'POST' == request.method:\\n file_id = request.form['file_id']\\n else:\\n file_id = request.args.get('file_id')\\n\\n # 1 ==> example_1.tgz\\n file_path = file_manager.get_file_path_from_id(file_id)\\n print \\\"serving file: \\\" + file_path\\n return send_file(file_path, as_attachment=True)\",\n \"def main(url, localfile):\\n ph.download_file(url, localfile)\",\n \"def download_and_save(url, file_name,file_extension):\\n #make a request for the file\\n response = requests.get(url, allow_redirects =True)\\n\\n #compose the file + extension\\n file_to_be_saved = f\\\"{file_name}.{file_extension}\\\"\\n \\n #Create a new file with \\\"file_to_be_saved\\\" in the current directory\\n # And save this file and print the directory with the OS module\\n with open(file_to_be_saved, 'wb') as file:\\n print(\\\"saving file.... \\\\n\\\")\\n file.write(response.content)\\n print('done....\\\\n')\\n print('file saved as: ', file_to_be_saved )\\n print('in: ', os.getcwd() )\",\n \"def save_file(url, *, out_dir='sha_tmp/', out_name=None):\\n exten_types = {'image/fits': '.fits',\\n 'text/plain; charset=UTF-8': '.tbl',\\n 'application/zip': '.zip',\\n }\\n # Make request\\n response = requests.get(url, stream=True)\\n response.raise_for_status()\\n # Name file using ID at end\\n if out_name is None:\\n out_name = 'shaID_' + id_parse.findall(url)[0]\\n # Determine extension\\n exten = exten_types[response.headers['Content-Type']]\\n # Check if path exists\\n if not os.path.exists(out_dir):\\n os.makedirs(out_dir)\\n # Write file\\n with open(out_dir + out_name + exten, 'wb') as f:\\n for block in response.iter_content(1024):\\n f.write(block)\",\n \"def download_file(self, parsed_event, input_dir_path):\",\n \"def get_file(self, file_name: str) -> BytesIO:\\n fl = BytesIO()\\n self.client.download_fileobj(self.bucket, file_name, fl)\\n fl.seek(0)\\n return fl\",\n \"def download_file(self, bucket, key, download_dir, download_file=None, temp_dir=None):\\n for argument in [(\\\"Bucket\\\", bucket), (\\\"Key\\\", key)]:\\n if not isinstance(argument[1], six.string_types):\\n raise ValueError('{} must be a string'.format(argument[0]))\\n\\n if not temp_dir:\\n temp_dir = download_dir\\n\\n if not download_file:\\n download_file = os.path.basename(key)\\n\\n create_directory_tree(temp_dir)\\n create_directory_tree(download_dir)\\n\\n local_file_path = os.path.join(download_dir, download_file)\\n\\n # The file was already downloaded\\n if os.path.isfile(local_file_path):\\n return local_file_path\\n\\n # Avoid other instances to download the same file\\n filelock_filepath = get_filelock_path(download_file)\\n lock = filelock.FileLock(filelock_filepath)\\n try:\\n with lock.acquire(timeout=10):\\n downloaded_file = self._download_parts(bucket, key, download_file, temp_dir)\\n if downloaded_file is not None and downloaded_file != local_file_path:\\n os.rename(downloaded_file, local_file_path)\\n except filelock.Timeout:\\n raise S3ResumableBloqued(\\\"Another instance is currently downloading {}\\\".format(\\n local_file_path))\\n\\n return local_file_path\",\n \"def _file_data(self, message, data, is_external=True):\\n message.file = o.File(data)\\n if data.get('is_starred'):\\n message.is_starred = True\\n\\n if is_external:\\n logging.debug(\\\"Found external file `%s'\\\", data['url_private'])\\n message.file.url = data['url_private']\\n else:\\n logging.debug(\\\"Found internal file `%s'\\\",\\n data['url_private_download'])\\n priv_url = data['url_private_download']\\n message.file.filepath = self.downloader.download(priv_url, 'file')\\n self.session.add(message.file)\",\n \"def save_file(self, name, file):\\n fs = FileSystemStorage()\\n filename = fs.save(name, file)\\n return fs.path(filename), fs.url(filename)\",\n \"def putFile(self, filename):\\n basename = os.path.basename(filename)\\n fp = open(filename, 'rb')\\n self.ftp.storbinary('stor ' + basename, fp)\\n fp.close();\",\n \"def get_file(url, file_name=None):\\n cache_dir = os.path.join(os.path.expanduser(\\\"~\\\"), \\\".jhML\\\")\\n\\n if file_name is None:\\n file_name = url[url.rfind('/') + 1:]\\n file_path = os.path.join(cache_dir, file_name)\\n\\n if not os.path.exists(cache_dir):\\n os.mkdir(cache_dir)\\n\\n if os.path.exists(file_path):\\n return file_path\\n\\n print(\\\"Downloading: \\\" + file_name)\\n try:\\n urllib.request.urlretrieve(url, file_path, show_progress)\\n except (Exception, KeyboardInterrupt) as e:\\n if os.path.exists(file_path):\\n os.remove(file_path)\\n raise\\n print(\\\" Done\\\")\\n\\n return file_path\",\n \"def fetch_file(self, path, content_type, response=settings.HTTP_OK):\\n try:\\n with open(path) as fp:\\n self.fetch_content(fp.read(), content_type, response)\\n except IOError:\\n self.send_error(settings.HTTP_INTERNAL_SERVER_ERROR)\",\n \"def download(filename):\\n print \\\"Downloading\\\", filename\\n file_content = urlopen(\\n urljoin(URL_PATH, filename)\\n )\\n write_data_to_file(\\n file_content.read(),\\n os.path.join(\\n '/tmp',\\n filename\\n )\\n )\",\n \"def download_file_from_icos(icos_obj, bucket: str, local_file_name: str, key: str) -> None:\\r\\n try:\\r\\n icos_obj.download_file(Bucket=bucket, Key=key, Filename=local_file_name)\\r\\n except Exception as e:\\r\\n print(Exception, e)\\r\\n else:\\r\\n print('File `{}` downloaded from ICOS and saved locally as `{}`.'.format(key, local_file_name))\",\n \"async def download_file_by_id(self, file_id: base.String, destination=None,\\n timeout: base.Integer = 30, chunk_size: base.Integer = 65536,\\n seek: base.Boolean = True):\\n file = await self.get_file(file_id)\\n return await self.download_file(file_path=file.file_path, destination=destination, timeout=timeout,\\n chunk_size=chunk_size, seek=seek)\",\n \"def get_datafile(file_):\\n\\n if os.path.exists(file_):\\n return file_\\n else:\\n\\n # download file, then return file_ path\\n\\n (path_, fname) = os.path.split(file_)\\n if path_ == '':\\n path_ = '.' # relative to current path\\n\\n try:\\n resp = urllib_request.urlopen(urljoin(DATA_SERVER, fname))\\n except urllib_request.HTTPError as ex:\\n ex.msg = (\\\"{0}. '{1}' not found on server or server is down\\\"\\n .format(ex.msg, fname))\\n raise ex\\n\\n # # progress bar\\n # widgets = [fname + ': ',\\n # pb.Percentage(),\\n # ' ',\\n # pb.Bar(),\\n # ' ',\\n # pb.ETA(),\\n # ' ',\\n # pb.FileTransferSpeed(),\\n # ]\\n\\n # pbar = pb.ProgressBar(widgets=widgets,\\n # maxval=int(resp.info().getheader('Content-Length'))\\n # ).start()\\n\\n if not os.path.exists(path_):\\n os.makedirs(path_)\\n\\n sz_read = 0\\n with open(file_, 'wb') as fh:\\n # while sz_read < resp.info().getheader('Content-Length')\\n # goes into infinite recursion so break loop for len(data) == 0\\n while True:\\n data = resp.read(CHUNKSIZE)\\n\\n if len(data) == 0:\\n break\\n else:\\n fh.write(data)\\n sz_read += len(data)\\n\\n # if sz_read >= CHUNKSIZE:\\n # pbar.update(CHUNKSIZE)\\n\\n # pbar.finish()\\n return file_\",\n \"def fetch(self, fname, processor=None, downloader=None, progressbar=False):\\n self._assert_file_in_registry(fname)\\n\\n # Create the local data directory if it doesn't already exist\\n make_local_storage(str(self.abspath))\\n\\n url = self.get_url(fname)\\n full_path = self.abspath / fname\\n known_hash = self.registry[fname]\\n action, verb = download_action(full_path, known_hash)\\n\\n if action == \\\"update\\\" and not self.allow_updates:\\n raise ValueError(\\n f\\\"{fname} needs to update {full_path} but updates are disallowed.\\\"\\n )\\n\\n if action in (\\\"download\\\", \\\"update\\\"):\\n get_logger().info(\\n \\\"%s file '%s' from '%s' to '%s'.\\\",\\n verb,\\n fname,\\n url,\\n str(self.abspath),\\n )\\n\\n if downloader is None:\\n downloader = choose_downloader(url, progressbar=progressbar)\\n\\n stream_download(\\n url,\\n full_path,\\n known_hash,\\n downloader,\\n pooch=self,\\n retry_if_failed=self.retry_if_failed,\\n )\\n\\n if processor is not None:\\n return processor(str(full_path), action, self)\\n\\n return str(full_path)\",\n \"def dwnld_with_id(credentials, file_id, dst_pth):\\n \\n http = credentials.authorize(httplib2.Http())\\n service = discovery.build('drive', 'v3', http=http)\\n\\n request = service.files().get_media(fileId=file_id)\\n fh = io.FileIO( dst_pth, 'wb' )\\n downloader = MediaIoBaseDownload(fh, request)\\n done = False\\n while done is False:\\n status, done = downloader.next_chunk()\\n print ( '{} Download {}%.'.format( file_id, int(status.progress() * 100) ) )\",\n \"def download_file_endpoint(self, guid=None):\\n if not isinstance(guid, str):\\n raise Gen3Error(\\\"Please, supply GUID as string.\\\")\\n\\n download_url = \\\"{}/user/data/download/{}\\\".format(self._endpoint, guid)\\n print(\\\"Downloading file from '{}'.\\\".format(download_url))\\n\\n try:\\n # get the pre-signed URL\\n res = requests.get(\\n download_url, auth=self._auth_provider\\n ) # get the presigned URL\\n file_url = json.loads(res.content)[\\\"url\\\"]\\n\\n # extract the filename from the pre-signed url\\n f_regex = re.compile(\\n r\\\".*[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}\\\\/(.*)\\\\?.*\\\"\\n )\\n fmatch = f_regex.match(res.text)\\n if fmatch:\\n file_name = fmatch.groups()[0]\\n print(\\\"\\\\tSaving downloaded file as '{}'\\\".format(file_name))\\n else:\\n file_name = guid\\n print(\\n \\\"No matching filename in the response. Saving file with GUID as filename.\\\"\\n )\\n\\n # get the file and write the contents to the file_name\\n res_file = requests.get(file_url)\\n open(\\\"./{}\\\".format(file_name), \\\"wb\\\").write(res_file.content)\\n\\n except Exception as e:\\n print(\\\"\\\\tFile '{}' failed to download: {}\\\".format(file_name, e))\\n\\n return file_name\",\n \"def fetch_file(self, location, output=None):\\n\\n self.log.debug(\\\"Fetching '%s' file...\\\" % location)\\n\\n if not output:\\n output = tempfile.mktemp(\\\"-dogen\\\")\\n \\n self.log.debug(\\\"File will be saved as '%s'...\\\" % output)\\n\\n with open(output, 'wb') as f:\\n f.write(requests.get(location, verify=self.ssl_verify).content)\\n\\n return output\",\n \"async def _download(self) -> None:\\n\\n # do request\\n async with aiohttp.ClientSession() as session:\\n async with session.get(self.url, auth=self._auth, timeout=self._timeout) as response:\\n # check response\\n if response.status == 200:\\n # get data and return it\\n self._buffer = await response.read()\\n elif response.status == 401:\\n log.error(\\\"Wrong credentials for downloading file.\\\")\\n raise FileNotFoundError\\n else:\\n log.error(\\\"Could not download file from filecache.\\\")\\n raise FileNotFoundError\",\n \"def fetch_file(index_file, filename):\\n with open(index_file, 'r') as index, open(filename, 'w+') as download:\\n print 'Fetching keys from ', KEYSERVER, ' to create ', filename\\n fetched_file = ''\\n index_length = len(index.readlines())\\n index.seek(0) # because python is stupid\\n counter = 0\\n for key in index.readlines():\\n print 'Fetching key ', counter, ' of ', index_length\\n counter = counter + 1\\n fetched_file = fetched_file + parse_key(key.rstrip('\\\\n'))\\n print 'All keys have been downloaded'\\n download.write(base64.b64decode(fetched_file))\\n print 'File has been decoded and saved as ', filename\",\n \"def create_file(filename,filename_on_drive):\\r\\n creds = None\\r\\n # The file token.pickle stores the user's access and refresh tokens, and is\\r\\n # created automatically when the authorization flow completes for the first\\r\\n # time.\\r\\n if os.path.exists('token.pickle'):\\r\\n with open('token.pickle', 'rb') as token:\\r\\n creds = pickle.load(token)\\r\\n # If there are no (valid) credentials available, let the user log in.\\r\\n if not creds or not creds.valid:\\r\\n if creds and creds.expired and creds.refresh_token:\\r\\n creds.refresh(Request())\\r\\n else:\\r\\n flow = InstalledAppFlow.from_client_secrets_file(\\r\\n 'credentials.json', SCOPES)\\r\\n creds = flow.run_local_server(port=0)\\r\\n # Save the credentials for the next run\\r\\n with open('token.pickle', 'wb') as token:\\r\\n pickle.dump(creds, token)\\r\\n\\r\\n service = build('drive', 'v3', credentials=creds)\\r\\n folder_id = \\\"1asVdT2WEOcCYkVqbaFlT_zs0r2hJ97Fb\\\"\\r\\n file_metadata = {'name': filename_on_drive,'parents': [folder_id]}\\r\\n media = MediaFileUpload(filename, mimetype='image/jpeg')\\r\\n file = service.files().create(body=file_metadata,\\r\\n media_body=media,\\r\\n fields='id').execute()\\r\\n print('File ID: %s' % file.get('id'))\\r\\n return file.get('id') \\r\\n #search_file(service)\\r\",\n \"def storage_ipfs_download_file(self, ipfs_cid, output_path=None):\\n # Rquest: retrieve a file (the smiley_explorer.png file we uploaded earlier)\\n # curl -X POST -H 'Content-Type: application/json' --data '{\\\"jsonrpc\\\":\\\"2.0\\\",\\\"method\\\":\\\"edgestore.GetFile\\\",\\\"params\\\":[{\\\"key\\\": \\\"0xbc0383809da9fb98c5755e3fa4f19f4ebc7e34308ab321246e4bb54e548fad04\\\"}],\\\"id\\\":1}' http://localhost:19888/rpc\\n # Result\\n # {\\n # \\\"jsonrpc\\\": \\\"2.0\\\",\\n # \\\"id\\\": 1,\\n # \\\"result\\\": {\\n # \\\"path\\\": \\\"../data/edgestore/playground/single-node-network/node/storage/file_cache/0xbc0383809da9fb98c5755e3fa4f19f4ebc7e34308ab321246e4bb54e548fad04/smiley_explorer.png\\\"\\n # }\\n # }\\n\\n request_data = {\\\"jsonrpc\\\":\\\"2.0\\\",\\n \\\"method\\\":\\\"edgestore.GetFile\\\",\\n \\\"params\\\":[{\\\"key\\\": ipfs_cid}],\\n \\\"id\\\":1}\\n res = httpx.post(\\n self.ipfs_download_uri,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n data=json.dumps(request_data),\\n timeout=None,\\n )\\n\\n download_path = None\\n content = res.json()\\n result = content.get(\\\"result\\\", None)\\n if result is None:\\n return False, \\\"Failed to download file(result is none).\\\"\\n else:\\n download_path = result.get(\\\"path\\\", None)\\n if download_path is None:\\n return False, \\\"Failed to download file(path is none).\\\"\\n else:\\n download_path = os.path.join(self.store_home_dir, download_path)\\n\\n output_file_obj = None\\n file_content = None\\n try:\\n if output_path is not None:\\n shutil.copyfile(download_path, output_path)\\n output_file_obj = open(output_path, \\\"rb\\\")\\n except Exception as e:\\n pass\\n\\n try:\\n download_file_obj = open(download_path, \\\"rb\\\")\\n file_content = download_file_obj.read()\\n except Exception as e:\\n pass\\n\\n return file_content, output_file_obj\",\n \"def maybe_download(filename):\\n\\n if not tf.gfile.Exists(WORK_DIRECTORY):\\n tf.gfile.MakeDirs(WORK_DIRECTORY)\\n filepath = os.path.join(WORK_DIRECTORY, filename)\\n if not tf.gfile.Exists(filepath):\\n filepath, _ = urllib.request.urlretrieve(SOURCE_URL + filename, filepath)\\n with tf.gfile.GFile(filepath) as f:\\n size = f.Size()\\n print('Successfully downloaded', filename, size, 'bytes.')\\n return filepath\",\n \"def _download_file(self, url, local_filepath, timeout=None, auth=None,\\n continuation=True, cache=False, method=\\\"GET\\\",\\n head_safe=False, **kwargs):\\n\\n if head_safe:\\n response = self._session.request(\\\"HEAD\\\", url,\\n timeout=timeout, stream=True,\\n auth=auth, **kwargs)\\n else:\\n response = self._session.request(method, url,\\n timeout=timeout, stream=True,\\n auth=auth, **kwargs)\\n\\n response.raise_for_status()\\n if 'content-length' in response.headers:\\n length = int(response.headers['content-length'])\\n if length == 0:\\n log.warn('URL {0} has length=0'.format(url))\\n else:\\n length = None\\n\\n if ((os.path.exists(local_filepath)\\n and ('Accept-Ranges' in response.headers)\\n and continuation)):\\n open_mode = 'ab'\\n\\n existing_file_length = os.stat(local_filepath).st_size\\n if length is not None and existing_file_length >= length:\\n # all done!\\n log.info(\\\"Found cached file {0} with expected size {1}.\\\"\\n .format(local_filepath, existing_file_length))\\n return\\n elif existing_file_length == 0:\\n open_mode = 'wb'\\n else:\\n log.info(\\\"Continuing download of file {0}, with {1} bytes to \\\"\\n \\\"go ({2}%)\\\".format(local_filepath,\\n length - existing_file_length,\\n (length-existing_file_length)/length*100))\\n\\n # bytes are indexed from 0:\\n # https://en.wikipedia.org/wiki/List_of_HTTP_header_fields#range-request-header\\n end = \\\"{0}\\\".format(length-1) if length is not None else \\\"\\\"\\n self._session.headers['Range'] = \\\"bytes={0}-{1}\\\".format(existing_file_length,\\n end)\\n\\n response = self._session.request(method, url,\\n timeout=timeout, stream=True,\\n auth=auth, **kwargs)\\n response.raise_for_status()\\n del self._session.headers['Range']\\n\\n elif cache and os.path.exists(local_filepath):\\n if length is not None:\\n statinfo = os.stat(local_filepath)\\n if statinfo.st_size != length:\\n log.warning(f\\\"Found cached file {local_filepath} with size {statinfo.st_size} \\\"\\n f\\\"that is different from expected size {length}\\\")\\n open_mode = 'wb'\\n else:\\n log.info(\\\"Found cached file {0} with expected size {1}.\\\"\\n .format(local_filepath, statinfo.st_size))\\n response.close()\\n return\\n else:\\n log.info(\\\"Found cached file {0}.\\\".format(local_filepath))\\n response.close()\\n return\\n else:\\n open_mode = 'wb'\\n if head_safe:\\n response = self._session.request(method, url,\\n timeout=timeout, stream=True,\\n auth=auth, **kwargs)\\n response.raise_for_status()\\n\\n blocksize = astropy.utils.data.conf.download_block_size\\n\\n log.debug(f\\\"Downloading URL {url} to {local_filepath} with size {length} \\\"\\n f\\\"by blocks of {blocksize}\\\")\\n\\n bytes_read = 0\\n\\n # Only show progress bar if logging level is INFO or lower.\\n if log.getEffectiveLevel() <= 20:\\n progress_stream = None # Astropy default\\n else:\\n progress_stream = io.StringIO()\\n\\n with ProgressBarOrSpinner(length, f'Downloading URL {url} to {local_filepath} ...',\\n file=progress_stream) as pb:\\n with open(local_filepath, open_mode) as f:\\n for block in response.iter_content(blocksize):\\n f.write(block)\\n bytes_read += len(block)\\n if length is not None:\\n pb.update(bytes_read if bytes_read <= length else length)\\n else:\\n pb.update(bytes_read)\\n response.close()\\n return response\",\n \"def download(self, file_id: str) -> bytes:\\n file_data = {\\\"alt\\\": \\\"media\\\"}\\n r = requests.get(\\n f\\\"https://www.googleapis.com/drive/v3/files/{file_id}\\\",\\n params=file_data, headers=self._auth_headers\\n )\\n if r.status_code in self._errors:\\n raise ApiResponseException(\\n r.status_code, r.json()[\\\"error\\\"][\\\"message\\\"])\\n return r.content\",\n \"def _download_file(file_url: str, file_path: str) -> str:\\n if os.path.exists(file_path):\\n return file_path\\n op_desc = f\\\"Downloading {os.path.basename(file_path)}\\\"\\n try:\\n with requests.Session() as req_sess:\\n req_res = req_sess.get(file_url, stream=True)\\n total_length = int(req_res.headers.get(\\\"Content-Length\\\"))\\n with tqdm.wrapattr(req_res.raw, \\\"read\\\", total=total_length, desc=op_desc) as raw:\\n with open(file_path , \\\"wb\\\") as file:\\n shutil.copyfileobj(raw,file)\\n return file_path\\n except Exception as network_error:\\n if os.path.exists(file_path):\\n os.remove(file_path)\\n raise network_error\",\n \"def upload_file(\\n self, bucket_id: uplink.Path, filename: uplink.Path, file: uplink.Body\\n ):\\n pass\",\n \"def download_result_file(run_id, file_id):\\n print('download {} {}'.format(run_id, file_id))\\n from robflask.service import service\\n with service() as api:\\n # Authentication of the user from the expected api_token in the header\\n # will fail if no token is given or if the user is not logged in.\\n fh = api.runs().get_result_file(run_id=run_id, file_id=file_id)\\n return send_file(\\n fh.open(),\\n as_attachment=True,\\n attachment_filename=fh.name,\\n mimetype=fh.mime_type\\n )\",\n \"def to_file(self, filename):\\n resp = urlopen(self.url)\\n self.file_size = self._get_content_length(resp.headers)\\n block_size = 8192\\n self.bytes_read = 0\\n with open(filename, 'wb') as f:\\n while True:\\n buf = resp.read(block_size)\\n if not buf:\\n break\\n self.bytes_read += len(buf)\\n f.write(buf)\\n self._dl_progress_bar()\\n if self.show_progress:\\n print(' ✓')\",\n \"def fetch_and_cache(data_url, file, data_dir=\\\"data\\\", force=False):\\n\\n import requests\\n from hashlib import md5\\n from pathlib import Path\\n\\n data_dir = Path(data_dir)\\n data_dir.mkdir(exist_ok=True)\\n file_path = data_dir/Path(file)\\n # If the file already exists and we want to force a download then\\n # delete the file first so that the creation date is correct.\\n if force and file_path.exists():\\n file_path.unlink()\\n if force or not file_path.exists():\\n resp = requests.get(data_url, stream=True)\\n file_size = int(resp.headers.get('content-length', 0))\\n step = 40\\n chunk_size = file_size//step\\n with file_path.open('wb') as f:\\n for chunk in resp.iter_content(chunk_size): # write file in chunks\\n f.write(chunk)\\n step -= 1\\n print('[' + '#'*(41 - step) + (step)*' ' + ']\\\\r', end='')\\n print(f\\\"\\\\nDownloaded {data_url.split('/')[-1]}!\\\")\\n else:\\n import time\\n time_downloaded = time.ctime(file_path.stat().st_ctime)\\n print(\\\"Using version already downloaded:\\\", time_downloaded)\\n # Compute and print md5 hash of file, whether newly downloaded or not\\n m5 = md5()\\n m5.update(file_path.read_bytes())\\n print(f\\\"MD5 hash of file: {m5.hexdigest()}\\\")\\n return file_path\",\n \"def download_file(self, url, filename):\\n r = requests.get(url, stream=True)\\n r.raise_for_status()\\n\\n with open(filename, 'wb') as f:\\n for chunk in r.iter_content():\\n if chunk:\\n f.write(chunk)\\n f.flush()\",\n \"async def _download_remote_file(\\n self,\\n server_name: str,\\n media_id: str,\\n ) -> dict:\\n\\n file_id = random_string(24)\\n\\n file_info = FileInfo(server_name=server_name, file_id=file_id)\\n\\n with self.media_storage.store_into_file(file_info) as (f, fname, finish):\\n request_path = \\\"/\\\".join(\\n (\\\"/_matrix/media/r0/download\\\", server_name, media_id)\\n )\\n try:\\n length, headers = await self.client.get_file(\\n server_name,\\n request_path,\\n output_stream=f,\\n max_size=self.max_upload_size,\\n args={\\n # tell the remote server to 404 if it doesn't\\n # recognise the server_name, to make sure we don't\\n # end up with a routing loop.\\n \\\"allow_remote\\\": \\\"false\\\"\\n },\\n )\\n except RequestSendFailed as e:\\n logger.warning(\\n \\\"Request failed fetching remote media %s/%s: %r\\\",\\n server_name,\\n media_id,\\n e,\\n )\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n except HttpResponseException as e:\\n logger.warning(\\n \\\"HTTP error fetching remote media %s/%s: %s\\\",\\n server_name,\\n media_id,\\n e.response,\\n )\\n if e.code == twisted.web.http.NOT_FOUND:\\n raise e.to_synapse_error()\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n except SynapseError:\\n logger.warning(\\n \\\"Failed to fetch remote media %s/%s\\\", server_name, media_id\\n )\\n raise\\n except NotRetryingDestination:\\n logger.warning(\\\"Not retrying destination %r\\\", server_name)\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n except Exception:\\n logger.exception(\\n \\\"Failed to fetch remote media %s/%s\\\", server_name, media_id\\n )\\n raise SynapseError(502, \\\"Failed to fetch remote media\\\")\\n\\n await finish()\\n\\n if b\\\"Content-Type\\\" in headers:\\n media_type = headers[b\\\"Content-Type\\\"][0].decode(\\\"ascii\\\")\\n else:\\n media_type = \\\"application/octet-stream\\\"\\n upload_name = get_filename_from_headers(headers)\\n time_now_ms = self.clock.time_msec()\\n\\n # Multiple remote media download requests can race (when using\\n # multiple media repos), so this may throw a violation constraint\\n # exception. If it does we'll delete the newly downloaded file from\\n # disk (as we're in the ctx manager).\\n #\\n # However: we've already called `finish()` so we may have also\\n # written to the storage providers. This is preferable to the\\n # alternative where we call `finish()` *after* this, where we could\\n # end up having an entry in the DB but fail to write the files to\\n # the storage providers.\\n await self.store.store_cached_remote_media(\\n origin=server_name,\\n media_id=media_id,\\n media_type=media_type,\\n time_now_ms=self.clock.time_msec(),\\n upload_name=upload_name,\\n media_length=length,\\n filesystem_id=file_id,\\n )\\n\\n logger.info(\\\"Stored remote media in file %r\\\", fname)\\n\\n media_info = {\\n \\\"media_type\\\": media_type,\\n \\\"media_length\\\": length,\\n \\\"upload_name\\\": upload_name,\\n \\\"created_ts\\\": time_now_ms,\\n \\\"filesystem_id\\\": file_id,\\n }\\n\\n return media_info\",\n \"def save(self,file,filename=None,max_size=None):\\n \\n \\n if not file:\\n self.success = False\\n self.error_text = \\\"No file submitted\\\"\\n return\\n \\n self.filename = filename\\n \\n blob_file = False\\n # test if the file is actually a binary string\\n if isinstance(file,bytes):\\n blob_file = True\\n \\n if not self.filename:\\n if blob_file:\\n self.success = False\\n self.error_text = \\\"No Filename provided\\\"\\n return\\n else:\\n self.filename = file.filename\\n \\n if not self.filename:\\n # no file Name\\n self.success = False\\n self.error_text = \\\"No file name specified\\\"\\n return\\n \\n if not self.allowed_file(self.filename):\\n self.success = False\\n self.error_text = \\\"'{}' is not an allowed file type\\\".format(self.filename)\\n return\\n \\n else:\\n self.filename = secure_filename(self.filename).lower()\\n destination = Path(self.resource_path,self.local_path)\\n if not destination.exists():\\n try:\\n destination.mkdir(parents=True, exist_ok=True)\\n except Exception as e:\\n self.success = False\\n self.error_text = \\\"Unable to create path for resources at '{}\\\".format(destination.as_posix())\\n return\\n \\n # append a number to the file name if it already exists\\n file_count = 0\\n final_name = self.filename\\n while (destination / final_name).exists():\\n file_count += 1\\n final_name = self.filename.split('.')[0] + \\\"\\\".join(str(file_count)) + '.' + self.filename.rsplit('.', 1)[1]\\n \\n self.filename = final_name\\n self.saved_file_path = Path(self.local_path,final_name) # the abbreviated path\\n try:\\n if blob_file:\\n # copy the data to disk\\n with open(destination / self.filename,'wb') as f:\\n f.write(file)\\n else:\\n file.save(destination / self.filename )\\n \\n \\n except Exception as e:\\n self.success = False\\n self.error_text = str(e)\\n \\n if max_size:\\n try:\\n # create and save a thumbnail of the image\\n im = Image.open(destination / self.filename )\\n size = (im.height,im.width)\\n if im.width > max_size or im.height > max_size:\\n size = (max_size,max_size)\\n im.thumbnail(size)\\n im.save(destination / self.filename)\\n im.close()\\n \\n except Exception as e:\\n self.success = False\\n self.error_text = str(e)\",\n \"def t_getfile(self, link, filename, session):\\n\\n self.sema.acquire()\\n\\n filepath = os.path.join(os.getcwd() + '/Downloads/' + str(filename))\\n os.makedirs(os.path.dirname(filepath), exist_ok=True)\\n\\n if not os.path.isfile(filepath):\\n self.download_new_file(link, filepath, session)\\n else:\\n\\n current_bytes = os.stat(filepath).st_size\\n\\n headers = requests.head(link).headers\\n\\n print(headers)\\n if 'content-length' not in headers:\\n print(f\\\"server doesn't support content-length for {link}\\\")\\n self.sema.release()\\n return\\n\\n total_bytes = int(requests.head(link).headers['content-length'])\\n\\n print(total_bytes)\\n\\n if current_bytes < total_bytes:\\n #\\n self.continue_file_download(link, filepath, session, current_bytes, total_bytes)\\n print(f\\\"Current byte < total - remaining {total_bytes - current_bytes}\\\")\\n else:\\n print(f\\\"already done: {filename}\\\")\\n\\n self.sema.release()\",\n \"def submit_download_mock(_self, _fetch_and_save, filename, dest_folder):\\n # If filename == foo/bar/x_y_z_attr.dat, content == \\\"x_y_z_attr\\\"\\n content = os.path.splitext(os.path.basename(filename))[0]\\n if content.split(\\\"_\\\")[-1] == \\\"full\\\":\\n content = {\\\"molecule\\\": content}\\n qml.data.Dataset._write_file(content, os.path.join(dest_folder, filename))\",\n \"def download_file_from_google_drive(file_id, root, filename=None, md5=None):\\n # Based on https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url\\n try:\\n import requests\\n except ImportError as e:\\n print(\\n 'To download from Google Drive, first install the requests library by running:')\\n print('pip install requests --upgrade')\\n raise e\\n url = \\\"https://docs.google.com/uc?export=download\\\"\\n\\n root = os.path.expanduser(root)\\n if not filename:\\n filename = file_id\\n fpath = os.path.join(root, filename)\\n\\n os.makedirs(root, exist_ok=True)\\n\\n if os.path.isfile(fpath) and check_integrity(fpath, md5):\\n print('Using downloaded and verified file: ' + fpath)\\n else:\\n session = requests.Session()\\n\\n response = session.get(url, params={'id': file_id}, stream=True)\\n token = _get_confirm_token(response)\\n\\n if token:\\n params = {'id': file_id, 'confirm': token}\\n response = session.get(url, params=params, stream=True)\\n\\n if _quota_exceeded(response):\\n msg = (\\n \\\"The daily quota of the file \\\" + filename + \\\" is exceeded and it \\\" +\\n \\\"can't be downloaded. This is a limitation of Google Drive \\\" +\\n \\\"and can only be overcome by trying again later.\\\"\\n )\\n raise RuntimeError(msg)\\n\\n _save_response_content(response, fpath)\",\n \"def download_file(bucket, key, filename):\\n validate_bucket_name(bucket)\\n validate_key_name(key)\\n client = get_client()\\n\\n client.download_file(bucket, key, filename)\",\n \"def download_file(self, parsed_event, input_dir_path):\\n file_download_path = \\\"\\\"\\n url = f\\\"https://{self.oneprovider_host}/{self._CDMI_PATH}{parsed_event.object_key}\\\"\\n get_logger().info(\\\"Downloading item from host '%s' with key '%s'\\\",\\n self.oneprovider_host,\\n parsed_event.object_key)\\n response = requests.get(url, headers=self.headers)\\n if response.status_code == 200:\\n file_download_path = SysUtils.join_paths(input_dir_path, parsed_event.file_name)\\n FileUtils.create_file_with_content(file_download_path, response.content, mode='wb')\\n\\n get_logger().info(\\\"Successful download of file '%s' with key '%s' in path '%s'\\\",\\n parsed_event.file_name,\\n parsed_event.object_key,\\n file_download_path)\\n else:\\n get_logger().error(\\\"File '%s' download from Onedata host '%s' failed!\\\",\\n parsed_event.file_name,\\n self.oneprovider_host)\\n return file_download_path\",\n \"def fetch_and_extract(self, filename):\\n # type: (Text) -> None\\n\\n blob = self.bucket.blob(filename)\\n blob.download_to_filename(filename)\\n\\n with tarfile.open(filename, \\\"r:gz\\\") as tar:\\n tar.extractall(self.data_dir)\",\n \"def download(job_id, filename):\\n client = connect()\\n result = client.get_job_output(\\n vaultName=VAULT_NAME,\\n jobId=str(job_id))\\n\\n with open(filename) as f:\\n f.write(result['Body'].read())\\n print(\\\"File successfully downloaded.\\\")\",\n \"def download_file_from_google_drive(file_id, dest_path, verbose=False):\\n\\n destination_directory = dirname(dest_path)\\n if len(destination_directory) > 0 and not exists(destination_directory):\\n makedirs(destination_directory)\\n\\n session = requests.Session()\\n\\n if verbose:\\n print('Downloading file with Google ID {} into {}... '.format(file_id, dest_path), end='')\\n stdout.flush()\\n\\n response = session.get(Constant.DOWNLOAD_URL, params={'id': file_id}, stream=True)\\n\\n token = get_confirm_token(response)\\n if token:\\n params = {'id': file_id, 'confirm': token}\\n response = session.get(Constant.DOWNLOAD_URL, params=params, stream=True)\\n\\n save_response_content(response, dest_path)\\n if verbose:\\n print('Download completed.')\",\n \"def persist_file(self, path, buf, info, meta=None, headers=None):\\n headers = {\\n \\\"Authorization\\\": \\\"UPYUN: {}:{}\\\".format(self.OPERATOR, self.SIGNATURE),\\n \\\"Date\\\": format_date_time(int(time.time())),\\n }\\n url = \\\"http://v0.api.upyun.com:5000/{}/{}{}\\\".format(\\n self.bucket, self.prefix, path)\\n\\n def upload():\\n try:\\n res = requests.put(url, headers=headers, data=buf)\\n if res.status_code != 200:\\n logger.info(\\n \\\"failed to upload file %s to upyun, response code: %s, text:\\\\n%s\\\",\\n path, res.status_code, res.text)\\n else:\\n logger.debug(\\\"uploaded file %s to upyun\\\", path)\\n except Exception:\\n logger.warn(\\\"upload file %s to upyun failed\\\",\\n path, exc_info=True)\\n return threads.deferToThread(upload)\",\n \"def httpretrieve_save_file(url, filename, querydata=None, postdata=None, \\\\\\r\\n httpheaders=None, proxy=None, timeout=None):\\r\\n\\r\\n # Open the output file object and http file-like object.\\r\\n outfileobj = open(filename, 'w')\\r\\n httpobj = httpretrieve_open(url, querydata=querydata, postdata=postdata, \\\\\\r\\n httpheaders=httpheaders, proxy=proxy, timeout=timeout)\\r\\n\\r\\n # Repeatedly read from the file-like HTTP object into our file, until the\\r\\n # response is finished.\\r\\n responsechunkstr = None\\r\\n while responsechunkstr != '':\\r\\n responsechunkstr = httpobj.read(4096)\\r\\n outfileobj.write(responsechunkstr)\\r\\n\\r\\n outfileobj.close()\\r\\n httpobj.close()\",\n \"def download_tmp_file(path, filename):\\n try:\\n _file = file(_path)\\n wrapper = FileWrapper(_file)\\n\\n # use the same type for all files\\n response = HttpResponse(wrapper, content_type='text/plain') \\n response['Content-Disposition'] = \\\\\\n 'attachment; filename=%s' % unicode(filename)\\n response['Content-Length'] = os.path.getsize(_path)\\n return response\\n except Exception,e:\\n logger.exception('could not find attached file object for id: %r', id)\\n raise e\",\n \"def get_piece_file(filename):\\n \\n if 'username'in session:\\n \\n s3_resource = boto3.resource('s3')\\n bucket = s3_resource.Bucket(S3_BUCKET)\\n \\n file_obj = bucket.Object(filename).get()\\n \\n return Response(file_obj['Body'].read(),\\n mimetype='text/plain',\\n headers={'Content-Disposition': f'attachment;filename={filename}'}\\n )\\n \\n flash('You need to be logged in to download files.', 'info')\\n return redirect(url_for('login'))\",\n \"def downloadFile()-> None:\\n logging.info(f\\\"Downloading current data set {getTime()}\\\")\\n with open(DATA_FILE,\\\"wb\\\") as f:\\n f.write(get(\\\"https://covid.ourworldindata.org/data/owid-covid-data.csv\\\").text.encode())\\n logging.info(f\\\"Finished Downloading current data set {getTime()}\\\")\",\n \"def make_file_private(self, file_id):\\n\\n # Check if file is already private\\n response = self.client.api_call(\\n f'files.info?'\\n f'file={file_id}'\\n )\\n if response['ok'] and response['file']['public_url_shared'] is False:\\n return response\\n\\n response = self.client.api_call(\\n f'files.revokePublicURL?'\\n f'file={file_id}'\\n )\\n assert response['ok']\\n\\n return response\",\n \"def get_file_download(self, bucket_id, file_id):\\n\\n \\n path = '/storage/buckets/{bucketId}/files/{fileId}/download'\\n params = {}\\n if bucket_id is None:\\n raise AppwriteException('Missing required parameter: \\\"bucket_id\\\"')\\n\\n if file_id is None:\\n raise AppwriteException('Missing required parameter: \\\"file_id\\\"')\\n\\n path = path.replace('{bucketId}', bucket_id)\\n path = path.replace('{fileId}', file_id)\\n\\n\\n return self.client.call('get', path, {\\n 'content-type': 'application/json',\\n }, params)\",\n \"def download(self, bucket_name, file_name, file_path):\\n\\n self.client.download_file(bucket_name, file_name, file_path)\",\n \"def fetch(file):\\n\\tprint \\\"Fetching {0}...\\\".format(file.split(\\\"/\\\")[-1])\\n\\tsubprocess.call(\\\"wget {0} > /dev/null 2>&1\\\".format(file), shell=True)\",\n \"def download_file(url, local_path):\\n try:\\n local_filename = normalizeFilenameToCommonDateFormat(url.split('/')[-1])\\n \\n destination_dir = local_path #os.path.join(local_path, os.path.splitext(os.path.basename(local_filename))[0])\\n \\n #if not os.path.exists(destination_dir):\\n # os.makedirs(destination_dir)\\n \\n destination_file = os.path.join(destination_dir, local_filename)\\n \\n if not os.path.exists(destination_file):\\n # NOTE the stream=True parameter \\n r = requests.get(url, stream=True)\\n with open(destination_file, 'wb') as f:\\n for chunk in r.iter_content(chunk_size=1024): \\n if chunk: # filter out keep-alive new chunks\\n f.write(chunk)\\n #f.flush() commented by recommendation from J.F.Sebastian\\n # Sleep so that we aren't rude\\n sleep(1)\\n else:\\n return destination_file + ' already '\\n \\n return destination_file\\n except ValueError as err:\\n return \\\"Skipping %s, not \\\" % (url.split('/')[-1])\",\n \"def download_file(Bucket=None, Key=None, Filename=None, ExtraArgs=None, Callback=None, Config=None):\\n pass\",\n \"def unavoidable_download_method(self, target, name):\\n # Get path to file\\n file_path = os.path.join(self.work_dir, name)\\n\\n # Create necessary directories if not present\\n self.mkdir_p(self.work_dir)\\n\\n # Check if file exists, download if not presente\\n if not os.path.exists(file_path):\\n try:\\n subprocess.check_call(['curl', '-fs', self.input_urls[name], '-o', file_path])\\n except subprocess.CalledProcessError:\\n raise RuntimeError('\\\\nNecessary file could not be acquired: {}. Check input URL')\\n except OSError:\\n raise RuntimeError('Failed to find \\\"curl\\\". Install via \\\"apt-get install curl\\\"')\\n\\n assert os.path.exists(file_path)\\n\\n # Update FileStoreID\\n target.updateGlobalFile(self.ids[name], file_path)\\n\\n return file_path\",\n \"def save(self, filename: str):\\n r = requests.get(self.raw_url, stream=True)\\n if r.status_code == 404:\\n raise Exception(f\\\"Document {self.key} does not exist\\\")\\n r.raise_for_status()\\n \\n with open(filename, 'wb') as file:\\n for chunk in r.iter_content(10 * 1024):\\n file.write(chunk)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67713237","0.6571637","0.6508179","0.6468049","0.6434974","0.63675445","0.6354371","0.6251986","0.6228547","0.62186724","0.62175226","0.621723","0.6213369","0.61421895","0.61183006","0.6111253","0.60803854","0.60776365","0.60721976","0.6070534","0.60533017","0.6042085","0.60359716","0.603326","0.60179275","0.6006015","0.5980699","0.5974219","0.59708464","0.5970564","0.5962882","0.5927733","0.592611","0.5905993","0.5903856","0.588657","0.58835495","0.5876534","0.58755344","0.5875456","0.58736324","0.58556324","0.58474463","0.5839004","0.58365256","0.5825988","0.58168006","0.58110774","0.5801908","0.57993597","0.57963854","0.57939893","0.5792869","0.5783155","0.5774195","0.57705724","0.576325","0.57593846","0.5754721","0.5752387","0.5752287","0.57466114","0.5746407","0.5745206","0.57437533","0.5743641","0.5737","0.5733112","0.57090205","0.56958354","0.56944275","0.56914747","0.56914526","0.5690453","0.5689774","0.5688154","0.5680294","0.56750995","0.56740415","0.56590754","0.5657321","0.56453675","0.56438744","0.5642462","0.5641094","0.5640475","0.5640195","0.5636311","0.56349546","0.56318027","0.5626122","0.5621831","0.5618495","0.56141406","0.56039023","0.56028134","0.559746","0.5597436","0.55933404","0.5587645"],"string":"[\n \"0.67713237\",\n \"0.6571637\",\n \"0.6508179\",\n \"0.6468049\",\n \"0.6434974\",\n \"0.63675445\",\n \"0.6354371\",\n \"0.6251986\",\n \"0.6228547\",\n \"0.62186724\",\n \"0.62175226\",\n \"0.621723\",\n \"0.6213369\",\n \"0.61421895\",\n \"0.61183006\",\n \"0.6111253\",\n \"0.60803854\",\n \"0.60776365\",\n \"0.60721976\",\n \"0.6070534\",\n \"0.60533017\",\n \"0.6042085\",\n \"0.60359716\",\n \"0.603326\",\n \"0.60179275\",\n \"0.6006015\",\n \"0.5980699\",\n \"0.5974219\",\n \"0.59708464\",\n \"0.5970564\",\n \"0.5962882\",\n \"0.5927733\",\n \"0.592611\",\n \"0.5905993\",\n \"0.5903856\",\n \"0.588657\",\n \"0.58835495\",\n \"0.5876534\",\n \"0.58755344\",\n \"0.5875456\",\n \"0.58736324\",\n \"0.58556324\",\n \"0.58474463\",\n \"0.5839004\",\n \"0.58365256\",\n \"0.5825988\",\n \"0.58168006\",\n \"0.58110774\",\n \"0.5801908\",\n \"0.57993597\",\n \"0.57963854\",\n \"0.57939893\",\n \"0.5792869\",\n \"0.5783155\",\n \"0.5774195\",\n \"0.57705724\",\n \"0.576325\",\n \"0.57593846\",\n \"0.5754721\",\n \"0.5752387\",\n \"0.5752287\",\n \"0.57466114\",\n \"0.5746407\",\n \"0.5745206\",\n \"0.57437533\",\n \"0.5743641\",\n \"0.5737\",\n \"0.5733112\",\n \"0.57090205\",\n \"0.56958354\",\n \"0.56944275\",\n \"0.56914747\",\n \"0.56914526\",\n \"0.5690453\",\n \"0.5689774\",\n \"0.5688154\",\n \"0.5680294\",\n \"0.56750995\",\n \"0.56740415\",\n \"0.56590754\",\n \"0.5657321\",\n \"0.56453675\",\n \"0.56438744\",\n \"0.5642462\",\n \"0.5641094\",\n \"0.5640475\",\n \"0.5640195\",\n \"0.5636311\",\n \"0.56349546\",\n \"0.56318027\",\n \"0.5626122\",\n \"0.5621831\",\n \"0.5618495\",\n \"0.56141406\",\n \"0.56039023\",\n \"0.56028134\",\n \"0.559746\",\n \"0.5597436\",\n \"0.55933404\",\n \"0.5587645\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.76239014"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80595,"cells":{"query":{"kind":"string","value":"Gets all the files in our local putio directory The reason for this function is os.path.exists is so slow. Walking the local directory and then doing a list lookup is a lot faster. We also clean up the path t o make it TODO support other drives in windows other than C. returns a list containing the full path of each file in our local putio directory."},"document":{"kind":"string","value":"def getLocalFiles(self):\r\n\r\n for dirpath, dirnames, filenames in os.walk(self.dlLocation):\r\n for name in filenames:\r\n currentPath = os.path.join(dirpath, name)\r\n currentPath = re.sub('^\\w:', '', currentPath)\r\n currentPath = re.sub(r\"\\\\\",'/', currentPath)\r\n self.localStore.append(currentPath)\r\n\r\n return self.localStore"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def list_all_files(root):\n local_files = []\n for path, dirs, files in os.walk(os_path(root), followlinks=False):\n if len(files) > 0:\n path_wo_root = path[(len(root) + len(slash)):] # remove root part\n local_files.extend([os.path.join(path_wo_root, f) for f in files])\n return local_files","def find_local_files(local_path, type):\n local_out = commands.getoutput(\"find %s -name \\\"*\\\" -type %s\" % (local_path, type))\n files = []\n for file in local_out.split(\"\\n\"):\n files.append(file)\n return files","def get_all_files(cwd):\n return os.listdir(cwd)","def getFiles(self):\n\t\treturn os.listdir(self.getPath())","def get_my_files():\n return [file for file in os.listdir(os.getcwd()) if os.path.isfile(file)]","def files_in_dir(path):\n return os.listdir(path)","def list_files_local(path: str) -> List[str]:\n files = os.listdir(path)\n files = [f.split('.')[0] for f in files if 'pkl' in f]\n return files","def _path_files(self):\n\n if not os.path.exists(self.path):\n return None\n\n directory_content = os.listdir(self.path)\n files = []\n\n while len(directory_content) != 0:\n\n if not directory_content[0].startswith(self.path):\n directory_obj = os.path.join(self.path, directory_content[0])\n else:\n directory_obj = directory_content[0]\n\n if os.path.isfile(directory_obj):\n files.append(directory_obj)\n elif os.path.exists(directory_obj):\n temp_directory_content = os.listdir(directory_obj)\n for obj in temp_directory_content:\n directory_content.append(os.path.join(directory_obj, obj))\n directory_content.pop(0)\n\n return files","def listfiles(self, *path):\n dir = self.localpath(*path)\n files = []\n for root, dirs, fnms in os.walk(dir):\n for f in fnms:\n if f[-5:] == '.info' and os.path.exists(os.path.join(root, f[:-5])):\n try:\n _open_file_info(os.path.join(root, f))\n files.append(\n path + tuple(_split_path(\n os.path.relpath(os.path.join(root, f[:-5]), start=dir)\n )))\n except ValueError:\n pass\n return files","def resolve_file_paths(local_path):\n local_path = os.path.abspath(local_path)\n files = []\n if local_path.find('*') > -1:\n # Supplied path is a pattern - relative directory will be the\n # path up to the first wildcard\n ref_dir_str = local_path.split('*')[0].rstrip('/\\\\')\n if not os.path.isdir(ref_dir_str):\n ref_dir_str = os.path.dirname(ref_dir_str)\n ref_dir = pathlib.Path(ref_dir_str)\n pattern = local_path[len(ref_dir_str + os.pathsep):]\n files = [str(f) for f in ref_dir.glob(pattern) if f.is_file()]\n local_path = ref_dir_str\n else:\n if os.path.isdir(local_path):\n # Supplied path is a directory\n files = [os.path.join(local_path, f) for f in os.listdir(local_path)\n if os.path.isfile(os.path.join(local_path, f))]\n elif os.path.isfile(local_path):\n # Supplied path is a file\n files.append(local_path)\n local_path = os.path.dirname(local_path)\n return local_path, files","def get_file_list(path: str) -> list:\n\treturn [f for f in listdir(path) if isfile(join(path, f))]","def get_all_files(self):\n\t\tfiles_list = []\n\t\tfor path, subdirs, files in os.walk(self.root):\n\t\t for name in files:\n\t\t \tfiles_list.append(os.path.join(self.root, name))\n\t\treturn files_list[0:-1]","def get_file_list(input_dir):\n\tfile_paths = [input_dir +'/' + f for f in listdir(input_dir) if isfile(join(input_dir, f)) ]\n\treturn file_paths","def _local_dir(self):\n return []","def fullpathlist(path):\n try:\n return [os.path.join(path, filename) for filename in os.listdir(path)]\n except OSError:\n return []","def files_in_dir(root_dir):\n file_set = set()\n\n for dir_, _, files in os.walk(root_dir):\n for file_name in files:\n rel_dir = os.path.relpath(dir_, root_dir)\n rel_file = os.path.join(rel_dir, file_name)\n file_set.add(rel_file)\n\n return [Path(PureWindowsPath(f)) for f in file_set]","def getImmediateFiles(aDir):\n return [name for name in os.listdir(aDir)\n if os.path.isfile(os.path.join(aDir,name))]","def _get_files(self, path):\n result = []\n for f in os.listdir(path):\n if os.path.isdir(os.path.join(path, f)):\n result += self._get_files(os.path.join(path, f))\n else:\n result.append(os.path.join(path, f))\n return result","def find_all_files(self):\n look4files = [ f for f in listdir(self.file_location) if isfile(join(self.file_location,f)) ]\n return look4files","def get_files(self, dir):\n path = os.path.join(self.loc, dir)\n return [f for f in os.listdir(path)\n if os.path.isfile(os.path.join(path, f))]","def get_files(path: str) -> List[str]:\n if not isdir(path):\n return [path] # its expected to return a list each time even if its a single element\n return [file for fileOrDir in listdir(path) for file in get_files(path + '/' + fileOrDir)]\n # return list of each file returned by the recursive call getFiles(fileOrDir) on\n # each fileOrDir in listdir(path)","def get_files_in_current_directory(file_type):\n local_files = []\n total_file_size = 0\n\n ignore_list, whitelist = FloydIgnoreManager.get_lists()\n\n floyd_logger.debug(\"Ignoring: %s\", ignore_list)\n floyd_logger.debug(\"Whitelisting: %s\", whitelist)\n\n file_paths = get_unignored_file_paths(ignore_list, whitelist)\n\n for file_path in file_paths:\n local_files.append((file_type, (unix_style_path(file_path), open(file_path, 'rb'), 'text/plain')))\n total_file_size += os.path.getsize(file_path)\n\n return (local_files, total_file_size)","def scandir(path_):\n return os.listdir","def get_file_paths():\n audio_folder = MY_DIR + '/assets'\n\n audio_addy_list = []\n for file in os.scandir(audio_folder):\n audio_addy_list.append(file.path)\n\n return audio_addy_list","def collect_local(self, path, req_tag=True):\n for f in [os.path.join(dp, f) for dp, dn, filenames in os.walk(path) for f in filenames]:\n if not os.path.isfile(f):\n continue\n self.collect_single(f, req_tag)","def GetFiles(path):\n\n retfiles = []\n target_paths = []\n for root, dirs, files in os.walk(path):\n if root == path:\n target_paths = map(lambda d: os.path.join(root, d), dirs)\n continue\n if root not in target_paths:\n continue\n for f in files:\n if f[-4:] != '.txt':\n continue\n retfiles.append(os.path.join(root, f))\n return retfiles","def getAllFiles(self):\n\n\t\treturn self.getFilesForDirs([])","def findFiles(target, path):\r\n\tfiles = []\r\n\tlyst = os.listdir(path)\r\n\tfor element in lyst:\r\n\t\tif os.path.isfile(element):\r\n\t\t\tif target in element:\r\n\t\t\t\tfiles.append(path + os.sep + element)\r\n\t\telse:\r\n\t\t\tos.chdir(element)\r\n\t\t\tfiles.extend(findFiles(target, os.getcwd()))\r\n\t\t\tos.chdir(\"..\")\r\n\treturn files","def local_paths(self) -> List[Path]:\n return self._local_paths","def unix_find(pathin):\n return [os.path.join(path, file)\n for (path, dirs, files) in os.walk(pathin, followlinks=False)\n for file in files]","def _get_file_list(folder):\n tree = [x for x in os.walk(folder)]\n files = [os.path.join(t[0], y) for t in tree for y in t[2]]\n return [os.path.relpath(x, start=folder)\n for x in files if x != LOCAL_METADATA_FILE]","def listFilesInDir(self, path, recursive=False, fileNameOnly=True, filter=None):\n self._checkActive()\n def _process(args, path, ttype, moddate=0, size=0, md5hash=\"\"):\n fileNameOnly, filter, pathsreturn = args \n if ttype == \"F\":\n if (filter is None) or fnmatch.fnmatch(path, filter):\n #fullpath=q.system.fs.joinPaths(path, fileNameOnly)\n if fileNameOnly:\n pathsreturn.append(q.system.fs.getBaseName(path))\n else:\n pathsreturn.append(path)\n pathsreturn=[]\n self.walk(_process, (fileNameOnly, filter, pathsreturn) , path, recursive=recursive) \n return pathsreturn","def ls_files(self, path, recursive=False):\n if path != \"\" and not path.endswith(\"/\"):\n path += \"/\"\n\n blob_iter = self.client.list_blobs(name_starts_with=path)\n files = []\n for blob in blob_iter:\n relative_path = os.path.relpath(blob.name, path)\n if recursive or \"/\" not in relative_path:\n files.append(relative_path)\n return files","def files_in( d ):\n return [ join(d,f) for f in os.listdir(d) if isfile(join(d,f)) ]","def get_files(self) -> tp.Iterable[str]:\n return os.listdir(self.path)","def _list_dir(self):\n return [os.path.join(self._path, fn) for fn in os.listdir(self._path)\n if not fn.endswith(self._fs_transaction_suffix)]","def files(self):\n self._printer('\\tFiles Walk')\n for directory in self.directory:\n for path in os.listdir(directory):\n full_path = os.path.join(directory, path)\n if os.path.isfile(full_path):\n if not path.startswith('.'):\n self.filepaths.append(full_path)\n return self._get_filepaths()","def list_files(path):\n ls_output = os.listdir(path)\n return ls_output","def get_all_images_from_filesystem():\r\n\r\n logging.debug('get_all_images_from_filesystem()')\r\n\r\n dir_path = os.path.join(os.environ['TEMP'],'WarietyWallpaperImages')\r\n all_full_image_paths = []\r\n for my_file in os.listdir(dir_path):\r\n if os.path.isfile(os.path.join(dir_path, my_file)):\r\n all_full_image_paths.append(os.path.join(dir_path, my_file))\r\n return all_full_image_paths","def get_all_files(pathdir: str) -> list:\n from os import path, walk\n\n '''\n os.walk(root_path) - directory tree generator.\n For each directory on root_path return a tuple:\n (path_for_dir, list_dirs_on_the_dir, list_files_on_the_dir)\n\n trash\n ├── dir1\n │ ├── dir2\n │ │ ├── dir3\n │ │ └── file3\n │ ├── file1\n │ └── file2\n └── dir4\n ├── dir5\n │ ├── file5\n │ └── file6\n └── file4\n\n >>> import os\n >>> list(os.walk('/home/myrequiem/trash'))\n [\n ('trash', ['dir1', 'dir4'], []),\n ('trash/dir1', ['dir2'], ['file2', 'file1']),\n ('trash/dir1/dir2', ['dir3'], ['file3']),\n ('trash/dir1/dir2/dir3', [], []),\n ('trash/dir4', ['dir5'], ['file4']),\n ('trash/dir4/dir5', [], ['file5', 'file6'])\n ]\n '''\n\n allfiles = []\n\n try:\n from tqdm import tqdm\n except ImportError:\n def tqdm(*args, **kwargs):\n if args:\n return args[0]\n return kwargs.get('iterable', None)\n\n for root, dirs, files in tqdm(walk(pathdir), leave=False,\n ncols=80, unit=''):\n del dirs\n for fls in files:\n allfiles.append(path.join(root, fls))\n\n return allfiles","def GetFilesInDirectory(dir_path):\n\treturn [f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path,f))]","def getfiles(path): \n global picture_list\n try:\n # dir_list has all files and directories in path\n # any directory is WITHOUT ending '/'\n dir_list = os.listdir(path)\n except:\n # path may not be a directory or permission error\n print \"ERROR: in getfiles, picture_list:\", picture_list\n picture_list = None\n return\n \n for line in dir_list:\n file = path + \"/\" + line\n if os.path.isdir(file):\n getfiles( file) # dig into subdirectory\n elif isPicture(file):\n picture_list.append(file)\n else: \n # neither picture file nor directory; ignore \n pass\n return","def retrieve_all_files(self):\n result = utilities.rscandir(\n self.folder(), ignore_dirs=[\".git\"])\n\n return result","def get_files(self) -> list:\n files = []\n for file in os.listdir(self.root):\n if file.endswith(f\".{self.suffix}\"):\n files.append(os.path.join(self.root, file))\n return files","def list_local(paths, prefix=None):\n results = []\n for path in paths:\n if os.path.isdir(path):\n for filename in os.listdir(path):\n fullpath = os.path.join(path, filename)\n if os.path.isdir(fullpath):\n results += list_local([fullpath], prefix)\n else:\n fullname = fullpath\n if prefix and fullname.startswith(prefix):\n fullname = fullname[len(prefix):]\n mtime = datetime.datetime.fromtimestamp(\n os.path.getmtime(fullpath), tz=utc)\n results += [{\"Key\": fullname,\n \"LastModified\": mtime.strftime(\n '%a, %d %b %Y %H:%M:%S %Z')}]\n else:\n fullpath = path\n fullname = fullpath\n if prefix and fullname.startswith(prefix):\n fullname = fullname[len(prefix):]\n mtime = datetime.datetime.fromtimestamp(\n os.path.getmtime(fullpath), tz=utc)\n results += [{\"Key\": fullname,\n \"LastModified\": mtime.strftime(\n '%a, %d %b %Y %H:%M:%S %Z')}]\n return results","def get_paths(file_path):\n return glob(path.join(file_path, '*'))","def get_files(a_dir):\n gf = []\n for file in os.listdir(a_dir):\n if file.endswith(\".txt\"):\n gf.append(a_dir + \"/\" + str(file))\n if len(gf) != 0:\n return gf\n else:\n print \"Error: Cannot find TXT files in subdirectory!\\n\\t (%s)\" % a_dir","def list_files():\n try:\n return jsonify(os.listdir(env(\"FILES_DIRECTORY\"))), 200\n except:\n return {\"msg\": \"Não há arquivos a serem listados.\"}, 404","def prep_files(app):\n smali_paths = []\n start = time.time()\n \n for root, dirs, files in os.walk(app, topdown=False):\n for name in files:\n if name[-6:] == \".smali\":\n smali_paths.append(str(os.path.join(root, name)))\n \n return smali_paths","def list_dir(self, path):","def getFiles(directory):\n # os.listdir only for locally downloaded files\n _files=[]\n for item in os.listdir(directory):\n path = os.path.join(directory, item)\n if not os.path.isdir(path) and \".lhe.gz\" in path:\n _files.append(path)\n elif os.path.isdir(path):\n getFiles(path)\n return _files","def get_terraform_files() -> list:\n terraform_files = []\n for dir in SCAN_DIR:\n for root, _, files in os.walk(dir, topdown=False):\n if is_blacklist_dir(root):\n continue\n\n for file in files:\n if is_whitelist_file(file):\n filepath = root + \"/\" + file\n terraform_files.append(filepath)\n\n return terraform_files","def _get_files(file_path: str, file_name=None) -> List[File]:\n files = []\n items = os.scandir(file_path)\n for item in items:\n if item.is_file():\n if item.name.startswith('.'):\n continue # Ignore hidden files\n if item.name == FileSystemService.WF_JSON_FILE:\n continue # Ignore the json files.\n if file_name is not None and item.name != file_name:\n continue\n file = FileSystemService.to_file_object_from_dir_entry(item)\n files.append(file)\n return files","def list_files(path, base=None):\n if not base:\n base = path\n bag = []\n for entry in os.listdir(path):\n if entry[0] == '.':\n continue # skip dot files and directories\n fullpath = '/'.join([path, entry]) # not use os.path.join\n if os.path.isfile(fullpath):\n bag.append(fullpath[1+len(base):]) # not use os.path.relpath\n else:\n bag += list_files(fullpath, base)\n return bag;","def getFilesList(data):\n\n filesList = []\n\n if os.path.isdir(data):\n logging.info(\"Using files from \" + data)\n #Create a list containing the file names\n for root, dirs, files in os.walk(data):\n for filename in files:\n filesList.append(os.path.join(root,filename))\n\n else:\n logging.info(\"Using file \" + data)\n filesList.append(os.path.abspath(data))\n\n return sorted(filesList)","def get_test_files(dirname):\n if not os.path.isdir(dirname):\n return []\n path = dirname + \"/{}\"\n return list(map(path.format, sorted(os.listdir(dirname))))","def getGlobusFiles(self):\n\t\treturn self.transfer_client.operation_ls(self.transfer_client.endpoint_search(DATA_ENDPOINT_NAME)[0]['name'])","def GetAllFiles(self):\r\n\t\tdir_list = []\r\n\t\tdir_list.append(self.path) \r\n\t\tfor dir in dir_list: \r\n\t\t\tfiles = os.listdir(dir)\r\n\t\t\tfor file in files:\r\n\t\t\t\tfull_name = dir + \"\\\\\\\\\" + file\r\n\t\t\t\tif(os.path.isdir(full_name)): \r\n\t\t\t\t\tif(file[0] == '.'):\t# 排除隐藏文件夹\r\n\t\t\t\t\t\tpass \r\n\t\t\t\t\telse:\t# 添加非隐藏文件夹 \r\n\t\t\t\t\t\tdir_list.append(full_name) \r\n\t\t\t\tif(os.path.isfile(full_name)):\r\n\t\t\t\t\tfor type in self.types.split('|'):\r\n\t\t\t\t\t\tif file.find(type) != -1:\r\n\t\t\t\t\t\t\t# 添加文件 \r\n\t\t\t\t\t\t\tself.file_list.append(full_name)\r\n\t\t\t\t\t\t\t#print \"Add file \" + full_name\r","def get_file_list(rootdir): #{{{\n file_list = []\n for f in os.listdir(rootdir):\n if f == None or not f.endswith(\".csv\"):\n continue\n file_list.append(os.path.join(rootdir, f))\n \n return file_list","def lists(path):\r\n return os.listdir(path)","def __get_files(self):\n if len(self.files) == 0:\n self.files = os.listdir(self.__path())\n self.files.sort()\n if self.parent:\n self.files.insert(0, \"..\")\n for index, name in enumerate(self.files, start=1):\n if self.__is_dir(self.__make_path(name)):\n self.files[index] = name + \"/\"","def ls(self, *args, full=False):\n paths = args\n\n path = _os.sep.join([self.__str__(), _os.sep.join(paths)])\n\n files_and_stuff = _os.listdir(path)\n\n if full == True:\n return [getpath(path, custom=True) for path in files_and_stuff]\n else:\n return files_and_stuff","def get_file_list(self):\n try:\n for filename in os.listdir(SHARED_DIR):\n self.file_list.append(filename)\n except Exception as e:\n print \"Error: retriving file list, %s\" % e","def get_files(path: str) -> List:\n files = []\n for file in os.listdir(path):\n if os.path.isfile(os.path.join(path, file)):\n files.append(file)\n # Reversed to prevent collision upon renaming\n return sorted(files, reverse=True)","def _get_files_list(self):\n ts_filepaths = []\n conn_filepaths = []\n ts_filepaths_from_dir = sorted(os.listdir(self.ts_dir))\n conn_filepaths_from_dir = sorted(os.listdir(self.conn_dir))\n for sub_id in self.ids:\n for ts_file in ts_filepaths_from_dir:\n if sub_id in ts_file:\n ts_filepaths += [os.path.join(self.ts_dir, ts_file)]\n ts_filepaths_from_dir.remove(ts_file)\n break\n for conn_file in conn_filepaths_from_dir:\n if sub_id in conn_file:\n conn_filepaths += [os.path.join(self.conn_dir, conn_file)]\n conn_filepaths_from_dir.remove(conn_file)\n break\n\n return ts_filepaths, conn_filepaths","def listoffiles(self, path):\n return os.listdir(path)","def flatfiles(cam):\n return fullpathlist(flatpath(cam))","def GetAllFilepaths(root_directory):\n path_list = []\n for dirpath, _, filenames in os.walk(root_directory):\n for filename in filenames:\n path_list.append(os.path.abspath(os.path.join(dirpath, filename)))\n return path_list","def get_files(path):\r\n\tfiles = []\r\n\tfor dirpath, _, filenames in os.walk(path):\r\n\t\tfor filename in [f for f in filenames]:\r\n\t\t\tfiles.append(os.path.join(dirpath, filename))\r\n\treturn files","def files_in_folder(self):\n non_til = set()\n filesInFolder = []\n for f in self.find_all_files():\n newstr = f.replace(\"~\", \"\") \n if newstr in self.find_all_files():\n non_til.add(newstr)\n for fs in non_til:\n filesInFolder.append(fs)\n return filesInFolder","def _complete_path(path=None):\r\n if not path:\r\n return _listdir('.')\r\n dirname, rest = os.path.split(path)\r\n tmp = dirname if dirname else '.'\r\n res = [p for p in _listdir(tmp) if p.startswith(rest)]\r\n # more than one match, or single match which does not exist (typo)\r\n if len(res) > 1 or not os.path.exists(path):\r\n return res\r\n # resolved to a single directory, so return list of files below it\r\n if os.path.isdir(path):\r\n return [p for p in _listdir(path)]\r\n # exact file match terminates this completion\r\n return [path + ' ']","def retrieve_tracked_files(self):\n result = []\n\n for key in self.repo.index.entries.keys():\n\n result.append(os.path.join(self.repo.working_dir, key[0]))\n\n return result","def get_paths(input_folder):\n list_files = []\n conll_folder = glob.glob(input_folder + '/*.json')\n \n for filename in conll_folder:\n list_files.append(filename)\n\n return list_files","def glob_fs(self):\n\n found_files = []\n for pattern in self.glob_patterns:\n found_files += [PathString(present_file)\n for present_file in glob.glob(pattern)]\n return found_files","def list_of_files(self, dirname): \n\n list_of_files = os.listdir(dirname)\n all_files = []\n\n for entry in list_of_files:\n full_path = os.path.join(dirname, entry)\n\n if os.path.isdir(full_path):\n all_files = all_files + self.list_of_files(full_path)\n else:\n all_files.append(full_path)\n\n return all_files","def folder(fpath):\n file_paths = glob.glob(fpath + '/*.dat')\n return list(file_paths)","def get_files(self) -> Set[str]:\n return ({f for f in os.listdir(self.get_directory())\n if os.path.isfile(os.path.join(self.get_directory(), f))} if self.directory_exists(self.get_directory()) else set())","def search_file(path, f):\n output = []\n for root, dirs, files in os.walk(path, topdown=True):\n for file in files:\n if file == f:\n path = os.path.join(root, file)\n output.append(path)\n\n return output","def listdir(self, path):\n return os.listdir(path)","def listFiles(path):\n outputList = []\n for root, dirs, files in os.walk(path):\n for f in files:\n outputList.append('/'.join([root, f]))\n return outputList","def list_files(self):\n if self.remote:\n return self.remote.list_files()\n\n M.mset('DUZ',self.DUZ)\n M.mset('U', \"^\")\n if self.isProgrammer:\n M.mset('DUZ(0)', \"@\")\n rv = []\n s0 = \"0\"\n while s0 != \"\":\n s0, name = M.mexec(\n '''set s0=$order(^DIC(s0)) Q:s0'=+s0 I $D(^DIC(s0,0))&$D(^DIC(s0,0,\"GL\"))&$$VFILE^DILFD(s0) S s1=$P(^DIC(s0,0),U,1)''',\n M.INOUT(s0), M.INOUT(\"\"))\n if name:\n rv.append((name, s0))\n return rv","def get_object_list(self, url):\n path = self.base_path / url\n return [\n os.fspath((Path(dirpath) / filename).relative_to(path))\n for dirpath, _, files in os.walk(path)\n for filename in files\n if filename != path\n ]","def get_image_path(raw_input_dir: str) -> list:\n result = []\n for root, dirs, files in os.walk(raw_input_dir):\n for file in files:\n result.append(os.path.join(root, file))\n return result","def get_paths(input_folder: str) -> list[str]:\n\n return [f for f in os.listdir(input_folder) if f[-4:] == '.txt' and f[:3] != 'top']","def get_files_from_directory(path):\n return [f for f in listdir(path) if isfile(join(path, f))]","def _list_dir(self):\n return [os.path.join(self.cache_dir, fn)\n for fn in os.listdir(self.cache_dir)]","def list_files(top_path):\n\n results = []\n\n for root, dirs, files in os.walk(top_path, topdown=True):\n\n # Exclude dot files like .git\n dirs[:] = [name for name in dirs if not name.startswith('.')]\n files[:] = [name for name in files if not name.startswith('.')]\n\n for file_name in files:\n results.append(os.path.join(root, file_name))\n\n results.sort()\n return results","def file_list(start_dir):\n file_list = []\n for root, dirs, files in os.walk(start_dir):\n for f in files:\n if f[0] != '.':\n file_list.append(f)\n return file_list","def ffind(path, shellglobs=None, namefs=None, relative=True):\n if not os.access(path, os.R_OK):\n raise ScriptError(\"cannot access path: '%s'\" % path)\n\n fileList = [] # result list\n try:\n for dir, subdirs, files in os.walk(path):\n if shellglobs:\n matched = []\n for pattern in shellglobs:\n filterf = lambda s: fnmatch.fnmatchcase(s, pattern)\n matched.extend(list(filter(filterf, files)))\n fileList.extend(['%s%s%s' % (dir, os.sep, f) for f in matched])\n else:\n fileList.extend(['%s%s%s' % (dir, os.sep, f) for f in files])\n if not relative: fileList = list(map(os.path.abspath, fileList))\n if namefs:\n for ff in namefs: fileList = list(filter(ff, fileList))\n except Exception as e: raise ScriptError(str(e))\n return(fileList)","def list_file(self, path: str) -> List[FileName]:\n current_file = self.file_exists(path)\n if current_file is None:\n raise FileNotExistException(\n \"Path doesn't exist. Can't list non-existent path\"\n )\n if current_file.file_type != GOOGLE_FOLDER_TYPE:\n raise NotAFolderException(\"file_nod has to be a folder to list contents\")\n if current_file.children is None:\n raise NotAFolderException(\"file_nod has to be a folder to list contents\")\n if len(current_file.children) == 0:\n return []\n return [\n child_file.file_name for child_file in list(current_file.children.values())\n ]","def GetSongFilenames():\n\n\t## Loop through each directory\n\tsong_files = []\n\tfor root, dirs, fnames in os.walk(\"_data\\\\fma_small\\\\\"):\n\t\t\n\t\t## Skip the first level\n\t\tif root == \"_data\\\\fma_small\\\\\":\n\t\t\tcontinue\n\n\t\t## Otherwise collect the files, appending\n\t\t## the root path.\n\t\tsong_files += [root+\"\\\\\"+f for f in fnames]\n\n\treturn song_files","def glob_files(sc, url,verbose):\n URI = sc._gateway.jvm.java.net.URI\n Path = sc._gateway.jvm.org.apache.hadoop.fs.Path\n FileSystem = sc._gateway.jvm.org.apache.hadoop.fs.FileSystem\n fs = FileSystem.get(URI(\"hdfs:///\"), sc._jsc.hadoopConfiguration())\n l = fs.globStatus(Path(url))\n return [f.getPath().toString() for f in l]","def file_list_emptydirs(load):\n # TODO - implement this\n _init()\n\n return []","def __getFileList(self, path, filterRe):\n path = os.path.abspath(path)\n files = []\n for dirname, _, names in os.walk(path):\n files.extend([os.path.join(dirname, f)\n for f in names\n if re.match(filterRe, f)]\n )\n return files","def filelist(root):\n allfiles = []\n for path, subdirs, files in os.walk(root):\n for name in files:\n if name.find(\"xls\") >= 0:\n allfiles.append(os.path.join(path, name))\n return allfiles","def volume_paths(path):\n files = (os.path.join(path, f) for f in sorted(os.listdir(path)))\n return [f for f in files if os.path.isdir(f) or f.endswith('.zip')]","def _listdir(dirpath):\n names = os.listdir(dirpath)\n return [os.path.join(dirpath, n) for n in names]","def get_list_of_files_in_dir(file_list_path=None):\n return os.listdir(file_list_path)","def find_all(path, filenames):\n path = os.path.abspath(path)\n try:\n for root, dirs, files in os.walk(path, topdown=True):\n dirs.sort()\n for filename in filenames:\n if filename in files:\n yield os.path.abspath(os.path.join(root, filename))\n except UnicodeDecodeError:\n # This is an error of not being able to walk the dir when there are unicode files in them :|\n pass","def getFiles(folderToProcess,filter):\n\n print(f\"Parsing {folderToProcess} for {filter} files\")\n\n if debug:\n for path in Path(folderToProcess).rglob(filter):\n print(f\"Found {path}\")\n\n all_files = [str(x) for x in Path(folderToProcess).rglob(filter)] \n\n return all_files"],"string":"[\n \"def list_all_files(root):\\n local_files = []\\n for path, dirs, files in os.walk(os_path(root), followlinks=False):\\n if len(files) > 0:\\n path_wo_root = path[(len(root) + len(slash)):] # remove root part\\n local_files.extend([os.path.join(path_wo_root, f) for f in files])\\n return local_files\",\n \"def find_local_files(local_path, type):\\n local_out = commands.getoutput(\\\"find %s -name \\\\\\\"*\\\\\\\" -type %s\\\" % (local_path, type))\\n files = []\\n for file in local_out.split(\\\"\\\\n\\\"):\\n files.append(file)\\n return files\",\n \"def get_all_files(cwd):\\n return os.listdir(cwd)\",\n \"def getFiles(self):\\n\\t\\treturn os.listdir(self.getPath())\",\n \"def get_my_files():\\n return [file for file in os.listdir(os.getcwd()) if os.path.isfile(file)]\",\n \"def files_in_dir(path):\\n return os.listdir(path)\",\n \"def list_files_local(path: str) -> List[str]:\\n files = os.listdir(path)\\n files = [f.split('.')[0] for f in files if 'pkl' in f]\\n return files\",\n \"def _path_files(self):\\n\\n if not os.path.exists(self.path):\\n return None\\n\\n directory_content = os.listdir(self.path)\\n files = []\\n\\n while len(directory_content) != 0:\\n\\n if not directory_content[0].startswith(self.path):\\n directory_obj = os.path.join(self.path, directory_content[0])\\n else:\\n directory_obj = directory_content[0]\\n\\n if os.path.isfile(directory_obj):\\n files.append(directory_obj)\\n elif os.path.exists(directory_obj):\\n temp_directory_content = os.listdir(directory_obj)\\n for obj in temp_directory_content:\\n directory_content.append(os.path.join(directory_obj, obj))\\n directory_content.pop(0)\\n\\n return files\",\n \"def listfiles(self, *path):\\n dir = self.localpath(*path)\\n files = []\\n for root, dirs, fnms in os.walk(dir):\\n for f in fnms:\\n if f[-5:] == '.info' and os.path.exists(os.path.join(root, f[:-5])):\\n try:\\n _open_file_info(os.path.join(root, f))\\n files.append(\\n path + tuple(_split_path(\\n os.path.relpath(os.path.join(root, f[:-5]), start=dir)\\n )))\\n except ValueError:\\n pass\\n return files\",\n \"def resolve_file_paths(local_path):\\n local_path = os.path.abspath(local_path)\\n files = []\\n if local_path.find('*') > -1:\\n # Supplied path is a pattern - relative directory will be the\\n # path up to the first wildcard\\n ref_dir_str = local_path.split('*')[0].rstrip('/\\\\\\\\')\\n if not os.path.isdir(ref_dir_str):\\n ref_dir_str = os.path.dirname(ref_dir_str)\\n ref_dir = pathlib.Path(ref_dir_str)\\n pattern = local_path[len(ref_dir_str + os.pathsep):]\\n files = [str(f) for f in ref_dir.glob(pattern) if f.is_file()]\\n local_path = ref_dir_str\\n else:\\n if os.path.isdir(local_path):\\n # Supplied path is a directory\\n files = [os.path.join(local_path, f) for f in os.listdir(local_path)\\n if os.path.isfile(os.path.join(local_path, f))]\\n elif os.path.isfile(local_path):\\n # Supplied path is a file\\n files.append(local_path)\\n local_path = os.path.dirname(local_path)\\n return local_path, files\",\n \"def get_file_list(path: str) -> list:\\n\\treturn [f for f in listdir(path) if isfile(join(path, f))]\",\n \"def get_all_files(self):\\n\\t\\tfiles_list = []\\n\\t\\tfor path, subdirs, files in os.walk(self.root):\\n\\t\\t for name in files:\\n\\t\\t \\tfiles_list.append(os.path.join(self.root, name))\\n\\t\\treturn files_list[0:-1]\",\n \"def get_file_list(input_dir):\\n\\tfile_paths = [input_dir +'/' + f for f in listdir(input_dir) if isfile(join(input_dir, f)) ]\\n\\treturn file_paths\",\n \"def _local_dir(self):\\n return []\",\n \"def fullpathlist(path):\\n try:\\n return [os.path.join(path, filename) for filename in os.listdir(path)]\\n except OSError:\\n return []\",\n \"def files_in_dir(root_dir):\\n file_set = set()\\n\\n for dir_, _, files in os.walk(root_dir):\\n for file_name in files:\\n rel_dir = os.path.relpath(dir_, root_dir)\\n rel_file = os.path.join(rel_dir, file_name)\\n file_set.add(rel_file)\\n\\n return [Path(PureWindowsPath(f)) for f in file_set]\",\n \"def getImmediateFiles(aDir):\\n return [name for name in os.listdir(aDir)\\n if os.path.isfile(os.path.join(aDir,name))]\",\n \"def _get_files(self, path):\\n result = []\\n for f in os.listdir(path):\\n if os.path.isdir(os.path.join(path, f)):\\n result += self._get_files(os.path.join(path, f))\\n else:\\n result.append(os.path.join(path, f))\\n return result\",\n \"def find_all_files(self):\\n look4files = [ f for f in listdir(self.file_location) if isfile(join(self.file_location,f)) ]\\n return look4files\",\n \"def get_files(self, dir):\\n path = os.path.join(self.loc, dir)\\n return [f for f in os.listdir(path)\\n if os.path.isfile(os.path.join(path, f))]\",\n \"def get_files(path: str) -> List[str]:\\n if not isdir(path):\\n return [path] # its expected to return a list each time even if its a single element\\n return [file for fileOrDir in listdir(path) for file in get_files(path + '/' + fileOrDir)]\\n # return list of each file returned by the recursive call getFiles(fileOrDir) on\\n # each fileOrDir in listdir(path)\",\n \"def get_files_in_current_directory(file_type):\\n local_files = []\\n total_file_size = 0\\n\\n ignore_list, whitelist = FloydIgnoreManager.get_lists()\\n\\n floyd_logger.debug(\\\"Ignoring: %s\\\", ignore_list)\\n floyd_logger.debug(\\\"Whitelisting: %s\\\", whitelist)\\n\\n file_paths = get_unignored_file_paths(ignore_list, whitelist)\\n\\n for file_path in file_paths:\\n local_files.append((file_type, (unix_style_path(file_path), open(file_path, 'rb'), 'text/plain')))\\n total_file_size += os.path.getsize(file_path)\\n\\n return (local_files, total_file_size)\",\n \"def scandir(path_):\\n return os.listdir\",\n \"def get_file_paths():\\n audio_folder = MY_DIR + '/assets'\\n\\n audio_addy_list = []\\n for file in os.scandir(audio_folder):\\n audio_addy_list.append(file.path)\\n\\n return audio_addy_list\",\n \"def collect_local(self, path, req_tag=True):\\n for f in [os.path.join(dp, f) for dp, dn, filenames in os.walk(path) for f in filenames]:\\n if not os.path.isfile(f):\\n continue\\n self.collect_single(f, req_tag)\",\n \"def GetFiles(path):\\n\\n retfiles = []\\n target_paths = []\\n for root, dirs, files in os.walk(path):\\n if root == path:\\n target_paths = map(lambda d: os.path.join(root, d), dirs)\\n continue\\n if root not in target_paths:\\n continue\\n for f in files:\\n if f[-4:] != '.txt':\\n continue\\n retfiles.append(os.path.join(root, f))\\n return retfiles\",\n \"def getAllFiles(self):\\n\\n\\t\\treturn self.getFilesForDirs([])\",\n \"def findFiles(target, path):\\r\\n\\tfiles = []\\r\\n\\tlyst = os.listdir(path)\\r\\n\\tfor element in lyst:\\r\\n\\t\\tif os.path.isfile(element):\\r\\n\\t\\t\\tif target in element:\\r\\n\\t\\t\\t\\tfiles.append(path + os.sep + element)\\r\\n\\t\\telse:\\r\\n\\t\\t\\tos.chdir(element)\\r\\n\\t\\t\\tfiles.extend(findFiles(target, os.getcwd()))\\r\\n\\t\\t\\tos.chdir(\\\"..\\\")\\r\\n\\treturn files\",\n \"def local_paths(self) -> List[Path]:\\n return self._local_paths\",\n \"def unix_find(pathin):\\n return [os.path.join(path, file)\\n for (path, dirs, files) in os.walk(pathin, followlinks=False)\\n for file in files]\",\n \"def _get_file_list(folder):\\n tree = [x for x in os.walk(folder)]\\n files = [os.path.join(t[0], y) for t in tree for y in t[2]]\\n return [os.path.relpath(x, start=folder)\\n for x in files if x != LOCAL_METADATA_FILE]\",\n \"def listFilesInDir(self, path, recursive=False, fileNameOnly=True, filter=None):\\n self._checkActive()\\n def _process(args, path, ttype, moddate=0, size=0, md5hash=\\\"\\\"):\\n fileNameOnly, filter, pathsreturn = args \\n if ttype == \\\"F\\\":\\n if (filter is None) or fnmatch.fnmatch(path, filter):\\n #fullpath=q.system.fs.joinPaths(path, fileNameOnly)\\n if fileNameOnly:\\n pathsreturn.append(q.system.fs.getBaseName(path))\\n else:\\n pathsreturn.append(path)\\n pathsreturn=[]\\n self.walk(_process, (fileNameOnly, filter, pathsreturn) , path, recursive=recursive) \\n return pathsreturn\",\n \"def ls_files(self, path, recursive=False):\\n if path != \\\"\\\" and not path.endswith(\\\"/\\\"):\\n path += \\\"/\\\"\\n\\n blob_iter = self.client.list_blobs(name_starts_with=path)\\n files = []\\n for blob in blob_iter:\\n relative_path = os.path.relpath(blob.name, path)\\n if recursive or \\\"/\\\" not in relative_path:\\n files.append(relative_path)\\n return files\",\n \"def files_in( d ):\\n return [ join(d,f) for f in os.listdir(d) if isfile(join(d,f)) ]\",\n \"def get_files(self) -> tp.Iterable[str]:\\n return os.listdir(self.path)\",\n \"def _list_dir(self):\\n return [os.path.join(self._path, fn) for fn in os.listdir(self._path)\\n if not fn.endswith(self._fs_transaction_suffix)]\",\n \"def files(self):\\n self._printer('\\\\tFiles Walk')\\n for directory in self.directory:\\n for path in os.listdir(directory):\\n full_path = os.path.join(directory, path)\\n if os.path.isfile(full_path):\\n if not path.startswith('.'):\\n self.filepaths.append(full_path)\\n return self._get_filepaths()\",\n \"def list_files(path):\\n ls_output = os.listdir(path)\\n return ls_output\",\n \"def get_all_images_from_filesystem():\\r\\n\\r\\n logging.debug('get_all_images_from_filesystem()')\\r\\n\\r\\n dir_path = os.path.join(os.environ['TEMP'],'WarietyWallpaperImages')\\r\\n all_full_image_paths = []\\r\\n for my_file in os.listdir(dir_path):\\r\\n if os.path.isfile(os.path.join(dir_path, my_file)):\\r\\n all_full_image_paths.append(os.path.join(dir_path, my_file))\\r\\n return all_full_image_paths\",\n \"def get_all_files(pathdir: str) -> list:\\n from os import path, walk\\n\\n '''\\n os.walk(root_path) - directory tree generator.\\n For each directory on root_path return a tuple:\\n (path_for_dir, list_dirs_on_the_dir, list_files_on_the_dir)\\n\\n trash\\n ├── dir1\\n │ ├── dir2\\n │ │ ├── dir3\\n │ │ └── file3\\n │ ├── file1\\n │ └── file2\\n └── dir4\\n ├── dir5\\n │ ├── file5\\n │ └── file6\\n └── file4\\n\\n >>> import os\\n >>> list(os.walk('/home/myrequiem/trash'))\\n [\\n ('trash', ['dir1', 'dir4'], []),\\n ('trash/dir1', ['dir2'], ['file2', 'file1']),\\n ('trash/dir1/dir2', ['dir3'], ['file3']),\\n ('trash/dir1/dir2/dir3', [], []),\\n ('trash/dir4', ['dir5'], ['file4']),\\n ('trash/dir4/dir5', [], ['file5', 'file6'])\\n ]\\n '''\\n\\n allfiles = []\\n\\n try:\\n from tqdm import tqdm\\n except ImportError:\\n def tqdm(*args, **kwargs):\\n if args:\\n return args[0]\\n return kwargs.get('iterable', None)\\n\\n for root, dirs, files in tqdm(walk(pathdir), leave=False,\\n ncols=80, unit=''):\\n del dirs\\n for fls in files:\\n allfiles.append(path.join(root, fls))\\n\\n return allfiles\",\n \"def GetFilesInDirectory(dir_path):\\n\\treturn [f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path,f))]\",\n \"def getfiles(path): \\n global picture_list\\n try:\\n # dir_list has all files and directories in path\\n # any directory is WITHOUT ending '/'\\n dir_list = os.listdir(path)\\n except:\\n # path may not be a directory or permission error\\n print \\\"ERROR: in getfiles, picture_list:\\\", picture_list\\n picture_list = None\\n return\\n \\n for line in dir_list:\\n file = path + \\\"/\\\" + line\\n if os.path.isdir(file):\\n getfiles( file) # dig into subdirectory\\n elif isPicture(file):\\n picture_list.append(file)\\n else: \\n # neither picture file nor directory; ignore \\n pass\\n return\",\n \"def retrieve_all_files(self):\\n result = utilities.rscandir(\\n self.folder(), ignore_dirs=[\\\".git\\\"])\\n\\n return result\",\n \"def get_files(self) -> list:\\n files = []\\n for file in os.listdir(self.root):\\n if file.endswith(f\\\".{self.suffix}\\\"):\\n files.append(os.path.join(self.root, file))\\n return files\",\n \"def list_local(paths, prefix=None):\\n results = []\\n for path in paths:\\n if os.path.isdir(path):\\n for filename in os.listdir(path):\\n fullpath = os.path.join(path, filename)\\n if os.path.isdir(fullpath):\\n results += list_local([fullpath], prefix)\\n else:\\n fullname = fullpath\\n if prefix and fullname.startswith(prefix):\\n fullname = fullname[len(prefix):]\\n mtime = datetime.datetime.fromtimestamp(\\n os.path.getmtime(fullpath), tz=utc)\\n results += [{\\\"Key\\\": fullname,\\n \\\"LastModified\\\": mtime.strftime(\\n '%a, %d %b %Y %H:%M:%S %Z')}]\\n else:\\n fullpath = path\\n fullname = fullpath\\n if prefix and fullname.startswith(prefix):\\n fullname = fullname[len(prefix):]\\n mtime = datetime.datetime.fromtimestamp(\\n os.path.getmtime(fullpath), tz=utc)\\n results += [{\\\"Key\\\": fullname,\\n \\\"LastModified\\\": mtime.strftime(\\n '%a, %d %b %Y %H:%M:%S %Z')}]\\n return results\",\n \"def get_paths(file_path):\\n return glob(path.join(file_path, '*'))\",\n \"def get_files(a_dir):\\n gf = []\\n for file in os.listdir(a_dir):\\n if file.endswith(\\\".txt\\\"):\\n gf.append(a_dir + \\\"/\\\" + str(file))\\n if len(gf) != 0:\\n return gf\\n else:\\n print \\\"Error: Cannot find TXT files in subdirectory!\\\\n\\\\t (%s)\\\" % a_dir\",\n \"def list_files():\\n try:\\n return jsonify(os.listdir(env(\\\"FILES_DIRECTORY\\\"))), 200\\n except:\\n return {\\\"msg\\\": \\\"Não há arquivos a serem listados.\\\"}, 404\",\n \"def prep_files(app):\\n smali_paths = []\\n start = time.time()\\n \\n for root, dirs, files in os.walk(app, topdown=False):\\n for name in files:\\n if name[-6:] == \\\".smali\\\":\\n smali_paths.append(str(os.path.join(root, name)))\\n \\n return smali_paths\",\n \"def list_dir(self, path):\",\n \"def getFiles(directory):\\n # os.listdir only for locally downloaded files\\n _files=[]\\n for item in os.listdir(directory):\\n path = os.path.join(directory, item)\\n if not os.path.isdir(path) and \\\".lhe.gz\\\" in path:\\n _files.append(path)\\n elif os.path.isdir(path):\\n getFiles(path)\\n return _files\",\n \"def get_terraform_files() -> list:\\n terraform_files = []\\n for dir in SCAN_DIR:\\n for root, _, files in os.walk(dir, topdown=False):\\n if is_blacklist_dir(root):\\n continue\\n\\n for file in files:\\n if is_whitelist_file(file):\\n filepath = root + \\\"/\\\" + file\\n terraform_files.append(filepath)\\n\\n return terraform_files\",\n \"def _get_files(file_path: str, file_name=None) -> List[File]:\\n files = []\\n items = os.scandir(file_path)\\n for item in items:\\n if item.is_file():\\n if item.name.startswith('.'):\\n continue # Ignore hidden files\\n if item.name == FileSystemService.WF_JSON_FILE:\\n continue # Ignore the json files.\\n if file_name is not None and item.name != file_name:\\n continue\\n file = FileSystemService.to_file_object_from_dir_entry(item)\\n files.append(file)\\n return files\",\n \"def list_files(path, base=None):\\n if not base:\\n base = path\\n bag = []\\n for entry in os.listdir(path):\\n if entry[0] == '.':\\n continue # skip dot files and directories\\n fullpath = '/'.join([path, entry]) # not use os.path.join\\n if os.path.isfile(fullpath):\\n bag.append(fullpath[1+len(base):]) # not use os.path.relpath\\n else:\\n bag += list_files(fullpath, base)\\n return bag;\",\n \"def getFilesList(data):\\n\\n filesList = []\\n\\n if os.path.isdir(data):\\n logging.info(\\\"Using files from \\\" + data)\\n #Create a list containing the file names\\n for root, dirs, files in os.walk(data):\\n for filename in files:\\n filesList.append(os.path.join(root,filename))\\n\\n else:\\n logging.info(\\\"Using file \\\" + data)\\n filesList.append(os.path.abspath(data))\\n\\n return sorted(filesList)\",\n \"def get_test_files(dirname):\\n if not os.path.isdir(dirname):\\n return []\\n path = dirname + \\\"/{}\\\"\\n return list(map(path.format, sorted(os.listdir(dirname))))\",\n \"def getGlobusFiles(self):\\n\\t\\treturn self.transfer_client.operation_ls(self.transfer_client.endpoint_search(DATA_ENDPOINT_NAME)[0]['name'])\",\n \"def GetAllFiles(self):\\r\\n\\t\\tdir_list = []\\r\\n\\t\\tdir_list.append(self.path) \\r\\n\\t\\tfor dir in dir_list: \\r\\n\\t\\t\\tfiles = os.listdir(dir)\\r\\n\\t\\t\\tfor file in files:\\r\\n\\t\\t\\t\\tfull_name = dir + \\\"\\\\\\\\\\\\\\\\\\\" + file\\r\\n\\t\\t\\t\\tif(os.path.isdir(full_name)): \\r\\n\\t\\t\\t\\t\\tif(file[0] == '.'):\\t# 排除隐藏文件夹\\r\\n\\t\\t\\t\\t\\t\\tpass \\r\\n\\t\\t\\t\\t\\telse:\\t# 添加非隐藏文件夹 \\r\\n\\t\\t\\t\\t\\t\\tdir_list.append(full_name) \\r\\n\\t\\t\\t\\tif(os.path.isfile(full_name)):\\r\\n\\t\\t\\t\\t\\tfor type in self.types.split('|'):\\r\\n\\t\\t\\t\\t\\t\\tif file.find(type) != -1:\\r\\n\\t\\t\\t\\t\\t\\t\\t# 添加文件 \\r\\n\\t\\t\\t\\t\\t\\t\\tself.file_list.append(full_name)\\r\\n\\t\\t\\t\\t\\t\\t\\t#print \\\"Add file \\\" + full_name\\r\",\n \"def get_file_list(rootdir): #{{{\\n file_list = []\\n for f in os.listdir(rootdir):\\n if f == None or not f.endswith(\\\".csv\\\"):\\n continue\\n file_list.append(os.path.join(rootdir, f))\\n \\n return file_list\",\n \"def lists(path):\\r\\n return os.listdir(path)\",\n \"def __get_files(self):\\n if len(self.files) == 0:\\n self.files = os.listdir(self.__path())\\n self.files.sort()\\n if self.parent:\\n self.files.insert(0, \\\"..\\\")\\n for index, name in enumerate(self.files, start=1):\\n if self.__is_dir(self.__make_path(name)):\\n self.files[index] = name + \\\"/\\\"\",\n \"def ls(self, *args, full=False):\\n paths = args\\n\\n path = _os.sep.join([self.__str__(), _os.sep.join(paths)])\\n\\n files_and_stuff = _os.listdir(path)\\n\\n if full == True:\\n return [getpath(path, custom=True) for path in files_and_stuff]\\n else:\\n return files_and_stuff\",\n \"def get_file_list(self):\\n try:\\n for filename in os.listdir(SHARED_DIR):\\n self.file_list.append(filename)\\n except Exception as e:\\n print \\\"Error: retriving file list, %s\\\" % e\",\n \"def get_files(path: str) -> List:\\n files = []\\n for file in os.listdir(path):\\n if os.path.isfile(os.path.join(path, file)):\\n files.append(file)\\n # Reversed to prevent collision upon renaming\\n return sorted(files, reverse=True)\",\n \"def _get_files_list(self):\\n ts_filepaths = []\\n conn_filepaths = []\\n ts_filepaths_from_dir = sorted(os.listdir(self.ts_dir))\\n conn_filepaths_from_dir = sorted(os.listdir(self.conn_dir))\\n for sub_id in self.ids:\\n for ts_file in ts_filepaths_from_dir:\\n if sub_id in ts_file:\\n ts_filepaths += [os.path.join(self.ts_dir, ts_file)]\\n ts_filepaths_from_dir.remove(ts_file)\\n break\\n for conn_file in conn_filepaths_from_dir:\\n if sub_id in conn_file:\\n conn_filepaths += [os.path.join(self.conn_dir, conn_file)]\\n conn_filepaths_from_dir.remove(conn_file)\\n break\\n\\n return ts_filepaths, conn_filepaths\",\n \"def listoffiles(self, path):\\n return os.listdir(path)\",\n \"def flatfiles(cam):\\n return fullpathlist(flatpath(cam))\",\n \"def GetAllFilepaths(root_directory):\\n path_list = []\\n for dirpath, _, filenames in os.walk(root_directory):\\n for filename in filenames:\\n path_list.append(os.path.abspath(os.path.join(dirpath, filename)))\\n return path_list\",\n \"def get_files(path):\\r\\n\\tfiles = []\\r\\n\\tfor dirpath, _, filenames in os.walk(path):\\r\\n\\t\\tfor filename in [f for f in filenames]:\\r\\n\\t\\t\\tfiles.append(os.path.join(dirpath, filename))\\r\\n\\treturn files\",\n \"def files_in_folder(self):\\n non_til = set()\\n filesInFolder = []\\n for f in self.find_all_files():\\n newstr = f.replace(\\\"~\\\", \\\"\\\") \\n if newstr in self.find_all_files():\\n non_til.add(newstr)\\n for fs in non_til:\\n filesInFolder.append(fs)\\n return filesInFolder\",\n \"def _complete_path(path=None):\\r\\n if not path:\\r\\n return _listdir('.')\\r\\n dirname, rest = os.path.split(path)\\r\\n tmp = dirname if dirname else '.'\\r\\n res = [p for p in _listdir(tmp) if p.startswith(rest)]\\r\\n # more than one match, or single match which does not exist (typo)\\r\\n if len(res) > 1 or not os.path.exists(path):\\r\\n return res\\r\\n # resolved to a single directory, so return list of files below it\\r\\n if os.path.isdir(path):\\r\\n return [p for p in _listdir(path)]\\r\\n # exact file match terminates this completion\\r\\n return [path + ' ']\",\n \"def retrieve_tracked_files(self):\\n result = []\\n\\n for key in self.repo.index.entries.keys():\\n\\n result.append(os.path.join(self.repo.working_dir, key[0]))\\n\\n return result\",\n \"def get_paths(input_folder):\\n list_files = []\\n conll_folder = glob.glob(input_folder + '/*.json')\\n \\n for filename in conll_folder:\\n list_files.append(filename)\\n\\n return list_files\",\n \"def glob_fs(self):\\n\\n found_files = []\\n for pattern in self.glob_patterns:\\n found_files += [PathString(present_file)\\n for present_file in glob.glob(pattern)]\\n return found_files\",\n \"def list_of_files(self, dirname): \\n\\n list_of_files = os.listdir(dirname)\\n all_files = []\\n\\n for entry in list_of_files:\\n full_path = os.path.join(dirname, entry)\\n\\n if os.path.isdir(full_path):\\n all_files = all_files + self.list_of_files(full_path)\\n else:\\n all_files.append(full_path)\\n\\n return all_files\",\n \"def folder(fpath):\\n file_paths = glob.glob(fpath + '/*.dat')\\n return list(file_paths)\",\n \"def get_files(self) -> Set[str]:\\n return ({f for f in os.listdir(self.get_directory())\\n if os.path.isfile(os.path.join(self.get_directory(), f))} if self.directory_exists(self.get_directory()) else set())\",\n \"def search_file(path, f):\\n output = []\\n for root, dirs, files in os.walk(path, topdown=True):\\n for file in files:\\n if file == f:\\n path = os.path.join(root, file)\\n output.append(path)\\n\\n return output\",\n \"def listdir(self, path):\\n return os.listdir(path)\",\n \"def listFiles(path):\\n outputList = []\\n for root, dirs, files in os.walk(path):\\n for f in files:\\n outputList.append('/'.join([root, f]))\\n return outputList\",\n \"def list_files(self):\\n if self.remote:\\n return self.remote.list_files()\\n\\n M.mset('DUZ',self.DUZ)\\n M.mset('U', \\\"^\\\")\\n if self.isProgrammer:\\n M.mset('DUZ(0)', \\\"@\\\")\\n rv = []\\n s0 = \\\"0\\\"\\n while s0 != \\\"\\\":\\n s0, name = M.mexec(\\n '''set s0=$order(^DIC(s0)) Q:s0'=+s0 I $D(^DIC(s0,0))&$D(^DIC(s0,0,\\\"GL\\\"))&$$VFILE^DILFD(s0) S s1=$P(^DIC(s0,0),U,1)''',\\n M.INOUT(s0), M.INOUT(\\\"\\\"))\\n if name:\\n rv.append((name, s0))\\n return rv\",\n \"def get_object_list(self, url):\\n path = self.base_path / url\\n return [\\n os.fspath((Path(dirpath) / filename).relative_to(path))\\n for dirpath, _, files in os.walk(path)\\n for filename in files\\n if filename != path\\n ]\",\n \"def get_image_path(raw_input_dir: str) -> list:\\n result = []\\n for root, dirs, files in os.walk(raw_input_dir):\\n for file in files:\\n result.append(os.path.join(root, file))\\n return result\",\n \"def get_paths(input_folder: str) -> list[str]:\\n\\n return [f for f in os.listdir(input_folder) if f[-4:] == '.txt' and f[:3] != 'top']\",\n \"def get_files_from_directory(path):\\n return [f for f in listdir(path) if isfile(join(path, f))]\",\n \"def _list_dir(self):\\n return [os.path.join(self.cache_dir, fn)\\n for fn in os.listdir(self.cache_dir)]\",\n \"def list_files(top_path):\\n\\n results = []\\n\\n for root, dirs, files in os.walk(top_path, topdown=True):\\n\\n # Exclude dot files like .git\\n dirs[:] = [name for name in dirs if not name.startswith('.')]\\n files[:] = [name for name in files if not name.startswith('.')]\\n\\n for file_name in files:\\n results.append(os.path.join(root, file_name))\\n\\n results.sort()\\n return results\",\n \"def file_list(start_dir):\\n file_list = []\\n for root, dirs, files in os.walk(start_dir):\\n for f in files:\\n if f[0] != '.':\\n file_list.append(f)\\n return file_list\",\n \"def ffind(path, shellglobs=None, namefs=None, relative=True):\\n if not os.access(path, os.R_OK):\\n raise ScriptError(\\\"cannot access path: '%s'\\\" % path)\\n\\n fileList = [] # result list\\n try:\\n for dir, subdirs, files in os.walk(path):\\n if shellglobs:\\n matched = []\\n for pattern in shellglobs:\\n filterf = lambda s: fnmatch.fnmatchcase(s, pattern)\\n matched.extend(list(filter(filterf, files)))\\n fileList.extend(['%s%s%s' % (dir, os.sep, f) for f in matched])\\n else:\\n fileList.extend(['%s%s%s' % (dir, os.sep, f) for f in files])\\n if not relative: fileList = list(map(os.path.abspath, fileList))\\n if namefs:\\n for ff in namefs: fileList = list(filter(ff, fileList))\\n except Exception as e: raise ScriptError(str(e))\\n return(fileList)\",\n \"def list_file(self, path: str) -> List[FileName]:\\n current_file = self.file_exists(path)\\n if current_file is None:\\n raise FileNotExistException(\\n \\\"Path doesn't exist. Can't list non-existent path\\\"\\n )\\n if current_file.file_type != GOOGLE_FOLDER_TYPE:\\n raise NotAFolderException(\\\"file_nod has to be a folder to list contents\\\")\\n if current_file.children is None:\\n raise NotAFolderException(\\\"file_nod has to be a folder to list contents\\\")\\n if len(current_file.children) == 0:\\n return []\\n return [\\n child_file.file_name for child_file in list(current_file.children.values())\\n ]\",\n \"def GetSongFilenames():\\n\\n\\t## Loop through each directory\\n\\tsong_files = []\\n\\tfor root, dirs, fnames in os.walk(\\\"_data\\\\\\\\fma_small\\\\\\\\\\\"):\\n\\t\\t\\n\\t\\t## Skip the first level\\n\\t\\tif root == \\\"_data\\\\\\\\fma_small\\\\\\\\\\\":\\n\\t\\t\\tcontinue\\n\\n\\t\\t## Otherwise collect the files, appending\\n\\t\\t## the root path.\\n\\t\\tsong_files += [root+\\\"\\\\\\\\\\\"+f for f in fnames]\\n\\n\\treturn song_files\",\n \"def glob_files(sc, url,verbose):\\n URI = sc._gateway.jvm.java.net.URI\\n Path = sc._gateway.jvm.org.apache.hadoop.fs.Path\\n FileSystem = sc._gateway.jvm.org.apache.hadoop.fs.FileSystem\\n fs = FileSystem.get(URI(\\\"hdfs:///\\\"), sc._jsc.hadoopConfiguration())\\n l = fs.globStatus(Path(url))\\n return [f.getPath().toString() for f in l]\",\n \"def file_list_emptydirs(load):\\n # TODO - implement this\\n _init()\\n\\n return []\",\n \"def __getFileList(self, path, filterRe):\\n path = os.path.abspath(path)\\n files = []\\n for dirname, _, names in os.walk(path):\\n files.extend([os.path.join(dirname, f)\\n for f in names\\n if re.match(filterRe, f)]\\n )\\n return files\",\n \"def filelist(root):\\n allfiles = []\\n for path, subdirs, files in os.walk(root):\\n for name in files:\\n if name.find(\\\"xls\\\") >= 0:\\n allfiles.append(os.path.join(path, name))\\n return allfiles\",\n \"def volume_paths(path):\\n files = (os.path.join(path, f) for f in sorted(os.listdir(path)))\\n return [f for f in files if os.path.isdir(f) or f.endswith('.zip')]\",\n \"def _listdir(dirpath):\\n names = os.listdir(dirpath)\\n return [os.path.join(dirpath, n) for n in names]\",\n \"def get_list_of_files_in_dir(file_list_path=None):\\n return os.listdir(file_list_path)\",\n \"def find_all(path, filenames):\\n path = os.path.abspath(path)\\n try:\\n for root, dirs, files in os.walk(path, topdown=True):\\n dirs.sort()\\n for filename in filenames:\\n if filename in files:\\n yield os.path.abspath(os.path.join(root, filename))\\n except UnicodeDecodeError:\\n # This is an error of not being able to walk the dir when there are unicode files in them :|\\n pass\",\n \"def getFiles(folderToProcess,filter):\\n\\n print(f\\\"Parsing {folderToProcess} for {filter} files\\\")\\n\\n if debug:\\n for path in Path(folderToProcess).rglob(filter):\\n print(f\\\"Found {path}\\\")\\n\\n all_files = [str(x) for x in Path(folderToProcess).rglob(filter)] \\n\\n return all_files\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7015901","0.68982315","0.6829185","0.67371505","0.6656817","0.662845","0.65805537","0.6536745","0.6507714","0.6487095","0.6482098","0.6480075","0.64740694","0.6470006","0.6440682","0.6436125","0.64173836","0.6416718","0.637361","0.63688713","0.6312427","0.6300582","0.62761694","0.62747455","0.62168676","0.61797947","0.61747307","0.6164301","0.61639965","0.61612356","0.61587375","0.61524194","0.61471987","0.61436236","0.6138482","0.61380583","0.6127435","0.6106627","0.6104703","0.60998815","0.60953254","0.60916895","0.60830235","0.60785353","0.60774595","0.6071797","0.6068673","0.60680515","0.60595185","0.6046252","0.6036501","0.6033035","0.603146","0.60211086","0.60123587","0.60048807","0.6004018","0.60019994","0.5988783","0.59883237","0.59649384","0.5960682","0.5959402","0.59538215","0.5953349","0.59474236","0.5939642","0.59381306","0.59367764","0.5934834","0.5928125","0.5915368","0.5914555","0.5913821","0.5904164","0.59038466","0.5901936","0.58951366","0.5895086","0.5888682","0.58817023","0.5881626","0.5878458","0.58780277","0.58765423","0.58757806","0.5870691","0.586491","0.5857879","0.58555275","0.58553135","0.5853854","0.58373386","0.5836694","0.583564","0.58313525","0.58224636","0.58014","0.5800348","0.57998025"],"string":"[\n \"0.7015901\",\n \"0.68982315\",\n \"0.6829185\",\n \"0.67371505\",\n \"0.6656817\",\n \"0.662845\",\n \"0.65805537\",\n \"0.6536745\",\n \"0.6507714\",\n \"0.6487095\",\n \"0.6482098\",\n \"0.6480075\",\n \"0.64740694\",\n \"0.6470006\",\n \"0.6440682\",\n \"0.6436125\",\n \"0.64173836\",\n \"0.6416718\",\n \"0.637361\",\n \"0.63688713\",\n \"0.6312427\",\n \"0.6300582\",\n \"0.62761694\",\n \"0.62747455\",\n \"0.62168676\",\n \"0.61797947\",\n \"0.61747307\",\n \"0.6164301\",\n \"0.61639965\",\n \"0.61612356\",\n \"0.61587375\",\n \"0.61524194\",\n \"0.61471987\",\n \"0.61436236\",\n \"0.6138482\",\n \"0.61380583\",\n \"0.6127435\",\n \"0.6106627\",\n \"0.6104703\",\n \"0.60998815\",\n \"0.60953254\",\n \"0.60916895\",\n \"0.60830235\",\n \"0.60785353\",\n \"0.60774595\",\n \"0.6071797\",\n \"0.6068673\",\n \"0.60680515\",\n \"0.60595185\",\n \"0.6046252\",\n \"0.6036501\",\n \"0.6033035\",\n \"0.603146\",\n \"0.60211086\",\n \"0.60123587\",\n \"0.60048807\",\n \"0.6004018\",\n \"0.60019994\",\n \"0.5988783\",\n \"0.59883237\",\n \"0.59649384\",\n \"0.5960682\",\n \"0.5959402\",\n \"0.59538215\",\n \"0.5953349\",\n \"0.59474236\",\n \"0.5939642\",\n \"0.59381306\",\n \"0.59367764\",\n \"0.5934834\",\n \"0.5928125\",\n \"0.5915368\",\n \"0.5914555\",\n \"0.5913821\",\n \"0.5904164\",\n \"0.59038466\",\n \"0.5901936\",\n \"0.58951366\",\n \"0.5895086\",\n \"0.5888682\",\n \"0.58817023\",\n \"0.5881626\",\n \"0.5878458\",\n \"0.58780277\",\n \"0.58765423\",\n \"0.58757806\",\n \"0.5870691\",\n \"0.586491\",\n \"0.5857879\",\n \"0.58555275\",\n \"0.58553135\",\n \"0.5853854\",\n \"0.58373386\",\n \"0.5836694\",\n \"0.583564\",\n \"0.58313525\",\n \"0.58224636\",\n \"0.58014\",\n \"0.5800348\",\n \"0.57998025\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6604958"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":80596,"cells":{"query":{"kind":"string","value":"calculate the point of intersection of axes of wheels F and B"},"document":{"kind":"string","value":"def calc_O(F:Vec3, B:Vec3, theta:float):\n if F == B:\n raise ValueError('F cannot be equal to B')\n if theta == 0.0:\n raise ValueError('theta cannot be equal to 0.0')\n L = F - B\n Ox = norm2(L) / tan(theta)\n phi = atan2(L.y, L.x)\n alpha = phi - pi/2.0\n return Vec3(cos(alpha)*Ox, sin(alpha)*Ox) + B"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def intersection(self, axis2):","def intersection(x, y, f, p):","def fun(x0, x1, y0, y1, xx, yy): \n\n # Look for point of intersection between interpolated curve between nodes in x, y\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\n # Transform coordinate axes\n # Center of face is xs, ys\n xs = (x0 + x1)/2.\n ys = (y0 + y1)/2.\n\n if abs(y1 - y0) > abs(x1 - x0):\n theta = arctan((x1 - x0)/(y1 - y0))\n theta2 = arctan((xx - xs)/(yy - ys))\n dy = (yy - ys)/cos(theta2)\n xn = copy(xx)\n yn = copy(yy)\n xn = dy*sin(theta2 - theta)\n yn = dy*cos(theta2 - theta)\n w = barycentric_weight(yn)\n y2 = - yn\n f = zeros(len(y2), float)\n ss = sum(w/y2)\n f[:] = w/y2/ss\n dy = dot(f, xn)\n xny = xs + dy*sin(theta + pi/2.)\n yny = ys + dy*cos(theta + pi/2.)\n\n else: \n theta = arctan((y1 - y0)/(x1 - x0))\n theta2 = arctan((yy - ys)/(xx - xs))\n dx = (xx - xs)/cos(theta)\n xn = copy(xx)\n yn = copy(yy)\n xn = dx*cos(theta2 - theta)\n yn = dx*sin(theta2 - theta)\n w = barycentric_weight(xn)\n x2 = - xn\n f = zeros(len(x2), float)\n ss = sum(w/x2)\n f[:] = w/x2/ss\n dy = dot(f, yn)\n xny = xs + dy*cos(theta + pi/2.)\n yny = ys + dy*sin(theta + pi/2.)\n \n return xny, yny","def front_wheel_from_axis():","def center(f, b=None):\n\n if b is None: b = secross()\n y = f\n diff = 0\n while not diff:\n aux = y\n beta1 = asf(y,'COC',b,1)\n beta2 = asf(y,'OCO',b,1)\n y = union(intersec(y,beta1),beta2)\n diff = isequal(aux,y)\n return y","def _curvature(self):\n y_eval = self.left_fitx.shape[0] - 10\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.left_fit[0]))\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\n np.absolute(2 * self.right_fit[0]))\n return left_curverad, right_curverad","def side_wheel_from_axis():","def intersection_ring(self, q_total):\n \n # WARNING: This ignores the effect of the incident angle\n \n \n\n # This is a point that intersects the Ewald sphere\n # (if incident_angle = 0)\n theta = np.arcsin(q_total/(2*self.get_k()))\n qx, qy, qz = 0, -q_total*np.sin(theta), q_total*np.cos(theta)\n \n #qx, qy, qz = 0, 0, q_total\n \n qxs = []\n qys = []\n qzs = []\n \n for rot_angle in np.linspace(0, 2*np.pi, num=200):\n qx_rot = qx*np.cos(rot_angle) + qz*np.sin(rot_angle)\n qy_rot = qy\n qz_rot = -qx*np.sin(rot_angle) + qz*np.cos(rot_angle)\n qxy_rot = np.sqrt(np.square(qx_rot)+np.square(qy_rot))\n if qx_rot<0:\n qxy_rot *= -1\n \n qxs.append( qx_rot )\n qys.append( qy_rot )\n qzs.append( qz_rot )\n \n return qxs, qys, qzs","def c(xA,yA,rA, xB,yB,rB):\n\td2 = (xB-xA)**2 + (yB-yA)**2 \n\tK = (1/4.0) * sqrt(((rA+rB)**2-d2) * (d2-(rA-rB)**2))\n\t\n\txb = (1/2.0)*(xB+xA) + (1/2.0)*(xB-xA)*(rA**2-rB**2)/d2\n\tdx = 2*(yB-yA)*K/d2 \n\tyb = (1/2.0)*(yB+yA) + (1/2.0)*(yB-yA)*(rA**2-rB**2)/d2\n\tdy = -2*(xB-xA)*K/d2\n\n\treturn ((xb+dx,yb+dy), (xb-dx,yb-dy))","def HFincidentAngle(self,PFC, MHD):\n xyz = PFC.centers\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\n return","def inner(Ax, Ay, Bx, By):\n return (Ax*Bx + Ay*By) / (Ax**2+Ay**2)**0.5 / (Bx**2+By**2)**0.5","def intersection(self, L):\n if self.slope() == L.slope():\n return None\n intpt_xcood = (self.c * L.b - L.c * self.b)/(self.a * L.b - L.a * self.b)\n intpt_ycood = (self.c * L.a - L.c * self.a)/(self.b * L.a - L.b * self.a)\n\n return (intpt_xcood, intpt_ycood)","def get_candidate_locations_ellipse(f1, f2, major_axis, row_num, col_num):\n f1_y, f1_x = f1\n f2_y, f2_x = f2\n a = major_axis / 2.0\n c = distance(f1_x, f1_y, f2_x, f2_y) / 2.0\n b = np.sqrt(a * a - c * c)\n major_bound_1 = ((f2_x - f1_x) * (a + c) / (2 * c) + f1_x, (f2_y - f1_y) * (a + c) / (2 * c) + f1_y)\n major_bound_2 = ((f1_x - f2_x) * (a + c) / (2 * c) + f2_x, (f1_y - f2_y) * (a + c) / (2 * c) + f2_y)\n delta_x = b * (abs(major_bound_1[1] - major_bound_2[1])) / (2 * a)\n if f1_x == f2_x:\n delta_y = 0\n else:\n delta_y = np.sqrt(b * b - delta_x * delta_x)\n p1 = (major_bound_1[0] + delta_x, major_bound_1[1] - delta_y)\n p2 = (major_bound_1[0] - delta_x, major_bound_1[1] + delta_y)\n p3 = (major_bound_2[0] - delta_x, major_bound_2[1] + delta_y)\n p4 = (major_bound_2[0] + delta_x, major_bound_2[1] - delta_y)\n min_x = int(max(min([p1[0], p2[0], p3[0], p4[0]]), 0))\n max_x = int(min(max([p1[0], p2[0], p3[0], p4[0]]), col_num - 1))\n min_y = int(max(min([p1[1], p2[1], p3[1], p4[1]]), 0))\n max_y = int(min(max([p1[1], p2[1], p3[1], p4[1]]), row_num - 1))\n candidates = []\n for x in range(min_x, max_x + 1):\n for y in range(min_y, max_y + 1):\n if distance(f1_x, f1_y, x, y) + distance(x, y, f2_x, f2_y) < major_axis:\n candidates.append((y, x))\n return candidates","def get_intersection_point(l1, l2):\n m, b = l1\n n, c = l2\n # Find when mx + b = nx + c\n # mx - nx = c - b\n # And...\n x = (c-b) / (m-n)\n # Then plug back in\n y = m*x + b\n return (x, y)","def find_intersection(coefs_1, coefs_2):\r\n # Form the necessary matrices\r\n A = np.matrix([[coefs_1[0,0], coefs_1[1,0]], [coefs_2[0,0], coefs_2[1,0]]])\r\n B = np.matrix([[coefs_1[2,0]],[coefs_2[2,0]]])\r\n if np.linalg.det(A) == 0:\r\n return None\r\n else:\r\n _intersection = -np.linalg.inv(A) * B\r\n return Point(_intersection[0,0], _intersection[1,0])","def _intersect(A, B, C, D):\n d = (B[0] - A[0]) * (D[1] - C[1]) - (D[0] - C[0]) * (B[1] - A[1])\n x = ((B[0] * A[1] - A[0] * B[1]) * (D[0] - C[0]) - (D[0] * C[1] - C[0] * D[1]) * (B[0] - A[0])) / d\n y = ((B[0] * A[1] - A[0] * B[1]) * (D[1] - C[1]) - (D[0] * C[1] - C[0] * D[1]) * (B[1] - A[1])) / d\n return (np.round(x, 6), np.round(y, 6))","def test_x_intersection_2d(self):\n\n f_1 = np.array([[0, 2], [1, 1]])\n f_2 = np.array([[1, 1], [0, 2]])\n\n f_set = [f_1, f_2]\n nx = [3, 3]\n\n grids = meshing.cart_grid(f_set, nx, physdims=nx)\n\n # 2D grid:\n g_2d = grids.grids_of_dimension(2)[0]\n\n f_tags_2d = np.array([False, True, False, False, # first row\n False, True, False, False, # Second row\n False, False, False, False, # third row\n False, False, False, # Bottom column\n True, True, False, # Second column\n False, False, False, # Third column\n False, False, False, # Top column\n True, True, True, True]) # Added faces\n\n d_tags_2d = np.array([True, False, False, True, # first row\n True, False, False, True, # Second row\n True, False, False, True, # third row\n True, True, True, # Bottom column\n False, False, False, # Second column\n False, False, False, # Third column\n True, True, True, # Top column\n False, False, False, False]) # Added Faces\n t_tags_2d = np.zeros(f_tags_2d.size, dtype=bool)\n b_tags_1d = np.sum(f_tags_2d + d_tags_2d +\n t_tags_2d, axis=0).astype(bool)\n b_tags_2d = (f_tags_2d + d_tags_2d + t_tags_2d).astype(bool)\n assert np.all(g_2d.has_face_tag(FaceTag.TIP) == t_tags_2d)\n assert np.all(g_2d.has_face_tag(FaceTag.FRACTURE) == f_tags_2d)\n assert np.all(g_2d.has_face_tag(FaceTag.DOMAIN_BOUNDARY) == d_tags_2d)\n assert np.all(g_2d.has_face_tag(FaceTag.BOUNDARY) == b_tags_2d)\n\n # 1D grids:\n for g_1d in grids.grids_of_dimension(1):\n f_tags_1d = np.array([False, True, False, True])\n if g_1d.face_centers[0, 0] > 0.1:\n t_tags_1d = np.array([True, False, False, False])\n d_tags_1d = np.array([False, False, True, False])\n else:\n t_tags_1d = np.array([False, False, True, False])\n d_tags_1d = np.array([True, False, False, False])\n\n b_tags_1d = np.sum(f_tags_1d + d_tags_1d +\n t_tags_1d, axis=0).astype(bool)\n\n assert np.all(g_1d.has_face_tag(FaceTag.TIP) == t_tags_1d)\n assert np.all(g_1d.has_face_tag(FaceTag.FRACTURE) == f_tags_1d)\n assert np.all(g_1d.has_face_tag(\n FaceTag.DOMAIN_BOUNDARY) == d_tags_1d)\n assert np.all(g_1d.has_face_tag(FaceTag.BOUNDARY) == b_tags_1d)","def intersect_circles(a_pos, a_radius, b_pos, b_radius):\n # vector from A to B \n dp1p2 = b_pos - a_pos\n \n if a_radius + b_radius >= abs(dp1p2):\n return dp1p2.normalized()\n else:\n raise Exception(\"No intersection\")","def intersection(a, b):\n x = max(a[0],b[0])\n y = max(a[1],b[1])\n w = min(a[2],b[2]) - x\n h = min(a[3],b[3]) - y\n \n if h<0 or w<0 :\n return 0\n \n return h*w","def fd_center(f, h, x0):\n return (f(x0 + h) - 2*f(x0) + f(x0 - h))/(h**2)","def intersects(p1, p2):\n if p1^p2:\n return -(np.dot(p1.v, p2.w) * np.eye(3, 3) + \\\n p1.w.reshape((3,1)) @ p2.v.reshape((1,3)) - \n p2.w.reshape((3,1)) @ p1.v.reshape((1,3))) * sm.unitvec(np.cross(p1.w, p2.w))\n else:\n return None","def intersect(f, df, g, dg):\n \"*** YOUR CODE HERE ***\"","def common_line_in3D(phiA,thetaA,phiB,thetaB):\n\n\tfrom math import pi, sqrt, cos, sin, asin, atan2\n\n\tpiOver=pi/180.0;\n\tph1 = phiA*piOver; \n\tth1 = thetaA*piOver; \n\tph2 = phiB*piOver; \n\tth2 = thetaB*piOver;\n\t\n \t#nx = cos(thetaBR)*sin(thetaAR)*sin(phiAR) - cos(thetaAR)*sin(thetaBR)*sin(phiBR) ;\n\t#ny = cos(thetaAR)*sin(thetaBR)*cos(phiBR) - cos(thetaBR)*sin(thetaAR)*cos(phiAR) ;\n\t#nz = sin(thetaAR)*sin(thetaBR)*sin(phiAR-phiBR);\n\n\n\tnx = sin(th1)*cos(ph1)*sin(ph2)-sin(th2)*sin(ph1)*cos(ph2)\n\tny = sin(th1)*cos(th2)*cos(ph1)*cos(ph2)-cos(th1)*sin(th2)*cos(ph1)*cos(ph2)\n\tnz = cos(th2)*sin(ph1)*cos(ph2)-cos(th1)*cos(ph1)*sin(ph2)\n\n\tnorm = nx*nx + ny*ny + nz*nz\n \n\tif norm < 1e-5:\n\t\t#print 'phiA,thetaA,phiB,thetaB:', phiA, thetaA, phiB, thetaB\n\t\treturn 0.0, 0.0\n\n\tif nz<0: nx=-nx; ny=-ny; nz=-nz;\n\n\t#thetaCom = asin(nz/sqrt(norm))\n\tphiCom = asin(nz/sqrt(norm))\n\t#phiCom = atan2(ny,nx)\n\tthetaCom = atan2(ny, nx)\n\t\n\treturn phiCom*180.0/pi , thetaCom*180.0/pi","def get_line_circle_intersections(A, B, C, r):\n Lx = B[0] - A[0]\n Ly = B[1] - A[1]\n Lz = B[2] - A[2]\n\n # stranger things\n D = Lx**2 + Ly**2\n E = 2 * ( Lx * (A[0] - C[0]) + Ly * (A[1] - C[1]) )\n F = (\n (A[0] - C[0])**2\n + (A[1] - C[1])**2\n - r**2\n )\n det = E**2 - 4 * D * F\n \n # declare null vectors\n P1 = [0, 0, 0]\n P2 = [0, 0, 0]\n t1 = t2 = None\n eps = .00001\n if ( not (D <= eps) or (det < 0) ):\n if det == 0:\n print \"tangential intersection found\",\n t1 = t2 = -E / (2*D)\n else:\n print \"pass-through intersection found\",\n t1 = ( (-E + math.sqrt(det)) / (2 * D) )\n t2 = ( (-E - math.sqrt(det)) / (2 * D) )\n P1[0] = A[0] + t1 * Lx\n P1[1] = A[1] + t1 * Ly\n P1[2] = A[2] + t1 * Lz\n P2[0] = A[0] + t2 * Lx\n P2[1] = A[1] + t2 * Ly\n P2[2] = A[2] + t2 * Lz\n else:\n print \"no intersections are available\",\n\n return P1, P2","def p_exact_2d(X, Y):\n \n sol = ( -1.0 / (2.0*np.pi**2) * np.sin(np.pi * X) * np.cos(np.pi * Y) + \n -1.0 / (50.0*np.pi**2) * np.sin(5.0 * np.pi * X) * np.cos(5.0 * np.pi * Y) )\n \n return sol","def distance_between_wheels():","def x(self):\n return np.sum(self.bbox, 0)[0] / 2","def _find_wing_coord(self):\n frac = 0.1\n r = 0.5\n sin45 = np.sin(np.pi / 4.)\n\n if self.out == True:\n d = r - frac * sin45\n elif self.out == False:\n d = r + frac * sin45\n else:\n raise TypeError(\"arg: out must be True or False\")\n\n a = np.sqrt(frac**2 * sin45**2 + d**2)\n alpha = np.arccos(d / a)\n return [a, alpha]","def _lines_intersection(self, other):\n\n the_slope, the_y_intercept = False, False\n\n # parallel?\n if self.slope == other.slope:\n return (\n self.y_intercept == other.y_intercept and\n self.x_value == other.x_value\n )\n\n if self.is_vertical():\n x = self.x_value\n the_slope = other.slope\n the_y_intercept = other.y_intercept\n elif other.is_vertical():\n x = other.x_value\n else:\n x = (other.y_intercept - self.y_intercept) / (self.slope - other.slope)\n\n if the_slope is None or the_slope is False:\n the_slope = self.slope\n the_y_intercept = self.y_intercept\n\n y = the_slope * x + the_y_intercept\n\n return Point(x, y)","def intersect_point(self,m1,c1,m2,c2):\n\n x = (c2 - c1)/(m1 - m2)\n y = m1*x + c1\n return x, y","def intersection(L1, L2):\n D = L1[0] * L2[1] - L1[1] * L2[0]\n Dx = L1[2] * L2[1] - L1[1] * L2[2]\n Dy = L1[0] * L2[2] - L1[2] * L2[0]\n if D != 0:\n x = Dx / D\n y = Dy / D\n return x, y\n else:\n return False","def get_intersection(self, l, max_y=None):\n\n # Get the points\n i, j = self.breakpoint\n\n # Initialize the resulting point\n result = Coordinate()\n p: Coordinate = i\n\n # First we replace some stuff to make it easier\n a = i.xd\n b = i.yd\n c = j.xd\n d = j.yd\n u = 2 * (b - l)\n v = 2 * (d - l)\n\n # Handle the case where the two points have the same y-coordinate (breakpoint is in the middle)\n if i.yd == j.yd:\n result.xd = (i.xd + j.xd) / 2\n\n if j.xd < i.xd:\n result.yd = max_y or float('inf')\n return result\n\n # Handle cases where one point's y-coordinate is the same as the sweep line\n elif i.yd == l:\n result.xd = i.xd\n p = j\n elif j.yd == l:\n result.xd = j.xd\n else:\n # We now need to solve for x\n # 1/u * (x**2 - 2*a*x + a**2 + b**2 - l**2) = 1/v * (x**2 - 2*c*x + c**2 + d**2 - l**2)\n # Then we let Wolfram alpha do the heavy work for us, and we put it here in the code :D\n x = -(Decimal.sqrt(\n v * (a ** 2 * u - 2 * a * c * u + b ** 2 * (u - v) + c ** 2 * u) + d ** 2 * u * (v - u) + l ** 2 * (\n u - v) ** 2) + a * v - c * u) / (u - v)\n result.xd = x\n\n # We have to re-evaluate this, since the point might have been changed\n a = p.xd\n b = p.yd\n x = result.xd\n u = 2 * (b - l)\n\n # Handle degenerate case where parabolas don't intersect\n if u == 0:\n result.yd = float(\"inf\")\n return result\n\n # And we put everything back in y\n result.yd = 1 / u * (x ** 2 - 2 * a * x + a ** 2 + b ** 2 - l ** 2)\n return result","def fce(B):\n return wce(B)/(2.*np.pi)","def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\n # Convert latitude, longitude, azimuth of the begining point to radians\n lat1 = math.radians(begin_lat)\n lon1 = math.radians(begin_lon)\n alfa1 = math.radians(begin_azimuth)\n\n sinAlfa1 = math.sin(alfa1)\n cosAlfa1 = math.cos(alfa1)\n \n # U1 - reduced latitude\n tanU1 = (1 - f) * math.tan(lat1)\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\n sinU1 = tanU1 * cosU1\n \n # sigma1 - angular distance on the sphere from the equator to begining point\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\n \n # sinAlfa - azimuth of the geodesic at the equator\n sinAlfa = cosU1 * sinAlfa1\n cosSqAlfa = 1 - sinAlfa * sinAlfa\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\n A = 1 + uSq/16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\n B = uSq/1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\n \n sigma = distance / (b * A)\n sigmap = 1\n \n while (math.fabs(sigma - sigmap) > 1e-12):\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\n sinSigma = math.sin(sigma)\n cosSigma = math.cos(sigma)\n dSigma = B*sinSigma*(cos2sigmaM+B/4*(cosSigma*(-1+2*cos2sigmaM*cos2sigmaM)-B/6*cos2sigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2sigmaM*cos2sigmaM))) \n sigmap = sigma\n sigma = distance / (b * A) + dSigma\n \n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1\n \n # Latitude of the end point in radians\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma*cosAlfa1, (1 - f)*math.sqrt(sinAlfa * sinAlfa + var_aux*var_aux))\n \n lamb = math.atan2 (sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\n L = lamb - (1 - C) * f * sinAlfa *(sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\n # Longitude of the second point in radians\n lon2 = (lon1 + L +3*math.pi)%(2*math.pi) - math.pi\n \n # Convert to decimal degrees\n lat2_dd = math.degrees(lat2) \n lon2_dd = math.degrees(lon2)\n \n return lat2_dd, lon2_dd","def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\n # Convert latitude, longitude, azimuth of the begining point to radians\n lat1 = math.radians(begin_lat)\n lon1 = math.radians(begin_lon)\n alfa1 = math.radians(begin_azimuth)\n\n sinAlfa1 = math.sin(alfa1)\n cosAlfa1 = math.cos(alfa1)\n\n # U1 - reduced latitude\n tanU1 = (1 - f) * math.tan(lat1)\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\n sinU1 = tanU1 * cosU1\n\n # sigma1 - angular distance on the sphere from the equator to begining point\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\n\n # sinAlfa - azimuth of the geodesic at the equator\n sinAlfa = cosU1 * sinAlfa1\n cosSqAlfa = 1 - sinAlfa * sinAlfa\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\n A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\n B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\n\n sigma = distance / (b * A)\n sigmap = 1\n\n while (math.fabs(sigma - sigmap) > 1e-12):\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\n sinSigma = math.sin(sigma)\n cosSigma = math.cos(sigma)\n dSigma = B * sinSigma * (cos2sigmaM + B / 4 * (\n cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM) - B / 6 * cos2sigmaM * (\n -3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2sigmaM * cos2sigmaM)))\n sigmap = sigma\n sigma = distance / (b * A) + dSigma\n\n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1 # Auxiliary variable\n\n # Latitude of the end point in radians\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlfa1,\n (1 - f) * math.sqrt(sinAlfa * sinAlfa + var_aux * var_aux))\n\n lamb = math.atan2(sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\n L = lamb - (1 - C) * f * sinAlfa * (\n sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\n # Longitude of the second point in radians\n lon2 = (lon1 + L + 3 * math.pi) % (2 * math.pi) - math.pi\n\n # Convert to decimal degrees\n lat2_dd = math.degrees(lat2)\n lon2_dd = math.degrees(lon2)\n\n return lat2_dd, lon2_dd","def get_barycentric_coord(self, ph):\n a_v_1 = np.cross(ph - self.v0.position, self.v2.position - ph) / 2\n a_v_2 = np.cross(ph - self.v1.position, self.v0.position - ph) / 2\n s = np.dot(self.n, a_v_1) / self.area\n t = np.dot(self.n, a_v_2) / self.area\n return s, t","def epipoles_location(f_mat):\r\n u, s, vh = np.linalg.svd(f_mat)\r\n e_l = vh[-1, :]\r\n e_r = u[:, -1]\r\n # get x, y by dividing by w\r\n e_l = (e_l[0] / e_l[2], e_l[1] / e_l[2])\r\n e_r = (e_r[0] / e_r[2], e_r[1] / e_r[2])\r\n return e_l, e_r","def get_kernel(self, c, d, a, b):\r\n global t\r\n \r\n t=math.radians(t_) \r\n if a == 0 and b == 0:\r\n if c == 0 and d == 0:\r\n return complex((math.cos(t*frec)**2)+((e**2)*(math.sin(t*frec)**2)/(frec**2)),0)\r\n elif c == 0 and d == 1:\r\n return complex((e*o*(math.sin(t*frec))**2)/(frec**2),(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))) \r\n elif c == 1 and d == 0:\r\n return complex((e*o*(math.sin(t*frec))**2)/(frec**2),-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))) \r\n elif c == 1 and d == 1:\r\n return complex((o**2)*((math.sin(t*frec))**2)/(frec**2),0)\r\n \r\n \r\n elif a == 0 and b == 1:\r\n if c == 0 and d == 0:\r\n return complex((e*o*(math.sin(t*frec))**2/(frec**2)),((o*(math.sin(t*frec))*(math.cos(t*frec))/(frec)))) \r\n elif c == 0 and d == 1:\r\n return complex(((math.cos(t*frec))**2-((e**2)*(math.sin(t*frec))**2)/(frec**2)),(-(2*e)*(math.sin(t*frec)*math.cos(t*frec))/frec)) \r\n elif c == 1 and d == 0:\r\n return complex(((o**2)*(math.sin(t*frec)**2)/(frec**2)),0) \r\n elif c == 1 and d == 1:\r\n return complex((-(o*e)*(math.sin(t*frec)**2)/(frec**2)),(-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))))\r\n \r\n \r\n elif a == 1 and b == 0: \r\n \r\n if c == 0 and d == 0:\r\n return complex((((o*e)*(math.sin(t*frec))**2)/(frec**2)),(-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))))\r\n elif c == 0 and d == 1:\r\n return complex((((o**2)*(math.sin(t*frec))**2)/(frec**2)),0)\r\n elif c == 1 and d == 0:\r\n return complex(((math.cos(t*frec))**2-((e**2)*(math.sin(t*frec))**2)/(frec**2)),(2*e*(math.sin(t*frec)*math.cos(t*frec))/frec))\r\n elif c == 1 and d == 1:\r\n return complex((-((o*e)*(math.sin(t*frec))**2)/(frec**2)),((o*(math.sin(t*frec))*(math.cos(t*frec))/frec)))\r\n \r\n elif a == 1 and b == 1:\r\n if c == 0 and d == 0:\r\n return complex(((o**2)*(math.sin(t*frec))**2)/(frec**2),0)\r\n elif c == 0 and d == 1:\r\n return complex(-(((o*e)*(math.sin(t*frec))**2)/(frec**2)),-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec)))\r\n elif c == 1 and d == 0:\r\n return complex(-((o*e)*(math.sin(t*frec))**2)/(frec**2),o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))\r\n elif c == 1 and d == 1:\r\n return complex((math.cos(t*frec))**2+((e**2)*(math.sin(t*frec))**2)/(frec**2),0)","def intersection(line1, line2):\n rho1, theta1 = line1\n rho2, theta2 = line2\n A = np.array([\n [np.cos(theta1), np.sin(theta1)],\n [np.cos(theta2), np.sin(theta2)]\n ])\n b = np.array([[rho1], [rho2]])\n x0, y0 = np.linalg.solve(A, b)\n x0, y0 = int(np.round(x0)), int(np.round(y0))\n return [x0, y0]","def center_of_bees(self):\n pos, com, success = self.perception\n return around(sum(pos)/(len(pos) + 1))","def intersection(v1, v2):\n x = v1[0:2] + v2[0:2]\n y = v1[2:4] + v2[2:4]\n if( x[3] == 0 ): #To avoid a divide by zero, if x[3] is 0 then we just solve for where lineA equals x[2]\n t1 = (x[2] - x[0])/\\\n (x[1])\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]\n\n else: \n t1 = ( y[0] - y[2] + (y[3]/x[3])*(x[2] - x[0]) )/\\\n ( (y[3]*x[1])/x[3] - y[1] )\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]","def intersection(boxes, box):\n ix = np.maximum(0, np.minimum(box[2], boxes[:,2]) - np.maximum(box[0], boxes[:,0]))\n iy = np.maximum(0, np.minimum(box[3], boxes[:,3]) - np.maximum(box[1], boxes[:,1]))\n return ix*iy","def _getReliefFcn(self, centerx, centery, a, b, angle):\n\n if a == 0 or b == 0:\n return (lambda x, y: 0)\n\n def f(x, y):\n center = Vect(centerx, centery)\n point = Vect(x, y)\n # angle coord of the point with respect to the ellipse center:\n phi = point.getAngle(center)\n # radial coord of the point with respect to the ellipse center:\n r = abs(point - center)\n # radial coord of the ellipse border at angle phi:\n elRadius = (a*b) / math.sqrt(a**2 * math.sin(phi - angle)**2 +\n b**2 * math.cos(phi - angle)**2)\n\n if r <= elRadius:\n # (x, y) is inside\n return 1\n else:\n # (x, y) is outside\n return 0\n return f","def calc_main_axis(self):\n #Clarify why the above step has been done\n c0, c1, c2 = self.calc_geom_center ()\n M = numpy.zeros ((3, 3), dtype=float)\n M = [[0] * 3, [0] * 3, [0] * 3]\n for x in self.atomcoords:\n xi = x[0] - c0\n yi = x[1] - c1\n zi = x[2] - c2\n M[0][0] = M[0][0] + xi * xi\n M[0][1] = M[0][1] + xi * yi\n M[0][2] = M[0][2] + xi * zi\n M[1][1] = M[1][1] + yi * yi\n M[1][2] = M[1][2] + yi * zi\n M[2][2] = M[2][2] + zi * zi\n M[1][0] = M[0][1]\n M[2][0] = M[0][2]\n M[2][1] = M[1][2]\n M = numpy.array (M)\n d = sum (numpy.diag (M))\n M = -M\n M[0, 0] = M[0, 0] + d\n M[1, 1] = M[1, 1] + d\n M[2, 2] = M[2, 2] + d\n\n eigenVals, eigenVecs = numpy.linalg.eig (M)\n eigenVecs = eigenVecs.transpose ()\n return eigenVecs","def find_intersection(A, B, C, D):\n \n a1, b1, c1 = line_equation(A.x, A.y, B.x, B.y)\n a2, b2, c2 = line_equation(C.x, C.y, D.x, D.y)\n \n Y = - np.array([[c1],\n [c2]])\n M = np.array([[a1, b1],\n [a2, b2]])\n\n X = np.linalg.solve(M, Y)\n intersection = Coordinates(X[0], X[1])\n \n return intersection","def coefA(x0,y0,x1,y1):\n return -(y1-y0)/(x1-x0)","def get_intersect(a1, a2, b1, b2):\n s = np.vstack([a1, a2, b1, b2]) # s for stacked\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\n l1 = np.cross(h[0], h[1]) # get first line\n l2 = np.cross(h[2], h[3]) # get second line\n x, y, z = np.cross(l1, l2) # point of intersection\n if z == 0: # lines are parallel\n return float('inf'), float('inf')\n return x / z, y / z","def find_root(function, point_a, point_b, step, tol, max_iterations, \n show_process = False):\n left_point , right_point = search_interval_3d(function, point_a, point_b, \n step, tol, max_iterations,\n show_process)\n \n point_where_zero = bisection_3d(function, left_point, right_point, tol, \n max_iterations, show_process)\n \n return point_where_zero","def intersection_area(self, footprint):\n dx = min(self.upperright[0], footprint.upperright[0]) - max(self.upperleft[0], footprint.upperleft[0])\n dy = min(self.bottomright[1], footprint.bottomright[1]) - max(self.upperright[1], footprint.upperright[1])\n #assert dx >= 0\n #assert dy >= 0\n return dx * dy","def find_ordinate(x_value, a_value, b_value, field):\n\n # y_value may be found by simple substitution of x_value in the equation\n return (int(pow(x_value, 3, field)) + a_value * x_value + b_value) % field","def line_sphere_intersection(p1, p2, c, r):\n\t# FILL in your code here\n\n\tline_vector=np.subtract(p2,p1) #np.array([p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2] ])\n\tval=np.sqrt(np.sum([(p2 - p1)**2\n\t\t\t\t\t\t for p1, p2 in zip(p1,p2)]))\n\n\tif val==0:\n\t\tunit_vector=np.array([0,0,0])\n\telse:\n\t\tunit_vector=[linevec/val for linevec in line_vector]\n\tvecO_C=np.subtract(p1,c)\n\t\t\n\tres=np.dot(unit_vector,vecO_C)* np.dot(unit_vector,vecO_C) - ( np.dot(vecO_C, vecO_C) - r*r )\n\treturn res","def intersection(line1, line2):\n p0, p1, p2, p3 = map(\n lambda tup : np.array(tup[:2]),\n [line1[0], line1[1], line2[0], line2[1]]\n )\n p1, p2, p3 = map(lambda x : x - p0, [p1, p2, p3])\n transform = np.zeros((2, 2))\n transform[:,0], transform[:,1] = p1, p2\n if np.linalg.det(transform) == 0: return\n inv = np.linalg.inv(transform)\n new_p3 = np.dot(inv, p3.reshape((2, 1)))\n #Where does line connecting (0, 1) to new_p3 hit x axis\n x_intercept = new_p3[0] / (1 - new_p3[1]) \n result = np.dot(transform, [[x_intercept], [0]])\n result = result.reshape((2,)) + p0\n return result","def intersection(line1, line2):\r\n rho1, theta1 = line1[0]\r\n rho2, theta2 = line2[0]\r\n A = np.array([[np.cos(theta1), np.sin(theta1)], [np.cos(theta2), np.sin(theta2)]])\r\n b = np.array([[rho1], [rho2]])\r\n x0, y0 = np.linalg.solve(A, b)\r\n x0, y0 = int(np.round(x0)), int(np.round(y0))\r\n return [[x0, y0]]","def hausdorffDistance(self,fiber1,fiber2):\n polyA = fiber1.GetPolyData()\n polyB = fiber2.GetPolyData()\n\n locA = vtk.vtkMergePoints()\n locB = vtk.vtkMergePoints()\n\n locA.SetDataSet(polyA)\n locB.SetDataSet(polyB)\n\n locs = (locA,locB)\n for loc in locs:\n loc.AutomaticOn()\n loc.BuildLocator()\n\n ptsA = polyA.GetPoints()\n ptsB = polyB.GetPoints()\n\n rangeA = ptsA.GetNumberOfPoints()\n rangeB = ptsB.GetNumberOfPoints()\n\n maxd = 0.0\n maxd1 = 0.0\n avgd = 0.0\n avgd1 = 0.0\n\n distanceA = vtk.vtkFloatArray()\n distanceA.SetName(\"Distance\")\n for i in range(rangeA):\n pt = ptsA.GetPoint(i)\n bid = locB.FindClosestPoint(pt)\n ptb = ptsB.GetPoint(bid)\n d = self.pointDistance(pt,ptb)\n distanceA.InsertNextValue(d)\n avgd += d\n if d > maxd:\n maxd = d\n avgd = avgd / rangeA\n\n distanceB = vtk.vtkFloatArray()\n distanceB.SetName(\"Distance\")\n for i in range(rangeB):\n pt = ptsB.GetPoint(i)\n bid = locA.FindClosestPoint(pt)\n ptb = ptsA.GetPoint(bid)\n d = self.pointDistance(pt,ptb)\n distanceB.InsertNextValue(d)\n avgd1 += d\n if d > maxd1:\n maxd1 = d\n avgd1 = avgd1 / rangeB\n\n polyA.GetPointData().SetScalars(distanceA)\n polyB.GetPointData().SetScalars(distanceB)\n\n return max(maxd,maxd1)","def compute_y_intersection(x, x1, x2, y1, y2):\n delta_x = x2 - x1\n if delta_x == 0:\n return x1\n return ((x - x1) * (y2 - y1) / delta_x) + y1","def calculate_y_axis_intersect(p, m):\n return p[1] - (m * p[0])","def calculate_intersections(self,P1,Q1,P2,Q2):\n x=(Q2[:,:,1]-Q1[:,:,1]-P2[:,:,1]/P2[:,:,2]*(Q2[:,:,2]-Q1[:,:,2]))/(P1[:,:,1]-P1[:,:,2]*P2[:,:,1]/P2[:,:,2])\n return Q1+x[:,:,np.newaxis]*P1,x","def intersection(line1, line2):\n\n rho1, theta1 = line1[0]\n rho2, theta2 = line2[0]\n A = np.array([\n [np.cos(theta1), np.sin(theta1)],\n [np.cos(theta2), np.sin(theta2)]\n ])\n b = np.array([[rho1], [rho2]])\n x0, y0 = np.linalg.solve(A, b)\n x0, y0 = int(np.round(x0)), int(np.round(y0))\n\n return [x0, y0]","def calculateElementBoundaryCoefficients(self):\n pass","def get_intersect(a1, a2, b1, b2):\r\n s = np.vstack([a1,a2,b1,b2]) # s for stacked\r\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\r\n l1 = np.cross(h[0], h[1]) # get first line\r\n l2 = np.cross(h[2], h[3]) # get second line\r\n x, y, z = np.cross(l1, l2) # point of intersection\r\n if z == 0: # lines are parallel\r\n return (float('inf'), float('inf'))\r\n return (x/z, y/z)","def compute_x_intersection(y, x1, x2, y1, y2):\n delta_y = y2 - y1\n if delta_y == 0:\n return x1\n return ((y - y1) * (x2 - x1) / delta_y) + x1","def ball_intersection_check(r0, step, radius): \n t = -(step[0]*r0[0] + step[1]*r0[1] + step[2]*r0[2]) + math.sqrt((step[0]*r0[0] + step[1]*r0[1] + step[2]*r0[2])**2 \\\n - (r0[0]**2+r0[1]**2+r0[2]**2) + radius**2)\n return t","def __getxyB(x, y):\n\t\treturn x*3+y","def midpoint(self,i,f):\n\n summation = self.points[f, :] + self.points[i, :]\n midploint = summation/2\n x_mid = midploint[0]\n y_mid = midploint[1]\n\n return x_mid,y_mid","def find_inplane_to_match(phiA,thetaA,phiB,thetaB,psiA=0,psiB=0):\n\t#from math import pi, sqrt, cos, acos, sin\n\n\tRA = Transform({'type': 'spider', 'phi': phiA, 'theta': thetaA, 'psi': psiA})\n\tRB = Transform({'type': 'spider', 'phi': phiB, 'theta': thetaB, 'psi': psiB})\n\tRBT = RB.transpose()\n\tRABT = RA * RBT\n\n\tRABTeuler = RABT.get_rotation('spider')\n\tRABTphi = RABTeuler['phi']\n\tRABTtheta = RABTeuler['theta']\n\tRABTpsi = RABTeuler['psi']\n\n\t#deg_to_rad = pi/180.0\n\t#thetaAR = thetaA*deg_to_rad\n\t#thetaBR = thetaB*deg_to_rad\n\t#phiAR = phiA*deg_to_rad\n\t#phiBR = phiB *deg_to_rad\n\n\t#d12=cos(thetaAR)*cos(thetaBR) + sin(thetaAR)*sin(thetaBR)*cos(phiAR-phiBR)\n\treturn (-RABTpsi-RABTphi),RABTtheta # 180.0*acos(d12)/pi;","def __call__(\n self, left: TFTBoxTensor, right: TFTBoxTensor\n ) -> TFTBoxTensor:\n\n return tf_hard_intersection(left, right)","def bBoxMiddle(bBox):\n x0, y0 = bBox[0]\n x1, y1 = bBox[1]\n return (x0 + x1) / 2 , (y0 + y1) /2","def an_intersection(v1, b1):\n try:\n return intersection(v1, b1, np.array([1,1]), 0)\n except np.linalg.linalg.LinAlgError:\n print v1\n return intersection(v1, b1, np.array([-1,1]), 0)","def midpoint(ptA, ptB):\n return( (ptA[0] + ptB[0]) * 0.5, (ptA[1]+ ptB[1]) * 0.5 )","def get_horizantal_b_reference(top_kp: Keypoint, middle_kp: Keypoint, bottom_kp: Keypoint) -> Keypoint:\n vector_a = keypoint_to_vector(top_kp, middle_kp)\n vector_c = keypoint_to_vector(bottom_kp, middle_kp)\n # NOTE: checking angle_left_opening has the same effect as to check if biscetion point is positioned to the left or right of the neck point\n angle_left_opening = np.cross(vector_a, vector_c) < 0\n return Keypoint(middle_kp.x - 100, middle_kp.y) if angle_left_opening else Keypoint(middle_kp.x + 100, middle_kp.y)","def segmentsIntersect(self, other, allowProjInt = False):\n \n \"\"\"\n If we are not allowing projected intersection and the bounding boxes\n do not intersect then return -3, None.\n \"\"\"\n if(not(allowProjInt) and not(self.doBoundingBoxesIntersect(other))): return -3, None #return if bounding boxes do not intersect\n \"\"\" A special case for colinear lines. \"\"\" \n if(self.areColinear(other)):\n \"\"\"\n First place all four endpoint into a set. This will elliminate shared\n end points. Next, convert the set back into a list so it can\n finally be sorted.\n \"\"\"\n pointList = sorted(list(set([self.start, self.end, other.start, other.end])), key=self.calcT) \n if len(pointList) == 3:\n \"\"\"\n if there are only three points in the list then return 2, the\n middle point in the list since it is the shared point of the\n two lines.\n \"\"\"\n return 2, pointList[1] #if they are colinear and two ends have the same point return that point\n elif len(pointList) == 2:\n \"\"\" If the two lines have the same endpoints. \"\"\"\n return 2.5, self.getMidPoint()\n else:\n \"\"\"\n If the length was not three then we know it is length 4 in which case\n we turn the two middle points into a line and return 3, the line's\n midpoint.\n \"\"\"\n tempLine = Line(pointList[1], pointList[2])\n return 3, tempLine.getMidPoint() #If they are colinear return half way inbetween middle two points\n \"\"\"\n To calculate the intersection of two points we put the lines into the\n form P+tr and Q+us where P and Q are the starting points of the lines\n r and s are vectors form the starting point to the end point, and\n t and u are scalars. Set the two equations equal to each other and \n then solve for t and u. If t and u are in the range [0-1] then the\n intersection point lines on the lines, else it is a projected point.\n \"\"\"\n r = np.subtract(self.end.get2DPoint(), self.start.get2DPoint())\n s = np.subtract(other.end.get2DPoint(), other.start.get2DPoint())\n Q_Less_P = np.subtract(other.start.get2DPoint(), self.start.get2DPoint())\n denom = np.cross(r, s)*1.0\n t = np.cross(Q_Less_P, s)/denom\n u = np.cross(Q_Less_P, r)/denom \n point = p.Point(self.start.x + r[c.X]*t, self.start.y+r[c.Y]*t) \n #If t or u are not in the range 0-1 then the intersection is projected\n if(t > 1 or u > 1 or t < 0 or u < 0):\n \"\"\"\n Due to floating point problems sometimes if t or u is outside the 0-1\n range we end up inside this if statement but are actually at the end\n of one of the lines. I can't figure out how to properly add in a tolerance\n so we are taking the four end points putting them into a list,\n then comparing them to the calculated point. The Point module is\n properly handling tolerances so if the point == any of the end\n points then we should not return a projected point.\n \"\"\"\n if not any(point == lineEnd for lineEnd in (self.start, self.end,\n other.start, other.end)):\n return -1, point #return for projected intersection of non-colinear lines\n return 1, point #lines intersect at given point","def getCurvature(f,x):\n df = f.derivative(nu=1)(x)\n ddf = f.derivative(nu=2)(x)\n k = ddf/pow(1-df*df,3/2)\n return k, abs(1.0/k)","def overlap(self, psi_1, psi_2):\n return self.dx * np.sum(np.min(np.c_[self.density(psi_1), self.density(psi_2)], 1))","def intersection(eqn0, eqn1):\n x = (eqn1[1] - eqn0[1]) / (eqn0[0] - eqn1[0])\n return (x, apply_eqn(eqn0, x))","def intersectsAB(self, ray):\n v1 = ray.origin - self.pointA\n v2 = self.pointB - self.pointA\n v3 = Point(-ray.direction.y, ray.direction.x)\n dot = v2.dot(v3)\n if (abs(dot) < 0.000001):\n return None\n t1 = v2.cross(v1) / dot\n t2 = v1.dot(v3) / dot\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\n return t1\n return None","def intersectConics(E1, E2):\n\n P = np.array([])\n r1 = matrix_rank(E1)\n r2 = matrix_rank(E2)\n \n if(r1==3 and r2==3):\n P = completeIntersection(E1,E2) \n else:\n if (r2 < 3): #E2 is degenerate\n defE = E2\n fullE = E1\n else:\n defE = E1 #E1 is degenerate\n fullE = E2\n m, l = decomposeDegenerateConic(defE)\n P1 = intersectConicLine(fullE,m)\n P2 = intersectConicLine(fullE,l)\n P = np.array([P1, P2])\n points_x = []\n points_y = []\n for i in range(2):\n P1 = P[i]\n if(P1.size!=0):\n for j in range(P1.shape[0]):\n points_x.append(P1[j,0]/P1[j,2])\n points_y.append(P1[j,1]/P1[j,2])\n return points_x, points_y","def find_intersection(center0, direction0, center1, direction1):\n # c0 + d0 t = c1 + d1 s\n # (-d0) t + (d1) s = c0 - c1\n # [-d0, d1] [t,s]^T = delta\n A = np.array([-direction0, direction1]).T\n delta = center0 - center1\n # Unpack M = A^T * A:\n # [[a, b],\n # [c, d]]\n (a, b), (c, d) = A.T.dot(A)\n # Inverse of M:\n # 1/ det(M) [[ d, -b],\n # [-c, a]]\n M_inv = np.array([[d, -b], [-c, a]]) / (a * d - b * c)\n t, s = M_inv.dot(A.T.dot(delta))\n return t, s","def get_x(EQ, M):\n return (EQ[0] * (EQ[0] * M[0] - EQ[1] * M[1]) - EQ[1] * EQ[2]) / (EQ[1] ** 2 + EQ[0] ** 2)","def planeLineIntersect(p1, p2, equ):\n n = vector(equ[0], equ[1], equ[2])\n v1, v2 = vector(p1), vector(p2)\n t = (equ[3] - n.dotProduct(v2)) / (n.dotProduct(v1 - v2))\n return (t * v1 + (1 - t) * v2).coords()","def getVisualFieldOrigin(self):\r\n\r\n if not hasattr(self, 'finalPatchesMarked'):\r\n raise LookupError('Please mark the final patches first!!')\r\n\r\n if not hasattr(self, 'altPosMapf'):\r\n _ = self._getSignMap()\r\n\r\n try:\r\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\r\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\r\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\r\n\r\n overlap = 0 # number of overlaping pixels\r\n iterNum = 1 # number of iteration\r\n while overlap < 1:\r\n # print 'Iteration number for finding overlapping pixel:', iterNum\r\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\r\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\r\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\r\n totalField = V1 + LM + RL\r\n # plt.imshow(totalField)\r\n overlap = len(np.argwhere(totalField == 3))\r\n iterNum += 1\r\n # print 'Number of overlapping pixels:', overlap\r\n # plt.show()\r\n\r\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\r\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\r\n\r\n except KeyError:\r\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\nSetting origins to 0 ...')\r\n altPosOrigin = 0.\r\n aziPosOrigin = 0.\r\n\r\n return altPosOrigin, aziPosOrigin","def central_x(self, func):\n\n roll_left = np.roll(func, -1, axis=1)\n roll_right = np.roll(func, 1, axis=1)\n f_dx = (roll_left - roll_right) / (2 * self.dx)\n return f_dx","def make_q(v0, v2):\n return (v0.y - v2.y)/(v0.x - v2.x)","def dist2cax(self) -> float:\n # TODO: see about using line and built-in dist to point.\n center_fit = np.poly1d(self.fit)\n if self.orientation == Orientation.UP_DOWN:\n length = self.image.shape[0]\n else:\n length = self.image.shape[1]\n x_data = np.arange(length)\n y_data = center_fit(x_data)\n idx = int(round(len(x_data) / 2))\n if self.orientation == Orientation.UP_DOWN:\n axis = \"x\"\n p1 = Point(y_data[idx], x_data[idx])\n else:\n axis = \"y\"\n p1 = Point(x_data[idx], y_data[idx])\n return (getattr(self.image.center, axis) - getattr(p1, axis)) / self.image.dpmm","def princ_axes(self):\r\n # get coordinates of mesh\r\n coords = BoundaryMesh(self.mesh,\"exterior\",True).coordinates()\r\n\r\n # get distances\r\n dist = np.sqrt(np.einsum('ij->i', np.square(coords)))\r\n\r\n # get maximal value\r\n maxind = np.argmax(dist)\r\n maxdist = dist[maxind]\r\n\r\n # get minimal value\r\n minind = np.argmin(dist)\r\n mindist = dist[minind]\r\n\r\n # find coordinates of maximal and minimal points\r\n maxax = coords[maxind, :]\r\n minax = coords[minind, :]\r\n\r\n # get the cross product of these vectors,\r\n # which is the ideal mid-size axis\r\n idealax = np.cross(maxax,minax)\r\n\r\n # get the dot product of this ideal axis with the coordinates,\r\n # take the absolute value, and find the index of the maximum\r\n secind = np.argmax(np.abs(np.einsum('j,ij->i',idealax,coords)))\r\n\r\n # get the second-axis distance\r\n secdist = dist[secind]\r\n\r\n return([maxdist, secdist, mindist], [\"a\", \"b\", \"c\"])","def intersect(box_a, box_b):\n #taken from fastai\n max_xy = torch.min(box_a[:, None, 2:], box_b[None, :, 2:])\n min_xy = torch.max(box_a[:, None, :2], box_b[None, :, :2])\n inter = torch.clamp((max_xy - min_xy), min=0)\n return inter[:, :, 0] * inter[:, :, 1]","def implicit_surface(self, F, y):\n y = y[:, :, None].expand(-1, -1, self.n_primitives, -1)\n y_latent, ldj = self.invertible_network.inverse(F, y)\n norm = torch.sqrt((y_latent**2).sum(-1))\n\n # <0 denotes internal points\n # >0 denotes external points\n # 0 is the boundary hence our primitive\n return norm - self.radius, ldj","def _arcArcIntersectXY(c1,c2,inside=True,params=False):\n x1=c1[0]\n x2=c2[0]\n r1=c1[1][0]\n r2=c2[1][0]\n\n # check for sample reverse condition\n sr1 = c1[1][3]==-2\n sr2 = c2[1][3]==-2\n\n ## first check for non-intersection due to distance between the\n ## centers of the arcs, treating both arcs as circles for the moment\n\n d=dist(x1,x2) #calculate the distance d between circle centers\n\n if d > r1+r2:\n return False # too far, no possiblity of intersection\n\n if ( r1> r2 and d < r1-r2) or (r2 >= r1 and d < r2-r1):\n return False # too close, little arc is fully inside bigger arc\n\n if d < epsilon:\n return False # circle centers too close for stable calculation\n\n ## OK, we are in the goldilocks zone of intersection. this means\n ## that if boh arcs are cicles or if inside=False we are\n ## guaranteed one or two intersections. Calculate those\n ## intersections and then test to see if they fall between start\n ## and end of the respective arcs\n\n ## we start by calculating the distance id of the intersection plane\n ## from the center of arc 1, knowing that by definition id <= r1\n\n ## Math: consider the triangle with side lengths r1, r2, and d,\n ## where d is the previously calculated distance between arc\n ## centers. Consider the two right triangles with side lengths\n ## r1, id, h, and r2, h, (d-id). We know that:\n ## id^2 + h^2 = r1^2, (d-id)^2 + h^2 = r2^2\n ## solving both for h2 and then substituting, this means:\n ## r1^2 - id^2 = r2^2 - (d-id)^2\n ## collecting terms and solving for id produces:\n ## id = (r1^2-r2^2 + d^2)/2d\n\n id = (r1*r1 - r2*r2 + d*d)/(2 * d)\n\n ## compute the point on the line connecting the two arc centers\n ## that is id away from the first arc\n\n v1 = scale3(sub(x2,x1),1.0/d) # unitary direction vector pointing\n # from x1 to x2\n v2 = scale3(v1,id) # point on line between two circles in\n # coordinate space centered at x1\n\n ## compute direction vector o orthgonal to v1 -- the line that\n ## intersects point v2 and v2+o will pass through our intersection\n ## points\n\n o = orthoXY(v1)\n \n ## now, transform back into world coordinates and calculate the\n ## intersection of this line with either of our arcs, treating\n ## them as circles for now\n\n l = [add(v2,x1),add(add(v2,o),x1)]\n\n s = _lineArcIntersectXY(l,c1,False)\n\n ## as a sanity check, do the same with the other arc. Results\n ## should be within epsilon\n #ss = _lineArcIntersectXY(l,c2,False)\n #foo = list(map(lambda x, y: dist(x,y) < epsilon,s,ss))\n #print(\"sanity check: \" , foo)\n\n if not s or len(s) == 0:\n raise ValueError('no computed intersections, something is wrong')\n\n if not inside and not params:\n return s\n \n ## jump back to arc1 and arc2 space and check angles\n\n s1 = list(map(lambda x: sub(x,x1),s))\n s2 = list(map(lambda x: sub(x,x2),s))\n\n ## compute start and end angles for arcs\n start1=c1[1][1]\n end1=c1[1][2]\n if not (start1 == 0 and end1 == 360):\n start1 = start1 % 360.0\n end1 = end1 % 360.0\n if end1 < start1:\n end1 = end1 + 360.0\n \n start2=c2[1][1]\n end2=c2[1][2]\n \n if not (start2 == 0 and end2 == 360):\n start2 = start2 % 360.0\n end2 = end2 % 360.0\n if end2 < start2:\n end2 = end2 + 360.0\n \n\n ## check each intersection against angles for each arc. \n ss = []\n uparam1 = []\n uparam2 = []\n for i in range(len(s)):\n p1 =s1[i]\n p2 =s2[i]\n ang1 = (atan2(p1[1],p1[0]) % pi2)*360.0/pi2\n ang2 = (atan2(p2[1],p2[0]) % pi2)*360.0/pi2\n\n if params:\n u1 = 0\n u2 = 0\n if end1 <= 360.0 or ang1 >= start1 or \\\n ( end1 > 360.0 and ang1 > end1-360.0):\n u1 = (ang1-start1)/(end1-start1)\n if sr1:\n u1 = 1.0-u1\n elif end1 > 360.0:\n u1 = (ang1+360.0-start1)/(end1-start1)\n if sr1:\n u1 = 1.0-u1\n uparam1 = uparam1 + [ u1 ]\n \n if end2 <= 360.0 or ang2 >= start2 or \\\n ( end2 > 360.0 and ang2 > end1-360.0):\n u2 = (ang2-start2)/(end2-start2)\n if sr2:\n u2 = 1.0-u2\n elif end2 > 360.0:\n u2 = (ang2+360.0-start2)/(end2-start2)\n if sr2:\n u2 = 1.0-u2\n uparam2 = uparam2 + [ u2]\n \n else:\n good = False\n ## check angle against first arc\n if end1 <= 360.0 and ang1 >= start1 and ang1 <= end1:\n good = True\n elif end1 > 360.0 and (ang1 >= start1 or ang1<= end1-360.0):\n good = True\n\n ## check angle against second arc\n if end2 <= 360.0 and ang2 >= start2 and ang2 <= end2:\n good = good and True\n elif end2 > 360.0 and (ang2 >= start2 or ang2<= end2-360.0):\n good = good and True\n else:\n good = False\n\n ## only add instersection to the list if both checks were passed\n if good:\n ss = ss + [ s[i] ]\n \n if not params and len(ss) == 0:\n return False\n else:\n if params:\n return [uparam1,uparam2]\n else:\n return ss","def central_differences(f, h, x):\n\treturn (f(x + h) - f(x - h)) / (2 * h)","def rectangle_circumference(a,b):\n return (2*(a+b))","def get_closest_intersection(wire1, wire2):\n pass","def E(q, r0, x, y):\n den = np.hypot(x - r0[0], y - r0[1]) ** 3\n return q * (x - r0[0]) / den, q * (y - r0[1]) / den","def _intersection(self, ix, iy):\n im = ix + iy # cv2.bitwise_or(ix, iy)\n # freq = cytoolz.frequencies(im.ravel())\n # hx = freq.get(1, 0) # x alone\n # hy = freq.get(2, 0) # y alone\n # ha = freq.get(3, 0) # x & y\n\n freq = np.bincount(im.ravel().astype(np.int64))\n hx = freq[1] if len(freq) > 1 else 0\n hy = freq[2] if len(freq) > 2 else 0\n ha = freq[3] if len(freq) > 3 else 0\n\n return hx, hy, ha","def test_10_kernels(self):\n ra0, dec0 = CRVAL\n res = 0.01 * DEG\n\n # Test zenithal -- (ra0, dec0) is the reference point.\n for proj in ['TAN', 'ZEA']:\n wcsk = coords.get_wcs_kernel(proj, ra0, dec0, res)\n msg = f'Check crpix for {proj}'\n self.assertAlmostEqual(wcsk.wcs.crpix[0], 1, delta=TOL_RAD, msg=msg)\n self.assertAlmostEqual(wcsk.wcs.crpix[1], 1, delta=TOL_RAD, msg=msg)\n\n # Test cylindrical -- pixell puts the crval[1] on the equator\n # and dec0 is used for the conformal latitude.\n for proj in ['CAR', 'CEA']:\n wcsk = coords.get_wcs_kernel(proj, ra0, dec0, res)\n msg = f'Check crpix for {proj}'\n self.assertAlmostEqual(wcsk.wcs.crpix[0], 1, delta=TOL_RAD, msg=msg)\n self.assertNotAlmostEqual(wcsk.wcs.crpix[1], 1, delta=TOL_RAD, msg=msg)\n\n # This is going to break.\n fp = FP(xi =[0., -0.01*DEG],\n eta=[0., -0.01*DEG])\n sight = get_sightline()\n tod = core.AxisManager(core.LabelAxis('dets', ['a']))\n fp = coords.get_footprint(tod, wcs_kernel=wcsk, focal_plane=fp, sight=sight)","def intersect(box_a, box_b):\n\n max_xy = torch.min(box_a[:, 2:].unsqueeze(1), box_b[:, 2:].unsqueeze(0))\n min_xy = torch.max(box_a[:, :2].unsqueeze(1), box_b[:, :2].unsqueeze(0))\n inter = torch.clamp((max_xy - min_xy), min=0)\n return inter[:, :, 0] * inter[:, :, 1]","def __init__(self,v0,v1):\n self.vinputs = v0,v1\n self.xhi = max([v0[0],v1[0]])\n self.yhi,self.ylo = v0[1]>v1[1] and (v0[1],v1[1],) or (v1[1],v0[1])\n\n self.m = (v1[0]-v0[0]) / (v1[1]-v0[1]) ### (x1-x0)/(y1-y0)\n self.b = v0[0] - (v0[1] * self.m) ### x0 - y0*(x1-x0)/(y1-y0)","def fCalc(self):\n # A dictionary composed of all internal and boundary points\n allPoints = dict(self.internalPoints.items() + self.boundaryPoints.items())\n\n for pointLabel in allPoints.keys():\n # Compute fE, fW, fN and fW only for internal mesh points\n if allPoints[pointLabel].type.lower() == 'internal':\n xLabel = pointLabel[0]\n yLabel = pointLabel[1]\n x = self.internalPoints[(xLabel,yLabel)].x\n y = self.internalPoints[(xLabel,yLabel)].y\n xE = allPoints[(xLabel + 1,yLabel)].x\n xW = allPoints[(xLabel - 1,yLabel)].x\n yN = allPoints[(xLabel,yLabel + 1)].y\n yS = allPoints[(xLabel,yLabel - 1)].y\n \n if (xE - x)/self.h < -0.000001 or (xE - x)/self.h > 1.000001:\n errorMessage = '**Error! (xE - x)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (xE - x)/h = ' + str((xE - x)/self.h)\n raise customError(errorMessage)\n else:\n self.internalPoints[(xLabel,yLabel)].fE = (xE - x)/self.h\n\n # Note that in the following we use -0.000001 and 1.000001 \n # instead of 0 and 1, respectively, to avoid problems with\n # with very small fractions. For example if the fractions is\n # greater than one by 2.22e-16 the condition (x - xW)/self.h > 1\n # will be false and the code returns an error\n if (x - xW)/self.h < -0.000001 or (x - xW)/self.h > 1.000001:\n errorMessage = '**Error! (x - xW)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (x - xW)/h = ' + str((x - xW)/self.h)\n raise customError(errorMessage)\n else:\n self.internalPoints[(xLabel,yLabel)].fW = (x - xW)/self.h\n \n if (yN - y)/self.h < -0.000001 or (yN - y)/self.h > 1.000001:\n errorMessage = '**Error! (yN - y)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (yN - y)/h = ' + str((yN - y)/self.h)\n raise customError(errorMessage)\n else:\n self.internalPoints[(xLabel,yLabel)].fN = (yN - y)/self.h\n \n if (y - yS)/self.h < -0.000001 or (y - yS)/self.h > 1.000001:\n errorMessage = '**Error! (y - yS)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (y - yS)/h = ' + str((y - yS)/self.h)\n raise customError(errorMessage)\n else:\n self.internalPoints[(xLabel,yLabel)].fS = (y - yS)/self.h\n \n # Calculate the coeeficients requried to compute the Laplacian \n self.internalPoints[(xLabel,yLabel)].LapCoeffCalc()","def F_cont(self):\n x0 = self.edp_par['x0'].value\n A = self.edp_par['A'].value\n f1 = self.edp_par['f1'].value\n f2 = self.edp_par['f2'].value\n lr = self.latt_par['lambda_r'].value\n w = 0.5 * (self.qx*x0 + self.qz*A)\n arg1 = 0.5*self.qx*lr + w\n arg2 = 0.5*self.qx*lr - w\n fir = x0 * np.sin(w) / lr / w\n sec = (lr-x0) * np.cos(0.5*arg1) * np.sin(arg2) / lr / np.cos(0.5*arg2) / arg2 \n #sec = (-1)**self.k * (lr-x0) * sin(self.k*pi-w)/(self.k*pi-w)/lr\n return (fir + f1*sec + 2*f2*np.cos(w)/lr)","def cylinder_intersection_check(r0, step, orientation, radius): \n A = 1 - (step[0]*orientation[0]+step[1]*orientation[1]+step[2]*orientation[2])**2\n B = 2 * (r0[0]*step[0]+r0[1]*step[1]+r0[2]*step[2] - (r0[0]*orientation[0]+r0[1]*orientation[1]+r0[2]*orientation[2]) * (step[0]*orientation[0]+step[1]*orientation[1]+step[2]*orientation[2]))\n C = r0[0]**2+r0[1]**2+r0[2]**2 - radius**2 -(r0[0]*orientation[0]+r0[1]*orientation[1]+r0[2]*orientation[2])**2 \n t = (-B + math.sqrt(B**2 - 4*A*C)) / (2*A)\n return t","def intersection(self, other): # -> BaseGeometry:\n ...","def ccw(A, B, C):\n return (B.x - A.x) * (C.y - A.y) > (B.y - A.y) * (C.x - A.x)"],"string":"[\n \"def intersection(self, axis2):\",\n \"def intersection(x, y, f, p):\",\n \"def fun(x0, x1, y0, y1, xx, yy): \\n\\n # Look for point of intersection between interpolated curve between nodes in x, y\\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\\n # Transform coordinate axes\\n # Center of face is xs, ys\\n xs = (x0 + x1)/2.\\n ys = (y0 + y1)/2.\\n\\n if abs(y1 - y0) > abs(x1 - x0):\\n theta = arctan((x1 - x0)/(y1 - y0))\\n theta2 = arctan((xx - xs)/(yy - ys))\\n dy = (yy - ys)/cos(theta2)\\n xn = copy(xx)\\n yn = copy(yy)\\n xn = dy*sin(theta2 - theta)\\n yn = dy*cos(theta2 - theta)\\n w = barycentric_weight(yn)\\n y2 = - yn\\n f = zeros(len(y2), float)\\n ss = sum(w/y2)\\n f[:] = w/y2/ss\\n dy = dot(f, xn)\\n xny = xs + dy*sin(theta + pi/2.)\\n yny = ys + dy*cos(theta + pi/2.)\\n\\n else: \\n theta = arctan((y1 - y0)/(x1 - x0))\\n theta2 = arctan((yy - ys)/(xx - xs))\\n dx = (xx - xs)/cos(theta)\\n xn = copy(xx)\\n yn = copy(yy)\\n xn = dx*cos(theta2 - theta)\\n yn = dx*sin(theta2 - theta)\\n w = barycentric_weight(xn)\\n x2 = - xn\\n f = zeros(len(x2), float)\\n ss = sum(w/x2)\\n f[:] = w/x2/ss\\n dy = dot(f, yn)\\n xny = xs + dy*cos(theta + pi/2.)\\n yny = ys + dy*sin(theta + pi/2.)\\n \\n return xny, yny\",\n \"def front_wheel_from_axis():\",\n \"def center(f, b=None):\\n\\n if b is None: b = secross()\\n y = f\\n diff = 0\\n while not diff:\\n aux = y\\n beta1 = asf(y,'COC',b,1)\\n beta2 = asf(y,'OCO',b,1)\\n y = union(intersec(y,beta1),beta2)\\n diff = isequal(aux,y)\\n return y\",\n \"def _curvature(self):\\n y_eval = self.left_fitx.shape[0] - 10\\n left_curverad = (((1 + (2 * self.left_fit[0] * y_eval + self.left_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.left_fit[0]))\\n right_curverad = (((1 + (2 * self.right_fit[0] * y_eval + self.right_fit[1]) ** 2) ** 1.5) /\\n np.absolute(2 * self.right_fit[0]))\\n return left_curverad, right_curverad\",\n \"def side_wheel_from_axis():\",\n \"def intersection_ring(self, q_total):\\n \\n # WARNING: This ignores the effect of the incident angle\\n \\n \\n\\n # This is a point that intersects the Ewald sphere\\n # (if incident_angle = 0)\\n theta = np.arcsin(q_total/(2*self.get_k()))\\n qx, qy, qz = 0, -q_total*np.sin(theta), q_total*np.cos(theta)\\n \\n #qx, qy, qz = 0, 0, q_total\\n \\n qxs = []\\n qys = []\\n qzs = []\\n \\n for rot_angle in np.linspace(0, 2*np.pi, num=200):\\n qx_rot = qx*np.cos(rot_angle) + qz*np.sin(rot_angle)\\n qy_rot = qy\\n qz_rot = -qx*np.sin(rot_angle) + qz*np.cos(rot_angle)\\n qxy_rot = np.sqrt(np.square(qx_rot)+np.square(qy_rot))\\n if qx_rot<0:\\n qxy_rot *= -1\\n \\n qxs.append( qx_rot )\\n qys.append( qy_rot )\\n qzs.append( qz_rot )\\n \\n return qxs, qys, qzs\",\n \"def c(xA,yA,rA, xB,yB,rB):\\n\\td2 = (xB-xA)**2 + (yB-yA)**2 \\n\\tK = (1/4.0) * sqrt(((rA+rB)**2-d2) * (d2-(rA-rB)**2))\\n\\t\\n\\txb = (1/2.0)*(xB+xA) + (1/2.0)*(xB-xA)*(rA**2-rB**2)/d2\\n\\tdx = 2*(yB-yA)*K/d2 \\n\\tyb = (1/2.0)*(yB+yA) + (1/2.0)*(yB-yA)*(rA**2-rB**2)/d2\\n\\tdy = -2*(xB-xA)*K/d2\\n\\n\\treturn ((xb+dx,yb+dy), (xb-dx,yb-dy))\",\n \"def HFincidentAngle(self,PFC, MHD):\\n xyz = PFC.centers\\n r,z,phi = tools.xyz2cyl(xyz[:,0],xyz[:,1],xyz[:,2])\\n BNorms = MHD.Bfield_pointcloud(PFC.ep, r, z, phi, PFC.powerDir, normal=True)\\n PFC.bdotn = np.multiply(PFC.norms, BNorms).sum(1)\\n return\",\n \"def inner(Ax, Ay, Bx, By):\\n return (Ax*Bx + Ay*By) / (Ax**2+Ay**2)**0.5 / (Bx**2+By**2)**0.5\",\n \"def intersection(self, L):\\n if self.slope() == L.slope():\\n return None\\n intpt_xcood = (self.c * L.b - L.c * self.b)/(self.a * L.b - L.a * self.b)\\n intpt_ycood = (self.c * L.a - L.c * self.a)/(self.b * L.a - L.b * self.a)\\n\\n return (intpt_xcood, intpt_ycood)\",\n \"def get_candidate_locations_ellipse(f1, f2, major_axis, row_num, col_num):\\n f1_y, f1_x = f1\\n f2_y, f2_x = f2\\n a = major_axis / 2.0\\n c = distance(f1_x, f1_y, f2_x, f2_y) / 2.0\\n b = np.sqrt(a * a - c * c)\\n major_bound_1 = ((f2_x - f1_x) * (a + c) / (2 * c) + f1_x, (f2_y - f1_y) * (a + c) / (2 * c) + f1_y)\\n major_bound_2 = ((f1_x - f2_x) * (a + c) / (2 * c) + f2_x, (f1_y - f2_y) * (a + c) / (2 * c) + f2_y)\\n delta_x = b * (abs(major_bound_1[1] - major_bound_2[1])) / (2 * a)\\n if f1_x == f2_x:\\n delta_y = 0\\n else:\\n delta_y = np.sqrt(b * b - delta_x * delta_x)\\n p1 = (major_bound_1[0] + delta_x, major_bound_1[1] - delta_y)\\n p2 = (major_bound_1[0] - delta_x, major_bound_1[1] + delta_y)\\n p3 = (major_bound_2[0] - delta_x, major_bound_2[1] + delta_y)\\n p4 = (major_bound_2[0] + delta_x, major_bound_2[1] - delta_y)\\n min_x = int(max(min([p1[0], p2[0], p3[0], p4[0]]), 0))\\n max_x = int(min(max([p1[0], p2[0], p3[0], p4[0]]), col_num - 1))\\n min_y = int(max(min([p1[1], p2[1], p3[1], p4[1]]), 0))\\n max_y = int(min(max([p1[1], p2[1], p3[1], p4[1]]), row_num - 1))\\n candidates = []\\n for x in range(min_x, max_x + 1):\\n for y in range(min_y, max_y + 1):\\n if distance(f1_x, f1_y, x, y) + distance(x, y, f2_x, f2_y) < major_axis:\\n candidates.append((y, x))\\n return candidates\",\n \"def get_intersection_point(l1, l2):\\n m, b = l1\\n n, c = l2\\n # Find when mx + b = nx + c\\n # mx - nx = c - b\\n # And...\\n x = (c-b) / (m-n)\\n # Then plug back in\\n y = m*x + b\\n return (x, y)\",\n \"def find_intersection(coefs_1, coefs_2):\\r\\n # Form the necessary matrices\\r\\n A = np.matrix([[coefs_1[0,0], coefs_1[1,0]], [coefs_2[0,0], coefs_2[1,0]]])\\r\\n B = np.matrix([[coefs_1[2,0]],[coefs_2[2,0]]])\\r\\n if np.linalg.det(A) == 0:\\r\\n return None\\r\\n else:\\r\\n _intersection = -np.linalg.inv(A) * B\\r\\n return Point(_intersection[0,0], _intersection[1,0])\",\n \"def _intersect(A, B, C, D):\\n d = (B[0] - A[0]) * (D[1] - C[1]) - (D[0] - C[0]) * (B[1] - A[1])\\n x = ((B[0] * A[1] - A[0] * B[1]) * (D[0] - C[0]) - (D[0] * C[1] - C[0] * D[1]) * (B[0] - A[0])) / d\\n y = ((B[0] * A[1] - A[0] * B[1]) * (D[1] - C[1]) - (D[0] * C[1] - C[0] * D[1]) * (B[1] - A[1])) / d\\n return (np.round(x, 6), np.round(y, 6))\",\n \"def test_x_intersection_2d(self):\\n\\n f_1 = np.array([[0, 2], [1, 1]])\\n f_2 = np.array([[1, 1], [0, 2]])\\n\\n f_set = [f_1, f_2]\\n nx = [3, 3]\\n\\n grids = meshing.cart_grid(f_set, nx, physdims=nx)\\n\\n # 2D grid:\\n g_2d = grids.grids_of_dimension(2)[0]\\n\\n f_tags_2d = np.array([False, True, False, False, # first row\\n False, True, False, False, # Second row\\n False, False, False, False, # third row\\n False, False, False, # Bottom column\\n True, True, False, # Second column\\n False, False, False, # Third column\\n False, False, False, # Top column\\n True, True, True, True]) # Added faces\\n\\n d_tags_2d = np.array([True, False, False, True, # first row\\n True, False, False, True, # Second row\\n True, False, False, True, # third row\\n True, True, True, # Bottom column\\n False, False, False, # Second column\\n False, False, False, # Third column\\n True, True, True, # Top column\\n False, False, False, False]) # Added Faces\\n t_tags_2d = np.zeros(f_tags_2d.size, dtype=bool)\\n b_tags_1d = np.sum(f_tags_2d + d_tags_2d +\\n t_tags_2d, axis=0).astype(bool)\\n b_tags_2d = (f_tags_2d + d_tags_2d + t_tags_2d).astype(bool)\\n assert np.all(g_2d.has_face_tag(FaceTag.TIP) == t_tags_2d)\\n assert np.all(g_2d.has_face_tag(FaceTag.FRACTURE) == f_tags_2d)\\n assert np.all(g_2d.has_face_tag(FaceTag.DOMAIN_BOUNDARY) == d_tags_2d)\\n assert np.all(g_2d.has_face_tag(FaceTag.BOUNDARY) == b_tags_2d)\\n\\n # 1D grids:\\n for g_1d in grids.grids_of_dimension(1):\\n f_tags_1d = np.array([False, True, False, True])\\n if g_1d.face_centers[0, 0] > 0.1:\\n t_tags_1d = np.array([True, False, False, False])\\n d_tags_1d = np.array([False, False, True, False])\\n else:\\n t_tags_1d = np.array([False, False, True, False])\\n d_tags_1d = np.array([True, False, False, False])\\n\\n b_tags_1d = np.sum(f_tags_1d + d_tags_1d +\\n t_tags_1d, axis=0).astype(bool)\\n\\n assert np.all(g_1d.has_face_tag(FaceTag.TIP) == t_tags_1d)\\n assert np.all(g_1d.has_face_tag(FaceTag.FRACTURE) == f_tags_1d)\\n assert np.all(g_1d.has_face_tag(\\n FaceTag.DOMAIN_BOUNDARY) == d_tags_1d)\\n assert np.all(g_1d.has_face_tag(FaceTag.BOUNDARY) == b_tags_1d)\",\n \"def intersect_circles(a_pos, a_radius, b_pos, b_radius):\\n # vector from A to B \\n dp1p2 = b_pos - a_pos\\n \\n if a_radius + b_radius >= abs(dp1p2):\\n return dp1p2.normalized()\\n else:\\n raise Exception(\\\"No intersection\\\")\",\n \"def intersection(a, b):\\n x = max(a[0],b[0])\\n y = max(a[1],b[1])\\n w = min(a[2],b[2]) - x\\n h = min(a[3],b[3]) - y\\n \\n if h<0 or w<0 :\\n return 0\\n \\n return h*w\",\n \"def fd_center(f, h, x0):\\n return (f(x0 + h) - 2*f(x0) + f(x0 - h))/(h**2)\",\n \"def intersects(p1, p2):\\n if p1^p2:\\n return -(np.dot(p1.v, p2.w) * np.eye(3, 3) + \\\\\\n p1.w.reshape((3,1)) @ p2.v.reshape((1,3)) - \\n p2.w.reshape((3,1)) @ p1.v.reshape((1,3))) * sm.unitvec(np.cross(p1.w, p2.w))\\n else:\\n return None\",\n \"def intersect(f, df, g, dg):\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def common_line_in3D(phiA,thetaA,phiB,thetaB):\\n\\n\\tfrom math import pi, sqrt, cos, sin, asin, atan2\\n\\n\\tpiOver=pi/180.0;\\n\\tph1 = phiA*piOver; \\n\\tth1 = thetaA*piOver; \\n\\tph2 = phiB*piOver; \\n\\tth2 = thetaB*piOver;\\n\\t\\n \\t#nx = cos(thetaBR)*sin(thetaAR)*sin(phiAR) - cos(thetaAR)*sin(thetaBR)*sin(phiBR) ;\\n\\t#ny = cos(thetaAR)*sin(thetaBR)*cos(phiBR) - cos(thetaBR)*sin(thetaAR)*cos(phiAR) ;\\n\\t#nz = sin(thetaAR)*sin(thetaBR)*sin(phiAR-phiBR);\\n\\n\\n\\tnx = sin(th1)*cos(ph1)*sin(ph2)-sin(th2)*sin(ph1)*cos(ph2)\\n\\tny = sin(th1)*cos(th2)*cos(ph1)*cos(ph2)-cos(th1)*sin(th2)*cos(ph1)*cos(ph2)\\n\\tnz = cos(th2)*sin(ph1)*cos(ph2)-cos(th1)*cos(ph1)*sin(ph2)\\n\\n\\tnorm = nx*nx + ny*ny + nz*nz\\n \\n\\tif norm < 1e-5:\\n\\t\\t#print 'phiA,thetaA,phiB,thetaB:', phiA, thetaA, phiB, thetaB\\n\\t\\treturn 0.0, 0.0\\n\\n\\tif nz<0: nx=-nx; ny=-ny; nz=-nz;\\n\\n\\t#thetaCom = asin(nz/sqrt(norm))\\n\\tphiCom = asin(nz/sqrt(norm))\\n\\t#phiCom = atan2(ny,nx)\\n\\tthetaCom = atan2(ny, nx)\\n\\t\\n\\treturn phiCom*180.0/pi , thetaCom*180.0/pi\",\n \"def get_line_circle_intersections(A, B, C, r):\\n Lx = B[0] - A[0]\\n Ly = B[1] - A[1]\\n Lz = B[2] - A[2]\\n\\n # stranger things\\n D = Lx**2 + Ly**2\\n E = 2 * ( Lx * (A[0] - C[0]) + Ly * (A[1] - C[1]) )\\n F = (\\n (A[0] - C[0])**2\\n + (A[1] - C[1])**2\\n - r**2\\n )\\n det = E**2 - 4 * D * F\\n \\n # declare null vectors\\n P1 = [0, 0, 0]\\n P2 = [0, 0, 0]\\n t1 = t2 = None\\n eps = .00001\\n if ( not (D <= eps) or (det < 0) ):\\n if det == 0:\\n print \\\"tangential intersection found\\\",\\n t1 = t2 = -E / (2*D)\\n else:\\n print \\\"pass-through intersection found\\\",\\n t1 = ( (-E + math.sqrt(det)) / (2 * D) )\\n t2 = ( (-E - math.sqrt(det)) / (2 * D) )\\n P1[0] = A[0] + t1 * Lx\\n P1[1] = A[1] + t1 * Ly\\n P1[2] = A[2] + t1 * Lz\\n P2[0] = A[0] + t2 * Lx\\n P2[1] = A[1] + t2 * Ly\\n P2[2] = A[2] + t2 * Lz\\n else:\\n print \\\"no intersections are available\\\",\\n\\n return P1, P2\",\n \"def p_exact_2d(X, Y):\\n \\n sol = ( -1.0 / (2.0*np.pi**2) * np.sin(np.pi * X) * np.cos(np.pi * Y) + \\n -1.0 / (50.0*np.pi**2) * np.sin(5.0 * np.pi * X) * np.cos(5.0 * np.pi * Y) )\\n \\n return sol\",\n \"def distance_between_wheels():\",\n \"def x(self):\\n return np.sum(self.bbox, 0)[0] / 2\",\n \"def _find_wing_coord(self):\\n frac = 0.1\\n r = 0.5\\n sin45 = np.sin(np.pi / 4.)\\n\\n if self.out == True:\\n d = r - frac * sin45\\n elif self.out == False:\\n d = r + frac * sin45\\n else:\\n raise TypeError(\\\"arg: out must be True or False\\\")\\n\\n a = np.sqrt(frac**2 * sin45**2 + d**2)\\n alpha = np.arccos(d / a)\\n return [a, alpha]\",\n \"def _lines_intersection(self, other):\\n\\n the_slope, the_y_intercept = False, False\\n\\n # parallel?\\n if self.slope == other.slope:\\n return (\\n self.y_intercept == other.y_intercept and\\n self.x_value == other.x_value\\n )\\n\\n if self.is_vertical():\\n x = self.x_value\\n the_slope = other.slope\\n the_y_intercept = other.y_intercept\\n elif other.is_vertical():\\n x = other.x_value\\n else:\\n x = (other.y_intercept - self.y_intercept) / (self.slope - other.slope)\\n\\n if the_slope is None or the_slope is False:\\n the_slope = self.slope\\n the_y_intercept = self.y_intercept\\n\\n y = the_slope * x + the_y_intercept\\n\\n return Point(x, y)\",\n \"def intersect_point(self,m1,c1,m2,c2):\\n\\n x = (c2 - c1)/(m1 - m2)\\n y = m1*x + c1\\n return x, y\",\n \"def intersection(L1, L2):\\n D = L1[0] * L2[1] - L1[1] * L2[0]\\n Dx = L1[2] * L2[1] - L1[1] * L2[2]\\n Dy = L1[0] * L2[2] - L1[2] * L2[0]\\n if D != 0:\\n x = Dx / D\\n y = Dy / D\\n return x, y\\n else:\\n return False\",\n \"def get_intersection(self, l, max_y=None):\\n\\n # Get the points\\n i, j = self.breakpoint\\n\\n # Initialize the resulting point\\n result = Coordinate()\\n p: Coordinate = i\\n\\n # First we replace some stuff to make it easier\\n a = i.xd\\n b = i.yd\\n c = j.xd\\n d = j.yd\\n u = 2 * (b - l)\\n v = 2 * (d - l)\\n\\n # Handle the case where the two points have the same y-coordinate (breakpoint is in the middle)\\n if i.yd == j.yd:\\n result.xd = (i.xd + j.xd) / 2\\n\\n if j.xd < i.xd:\\n result.yd = max_y or float('inf')\\n return result\\n\\n # Handle cases where one point's y-coordinate is the same as the sweep line\\n elif i.yd == l:\\n result.xd = i.xd\\n p = j\\n elif j.yd == l:\\n result.xd = j.xd\\n else:\\n # We now need to solve for x\\n # 1/u * (x**2 - 2*a*x + a**2 + b**2 - l**2) = 1/v * (x**2 - 2*c*x + c**2 + d**2 - l**2)\\n # Then we let Wolfram alpha do the heavy work for us, and we put it here in the code :D\\n x = -(Decimal.sqrt(\\n v * (a ** 2 * u - 2 * a * c * u + b ** 2 * (u - v) + c ** 2 * u) + d ** 2 * u * (v - u) + l ** 2 * (\\n u - v) ** 2) + a * v - c * u) / (u - v)\\n result.xd = x\\n\\n # We have to re-evaluate this, since the point might have been changed\\n a = p.xd\\n b = p.yd\\n x = result.xd\\n u = 2 * (b - l)\\n\\n # Handle degenerate case where parabolas don't intersect\\n if u == 0:\\n result.yd = float(\\\"inf\\\")\\n return result\\n\\n # And we put everything back in y\\n result.yd = 1 / u * (x ** 2 - 2 * a * x + a ** 2 + b ** 2 - l ** 2)\\n return result\",\n \"def fce(B):\\n return wce(B)/(2.*np.pi)\",\n \"def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\\n # Convert latitude, longitude, azimuth of the begining point to radians\\n lat1 = math.radians(begin_lat)\\n lon1 = math.radians(begin_lon)\\n alfa1 = math.radians(begin_azimuth)\\n\\n sinAlfa1 = math.sin(alfa1)\\n cosAlfa1 = math.cos(alfa1)\\n \\n # U1 - reduced latitude\\n tanU1 = (1 - f) * math.tan(lat1)\\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\\n sinU1 = tanU1 * cosU1\\n \\n # sigma1 - angular distance on the sphere from the equator to begining point\\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\\n \\n # sinAlfa - azimuth of the geodesic at the equator\\n sinAlfa = cosU1 * sinAlfa1\\n cosSqAlfa = 1 - sinAlfa * sinAlfa\\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\\n A = 1 + uSq/16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\\n B = uSq/1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\\n \\n sigma = distance / (b * A)\\n sigmap = 1\\n \\n while (math.fabs(sigma - sigmap) > 1e-12):\\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\\n sinSigma = math.sin(sigma)\\n cosSigma = math.cos(sigma)\\n dSigma = B*sinSigma*(cos2sigmaM+B/4*(cosSigma*(-1+2*cos2sigmaM*cos2sigmaM)-B/6*cos2sigmaM*(-3+4*sinSigma*sinSigma)*(-3+4*cos2sigmaM*cos2sigmaM))) \\n sigmap = sigma\\n sigma = distance / (b * A) + dSigma\\n \\n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1\\n \\n # Latitude of the end point in radians\\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma*cosAlfa1, (1 - f)*math.sqrt(sinAlfa * sinAlfa + var_aux*var_aux))\\n \\n lamb = math.atan2 (sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\\n L = lamb - (1 - C) * f * sinAlfa *(sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\\n # Longitude of the second point in radians\\n lon2 = (lon1 + L +3*math.pi)%(2*math.pi) - math.pi\\n \\n # Convert to decimal degrees\\n lat2_dd = math.degrees(lat2) \\n lon2_dd = math.degrees(lon2)\\n \\n return lat2_dd, lon2_dd\",\n \"def vincenty_direct_solution(begin_lat, begin_lon, begin_azimuth, distance, a, b, f):\\n # Convert latitude, longitude, azimuth of the begining point to radians\\n lat1 = math.radians(begin_lat)\\n lon1 = math.radians(begin_lon)\\n alfa1 = math.radians(begin_azimuth)\\n\\n sinAlfa1 = math.sin(alfa1)\\n cosAlfa1 = math.cos(alfa1)\\n\\n # U1 - reduced latitude\\n tanU1 = (1 - f) * math.tan(lat1)\\n cosU1 = 1 / math.sqrt(1 + tanU1 * tanU1)\\n sinU1 = tanU1 * cosU1\\n\\n # sigma1 - angular distance on the sphere from the equator to begining point\\n sigma1 = math.atan2(tanU1, math.cos(alfa1))\\n\\n # sinAlfa - azimuth of the geodesic at the equator\\n sinAlfa = cosU1 * sinAlfa1\\n cosSqAlfa = 1 - sinAlfa * sinAlfa\\n uSq = cosSqAlfa * (a * a - b * b) / (b * b)\\n A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))\\n B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))\\n\\n sigma = distance / (b * A)\\n sigmap = 1\\n\\n while (math.fabs(sigma - sigmap) > 1e-12):\\n cos2sigmaM = math.cos(2 * sigma1 + sigma)\\n sinSigma = math.sin(sigma)\\n cosSigma = math.cos(sigma)\\n dSigma = B * sinSigma * (cos2sigmaM + B / 4 * (\\n cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM) - B / 6 * cos2sigmaM * (\\n -3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2sigmaM * cos2sigmaM)))\\n sigmap = sigma\\n sigma = distance / (b * A) + dSigma\\n\\n var_aux = sinU1 * sinSigma - cosU1 * cosSigma * cosAlfa1 # Auxiliary variable\\n\\n # Latitude of the end point in radians\\n lat2 = math.atan2(sinU1 * cosSigma + cosU1 * sinSigma * cosAlfa1,\\n (1 - f) * math.sqrt(sinAlfa * sinAlfa + var_aux * var_aux))\\n\\n lamb = math.atan2(sinSigma * sinAlfa1, cosU1 * cosSigma - sinU1 * sinSigma * cosAlfa1)\\n C = f / 16 * cosSqAlfa * (4 + f * (4 - 3 * cosSqAlfa))\\n L = lamb - (1 - C) * f * sinAlfa * (\\n sigma + C * sinSigma * (cos2sigmaM + C * cosSigma * (-1 + 2 * cos2sigmaM * cos2sigmaM)))\\n # Longitude of the second point in radians\\n lon2 = (lon1 + L + 3 * math.pi) % (2 * math.pi) - math.pi\\n\\n # Convert to decimal degrees\\n lat2_dd = math.degrees(lat2)\\n lon2_dd = math.degrees(lon2)\\n\\n return lat2_dd, lon2_dd\",\n \"def get_barycentric_coord(self, ph):\\n a_v_1 = np.cross(ph - self.v0.position, self.v2.position - ph) / 2\\n a_v_2 = np.cross(ph - self.v1.position, self.v0.position - ph) / 2\\n s = np.dot(self.n, a_v_1) / self.area\\n t = np.dot(self.n, a_v_2) / self.area\\n return s, t\",\n \"def epipoles_location(f_mat):\\r\\n u, s, vh = np.linalg.svd(f_mat)\\r\\n e_l = vh[-1, :]\\r\\n e_r = u[:, -1]\\r\\n # get x, y by dividing by w\\r\\n e_l = (e_l[0] / e_l[2], e_l[1] / e_l[2])\\r\\n e_r = (e_r[0] / e_r[2], e_r[1] / e_r[2])\\r\\n return e_l, e_r\",\n \"def get_kernel(self, c, d, a, b):\\r\\n global t\\r\\n \\r\\n t=math.radians(t_) \\r\\n if a == 0 and b == 0:\\r\\n if c == 0 and d == 0:\\r\\n return complex((math.cos(t*frec)**2)+((e**2)*(math.sin(t*frec)**2)/(frec**2)),0)\\r\\n elif c == 0 and d == 1:\\r\\n return complex((e*o*(math.sin(t*frec))**2)/(frec**2),(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))) \\r\\n elif c == 1 and d == 0:\\r\\n return complex((e*o*(math.sin(t*frec))**2)/(frec**2),-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))) \\r\\n elif c == 1 and d == 1:\\r\\n return complex((o**2)*((math.sin(t*frec))**2)/(frec**2),0)\\r\\n \\r\\n \\r\\n elif a == 0 and b == 1:\\r\\n if c == 0 and d == 0:\\r\\n return complex((e*o*(math.sin(t*frec))**2/(frec**2)),((o*(math.sin(t*frec))*(math.cos(t*frec))/(frec)))) \\r\\n elif c == 0 and d == 1:\\r\\n return complex(((math.cos(t*frec))**2-((e**2)*(math.sin(t*frec))**2)/(frec**2)),(-(2*e)*(math.sin(t*frec)*math.cos(t*frec))/frec)) \\r\\n elif c == 1 and d == 0:\\r\\n return complex(((o**2)*(math.sin(t*frec)**2)/(frec**2)),0) \\r\\n elif c == 1 and d == 1:\\r\\n return complex((-(o*e)*(math.sin(t*frec)**2)/(frec**2)),(-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))))\\r\\n \\r\\n \\r\\n elif a == 1 and b == 0: \\r\\n \\r\\n if c == 0 and d == 0:\\r\\n return complex((((o*e)*(math.sin(t*frec))**2)/(frec**2)),(-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))))\\r\\n elif c == 0 and d == 1:\\r\\n return complex((((o**2)*(math.sin(t*frec))**2)/(frec**2)),0)\\r\\n elif c == 1 and d == 0:\\r\\n return complex(((math.cos(t*frec))**2-((e**2)*(math.sin(t*frec))**2)/(frec**2)),(2*e*(math.sin(t*frec)*math.cos(t*frec))/frec))\\r\\n elif c == 1 and d == 1:\\r\\n return complex((-((o*e)*(math.sin(t*frec))**2)/(frec**2)),((o*(math.sin(t*frec))*(math.cos(t*frec))/frec)))\\r\\n \\r\\n elif a == 1 and b == 1:\\r\\n if c == 0 and d == 0:\\r\\n return complex(((o**2)*(math.sin(t*frec))**2)/(frec**2),0)\\r\\n elif c == 0 and d == 1:\\r\\n return complex(-(((o*e)*(math.sin(t*frec))**2)/(frec**2)),-(o*(math.sin(t*frec))*(math.cos(t*frec))/(frec)))\\r\\n elif c == 1 and d == 0:\\r\\n return complex(-((o*e)*(math.sin(t*frec))**2)/(frec**2),o*(math.sin(t*frec))*(math.cos(t*frec))/(frec))\\r\\n elif c == 1 and d == 1:\\r\\n return complex((math.cos(t*frec))**2+((e**2)*(math.sin(t*frec))**2)/(frec**2),0)\",\n \"def intersection(line1, line2):\\n rho1, theta1 = line1\\n rho2, theta2 = line2\\n A = np.array([\\n [np.cos(theta1), np.sin(theta1)],\\n [np.cos(theta2), np.sin(theta2)]\\n ])\\n b = np.array([[rho1], [rho2]])\\n x0, y0 = np.linalg.solve(A, b)\\n x0, y0 = int(np.round(x0)), int(np.round(y0))\\n return [x0, y0]\",\n \"def center_of_bees(self):\\n pos, com, success = self.perception\\n return around(sum(pos)/(len(pos) + 1))\",\n \"def intersection(v1, v2):\\n x = v1[0:2] + v2[0:2]\\n y = v1[2:4] + v2[2:4]\\n if( x[3] == 0 ): #To avoid a divide by zero, if x[3] is 0 then we just solve for where lineA equals x[2]\\n t1 = (x[2] - x[0])/\\\\\\n (x[1])\\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]\\n\\n else: \\n t1 = ( y[0] - y[2] + (y[3]/x[3])*(x[2] - x[0]) )/\\\\\\n ( (y[3]*x[1])/x[3] - y[1] )\\n return [ v1[0] + v1[1]*t1, v1[2] + v1[3]*t1 ]\",\n \"def intersection(boxes, box):\\n ix = np.maximum(0, np.minimum(box[2], boxes[:,2]) - np.maximum(box[0], boxes[:,0]))\\n iy = np.maximum(0, np.minimum(box[3], boxes[:,3]) - np.maximum(box[1], boxes[:,1]))\\n return ix*iy\",\n \"def _getReliefFcn(self, centerx, centery, a, b, angle):\\n\\n if a == 0 or b == 0:\\n return (lambda x, y: 0)\\n\\n def f(x, y):\\n center = Vect(centerx, centery)\\n point = Vect(x, y)\\n # angle coord of the point with respect to the ellipse center:\\n phi = point.getAngle(center)\\n # radial coord of the point with respect to the ellipse center:\\n r = abs(point - center)\\n # radial coord of the ellipse border at angle phi:\\n elRadius = (a*b) / math.sqrt(a**2 * math.sin(phi - angle)**2 +\\n b**2 * math.cos(phi - angle)**2)\\n\\n if r <= elRadius:\\n # (x, y) is inside\\n return 1\\n else:\\n # (x, y) is outside\\n return 0\\n return f\",\n \"def calc_main_axis(self):\\n #Clarify why the above step has been done\\n c0, c1, c2 = self.calc_geom_center ()\\n M = numpy.zeros ((3, 3), dtype=float)\\n M = [[0] * 3, [0] * 3, [0] * 3]\\n for x in self.atomcoords:\\n xi = x[0] - c0\\n yi = x[1] - c1\\n zi = x[2] - c2\\n M[0][0] = M[0][0] + xi * xi\\n M[0][1] = M[0][1] + xi * yi\\n M[0][2] = M[0][2] + xi * zi\\n M[1][1] = M[1][1] + yi * yi\\n M[1][2] = M[1][2] + yi * zi\\n M[2][2] = M[2][2] + zi * zi\\n M[1][0] = M[0][1]\\n M[2][0] = M[0][2]\\n M[2][1] = M[1][2]\\n M = numpy.array (M)\\n d = sum (numpy.diag (M))\\n M = -M\\n M[0, 0] = M[0, 0] + d\\n M[1, 1] = M[1, 1] + d\\n M[2, 2] = M[2, 2] + d\\n\\n eigenVals, eigenVecs = numpy.linalg.eig (M)\\n eigenVecs = eigenVecs.transpose ()\\n return eigenVecs\",\n \"def find_intersection(A, B, C, D):\\n \\n a1, b1, c1 = line_equation(A.x, A.y, B.x, B.y)\\n a2, b2, c2 = line_equation(C.x, C.y, D.x, D.y)\\n \\n Y = - np.array([[c1],\\n [c2]])\\n M = np.array([[a1, b1],\\n [a2, b2]])\\n\\n X = np.linalg.solve(M, Y)\\n intersection = Coordinates(X[0], X[1])\\n \\n return intersection\",\n \"def coefA(x0,y0,x1,y1):\\n return -(y1-y0)/(x1-x0)\",\n \"def get_intersect(a1, a2, b1, b2):\\n s = np.vstack([a1, a2, b1, b2]) # s for stacked\\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\\n l1 = np.cross(h[0], h[1]) # get first line\\n l2 = np.cross(h[2], h[3]) # get second line\\n x, y, z = np.cross(l1, l2) # point of intersection\\n if z == 0: # lines are parallel\\n return float('inf'), float('inf')\\n return x / z, y / z\",\n \"def find_root(function, point_a, point_b, step, tol, max_iterations, \\n show_process = False):\\n left_point , right_point = search_interval_3d(function, point_a, point_b, \\n step, tol, max_iterations,\\n show_process)\\n \\n point_where_zero = bisection_3d(function, left_point, right_point, tol, \\n max_iterations, show_process)\\n \\n return point_where_zero\",\n \"def intersection_area(self, footprint):\\n dx = min(self.upperright[0], footprint.upperright[0]) - max(self.upperleft[0], footprint.upperleft[0])\\n dy = min(self.bottomright[1], footprint.bottomright[1]) - max(self.upperright[1], footprint.upperright[1])\\n #assert dx >= 0\\n #assert dy >= 0\\n return dx * dy\",\n \"def find_ordinate(x_value, a_value, b_value, field):\\n\\n # y_value may be found by simple substitution of x_value in the equation\\n return (int(pow(x_value, 3, field)) + a_value * x_value + b_value) % field\",\n \"def line_sphere_intersection(p1, p2, c, r):\\n\\t# FILL in your code here\\n\\n\\tline_vector=np.subtract(p2,p1) #np.array([p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2] ])\\n\\tval=np.sqrt(np.sum([(p2 - p1)**2\\n\\t\\t\\t\\t\\t\\t for p1, p2 in zip(p1,p2)]))\\n\\n\\tif val==0:\\n\\t\\tunit_vector=np.array([0,0,0])\\n\\telse:\\n\\t\\tunit_vector=[linevec/val for linevec in line_vector]\\n\\tvecO_C=np.subtract(p1,c)\\n\\t\\t\\n\\tres=np.dot(unit_vector,vecO_C)* np.dot(unit_vector,vecO_C) - ( np.dot(vecO_C, vecO_C) - r*r )\\n\\treturn res\",\n \"def intersection(line1, line2):\\n p0, p1, p2, p3 = map(\\n lambda tup : np.array(tup[:2]),\\n [line1[0], line1[1], line2[0], line2[1]]\\n )\\n p1, p2, p3 = map(lambda x : x - p0, [p1, p2, p3])\\n transform = np.zeros((2, 2))\\n transform[:,0], transform[:,1] = p1, p2\\n if np.linalg.det(transform) == 0: return\\n inv = np.linalg.inv(transform)\\n new_p3 = np.dot(inv, p3.reshape((2, 1)))\\n #Where does line connecting (0, 1) to new_p3 hit x axis\\n x_intercept = new_p3[0] / (1 - new_p3[1]) \\n result = np.dot(transform, [[x_intercept], [0]])\\n result = result.reshape((2,)) + p0\\n return result\",\n \"def intersection(line1, line2):\\r\\n rho1, theta1 = line1[0]\\r\\n rho2, theta2 = line2[0]\\r\\n A = np.array([[np.cos(theta1), np.sin(theta1)], [np.cos(theta2), np.sin(theta2)]])\\r\\n b = np.array([[rho1], [rho2]])\\r\\n x0, y0 = np.linalg.solve(A, b)\\r\\n x0, y0 = int(np.round(x0)), int(np.round(y0))\\r\\n return [[x0, y0]]\",\n \"def hausdorffDistance(self,fiber1,fiber2):\\n polyA = fiber1.GetPolyData()\\n polyB = fiber2.GetPolyData()\\n\\n locA = vtk.vtkMergePoints()\\n locB = vtk.vtkMergePoints()\\n\\n locA.SetDataSet(polyA)\\n locB.SetDataSet(polyB)\\n\\n locs = (locA,locB)\\n for loc in locs:\\n loc.AutomaticOn()\\n loc.BuildLocator()\\n\\n ptsA = polyA.GetPoints()\\n ptsB = polyB.GetPoints()\\n\\n rangeA = ptsA.GetNumberOfPoints()\\n rangeB = ptsB.GetNumberOfPoints()\\n\\n maxd = 0.0\\n maxd1 = 0.0\\n avgd = 0.0\\n avgd1 = 0.0\\n\\n distanceA = vtk.vtkFloatArray()\\n distanceA.SetName(\\\"Distance\\\")\\n for i in range(rangeA):\\n pt = ptsA.GetPoint(i)\\n bid = locB.FindClosestPoint(pt)\\n ptb = ptsB.GetPoint(bid)\\n d = self.pointDistance(pt,ptb)\\n distanceA.InsertNextValue(d)\\n avgd += d\\n if d > maxd:\\n maxd = d\\n avgd = avgd / rangeA\\n\\n distanceB = vtk.vtkFloatArray()\\n distanceB.SetName(\\\"Distance\\\")\\n for i in range(rangeB):\\n pt = ptsB.GetPoint(i)\\n bid = locA.FindClosestPoint(pt)\\n ptb = ptsA.GetPoint(bid)\\n d = self.pointDistance(pt,ptb)\\n distanceB.InsertNextValue(d)\\n avgd1 += d\\n if d > maxd1:\\n maxd1 = d\\n avgd1 = avgd1 / rangeB\\n\\n polyA.GetPointData().SetScalars(distanceA)\\n polyB.GetPointData().SetScalars(distanceB)\\n\\n return max(maxd,maxd1)\",\n \"def compute_y_intersection(x, x1, x2, y1, y2):\\n delta_x = x2 - x1\\n if delta_x == 0:\\n return x1\\n return ((x - x1) * (y2 - y1) / delta_x) + y1\",\n \"def calculate_y_axis_intersect(p, m):\\n return p[1] - (m * p[0])\",\n \"def calculate_intersections(self,P1,Q1,P2,Q2):\\n x=(Q2[:,:,1]-Q1[:,:,1]-P2[:,:,1]/P2[:,:,2]*(Q2[:,:,2]-Q1[:,:,2]))/(P1[:,:,1]-P1[:,:,2]*P2[:,:,1]/P2[:,:,2])\\n return Q1+x[:,:,np.newaxis]*P1,x\",\n \"def intersection(line1, line2):\\n\\n rho1, theta1 = line1[0]\\n rho2, theta2 = line2[0]\\n A = np.array([\\n [np.cos(theta1), np.sin(theta1)],\\n [np.cos(theta2), np.sin(theta2)]\\n ])\\n b = np.array([[rho1], [rho2]])\\n x0, y0 = np.linalg.solve(A, b)\\n x0, y0 = int(np.round(x0)), int(np.round(y0))\\n\\n return [x0, y0]\",\n \"def calculateElementBoundaryCoefficients(self):\\n pass\",\n \"def get_intersect(a1, a2, b1, b2):\\r\\n s = np.vstack([a1,a2,b1,b2]) # s for stacked\\r\\n h = np.hstack((s, np.ones((4, 1)))) # h for homogeneous\\r\\n l1 = np.cross(h[0], h[1]) # get first line\\r\\n l2 = np.cross(h[2], h[3]) # get second line\\r\\n x, y, z = np.cross(l1, l2) # point of intersection\\r\\n if z == 0: # lines are parallel\\r\\n return (float('inf'), float('inf'))\\r\\n return (x/z, y/z)\",\n \"def compute_x_intersection(y, x1, x2, y1, y2):\\n delta_y = y2 - y1\\n if delta_y == 0:\\n return x1\\n return ((y - y1) * (x2 - x1) / delta_y) + x1\",\n \"def ball_intersection_check(r0, step, radius): \\n t = -(step[0]*r0[0] + step[1]*r0[1] + step[2]*r0[2]) + math.sqrt((step[0]*r0[0] + step[1]*r0[1] + step[2]*r0[2])**2 \\\\\\n - (r0[0]**2+r0[1]**2+r0[2]**2) + radius**2)\\n return t\",\n \"def __getxyB(x, y):\\n\\t\\treturn x*3+y\",\n \"def midpoint(self,i,f):\\n\\n summation = self.points[f, :] + self.points[i, :]\\n midploint = summation/2\\n x_mid = midploint[0]\\n y_mid = midploint[1]\\n\\n return x_mid,y_mid\",\n \"def find_inplane_to_match(phiA,thetaA,phiB,thetaB,psiA=0,psiB=0):\\n\\t#from math import pi, sqrt, cos, acos, sin\\n\\n\\tRA = Transform({'type': 'spider', 'phi': phiA, 'theta': thetaA, 'psi': psiA})\\n\\tRB = Transform({'type': 'spider', 'phi': phiB, 'theta': thetaB, 'psi': psiB})\\n\\tRBT = RB.transpose()\\n\\tRABT = RA * RBT\\n\\n\\tRABTeuler = RABT.get_rotation('spider')\\n\\tRABTphi = RABTeuler['phi']\\n\\tRABTtheta = RABTeuler['theta']\\n\\tRABTpsi = RABTeuler['psi']\\n\\n\\t#deg_to_rad = pi/180.0\\n\\t#thetaAR = thetaA*deg_to_rad\\n\\t#thetaBR = thetaB*deg_to_rad\\n\\t#phiAR = phiA*deg_to_rad\\n\\t#phiBR = phiB *deg_to_rad\\n\\n\\t#d12=cos(thetaAR)*cos(thetaBR) + sin(thetaAR)*sin(thetaBR)*cos(phiAR-phiBR)\\n\\treturn (-RABTpsi-RABTphi),RABTtheta # 180.0*acos(d12)/pi;\",\n \"def __call__(\\n self, left: TFTBoxTensor, right: TFTBoxTensor\\n ) -> TFTBoxTensor:\\n\\n return tf_hard_intersection(left, right)\",\n \"def bBoxMiddle(bBox):\\n x0, y0 = bBox[0]\\n x1, y1 = bBox[1]\\n return (x0 + x1) / 2 , (y0 + y1) /2\",\n \"def an_intersection(v1, b1):\\n try:\\n return intersection(v1, b1, np.array([1,1]), 0)\\n except np.linalg.linalg.LinAlgError:\\n print v1\\n return intersection(v1, b1, np.array([-1,1]), 0)\",\n \"def midpoint(ptA, ptB):\\n return( (ptA[0] + ptB[0]) * 0.5, (ptA[1]+ ptB[1]) * 0.5 )\",\n \"def get_horizantal_b_reference(top_kp: Keypoint, middle_kp: Keypoint, bottom_kp: Keypoint) -> Keypoint:\\n vector_a = keypoint_to_vector(top_kp, middle_kp)\\n vector_c = keypoint_to_vector(bottom_kp, middle_kp)\\n # NOTE: checking angle_left_opening has the same effect as to check if biscetion point is positioned to the left or right of the neck point\\n angle_left_opening = np.cross(vector_a, vector_c) < 0\\n return Keypoint(middle_kp.x - 100, middle_kp.y) if angle_left_opening else Keypoint(middle_kp.x + 100, middle_kp.y)\",\n \"def segmentsIntersect(self, other, allowProjInt = False):\\n \\n \\\"\\\"\\\"\\n If we are not allowing projected intersection and the bounding boxes\\n do not intersect then return -3, None.\\n \\\"\\\"\\\"\\n if(not(allowProjInt) and not(self.doBoundingBoxesIntersect(other))): return -3, None #return if bounding boxes do not intersect\\n \\\"\\\"\\\" A special case for colinear lines. \\\"\\\"\\\" \\n if(self.areColinear(other)):\\n \\\"\\\"\\\"\\n First place all four endpoint into a set. This will elliminate shared\\n end points. Next, convert the set back into a list so it can\\n finally be sorted.\\n \\\"\\\"\\\"\\n pointList = sorted(list(set([self.start, self.end, other.start, other.end])), key=self.calcT) \\n if len(pointList) == 3:\\n \\\"\\\"\\\"\\n if there are only three points in the list then return 2, the\\n middle point in the list since it is the shared point of the\\n two lines.\\n \\\"\\\"\\\"\\n return 2, pointList[1] #if they are colinear and two ends have the same point return that point\\n elif len(pointList) == 2:\\n \\\"\\\"\\\" If the two lines have the same endpoints. \\\"\\\"\\\"\\n return 2.5, self.getMidPoint()\\n else:\\n \\\"\\\"\\\"\\n If the length was not three then we know it is length 4 in which case\\n we turn the two middle points into a line and return 3, the line's\\n midpoint.\\n \\\"\\\"\\\"\\n tempLine = Line(pointList[1], pointList[2])\\n return 3, tempLine.getMidPoint() #If they are colinear return half way inbetween middle two points\\n \\\"\\\"\\\"\\n To calculate the intersection of two points we put the lines into the\\n form P+tr and Q+us where P and Q are the starting points of the lines\\n r and s are vectors form the starting point to the end point, and\\n t and u are scalars. Set the two equations equal to each other and \\n then solve for t and u. If t and u are in the range [0-1] then the\\n intersection point lines on the lines, else it is a projected point.\\n \\\"\\\"\\\"\\n r = np.subtract(self.end.get2DPoint(), self.start.get2DPoint())\\n s = np.subtract(other.end.get2DPoint(), other.start.get2DPoint())\\n Q_Less_P = np.subtract(other.start.get2DPoint(), self.start.get2DPoint())\\n denom = np.cross(r, s)*1.0\\n t = np.cross(Q_Less_P, s)/denom\\n u = np.cross(Q_Less_P, r)/denom \\n point = p.Point(self.start.x + r[c.X]*t, self.start.y+r[c.Y]*t) \\n #If t or u are not in the range 0-1 then the intersection is projected\\n if(t > 1 or u > 1 or t < 0 or u < 0):\\n \\\"\\\"\\\"\\n Due to floating point problems sometimes if t or u is outside the 0-1\\n range we end up inside this if statement but are actually at the end\\n of one of the lines. I can't figure out how to properly add in a tolerance\\n so we are taking the four end points putting them into a list,\\n then comparing them to the calculated point. The Point module is\\n properly handling tolerances so if the point == any of the end\\n points then we should not return a projected point.\\n \\\"\\\"\\\"\\n if not any(point == lineEnd for lineEnd in (self.start, self.end,\\n other.start, other.end)):\\n return -1, point #return for projected intersection of non-colinear lines\\n return 1, point #lines intersect at given point\",\n \"def getCurvature(f,x):\\n df = f.derivative(nu=1)(x)\\n ddf = f.derivative(nu=2)(x)\\n k = ddf/pow(1-df*df,3/2)\\n return k, abs(1.0/k)\",\n \"def overlap(self, psi_1, psi_2):\\n return self.dx * np.sum(np.min(np.c_[self.density(psi_1), self.density(psi_2)], 1))\",\n \"def intersection(eqn0, eqn1):\\n x = (eqn1[1] - eqn0[1]) / (eqn0[0] - eqn1[0])\\n return (x, apply_eqn(eqn0, x))\",\n \"def intersectsAB(self, ray):\\n v1 = ray.origin - self.pointA\\n v2 = self.pointB - self.pointA\\n v3 = Point(-ray.direction.y, ray.direction.x)\\n dot = v2.dot(v3)\\n if (abs(dot) < 0.000001):\\n return None\\n t1 = v2.cross(v1) / dot\\n t2 = v1.dot(v3) / dot\\n if (t1 >= 0.0 and (t2 >= 0.0 and t2 <= 1.0)):\\n return t1\\n return None\",\n \"def intersectConics(E1, E2):\\n\\n P = np.array([])\\n r1 = matrix_rank(E1)\\n r2 = matrix_rank(E2)\\n \\n if(r1==3 and r2==3):\\n P = completeIntersection(E1,E2) \\n else:\\n if (r2 < 3): #E2 is degenerate\\n defE = E2\\n fullE = E1\\n else:\\n defE = E1 #E1 is degenerate\\n fullE = E2\\n m, l = decomposeDegenerateConic(defE)\\n P1 = intersectConicLine(fullE,m)\\n P2 = intersectConicLine(fullE,l)\\n P = np.array([P1, P2])\\n points_x = []\\n points_y = []\\n for i in range(2):\\n P1 = P[i]\\n if(P1.size!=0):\\n for j in range(P1.shape[0]):\\n points_x.append(P1[j,0]/P1[j,2])\\n points_y.append(P1[j,1]/P1[j,2])\\n return points_x, points_y\",\n \"def find_intersection(center0, direction0, center1, direction1):\\n # c0 + d0 t = c1 + d1 s\\n # (-d0) t + (d1) s = c0 - c1\\n # [-d0, d1] [t,s]^T = delta\\n A = np.array([-direction0, direction1]).T\\n delta = center0 - center1\\n # Unpack M = A^T * A:\\n # [[a, b],\\n # [c, d]]\\n (a, b), (c, d) = A.T.dot(A)\\n # Inverse of M:\\n # 1/ det(M) [[ d, -b],\\n # [-c, a]]\\n M_inv = np.array([[d, -b], [-c, a]]) / (a * d - b * c)\\n t, s = M_inv.dot(A.T.dot(delta))\\n return t, s\",\n \"def get_x(EQ, M):\\n return (EQ[0] * (EQ[0] * M[0] - EQ[1] * M[1]) - EQ[1] * EQ[2]) / (EQ[1] ** 2 + EQ[0] ** 2)\",\n \"def planeLineIntersect(p1, p2, equ):\\n n = vector(equ[0], equ[1], equ[2])\\n v1, v2 = vector(p1), vector(p2)\\n t = (equ[3] - n.dotProduct(v2)) / (n.dotProduct(v1 - v2))\\n return (t * v1 + (1 - t) * v2).coords()\",\n \"def getVisualFieldOrigin(self):\\r\\n\\r\\n if not hasattr(self, 'finalPatchesMarked'):\\r\\n raise LookupError('Please mark the final patches first!!')\\r\\n\\r\\n if not hasattr(self, 'altPosMapf'):\\r\\n _ = self._getSignMap()\\r\\n\\r\\n try:\\r\\n V1 = self.finalPatchesMarked['V1'].array.astype(np.float)\\r\\n LM = self.finalPatchesMarked['LM'].array.astype(np.float)\\r\\n RL = self.finalPatchesMarked['RL'].array.astype(np.float)\\r\\n\\r\\n overlap = 0 # number of overlaping pixels\\r\\n iterNum = 1 # number of iteration\\r\\n while overlap < 1:\\r\\n # print 'Iteration number for finding overlapping pixel:', iterNum\\r\\n V1 = ni.morphology.binary_dilation(V1, iterations=1).astype(np.float)\\r\\n LM = ni.morphology.binary_dilation(LM, iterations=1).astype(np.float)\\r\\n RL = ni.morphology.binary_dilation(RL, iterations=1).astype(np.float)\\r\\n totalField = V1 + LM + RL\\r\\n # plt.imshow(totalField)\\r\\n overlap = len(np.argwhere(totalField == 3))\\r\\n iterNum += 1\\r\\n # print 'Number of overlapping pixels:', overlap\\r\\n # plt.show()\\r\\n\\r\\n altPosOrigin = np.mean(self.altPosMapf[totalField == 3], axis=0)\\r\\n aziPosOrigin = np.mean(self.aziPosMapf[totalField == 3], axis=0)\\r\\n\\r\\n except KeyError:\\r\\n print('Can not find necessary visual areas (V1, LM, RL) for normalization. \\\\nSetting origins to 0 ...')\\r\\n altPosOrigin = 0.\\r\\n aziPosOrigin = 0.\\r\\n\\r\\n return altPosOrigin, aziPosOrigin\",\n \"def central_x(self, func):\\n\\n roll_left = np.roll(func, -1, axis=1)\\n roll_right = np.roll(func, 1, axis=1)\\n f_dx = (roll_left - roll_right) / (2 * self.dx)\\n return f_dx\",\n \"def make_q(v0, v2):\\n return (v0.y - v2.y)/(v0.x - v2.x)\",\n \"def dist2cax(self) -> float:\\n # TODO: see about using line and built-in dist to point.\\n center_fit = np.poly1d(self.fit)\\n if self.orientation == Orientation.UP_DOWN:\\n length = self.image.shape[0]\\n else:\\n length = self.image.shape[1]\\n x_data = np.arange(length)\\n y_data = center_fit(x_data)\\n idx = int(round(len(x_data) / 2))\\n if self.orientation == Orientation.UP_DOWN:\\n axis = \\\"x\\\"\\n p1 = Point(y_data[idx], x_data[idx])\\n else:\\n axis = \\\"y\\\"\\n p1 = Point(x_data[idx], y_data[idx])\\n return (getattr(self.image.center, axis) - getattr(p1, axis)) / self.image.dpmm\",\n \"def princ_axes(self):\\r\\n # get coordinates of mesh\\r\\n coords = BoundaryMesh(self.mesh,\\\"exterior\\\",True).coordinates()\\r\\n\\r\\n # get distances\\r\\n dist = np.sqrt(np.einsum('ij->i', np.square(coords)))\\r\\n\\r\\n # get maximal value\\r\\n maxind = np.argmax(dist)\\r\\n maxdist = dist[maxind]\\r\\n\\r\\n # get minimal value\\r\\n minind = np.argmin(dist)\\r\\n mindist = dist[minind]\\r\\n\\r\\n # find coordinates of maximal and minimal points\\r\\n maxax = coords[maxind, :]\\r\\n minax = coords[minind, :]\\r\\n\\r\\n # get the cross product of these vectors,\\r\\n # which is the ideal mid-size axis\\r\\n idealax = np.cross(maxax,minax)\\r\\n\\r\\n # get the dot product of this ideal axis with the coordinates,\\r\\n # take the absolute value, and find the index of the maximum\\r\\n secind = np.argmax(np.abs(np.einsum('j,ij->i',idealax,coords)))\\r\\n\\r\\n # get the second-axis distance\\r\\n secdist = dist[secind]\\r\\n\\r\\n return([maxdist, secdist, mindist], [\\\"a\\\", \\\"b\\\", \\\"c\\\"])\",\n \"def intersect(box_a, box_b):\\n #taken from fastai\\n max_xy = torch.min(box_a[:, None, 2:], box_b[None, :, 2:])\\n min_xy = torch.max(box_a[:, None, :2], box_b[None, :, :2])\\n inter = torch.clamp((max_xy - min_xy), min=0)\\n return inter[:, :, 0] * inter[:, :, 1]\",\n \"def implicit_surface(self, F, y):\\n y = y[:, :, None].expand(-1, -1, self.n_primitives, -1)\\n y_latent, ldj = self.invertible_network.inverse(F, y)\\n norm = torch.sqrt((y_latent**2).sum(-1))\\n\\n # <0 denotes internal points\\n # >0 denotes external points\\n # 0 is the boundary hence our primitive\\n return norm - self.radius, ldj\",\n \"def _arcArcIntersectXY(c1,c2,inside=True,params=False):\\n x1=c1[0]\\n x2=c2[0]\\n r1=c1[1][0]\\n r2=c2[1][0]\\n\\n # check for sample reverse condition\\n sr1 = c1[1][3]==-2\\n sr2 = c2[1][3]==-2\\n\\n ## first check for non-intersection due to distance between the\\n ## centers of the arcs, treating both arcs as circles for the moment\\n\\n d=dist(x1,x2) #calculate the distance d between circle centers\\n\\n if d > r1+r2:\\n return False # too far, no possiblity of intersection\\n\\n if ( r1> r2 and d < r1-r2) or (r2 >= r1 and d < r2-r1):\\n return False # too close, little arc is fully inside bigger arc\\n\\n if d < epsilon:\\n return False # circle centers too close for stable calculation\\n\\n ## OK, we are in the goldilocks zone of intersection. this means\\n ## that if boh arcs are cicles or if inside=False we are\\n ## guaranteed one or two intersections. Calculate those\\n ## intersections and then test to see if they fall between start\\n ## and end of the respective arcs\\n\\n ## we start by calculating the distance id of the intersection plane\\n ## from the center of arc 1, knowing that by definition id <= r1\\n\\n ## Math: consider the triangle with side lengths r1, r2, and d,\\n ## where d is the previously calculated distance between arc\\n ## centers. Consider the two right triangles with side lengths\\n ## r1, id, h, and r2, h, (d-id). We know that:\\n ## id^2 + h^2 = r1^2, (d-id)^2 + h^2 = r2^2\\n ## solving both for h2 and then substituting, this means:\\n ## r1^2 - id^2 = r2^2 - (d-id)^2\\n ## collecting terms and solving for id produces:\\n ## id = (r1^2-r2^2 + d^2)/2d\\n\\n id = (r1*r1 - r2*r2 + d*d)/(2 * d)\\n\\n ## compute the point on the line connecting the two arc centers\\n ## that is id away from the first arc\\n\\n v1 = scale3(sub(x2,x1),1.0/d) # unitary direction vector pointing\\n # from x1 to x2\\n v2 = scale3(v1,id) # point on line between two circles in\\n # coordinate space centered at x1\\n\\n ## compute direction vector o orthgonal to v1 -- the line that\\n ## intersects point v2 and v2+o will pass through our intersection\\n ## points\\n\\n o = orthoXY(v1)\\n \\n ## now, transform back into world coordinates and calculate the\\n ## intersection of this line with either of our arcs, treating\\n ## them as circles for now\\n\\n l = [add(v2,x1),add(add(v2,o),x1)]\\n\\n s = _lineArcIntersectXY(l,c1,False)\\n\\n ## as a sanity check, do the same with the other arc. Results\\n ## should be within epsilon\\n #ss = _lineArcIntersectXY(l,c2,False)\\n #foo = list(map(lambda x, y: dist(x,y) < epsilon,s,ss))\\n #print(\\\"sanity check: \\\" , foo)\\n\\n if not s or len(s) == 0:\\n raise ValueError('no computed intersections, something is wrong')\\n\\n if not inside and not params:\\n return s\\n \\n ## jump back to arc1 and arc2 space and check angles\\n\\n s1 = list(map(lambda x: sub(x,x1),s))\\n s2 = list(map(lambda x: sub(x,x2),s))\\n\\n ## compute start and end angles for arcs\\n start1=c1[1][1]\\n end1=c1[1][2]\\n if not (start1 == 0 and end1 == 360):\\n start1 = start1 % 360.0\\n end1 = end1 % 360.0\\n if end1 < start1:\\n end1 = end1 + 360.0\\n \\n start2=c2[1][1]\\n end2=c2[1][2]\\n \\n if not (start2 == 0 and end2 == 360):\\n start2 = start2 % 360.0\\n end2 = end2 % 360.0\\n if end2 < start2:\\n end2 = end2 + 360.0\\n \\n\\n ## check each intersection against angles for each arc. \\n ss = []\\n uparam1 = []\\n uparam2 = []\\n for i in range(len(s)):\\n p1 =s1[i]\\n p2 =s2[i]\\n ang1 = (atan2(p1[1],p1[0]) % pi2)*360.0/pi2\\n ang2 = (atan2(p2[1],p2[0]) % pi2)*360.0/pi2\\n\\n if params:\\n u1 = 0\\n u2 = 0\\n if end1 <= 360.0 or ang1 >= start1 or \\\\\\n ( end1 > 360.0 and ang1 > end1-360.0):\\n u1 = (ang1-start1)/(end1-start1)\\n if sr1:\\n u1 = 1.0-u1\\n elif end1 > 360.0:\\n u1 = (ang1+360.0-start1)/(end1-start1)\\n if sr1:\\n u1 = 1.0-u1\\n uparam1 = uparam1 + [ u1 ]\\n \\n if end2 <= 360.0 or ang2 >= start2 or \\\\\\n ( end2 > 360.0 and ang2 > end1-360.0):\\n u2 = (ang2-start2)/(end2-start2)\\n if sr2:\\n u2 = 1.0-u2\\n elif end2 > 360.0:\\n u2 = (ang2+360.0-start2)/(end2-start2)\\n if sr2:\\n u2 = 1.0-u2\\n uparam2 = uparam2 + [ u2]\\n \\n else:\\n good = False\\n ## check angle against first arc\\n if end1 <= 360.0 and ang1 >= start1 and ang1 <= end1:\\n good = True\\n elif end1 > 360.0 and (ang1 >= start1 or ang1<= end1-360.0):\\n good = True\\n\\n ## check angle against second arc\\n if end2 <= 360.0 and ang2 >= start2 and ang2 <= end2:\\n good = good and True\\n elif end2 > 360.0 and (ang2 >= start2 or ang2<= end2-360.0):\\n good = good and True\\n else:\\n good = False\\n\\n ## only add instersection to the list if both checks were passed\\n if good:\\n ss = ss + [ s[i] ]\\n \\n if not params and len(ss) == 0:\\n return False\\n else:\\n if params:\\n return [uparam1,uparam2]\\n else:\\n return ss\",\n \"def central_differences(f, h, x):\\n\\treturn (f(x + h) - f(x - h)) / (2 * h)\",\n \"def rectangle_circumference(a,b):\\n return (2*(a+b))\",\n \"def get_closest_intersection(wire1, wire2):\\n pass\",\n \"def E(q, r0, x, y):\\n den = np.hypot(x - r0[0], y - r0[1]) ** 3\\n return q * (x - r0[0]) / den, q * (y - r0[1]) / den\",\n \"def _intersection(self, ix, iy):\\n im = ix + iy # cv2.bitwise_or(ix, iy)\\n # freq = cytoolz.frequencies(im.ravel())\\n # hx = freq.get(1, 0) # x alone\\n # hy = freq.get(2, 0) # y alone\\n # ha = freq.get(3, 0) # x & y\\n\\n freq = np.bincount(im.ravel().astype(np.int64))\\n hx = freq[1] if len(freq) > 1 else 0\\n hy = freq[2] if len(freq) > 2 else 0\\n ha = freq[3] if len(freq) > 3 else 0\\n\\n return hx, hy, ha\",\n \"def test_10_kernels(self):\\n ra0, dec0 = CRVAL\\n res = 0.01 * DEG\\n\\n # Test zenithal -- (ra0, dec0) is the reference point.\\n for proj in ['TAN', 'ZEA']:\\n wcsk = coords.get_wcs_kernel(proj, ra0, dec0, res)\\n msg = f'Check crpix for {proj}'\\n self.assertAlmostEqual(wcsk.wcs.crpix[0], 1, delta=TOL_RAD, msg=msg)\\n self.assertAlmostEqual(wcsk.wcs.crpix[1], 1, delta=TOL_RAD, msg=msg)\\n\\n # Test cylindrical -- pixell puts the crval[1] on the equator\\n # and dec0 is used for the conformal latitude.\\n for proj in ['CAR', 'CEA']:\\n wcsk = coords.get_wcs_kernel(proj, ra0, dec0, res)\\n msg = f'Check crpix for {proj}'\\n self.assertAlmostEqual(wcsk.wcs.crpix[0], 1, delta=TOL_RAD, msg=msg)\\n self.assertNotAlmostEqual(wcsk.wcs.crpix[1], 1, delta=TOL_RAD, msg=msg)\\n\\n # This is going to break.\\n fp = FP(xi =[0., -0.01*DEG],\\n eta=[0., -0.01*DEG])\\n sight = get_sightline()\\n tod = core.AxisManager(core.LabelAxis('dets', ['a']))\\n fp = coords.get_footprint(tod, wcs_kernel=wcsk, focal_plane=fp, sight=sight)\",\n \"def intersect(box_a, box_b):\\n\\n max_xy = torch.min(box_a[:, 2:].unsqueeze(1), box_b[:, 2:].unsqueeze(0))\\n min_xy = torch.max(box_a[:, :2].unsqueeze(1), box_b[:, :2].unsqueeze(0))\\n inter = torch.clamp((max_xy - min_xy), min=0)\\n return inter[:, :, 0] * inter[:, :, 1]\",\n \"def __init__(self,v0,v1):\\n self.vinputs = v0,v1\\n self.xhi = max([v0[0],v1[0]])\\n self.yhi,self.ylo = v0[1]>v1[1] and (v0[1],v1[1],) or (v1[1],v0[1])\\n\\n self.m = (v1[0]-v0[0]) / (v1[1]-v0[1]) ### (x1-x0)/(y1-y0)\\n self.b = v0[0] - (v0[1] * self.m) ### x0 - y0*(x1-x0)/(y1-y0)\",\n \"def fCalc(self):\\n # A dictionary composed of all internal and boundary points\\n allPoints = dict(self.internalPoints.items() + self.boundaryPoints.items())\\n\\n for pointLabel in allPoints.keys():\\n # Compute fE, fW, fN and fW only for internal mesh points\\n if allPoints[pointLabel].type.lower() == 'internal':\\n xLabel = pointLabel[0]\\n yLabel = pointLabel[1]\\n x = self.internalPoints[(xLabel,yLabel)].x\\n y = self.internalPoints[(xLabel,yLabel)].y\\n xE = allPoints[(xLabel + 1,yLabel)].x\\n xW = allPoints[(xLabel - 1,yLabel)].x\\n yN = allPoints[(xLabel,yLabel + 1)].y\\n yS = allPoints[(xLabel,yLabel - 1)].y\\n \\n if (xE - x)/self.h < -0.000001 or (xE - x)/self.h > 1.000001:\\n errorMessage = '**Error! (xE - x)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (xE - x)/h = ' + str((xE - x)/self.h)\\n raise customError(errorMessage)\\n else:\\n self.internalPoints[(xLabel,yLabel)].fE = (xE - x)/self.h\\n\\n # Note that in the following we use -0.000001 and 1.000001 \\n # instead of 0 and 1, respectively, to avoid problems with\\n # with very small fractions. For example if the fractions is\\n # greater than one by 2.22e-16 the condition (x - xW)/self.h > 1\\n # will be false and the code returns an error\\n if (x - xW)/self.h < -0.000001 or (x - xW)/self.h > 1.000001:\\n errorMessage = '**Error! (x - xW)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (x - xW)/h = ' + str((x - xW)/self.h)\\n raise customError(errorMessage)\\n else:\\n self.internalPoints[(xLabel,yLabel)].fW = (x - xW)/self.h\\n \\n if (yN - y)/self.h < -0.000001 or (yN - y)/self.h > 1.000001:\\n errorMessage = '**Error! (yN - y)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (yN - y)/h = ' + str((yN - y)/self.h)\\n raise customError(errorMessage)\\n else:\\n self.internalPoints[(xLabel,yLabel)].fN = (yN - y)/self.h\\n \\n if (y - yS)/self.h < -0.000001 or (y - yS)/self.h > 1.000001:\\n errorMessage = '**Error! (y - yS)/h for the point with label ('+str(xLabel) + ',' + str(yLabel) + ') and coordinate (' + str(x) + ',' + str(y) + ') is not between zero and one: (y - yS)/h = ' + str((y - yS)/self.h)\\n raise customError(errorMessage)\\n else:\\n self.internalPoints[(xLabel,yLabel)].fS = (y - yS)/self.h\\n \\n # Calculate the coeeficients requried to compute the Laplacian \\n self.internalPoints[(xLabel,yLabel)].LapCoeffCalc()\",\n \"def F_cont(self):\\n x0 = self.edp_par['x0'].value\\n A = self.edp_par['A'].value\\n f1 = self.edp_par['f1'].value\\n f2 = self.edp_par['f2'].value\\n lr = self.latt_par['lambda_r'].value\\n w = 0.5 * (self.qx*x0 + self.qz*A)\\n arg1 = 0.5*self.qx*lr + w\\n arg2 = 0.5*self.qx*lr - w\\n fir = x0 * np.sin(w) / lr / w\\n sec = (lr-x0) * np.cos(0.5*arg1) * np.sin(arg2) / lr / np.cos(0.5*arg2) / arg2 \\n #sec = (-1)**self.k * (lr-x0) * sin(self.k*pi-w)/(self.k*pi-w)/lr\\n return (fir + f1*sec + 2*f2*np.cos(w)/lr)\",\n \"def cylinder_intersection_check(r0, step, orientation, radius): \\n A = 1 - (step[0]*orientation[0]+step[1]*orientation[1]+step[2]*orientation[2])**2\\n B = 2 * (r0[0]*step[0]+r0[1]*step[1]+r0[2]*step[2] - (r0[0]*orientation[0]+r0[1]*orientation[1]+r0[2]*orientation[2]) * (step[0]*orientation[0]+step[1]*orientation[1]+step[2]*orientation[2]))\\n C = r0[0]**2+r0[1]**2+r0[2]**2 - radius**2 -(r0[0]*orientation[0]+r0[1]*orientation[1]+r0[2]*orientation[2])**2 \\n t = (-B + math.sqrt(B**2 - 4*A*C)) / (2*A)\\n return t\",\n \"def intersection(self, other): # -> BaseGeometry:\\n ...\",\n \"def ccw(A, B, C):\\n return (B.x - A.x) * (C.y - A.y) > (B.y - A.y) * (C.x - A.x)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.646259","0.641344","0.6152979","0.5793187","0.57662004","0.5640328","0.5593812","0.55634004","0.55567926","0.5550685","0.55491304","0.5429276","0.5378254","0.537555","0.5375357","0.5359578","0.53533936","0.53409344","0.5306884","0.52935976","0.5290464","0.528548","0.52817166","0.52725816","0.52561563","0.5247264","0.52373934","0.5233181","0.52070564","0.520338","0.5198435","0.5177248","0.51771706","0.51723063","0.51549584","0.5154295","0.51535374","0.51493484","0.5139222","0.51329315","0.5131717","0.5130959","0.51274204","0.5124519","0.5124036","0.51231813","0.5121966","0.51216185","0.5120361","0.51198447","0.51154345","0.5100786","0.51004034","0.5091718","0.5074302","0.5071762","0.5069221","0.5066153","0.50643057","0.50642836","0.5061045","0.50606966","0.505079","0.5047638","0.5044566","0.50431204","0.5042627","0.5029655","0.5028366","0.50186217","0.50161064","0.50157243","0.5013986","0.50106746","0.5009315","0.5006876","0.50030696","0.50003886","0.49947786","0.49919796","0.49895084","0.49856162","0.49739656","0.49728665","0.49672607","0.49641076","0.49621814","0.4960939","0.49511784","0.49470145","0.49464113","0.49405485","0.49315608","0.49289787","0.49263385","0.4919405","0.49185753","0.49169862","0.49152064","0.49151352"],"string":"[\n \"0.646259\",\n \"0.641344\",\n \"0.6152979\",\n \"0.5793187\",\n \"0.57662004\",\n \"0.5640328\",\n \"0.5593812\",\n \"0.55634004\",\n \"0.55567926\",\n \"0.5550685\",\n \"0.55491304\",\n \"0.5429276\",\n \"0.5378254\",\n \"0.537555\",\n \"0.5375357\",\n \"0.5359578\",\n \"0.53533936\",\n \"0.53409344\",\n \"0.5306884\",\n \"0.52935976\",\n \"0.5290464\",\n \"0.528548\",\n \"0.52817166\",\n \"0.52725816\",\n \"0.52561563\",\n \"0.5247264\",\n \"0.52373934\",\n \"0.5233181\",\n \"0.52070564\",\n \"0.520338\",\n \"0.5198435\",\n \"0.5177248\",\n \"0.51771706\",\n \"0.51723063\",\n \"0.51549584\",\n \"0.5154295\",\n \"0.51535374\",\n \"0.51493484\",\n \"0.5139222\",\n \"0.51329315\",\n \"0.5131717\",\n \"0.5130959\",\n \"0.51274204\",\n \"0.5124519\",\n \"0.5124036\",\n \"0.51231813\",\n \"0.5121966\",\n \"0.51216185\",\n \"0.5120361\",\n \"0.51198447\",\n \"0.51154345\",\n \"0.5100786\",\n \"0.51004034\",\n \"0.5091718\",\n \"0.5074302\",\n \"0.5071762\",\n \"0.5069221\",\n \"0.5066153\",\n \"0.50643057\",\n \"0.50642836\",\n \"0.5061045\",\n \"0.50606966\",\n \"0.505079\",\n \"0.5047638\",\n \"0.5044566\",\n \"0.50431204\",\n \"0.5042627\",\n \"0.5029655\",\n \"0.5028366\",\n \"0.50186217\",\n \"0.50161064\",\n \"0.50157243\",\n \"0.5013986\",\n \"0.50106746\",\n \"0.5009315\",\n \"0.5006876\",\n \"0.50030696\",\n \"0.50003886\",\n \"0.49947786\",\n \"0.49919796\",\n \"0.49895084\",\n \"0.49856162\",\n \"0.49739656\",\n \"0.49728665\",\n \"0.49672607\",\n \"0.49641076\",\n \"0.49621814\",\n \"0.4960939\",\n \"0.49511784\",\n \"0.49470145\",\n \"0.49464113\",\n \"0.49405485\",\n \"0.49315608\",\n \"0.49289787\",\n \"0.49263385\",\n \"0.4919405\",\n \"0.49185753\",\n \"0.49169862\",\n \"0.49152064\",\n \"0.49151352\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50560206"},"document_rank":{"kind":"string","value":"62"}}},{"rowIdx":80597,"cells":{"query":{"kind":"string","value":"rotate point P about O by dtheta radians"},"document":{"kind":"string","value":"def rotate_point_by(P:Vec3, O:Vec3, dtheta:float):\n PO = P - O\n R = norm2(PO)\n cos_theta = PO.x / R\n sin_theta = PO.y / R\n cos_dtheta = cos(dtheta)\n sin_dtheta = sin(dtheta)\n cos_theta_plus_dtheta = cos_theta*cos_dtheta - sin_theta*sin_dtheta\n sin_theta_plus_dtheta = sin_theta*cos_dtheta + sin_dtheta*cos_theta\n return Vec3(cos_theta_plus_dtheta, sin_theta_plus_dtheta)*R + O"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def rotate_about(self, p, theta):\n result = self.clone()\n result.translate(-p.x, -p.y)\n result.rotate(theta)\n result.translate(p.x, p.y)\n return result","def rotate(self, theta, point):\n r = self - point\n x = r.x * math.cos(theta) - r.y * math.sin(theta)\n y = r.x * math.sin(theta) + r.y * math.cos(theta)\n return Point(point + x, point + y, *self[2:])","def rotate_about(self, p, theta):\n result = self.clone()\n result.slide(-p.x, -p.y)\n result.rotate(theta)\n result.slide(p.x, p.y)\n return result","def rotatePoint(self, point, dir=+1):\n pnew = np.zeros([len(point), point.shape[1], 2])\n pnew[:, :, 0] = point[:, :, 0]*self.ctheta + point[:, :, 1]*self.stheta*dir\n pnew[:, :, 1] = -point[:, :, 0] * \\\n self.stheta*dir + point[:, :, 1]*self.ctheta\n return pnew","def theta_rot(od, theta):\n rot_mat = np.array([[np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]])\n return rot_mat.dot(od)","def _rotate_point(origin, point, angle):\n\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def my_rodriguez_rotation(P, k, theta):\n\n P_rot = np.zeros((len(P), 3))\n\n for i in range(len(P)):\n P_rot[i] = P[i]*np.cos(theta) + np.cross(k, P[i])*np.sin(theta) + \\\n k*np.dot(k, P[i])*(1.0-np.cos(theta))\n\n return P_rot","def rotate(origin, point, angle): # Library export\r\n ox, oy = origin\r\n px, py = point\r\n\r\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\r\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\r\n return (qx, qy)","def rotate((x, y), theta):\n\n return math.cos(theta) * x + math.sin(theta) * y, -math.sin(theta) * x + math.cos(theta) * y","def rotate(self, theta, o=None):\n if o is None:\n o = Vector2(0, 0)\n x = o.x + math.cos(theta) * (self.x - o.x) - math.sin(theta) * (self.y - o.y)\n y = o.y + math.sin(theta) * (self.x - o.x) + math.cos(theta) * (self.y - o.y)\n return Vector2(x, y)","def rotate(prime_pos, theta, phi):\n light_dir = np.array([0, 0, 1])\n origin_prime = np.array(prime_pos)\n light_dir = phi_rot(light_dir, phi)\n light_dir = theta_rot(light_dir, theta)\n # origin = phi_rot(origin_prime, phi)\n origin = theta_rot(origin_prime, theta)\n return origin, light_dir","def rotate(self, angle):\n perp = TwoDV(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def RotatePointAroundPoint(c, p, a):\n\n\timport math\n\t\n\tp2 = Point()\n\n\tp2.x = math.cos(math.radians(a)) * (p.x-c.x) - math.sin(math.radians(a)) * (p.y-c.y) + c.x\n\tp2.y = math.sin(math.radians(a)) * (p.x-c.x) + math.cos(math.radians(a)) * (p.y-c.y) + c.y\n\n\treturn p2","def rotate(shape: Point, angle: Number) -> Point:\n sin = np.sin(angle)\n cos = np.cos(angle)\n return cos * shape[0] - sin * shape[1], cos * shape[1] + sin * shape[0]","def rotate(origin, point, angle):\r\n ox, oy = origin\r\n px, py = point\r\n\r\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\r\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\r\n return (qx,qy)","def rotate_shape(shape, xy_center, angle_degrees):","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + np.math.cos(angle) * (px - ox) - np.math.sin(angle) * (py - oy)\n qy = oy + np.math.sin(angle) * (px - ox) + np.math.cos(angle) * (py - oy)\n return qx, qy","def rotate(origin, point, angle):\n oy, ox = origin\n py, px = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qy, qx","def op_rotation(theta):\n C2 = np.cos(2 * theta)\n S2 = np.sin(2 * theta)\n rot = np.array([[1, 0, 0, 0],\n [0, C2, S2, 0],\n [0, -S2, C2, 0],\n [0, 0, 0, 1]])\n return rot","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\n return qx, qy","def rotate(self, angle, point=None):\n if not point:\n point = self.middle\n self.p1.rotate(angle, point)\n self.p2.rotate(angle, point)","def rotate(self, angle):\n perp = Vec2D(-self[1], self[0])\n angle = angle * math.pi / 180.0\n c, s = math.cos(angle), math.sin(angle)\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)","def rotate(self, origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\n return qx, qy","def _rotate_around_point(point, angle, center):\n x = point.x - center.x\n y = point.y - center.y\n cos = math.cos(angle)\n sin = math.sin(angle)\n x_ = x * cos - y * sin\n y_ = x * sin + y * cos\n return Point(x_, y_) + center","def _rotate_coords(self, x, y, theta, ox, oy):\n s, c = self._pkgs['numpy'].sin(theta), self._pkgs['numpy'].cos(theta)\n x, y = self._pkgs['numpy'].asarray(x) - ox, self._pkgs['numpy'].asarray(y) - oy\n return x * c - y * s + ox, x * s + y * c + oy","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate_point(ref_point: types.Point, angle: int, point: types.Point) -> types.Point:\n theta = math.radians(angle)\n return (round(math.cos(theta) * (point[0] - ref_point[0]) - math.sin(theta) * (point[1] - ref_point[1]) +\n ref_point[0]),\n round(math.sin(theta) * (point[0] - ref_point[0]) + math.cos(theta) * (point[1] - ref_point[1]) +\n ref_point[1]))","def rotate(origin, point, angle):\n ox, oy = origin[0], origin[1]\n px, py = point[0], point[1]\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return (int(round(qx)), int(round(qy)))","def trans_point(p,theta=0.,scale=1.):\n M = num.array([[cosd(theta), -sind(theta)],\n [sind(theta), cosd(theta)]])\n pp = scale*num.dot(M,p)\n return pp","def rotate(self, angle):\n n, a = Vector.polar([self.x, self.y])\n a += angle\n self.x = n * cos(a)\n self.y = n * sin(a)","def rot(theta):\n cos = np.cos(theta)\n sin = np.sin(theta)\n return( np.array( [[cos, sin], [-sin, cos]] ) )","def rotate(xy, theta):\n sin_theta, cos_theta = sin(theta), cos(theta)\n R = np.array([[cos_theta, -sin_theta], [sin_theta, cos_theta]])\n return np.dot(R, xy)","def rotate_point(pt, angle_rad):\n assert len(pt) == 2\n sn, cs = np.sin(angle_rad), np.cos(angle_rad)\n new_x = pt[0] * cs - pt[1] * sn\n new_y = pt[0] * sn + pt[1] * cs\n rotated_pt = [new_x, new_y]\n return rotated_pt","def rotate(self,theta=0.0):\n \n theta = theta/360.0*2*np.pi\n \n xi = self._obj.x*np.cos(theta) + self._obj.y*np.sin(theta)\n eta = self._obj.y*np.cos(theta) - self._obj.x*np.sin(theta)\n Uxi = self._obj.u*np.cos(theta) + self._obj.v*np.sin(theta)\n Ueta = self._obj.v*np.cos(theta) - self._obj.u*np.sin(theta)\n \n self._obj['x'] = xi\n self._obj['y'] = eta\n self._obj['u'] = Uxi\n self._obj['v'] = Ueta\n \n \n if 'theta' in self._obj:\n self._obj['theta'] += theta\n else:\n self._obj['theta'] = theta\n \n return self._obj","def cpvrotate(self, other):\n return Vec2d(self.x*other.x - self.y*other.y, self.x*other.y + self.y*other.x)","def rotate_y(p, a=0):\n # turn value to radians\n a = math.radians(a)\n translation_mat = np.matrix([\n [math.cos(a),0,-math.sin(a),0],\n [0,1,0,0],\n [math.sin(a),0,math.cos(a),0],\n [0,0,0,1],\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def rotate(point, angle, origin=(0.0, 0.0)):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate_about(self, angle, point):\n\t\tif not isinstance(point, Vector2d):\n\t\t\tpoint = Vector2d(*point)\n\t\treturn (self - point).rotate(angle) + point","def rotate(self, angle=pi, point=None):\n if not point: point = Point.origin(d=self.dimension)\n v = Vector.createFromTwoPoints(point, self)\n v.rotate(angle)\n self.components = v(point).components","def rotation(self, p1, p2, p3):\n return (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0])","def _rotate_points(x, y, ang):\n theta = np.radians(ang - 90.)\n xNew = x*np.cos(theta) - y*np.sin(theta)\n yNew = x*np.sin(theta) + y*np.cos(theta)\n return xNew, yNew","def rotate_x(p, a=0):\n # turn value to radians\n a = math.radians(a)\n translation_mat = np.matrix([\n [1,0,0,0],\n [0,math.cos(a),math.sin(a),0],\n [0,-math.sin(a),math.cos(a),0],\n [0,0,0,1],\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def theta(lam, gam, p):\n #lam = lam - 1e-15\n return np.pi - np.arccos(np.divide(-1 + lam*np.cos(2*np.pi*p ), w(lam, gam, p) ) )","def qrotate(points, axis, theta):\n q = Quaternion.rotator(axis, theta)\n return q.rotate(points)","def rotate_a(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate_points(x, y, ang):\n theta = np.radians(ang)\n xNew = x*np.cos(theta) - y*np.sin(theta)\n yNew = x*np.sin(theta) + y*np.cos(theta)\n\n return xNew, yNew","def rotate_point(point, angle):\n rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])\n rotated_point = rotation_matrix.dot(point)\n return rotated_point","def rotate_point(centerPoint,point,angle):\n\tangle = math.radians(angle)\n\t# print(centerPoint, point)\n\ttemp_point = point[0]-centerPoint[0] , point[1]-centerPoint[1]\n\ttemp_point = ( temp_point[0]*math.cos(angle)-temp_point[1]*math.sin(angle) , temp_point[0]*math.sin(angle)+temp_point[1]*math.cos(angle))\n\ttemp_point = int(temp_point[0]+centerPoint[0]) , int(temp_point[1]+centerPoint[1])\n\treturn temp_point","def rotate(origin, point, angle):\n ox, oy = origin[0],origin[1]\n px, py = point[0],point[1]\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return [qx, qy]","def theta(point_a, point_b):\r\n dx = point_b[0] - point_a[0]\r\n dy = point_b[1] - point_a[1]\r\n\r\n if abs(dx) < 1.e-6 and abs(dy) < 1.e-6:\r\n return 360\r\n else:\r\n t = dy/(abs(dx) + abs(dy))\r\n\r\n if dx < 0:\r\n t = 2 - t\r\n elif dy < 0:\r\n t += 4\r\n\r\n if t == 0:\r\n return 360\r\n\r\n return t*90","def rotatePoint(self, centerPoint, point, angle):\n import math\n angle = math.radians(angle)\n temp_point = point[0] - centerPoint[0], point[1] - centerPoint[1]\n temp_point = (temp_point[0] * math.cos(angle) - temp_point[1] * math.sin(angle),\n temp_point[0] * math.sin(angle) + temp_point[1] * math.cos(angle))\n temp_point = temp_point[0] + centerPoint[0], temp_point[1] + centerPoint[1]\n return temp_point","def rotate(x, y, angle):\n return x * cos(angle) - y * sin(angle), y * cos(angle) + x * sin(angle)","def phi_rot(od, phi):\n rot_mat = np.array([[np.cos(phi), 0, np.sin(phi)],\n [0, 1, 0],\n [-np.sin(phi), 0, np.cos(phi)]])\n return rot_mat.dot(od)","def theta_deg(self):\n return self.theta * 180 / np.pi","def orbit_rotate(center, obj, d_ang, dist = 0, ang = -20):\n if ang == -20:\n\n dx = obj.rect.centerx - center.rect.centerx\n dy = obj.rect.centery - center.rect.centery\n\n if dx > 0 and dy < 0:\n ang = abs(np.rad2deg(np.arctan(dx/dy)))\n elif dx < 0 and dy < 0:\n ang = abs(np.rad2deg(np.arctan(dy/dx)))\n elif dx > 0 and dy > 0:\n ang = abs(np.rad2deg(np.arctan(dy/dx)))\n elif dx < 0 and dy > 0:\n ang = abs(np.rad2deg(np.arctan(dx/dy)))\n else:\n ang = 90\n else:\n\n obj.orbit_ang += d_ang\n\n if obj.orbit_ang > 360:\n obj.orbit_ang += -360\n elif obj.orbit_ang < 0:\n obj.orbit_ang += 360\n\n ang = obj.orbit_ang\n\n if dist == 0:\n pass\n\n obj.rect.centerx = center.rect.centerx + dist*(np.sin(np.deg2rad(ang)))\n obj.rect.centery = center.rect.centery + dist*(np.cos(np.deg2rad(ang)))","def xy_rotation(vector,theta):\r\n R = np.array([[np.cos(theta), -np.sin(theta),0],\r\n [np.sin(theta), np.cos(theta),0],\r\n [0,0,1]\r\n ])\r\n return np.dot(R,vector)","def rotate(self, axis, theta):\n v = Vector3(self) # ensure vector\n k = Vector3(axis.uv())\n return type(self)(\n cosd(theta) * v\n + sind(theta) * k.cross(v)\n + (1 - cosd(theta)) * k * (k.dot(v))\n )","def rotate_waypoint(self, direction: str, argument: int):\n if direction == \"R\":\n angle = radians(argument)\n else:\n angle = -1 * radians(argument)\n y = self.waypoint_vector[0]\n x = self.waypoint_vector[1]\n self.waypoint_vector[0] = int(round(x * sin(angle) + y * cos(angle)))\n self.waypoint_vector[1] = int(round(x * cos(angle) - y * sin(angle)))","def rotate(xy, theta):\n r = np.array(\n [xy[0] * np.cos(theta) - xy[1] * np.sin(theta),\n xy[0] * np.sin(theta) + xy[1] * np.cos(theta)]\n ).T\n return r","def __call__( self , theta ):\r\n offset = np.dot( z_rot( theta ) , [ self.radius , 0 , 0 ] )\r\n # print \"Offset:\" , offset\r\n return np.add( self.center , offset )","def setPlotRotation(ang, x,y):\n dislin.trfrot(ang,x,y)","def theta(self):\n return atan2(self.y, self.x)","def rotate_about(self, rotation, point):\n\t\tif not isinstance(point,Vector3d):\n\t\t\tpoint = Vector3d(*point)\n\t\treturn (self - point).rotate(rotation) + point","def RotationX(theta):\n\n return Rotation([1., 0., 0.], theta)","def angle(p):\n\n # TODO: Make sure all the quaternions are rotations\n # where they need to be.\n\n _validate_unit(p)\n return 2*norm(log(p))","def rotate(X):\n return X","def rotate_z(p, a=0):\n # turn value to radians\n a = math.radians(a)\n translation_mat = np.matrix([\n [math.cos(a),math.sin(a),0,0],\n [-math.sin(a),math.cos(a),0,0],\n [0,0,0,0],\n [0,0,0,1],\n ], dtype=\"float32\")\n\n new_p = p @ translation_mat\n\n return new_p","def get_theta(p1,p2):\r\n \r\n dy = p1[1] - p2[1]\r\n dx = p1[0] - p2[0]\r\n theta = atan2(dy,dx)\r\n return theta","def rotate_coordinate(x, y, angle, rotc_x, rotc_y):\n rad = math.radians(angle)\n return rotc_x + (x - rotc_x) * math.cos(rad) + (y - rotc_y) * math.sin(rad),\\\n rotc_y - (x - rotc_x) * math.sin(rad) + (y - rotc_y) * math.cos(rad)","def rotate((x,y)):\n orientation = parameter('Orientation',90) # in degrees counter-clockwise\n if orientation == None: orienation = 0\n w,h = image_size()\n if orientation == 0: return (x,y)\n if orientation == -90: return (h-y,x)\n if orientation == 90: return (y,w-x)\n if orientation == 180: return (w-x,h-y)\n return (x,y)","def rotate(self,X):\n alpha = random.rand() * 2*pi\n\n beta = np.arccos(1.0-2*random.rand())\n psi = random.rand() * 2*pi\n\n R = Rotator.rotation_matrix(alpha,beta,psi)\n return np.dot(R,X)","def phase(self):\n\n self.theta = np.arctan(np.sqrt(self.P / (1 - self.P)))\n return self","def rotateAroundOrigin(origin, point, angle):\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return qx, qy","def rotate_point(point, angle, center_point=(0, 0)):\n angle_rad = radians(angle % 360)\n # Shift the point so that center_point becomes the origin\n new_point = (point[0] - center_point[0], point[1] - center_point[1])\n new_point = (new_point[0] * cos(angle_rad) - new_point[1] * sin(angle_rad),\n new_point[0] * sin(angle_rad) + new_point[1] * cos(angle_rad))\n # Reverse the shifting we have done\n new_point = (int(new_point[0] + center_point[0]), int(new_point[1] + center_point[1]))\n return new_point","def _rotate_coordinate(self, x, y, angle):\n\n sin = math.sin(angle)\n cos = math.cos(angle)\n\n x_ = x * cos - y * sin\n y_ = x * sin + y * cos\n\n return (x_, y_)","def theta(self):\n return float(np.arctan2(self.y, self.x))","def keypoint_rotate(keypoint, angle, rows, cols, **params):\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\n x, y, a, s = keypoint[:4]\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\n return x, y, a + math.radians(angle), s","def rotate(self, axis, theta):\n return NotImplemented","def rotation(self):\n\t\treturn self.piv.a.rotate.v","def Rotate(X,Y,sintheta=0,costheta=1):\n X1 = X * costheta - Y * sintheta \n Y1 = X * sintheta + Y * costheta \n return X1,Y1","def rotate(ox,oy, px,py, angle):\r\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\r\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\r\n return qx, qy","def rotate(self, angle, point=None):\n # Actually not working\n if not point:\n point = self.center\n for i in range(len(self.points)):\n self.points[i].rotate(angle, point)","def rotate_around_point_highperf(xy, degrees, origin=(0, 0)):\n x, y = xy\n radians = degrees * math.pi / 180\n offset_x, offset_y = origin\n adjusted_x = (x - offset_x)\n adjusted_y = (y - offset_y)\n cos_rad = math.cos(radians)\n sin_rad = math.sin(radians)\n qx = offset_x + cos_rad * adjusted_x + sin_rad * adjusted_y\n qy = offset_y + -sin_rad * adjusted_x + cos_rad * adjusted_y\n\n return qx, qy","def rotation(self) -> float:\n xs, ys = self.xcoords.data, self.ycoords.data\n rot = 0\n if xs.ndim == 2:\n ddx1 = xs[0, -1] - xs[0, 0]\n ddy1 = ys[0, -1] - ys[0, 0]\n if not np.isclose(ddx1, 0):\n rot = math.degrees(math.atan(ddy1 / ddx1))\n else:\n rot = -90\n if ddx1 < 0:\n rot = 180 + rot\n elif ddy1 < 0:\n rot = 360 + rot\n return rot","def rotateDegrees(angle):\n rotate(angle *2*math.pi / 360)","def odom_callback(data):\n global x\n global y\n global theta\n x = data.pose.pose.position.x\n y = data.pose.pose.position.y\n rot_q = data.pose.pose.orientation\n (roll, pitch, theta) = euler_from_quaternion([rot_q.x, rot_q.y, rot_q.z, rot_q.w])","def _rotation_from_gradient(self,m):\n\t\ttheta = -np.arctan(m)\n\t\tself.current_theta = theta\n\t\treturn self._rotation_from_angle(theta)","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslatef(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslatef(*-self.focus)","def pitch(self, dangle): # aka elevation\n vr = self.getViewRight()\n GL.glTranslatef(*self.focus)\n GL.glRotate(dangle, *vr)\n GL.glTranslatef(*-self.focus)","def orientation(xp, yp, xq, yq, xr, yr):\n cross = (xq-xp)*(yr-yp) - (xr-xp)*(yq-yp)\n dot = (xq-xp)*(xr-xp) + (yr-yp)*(yq-yp)\n if cross < 0:\n return -1\n elif cross > 0:\n return 1\n elif dot > 0:\n return 0\n else:\n return math.pi","def yaw(self, dangle): # aka azimuth\n vu = self.getViewUp()\n GL.glTranslate(*self.focus)\n GL.glRotate(dangle, *vu)\n GL.glTranslate(*-self.focus)","def srotate(self, angle):\n\n self.angle = self.angle + angle","def pitch(self, dangle): # aka elevation\n vr = self.getViewRight()\n GL.glTranslate(*self.focus)\n GL.glRotate(dangle, *vr)\n GL.glTranslate(*-self.focus)","def rotatedLatLon(thet, lmbd):\n thet_rad = thet * numpy.pi / 180.\n lmbd_rad = lmbd * numpy.pi / 180.\n thet_rad -= thetPole_rad\n lmbd_rad -= lmbdPole_rad\n cos_the = numpy.cos(thet_rad)\n sin_the = numpy.sin(thet_rad)\n cos_lam = numpy.cos(lmbd_rad)\n sin_lam = numpy.sin(lmbd_rad)\n x = cos_the * cos_lam\n y = cos_the * sin_lam\n z = sin_the\n thetaRotated = math.asin(z)\n lambdaRotated = math.atan2(y, x)\n\n return thetaRotated, lambdaRotated","def rotatePoint(origin, point, angle, radians=False):\n if not radians:\n angle = -math.radians(angle)\n\n ox, oy = origin\n px, py = point\n\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\n return [qx, qy]","def addOffsetRotation(self, point):\n\n ox, oy, oz = OpenMaya.MVector(0.0, 0.0, 0.0)\n px, py, pz = point\n\n # Z Rotation\n if self.offset_rotation.z != 0.0:\n point = self.rotateZ(point)\n\n # Y Rotation\n if self.offset_rotation.y != 0.0:\n point = self.rotateY(point)\n\n # X Rotation\n if self.offset_rotation.x != 0.0:\n point = self.rotateX(point)\n\n return point","def rotate(self, angle):\r\n radians = angle*pi/180\r\n return Vector(self.x*cos(radians) - self.y*sin(radians),\r\n self.x*sin(radians) + self.y*cos(radians))"],"string":"[\n \"def rotate_about(self, p, theta):\\n result = self.clone()\\n result.translate(-p.x, -p.y)\\n result.rotate(theta)\\n result.translate(p.x, p.y)\\n return result\",\n \"def rotate(self, theta, point):\\n r = self - point\\n x = r.x * math.cos(theta) - r.y * math.sin(theta)\\n y = r.x * math.sin(theta) + r.y * math.cos(theta)\\n return Point(point + x, point + y, *self[2:])\",\n \"def rotate_about(self, p, theta):\\n result = self.clone()\\n result.slide(-p.x, -p.y)\\n result.rotate(theta)\\n result.slide(p.x, p.y)\\n return result\",\n \"def rotatePoint(self, point, dir=+1):\\n pnew = np.zeros([len(point), point.shape[1], 2])\\n pnew[:, :, 0] = point[:, :, 0]*self.ctheta + point[:, :, 1]*self.stheta*dir\\n pnew[:, :, 1] = -point[:, :, 0] * \\\\\\n self.stheta*dir + point[:, :, 1]*self.ctheta\\n return pnew\",\n \"def theta_rot(od, theta):\\n rot_mat = np.array([[np.cos(theta), -np.sin(theta), 0],\\n [np.sin(theta), np.cos(theta), 0],\\n [0, 0, 1]])\\n return rot_mat.dot(od)\",\n \"def _rotate_point(origin, point, angle):\\n\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def my_rodriguez_rotation(P, k, theta):\\n\\n P_rot = np.zeros((len(P), 3))\\n\\n for i in range(len(P)):\\n P_rot[i] = P[i]*np.cos(theta) + np.cross(k, P[i])*np.sin(theta) + \\\\\\n k*np.dot(k, P[i])*(1.0-np.cos(theta))\\n\\n return P_rot\",\n \"def rotate(origin, point, angle): # Library export\\r\\n ox, oy = origin\\r\\n px, py = point\\r\\n\\r\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\r\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\r\\n return (qx, qy)\",\n \"def rotate((x, y), theta):\\n\\n return math.cos(theta) * x + math.sin(theta) * y, -math.sin(theta) * x + math.cos(theta) * y\",\n \"def rotate(self, theta, o=None):\\n if o is None:\\n o = Vector2(0, 0)\\n x = o.x + math.cos(theta) * (self.x - o.x) - math.sin(theta) * (self.y - o.y)\\n y = o.y + math.sin(theta) * (self.x - o.x) + math.cos(theta) * (self.y - o.y)\\n return Vector2(x, y)\",\n \"def rotate(prime_pos, theta, phi):\\n light_dir = np.array([0, 0, 1])\\n origin_prime = np.array(prime_pos)\\n light_dir = phi_rot(light_dir, phi)\\n light_dir = theta_rot(light_dir, theta)\\n # origin = phi_rot(origin_prime, phi)\\n origin = theta_rot(origin_prime, theta)\\n return origin, light_dir\",\n \"def rotate(self, angle):\\n perp = TwoDV(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return TwoDV(self[0]*c+perp[0]*s, self[1]*c+perp[1]*s)\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def RotatePointAroundPoint(c, p, a):\\n\\n\\timport math\\n\\t\\n\\tp2 = Point()\\n\\n\\tp2.x = math.cos(math.radians(a)) * (p.x-c.x) - math.sin(math.radians(a)) * (p.y-c.y) + c.x\\n\\tp2.y = math.sin(math.radians(a)) * (p.x-c.x) + math.cos(math.radians(a)) * (p.y-c.y) + c.y\\n\\n\\treturn p2\",\n \"def rotate(shape: Point, angle: Number) -> Point:\\n sin = np.sin(angle)\\n cos = np.cos(angle)\\n return cos * shape[0] - sin * shape[1], cos * shape[1] + sin * shape[0]\",\n \"def rotate(origin, point, angle):\\r\\n ox, oy = origin\\r\\n px, py = point\\r\\n\\r\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\r\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\r\\n return (qx,qy)\",\n \"def rotate_shape(shape, xy_center, angle_degrees):\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + np.math.cos(angle) * (px - ox) - np.math.sin(angle) * (py - oy)\\n qy = oy + np.math.sin(angle) * (px - ox) + np.math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate(origin, point, angle):\\n oy, ox = origin\\n py, px = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qy, qx\",\n \"def op_rotation(theta):\\n C2 = np.cos(2 * theta)\\n S2 = np.sin(2 * theta)\\n rot = np.array([[1, 0, 0, 0],\\n [0, C2, S2, 0],\\n [0, -S2, C2, 0],\\n [0, 0, 0, 1]])\\n return rot\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate(self, angle, point=None):\\n if not point:\\n point = self.middle\\n self.p1.rotate(angle, point)\\n self.p2.rotate(angle, point)\",\n \"def rotate(self, angle):\\n perp = Vec2D(-self[1], self[0])\\n angle = angle * math.pi / 180.0\\n c, s = math.cos(angle), math.sin(angle)\\n return Vec2D(self[0] * c + perp[0] * s, self[1] * c + perp[1] * s)\",\n \"def rotate(self, origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def _rotate_around_point(point, angle, center):\\n x = point.x - center.x\\n y = point.y - center.y\\n cos = math.cos(angle)\\n sin = math.sin(angle)\\n x_ = x * cos - y * sin\\n y_ = x * sin + y * cos\\n return Point(x_, y_) + center\",\n \"def _rotate_coords(self, x, y, theta, ox, oy):\\n s, c = self._pkgs['numpy'].sin(theta), self._pkgs['numpy'].cos(theta)\\n x, y = self._pkgs['numpy'].asarray(x) - ox, self._pkgs['numpy'].asarray(y) - oy\\n return x * c - y * s + ox, x * s + y * c + oy\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate_point(ref_point: types.Point, angle: int, point: types.Point) -> types.Point:\\n theta = math.radians(angle)\\n return (round(math.cos(theta) * (point[0] - ref_point[0]) - math.sin(theta) * (point[1] - ref_point[1]) +\\n ref_point[0]),\\n round(math.sin(theta) * (point[0] - ref_point[0]) + math.cos(theta) * (point[1] - ref_point[1]) +\\n ref_point[1]))\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin[0], origin[1]\\n px, py = point[0], point[1]\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return (int(round(qx)), int(round(qy)))\",\n \"def trans_point(p,theta=0.,scale=1.):\\n M = num.array([[cosd(theta), -sind(theta)],\\n [sind(theta), cosd(theta)]])\\n pp = scale*num.dot(M,p)\\n return pp\",\n \"def rotate(self, angle):\\n n, a = Vector.polar([self.x, self.y])\\n a += angle\\n self.x = n * cos(a)\\n self.y = n * sin(a)\",\n \"def rot(theta):\\n cos = np.cos(theta)\\n sin = np.sin(theta)\\n return( np.array( [[cos, sin], [-sin, cos]] ) )\",\n \"def rotate(xy, theta):\\n sin_theta, cos_theta = sin(theta), cos(theta)\\n R = np.array([[cos_theta, -sin_theta], [sin_theta, cos_theta]])\\n return np.dot(R, xy)\",\n \"def rotate_point(pt, angle_rad):\\n assert len(pt) == 2\\n sn, cs = np.sin(angle_rad), np.cos(angle_rad)\\n new_x = pt[0] * cs - pt[1] * sn\\n new_y = pt[0] * sn + pt[1] * cs\\n rotated_pt = [new_x, new_y]\\n return rotated_pt\",\n \"def rotate(self,theta=0.0):\\n \\n theta = theta/360.0*2*np.pi\\n \\n xi = self._obj.x*np.cos(theta) + self._obj.y*np.sin(theta)\\n eta = self._obj.y*np.cos(theta) - self._obj.x*np.sin(theta)\\n Uxi = self._obj.u*np.cos(theta) + self._obj.v*np.sin(theta)\\n Ueta = self._obj.v*np.cos(theta) - self._obj.u*np.sin(theta)\\n \\n self._obj['x'] = xi\\n self._obj['y'] = eta\\n self._obj['u'] = Uxi\\n self._obj['v'] = Ueta\\n \\n \\n if 'theta' in self._obj:\\n self._obj['theta'] += theta\\n else:\\n self._obj['theta'] = theta\\n \\n return self._obj\",\n \"def cpvrotate(self, other):\\n return Vec2d(self.x*other.x - self.y*other.y, self.x*other.y + self.y*other.x)\",\n \"def rotate_y(p, a=0):\\n # turn value to radians\\n a = math.radians(a)\\n translation_mat = np.matrix([\\n [math.cos(a),0,-math.sin(a),0],\\n [0,1,0,0],\\n [math.sin(a),0,math.cos(a),0],\\n [0,0,0,1],\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def rotate(point, angle, origin=(0.0, 0.0)):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate_about(self, angle, point):\\n\\t\\tif not isinstance(point, Vector2d):\\n\\t\\t\\tpoint = Vector2d(*point)\\n\\t\\treturn (self - point).rotate(angle) + point\",\n \"def rotate(self, angle=pi, point=None):\\n if not point: point = Point.origin(d=self.dimension)\\n v = Vector.createFromTwoPoints(point, self)\\n v.rotate(angle)\\n self.components = v(point).components\",\n \"def rotation(self, p1, p2, p3):\\n return (p2[0] - p1[0]) * (p3[1] - p1[1]) - (p2[1] - p1[1]) * (p3[0] - p1[0])\",\n \"def _rotate_points(x, y, ang):\\n theta = np.radians(ang - 90.)\\n xNew = x*np.cos(theta) - y*np.sin(theta)\\n yNew = x*np.sin(theta) + y*np.cos(theta)\\n return xNew, yNew\",\n \"def rotate_x(p, a=0):\\n # turn value to radians\\n a = math.radians(a)\\n translation_mat = np.matrix([\\n [1,0,0,0],\\n [0,math.cos(a),math.sin(a),0],\\n [0,-math.sin(a),math.cos(a),0],\\n [0,0,0,1],\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def theta(lam, gam, p):\\n #lam = lam - 1e-15\\n return np.pi - np.arccos(np.divide(-1 + lam*np.cos(2*np.pi*p ), w(lam, gam, p) ) )\",\n \"def qrotate(points, axis, theta):\\n q = Quaternion.rotator(axis, theta)\\n return q.rotate(points)\",\n \"def rotate_a(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate_points(x, y, ang):\\n theta = np.radians(ang)\\n xNew = x*np.cos(theta) - y*np.sin(theta)\\n yNew = x*np.sin(theta) + y*np.cos(theta)\\n\\n return xNew, yNew\",\n \"def rotate_point(point, angle):\\n rotation_matrix = np.array([[np.cos(angle), -np.sin(angle)], [np.sin(angle), np.cos(angle)]])\\n rotated_point = rotation_matrix.dot(point)\\n return rotated_point\",\n \"def rotate_point(centerPoint,point,angle):\\n\\tangle = math.radians(angle)\\n\\t# print(centerPoint, point)\\n\\ttemp_point = point[0]-centerPoint[0] , point[1]-centerPoint[1]\\n\\ttemp_point = ( temp_point[0]*math.cos(angle)-temp_point[1]*math.sin(angle) , temp_point[0]*math.sin(angle)+temp_point[1]*math.cos(angle))\\n\\ttemp_point = int(temp_point[0]+centerPoint[0]) , int(temp_point[1]+centerPoint[1])\\n\\treturn temp_point\",\n \"def rotate(origin, point, angle):\\n ox, oy = origin[0],origin[1]\\n px, py = point[0],point[1]\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return [qx, qy]\",\n \"def theta(point_a, point_b):\\r\\n dx = point_b[0] - point_a[0]\\r\\n dy = point_b[1] - point_a[1]\\r\\n\\r\\n if abs(dx) < 1.e-6 and abs(dy) < 1.e-6:\\r\\n return 360\\r\\n else:\\r\\n t = dy/(abs(dx) + abs(dy))\\r\\n\\r\\n if dx < 0:\\r\\n t = 2 - t\\r\\n elif dy < 0:\\r\\n t += 4\\r\\n\\r\\n if t == 0:\\r\\n return 360\\r\\n\\r\\n return t*90\",\n \"def rotatePoint(self, centerPoint, point, angle):\\n import math\\n angle = math.radians(angle)\\n temp_point = point[0] - centerPoint[0], point[1] - centerPoint[1]\\n temp_point = (temp_point[0] * math.cos(angle) - temp_point[1] * math.sin(angle),\\n temp_point[0] * math.sin(angle) + temp_point[1] * math.cos(angle))\\n temp_point = temp_point[0] + centerPoint[0], temp_point[1] + centerPoint[1]\\n return temp_point\",\n \"def rotate(x, y, angle):\\n return x * cos(angle) - y * sin(angle), y * cos(angle) + x * sin(angle)\",\n \"def phi_rot(od, phi):\\n rot_mat = np.array([[np.cos(phi), 0, np.sin(phi)],\\n [0, 1, 0],\\n [-np.sin(phi), 0, np.cos(phi)]])\\n return rot_mat.dot(od)\",\n \"def theta_deg(self):\\n return self.theta * 180 / np.pi\",\n \"def orbit_rotate(center, obj, d_ang, dist = 0, ang = -20):\\n if ang == -20:\\n\\n dx = obj.rect.centerx - center.rect.centerx\\n dy = obj.rect.centery - center.rect.centery\\n\\n if dx > 0 and dy < 0:\\n ang = abs(np.rad2deg(np.arctan(dx/dy)))\\n elif dx < 0 and dy < 0:\\n ang = abs(np.rad2deg(np.arctan(dy/dx)))\\n elif dx > 0 and dy > 0:\\n ang = abs(np.rad2deg(np.arctan(dy/dx)))\\n elif dx < 0 and dy > 0:\\n ang = abs(np.rad2deg(np.arctan(dx/dy)))\\n else:\\n ang = 90\\n else:\\n\\n obj.orbit_ang += d_ang\\n\\n if obj.orbit_ang > 360:\\n obj.orbit_ang += -360\\n elif obj.orbit_ang < 0:\\n obj.orbit_ang += 360\\n\\n ang = obj.orbit_ang\\n\\n if dist == 0:\\n pass\\n\\n obj.rect.centerx = center.rect.centerx + dist*(np.sin(np.deg2rad(ang)))\\n obj.rect.centery = center.rect.centery + dist*(np.cos(np.deg2rad(ang)))\",\n \"def xy_rotation(vector,theta):\\r\\n R = np.array([[np.cos(theta), -np.sin(theta),0],\\r\\n [np.sin(theta), np.cos(theta),0],\\r\\n [0,0,1]\\r\\n ])\\r\\n return np.dot(R,vector)\",\n \"def rotate(self, axis, theta):\\n v = Vector3(self) # ensure vector\\n k = Vector3(axis.uv())\\n return type(self)(\\n cosd(theta) * v\\n + sind(theta) * k.cross(v)\\n + (1 - cosd(theta)) * k * (k.dot(v))\\n )\",\n \"def rotate_waypoint(self, direction: str, argument: int):\\n if direction == \\\"R\\\":\\n angle = radians(argument)\\n else:\\n angle = -1 * radians(argument)\\n y = self.waypoint_vector[0]\\n x = self.waypoint_vector[1]\\n self.waypoint_vector[0] = int(round(x * sin(angle) + y * cos(angle)))\\n self.waypoint_vector[1] = int(round(x * cos(angle) - y * sin(angle)))\",\n \"def rotate(xy, theta):\\n r = np.array(\\n [xy[0] * np.cos(theta) - xy[1] * np.sin(theta),\\n xy[0] * np.sin(theta) + xy[1] * np.cos(theta)]\\n ).T\\n return r\",\n \"def __call__( self , theta ):\\r\\n offset = np.dot( z_rot( theta ) , [ self.radius , 0 , 0 ] )\\r\\n # print \\\"Offset:\\\" , offset\\r\\n return np.add( self.center , offset )\",\n \"def setPlotRotation(ang, x,y):\\n dislin.trfrot(ang,x,y)\",\n \"def theta(self):\\n return atan2(self.y, self.x)\",\n \"def rotate_about(self, rotation, point):\\n\\t\\tif not isinstance(point,Vector3d):\\n\\t\\t\\tpoint = Vector3d(*point)\\n\\t\\treturn (self - point).rotate(rotation) + point\",\n \"def RotationX(theta):\\n\\n return Rotation([1., 0., 0.], theta)\",\n \"def angle(p):\\n\\n # TODO: Make sure all the quaternions are rotations\\n # where they need to be.\\n\\n _validate_unit(p)\\n return 2*norm(log(p))\",\n \"def rotate(X):\\n return X\",\n \"def rotate_z(p, a=0):\\n # turn value to radians\\n a = math.radians(a)\\n translation_mat = np.matrix([\\n [math.cos(a),math.sin(a),0,0],\\n [-math.sin(a),math.cos(a),0,0],\\n [0,0,0,0],\\n [0,0,0,1],\\n ], dtype=\\\"float32\\\")\\n\\n new_p = p @ translation_mat\\n\\n return new_p\",\n \"def get_theta(p1,p2):\\r\\n \\r\\n dy = p1[1] - p2[1]\\r\\n dx = p1[0] - p2[0]\\r\\n theta = atan2(dy,dx)\\r\\n return theta\",\n \"def rotate_coordinate(x, y, angle, rotc_x, rotc_y):\\n rad = math.radians(angle)\\n return rotc_x + (x - rotc_x) * math.cos(rad) + (y - rotc_y) * math.sin(rad),\\\\\\n rotc_y - (x - rotc_x) * math.sin(rad) + (y - rotc_y) * math.cos(rad)\",\n \"def rotate((x,y)):\\n orientation = parameter('Orientation',90) # in degrees counter-clockwise\\n if orientation == None: orienation = 0\\n w,h = image_size()\\n if orientation == 0: return (x,y)\\n if orientation == -90: return (h-y,x)\\n if orientation == 90: return (y,w-x)\\n if orientation == 180: return (w-x,h-y)\\n return (x,y)\",\n \"def rotate(self,X):\\n alpha = random.rand() * 2*pi\\n\\n beta = np.arccos(1.0-2*random.rand())\\n psi = random.rand() * 2*pi\\n\\n R = Rotator.rotation_matrix(alpha,beta,psi)\\n return np.dot(R,X)\",\n \"def phase(self):\\n\\n self.theta = np.arctan(np.sqrt(self.P / (1 - self.P)))\\n return self\",\n \"def rotateAroundOrigin(origin, point, angle):\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return qx, qy\",\n \"def rotate_point(point, angle, center_point=(0, 0)):\\n angle_rad = radians(angle % 360)\\n # Shift the point so that center_point becomes the origin\\n new_point = (point[0] - center_point[0], point[1] - center_point[1])\\n new_point = (new_point[0] * cos(angle_rad) - new_point[1] * sin(angle_rad),\\n new_point[0] * sin(angle_rad) + new_point[1] * cos(angle_rad))\\n # Reverse the shifting we have done\\n new_point = (int(new_point[0] + center_point[0]), int(new_point[1] + center_point[1]))\\n return new_point\",\n \"def _rotate_coordinate(self, x, y, angle):\\n\\n sin = math.sin(angle)\\n cos = math.cos(angle)\\n\\n x_ = x * cos - y * sin\\n y_ = x * sin + y * cos\\n\\n return (x_, y_)\",\n \"def theta(self):\\n return float(np.arctan2(self.y, self.x))\",\n \"def keypoint_rotate(keypoint, angle, rows, cols, **params):\\n center = (cols - 1) * 0.5, (rows - 1) * 0.5\\n matrix = cv2.getRotationMatrix2D(center, angle, 1.0)\\n x, y, a, s = keypoint[:4]\\n x, y = cv2.transform(np.array([[[x, y]]]), matrix).squeeze()\\n return x, y, a + math.radians(angle), s\",\n \"def rotate(self, axis, theta):\\n return NotImplemented\",\n \"def rotation(self):\\n\\t\\treturn self.piv.a.rotate.v\",\n \"def Rotate(X,Y,sintheta=0,costheta=1):\\n X1 = X * costheta - Y * sintheta \\n Y1 = X * sintheta + Y * costheta \\n return X1,Y1\",\n \"def rotate(ox,oy, px,py, angle):\\r\\n qx = ox + np.cos(angle) * (px - ox) - np.sin(angle) * (py - oy)\\r\\n qy = oy + np.sin(angle) * (px - ox) + np.cos(angle) * (py - oy)\\r\\n return qx, qy\",\n \"def rotate(self, angle, point=None):\\n # Actually not working\\n if not point:\\n point = self.center\\n for i in range(len(self.points)):\\n self.points[i].rotate(angle, point)\",\n \"def rotate_around_point_highperf(xy, degrees, origin=(0, 0)):\\n x, y = xy\\n radians = degrees * math.pi / 180\\n offset_x, offset_y = origin\\n adjusted_x = (x - offset_x)\\n adjusted_y = (y - offset_y)\\n cos_rad = math.cos(radians)\\n sin_rad = math.sin(radians)\\n qx = offset_x + cos_rad * adjusted_x + sin_rad * adjusted_y\\n qy = offset_y + -sin_rad * adjusted_x + cos_rad * adjusted_y\\n\\n return qx, qy\",\n \"def rotation(self) -> float:\\n xs, ys = self.xcoords.data, self.ycoords.data\\n rot = 0\\n if xs.ndim == 2:\\n ddx1 = xs[0, -1] - xs[0, 0]\\n ddy1 = ys[0, -1] - ys[0, 0]\\n if not np.isclose(ddx1, 0):\\n rot = math.degrees(math.atan(ddy1 / ddx1))\\n else:\\n rot = -90\\n if ddx1 < 0:\\n rot = 180 + rot\\n elif ddy1 < 0:\\n rot = 360 + rot\\n return rot\",\n \"def rotateDegrees(angle):\\n rotate(angle *2*math.pi / 360)\",\n \"def odom_callback(data):\\n global x\\n global y\\n global theta\\n x = data.pose.pose.position.x\\n y = data.pose.pose.position.y\\n rot_q = data.pose.pose.orientation\\n (roll, pitch, theta) = euler_from_quaternion([rot_q.x, rot_q.y, rot_q.z, rot_q.w])\",\n \"def _rotation_from_gradient(self,m):\\n\\t\\ttheta = -np.arctan(m)\\n\\t\\tself.current_theta = theta\\n\\t\\treturn self._rotation_from_angle(theta)\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslatef(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslatef(*-self.focus)\",\n \"def pitch(self, dangle): # aka elevation\\n vr = self.getViewRight()\\n GL.glTranslatef(*self.focus)\\n GL.glRotate(dangle, *vr)\\n GL.glTranslatef(*-self.focus)\",\n \"def orientation(xp, yp, xq, yq, xr, yr):\\n cross = (xq-xp)*(yr-yp) - (xr-xp)*(yq-yp)\\n dot = (xq-xp)*(xr-xp) + (yr-yp)*(yq-yp)\\n if cross < 0:\\n return -1\\n elif cross > 0:\\n return 1\\n elif dot > 0:\\n return 0\\n else:\\n return math.pi\",\n \"def yaw(self, dangle): # aka azimuth\\n vu = self.getViewUp()\\n GL.glTranslate(*self.focus)\\n GL.glRotate(dangle, *vu)\\n GL.glTranslate(*-self.focus)\",\n \"def srotate(self, angle):\\n\\n self.angle = self.angle + angle\",\n \"def pitch(self, dangle): # aka elevation\\n vr = self.getViewRight()\\n GL.glTranslate(*self.focus)\\n GL.glRotate(dangle, *vr)\\n GL.glTranslate(*-self.focus)\",\n \"def rotatedLatLon(thet, lmbd):\\n thet_rad = thet * numpy.pi / 180.\\n lmbd_rad = lmbd * numpy.pi / 180.\\n thet_rad -= thetPole_rad\\n lmbd_rad -= lmbdPole_rad\\n cos_the = numpy.cos(thet_rad)\\n sin_the = numpy.sin(thet_rad)\\n cos_lam = numpy.cos(lmbd_rad)\\n sin_lam = numpy.sin(lmbd_rad)\\n x = cos_the * cos_lam\\n y = cos_the * sin_lam\\n z = sin_the\\n thetaRotated = math.asin(z)\\n lambdaRotated = math.atan2(y, x)\\n\\n return thetaRotated, lambdaRotated\",\n \"def rotatePoint(origin, point, angle, radians=False):\\n if not radians:\\n angle = -math.radians(angle)\\n\\n ox, oy = origin\\n px, py = point\\n\\n qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)\\n qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)\\n return [qx, qy]\",\n \"def addOffsetRotation(self, point):\\n\\n ox, oy, oz = OpenMaya.MVector(0.0, 0.0, 0.0)\\n px, py, pz = point\\n\\n # Z Rotation\\n if self.offset_rotation.z != 0.0:\\n point = self.rotateZ(point)\\n\\n # Y Rotation\\n if self.offset_rotation.y != 0.0:\\n point = self.rotateY(point)\\n\\n # X Rotation\\n if self.offset_rotation.x != 0.0:\\n point = self.rotateX(point)\\n\\n return point\",\n \"def rotate(self, angle):\\r\\n radians = angle*pi/180\\r\\n return Vector(self.x*cos(radians) - self.y*sin(radians),\\r\\n self.x*sin(radians) + self.y*cos(radians))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7366025","0.7336842","0.7231373","0.697945","0.6894734","0.68924886","0.6783059","0.67477643","0.6742044","0.6718778","0.6710311","0.66871434","0.665914","0.6606632","0.65712065","0.6569933","0.6564392","0.65294605","0.6525388","0.652423","0.6508847","0.6505262","0.6493982","0.6493535","0.64887744","0.64864147","0.6483898","0.6483898","0.6483898","0.6473501","0.64504445","0.6447832","0.6433221","0.64318705","0.63954544","0.63819313","0.63811636","0.6369387","0.63576615","0.63327557","0.6326552","0.63207954","0.62865984","0.6235148","0.62263435","0.6195128","0.61904675","0.61886615","0.61863136","0.6184853","0.6182109","0.6174549","0.61681485","0.6158724","0.61446214","0.6140516","0.6139633","0.61336255","0.6103298","0.6091037","0.6077953","0.6061587","0.60564977","0.60436285","0.6043169","0.6037912","0.60298085","0.60254294","0.60254085","0.6018112","0.60169196","0.6014927","0.599905","0.5992207","0.59743655","0.5966415","0.5964502","0.5960882","0.5955029","0.5953988","0.5945487","0.59416574","0.5931962","0.5931453","0.5929527","0.5925843","0.59231716","0.59228784","0.5914258","0.59088427","0.58872616","0.58860534","0.58763325","0.58753407","0.58727336","0.5871458","0.5867411","0.58651114","0.5862398","0.58622414"],"string":"[\n \"0.7366025\",\n \"0.7336842\",\n \"0.7231373\",\n \"0.697945\",\n \"0.6894734\",\n \"0.68924886\",\n \"0.6783059\",\n \"0.67477643\",\n \"0.6742044\",\n \"0.6718778\",\n \"0.6710311\",\n \"0.66871434\",\n \"0.665914\",\n \"0.6606632\",\n \"0.65712065\",\n \"0.6569933\",\n \"0.6564392\",\n \"0.65294605\",\n \"0.6525388\",\n \"0.652423\",\n \"0.6508847\",\n \"0.6505262\",\n \"0.6493982\",\n \"0.6493535\",\n \"0.64887744\",\n \"0.64864147\",\n \"0.6483898\",\n \"0.6483898\",\n \"0.6483898\",\n \"0.6473501\",\n \"0.64504445\",\n \"0.6447832\",\n \"0.6433221\",\n \"0.64318705\",\n \"0.63954544\",\n \"0.63819313\",\n \"0.63811636\",\n \"0.6369387\",\n \"0.63576615\",\n \"0.63327557\",\n \"0.6326552\",\n \"0.63207954\",\n \"0.62865984\",\n \"0.6235148\",\n \"0.62263435\",\n \"0.6195128\",\n \"0.61904675\",\n \"0.61886615\",\n \"0.61863136\",\n \"0.6184853\",\n \"0.6182109\",\n \"0.6174549\",\n \"0.61681485\",\n \"0.6158724\",\n \"0.61446214\",\n \"0.6140516\",\n \"0.6139633\",\n \"0.61336255\",\n \"0.6103298\",\n \"0.6091037\",\n \"0.6077953\",\n \"0.6061587\",\n \"0.60564977\",\n \"0.60436285\",\n \"0.6043169\",\n \"0.6037912\",\n \"0.60298085\",\n \"0.60254294\",\n \"0.60254085\",\n \"0.6018112\",\n \"0.60169196\",\n \"0.6014927\",\n \"0.599905\",\n \"0.5992207\",\n \"0.59743655\",\n \"0.5966415\",\n \"0.5964502\",\n \"0.5960882\",\n \"0.5955029\",\n \"0.5953988\",\n \"0.5945487\",\n \"0.59416574\",\n \"0.5931962\",\n \"0.5931453\",\n \"0.5929527\",\n \"0.5925843\",\n \"0.59231716\",\n \"0.59228784\",\n \"0.5914258\",\n \"0.59088427\",\n \"0.58872616\",\n \"0.58860534\",\n \"0.58763325\",\n \"0.58753407\",\n \"0.58727336\",\n \"0.5871458\",\n \"0.5867411\",\n \"0.58651114\",\n \"0.5862398\",\n \"0.58622414\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.88402575"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80598,"cells":{"query":{"kind":"string","value":"Function to perform read operation with the database to get the top artist"},"document":{"kind":"string","value":"def get_top_artist_tracks(session, number_of_artist):\n try:\n if not issubclass(type(session), sqlalchemy.orm.session.Session):\n raise AttributeError(\"session not passed correctly, should be of type 'sqlalchemy.orm.session.Session' \")\n\n if not issubclass(type(number_of_artist), int) or number_of_artist < 1:\n raise AttributeError(\"number of artist should be integer and greater than 0\")\n\n LOGGER.info(\"Performing Read Operation\")\n\n # Selecting the Artist id, Artist Name, and count of track id\n query = session.query(models.AlbumTable.artist_id, models.ArtistTable.name,\n func.count(models.TracksTable.track_id).label(\"number_of_tracks\"))\n\n # Joining tracks table and album table\n query = query.join(models.AlbumTable, models.TracksTable.album_id == models.AlbumTable.album_id)\n query = query.join(models.ArtistTable, models.AlbumTable.artist_id == models.ArtistTable.artist_id)\n\n # Grouping by Artist Id\n query = query.group_by(models.AlbumTable.artist_id)\n\n # Sorting by number_of_tracks and artist id\n query = query.order_by(desc(\"number_of_tracks\"), models.AlbumTable.artist_id)\n\n results = query.limit(number_of_artist).all()\n\n if not results:\n raise NoResultFound(\"No Records Found\")\n\n LOGGER.info(\"\\n\\nThe Top %s Artist based on number of tracks are\", number_of_artist)\n\n print(\"\\n\\n\")\n print(\"===\" * 50)\n print(\"\\n\\n\")\n\n LOGGER.info(\"\\n\\n %s\", tabulate(results, headers=[\"Artist ID\", \"Artist Name\", \"Number Of Tracks\"],\n tablefmt=\"grid\"))\n\n print(\"\\n\\n\")\n print(\"===\" * 50)\n print(\"\\n\\n\")\n except AttributeError as err:\n LOGGER.error(err)\n except NoResultFound as err:\n LOGGER.error(err)\n finally:\n session.close()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_artists_most_played(session_):\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\n artists = session_.query(Artist).order_by(Artist.plays.desc()).all()\n return artists","def top_artists_from_API(api_results):\r\n df = pd.DataFrame(api_results[\"items\"])\r\n cols = [\"name\",\"id\",\"genres\",\"popularity\",\"uri\"]\r\n return df[cols]","def topArticles():\n c = db.cursor()\n c.execute(\"select titles.title, tophits.hits\\\n from tophits, titles\\\n where tophits.path = titles.slug\\\n order by hits desc limit 3;\")\n results = c.fetchall()\n c.close()\n return results","def get_albums_most_played(session_):\n artists = session_.query(Album).order_by(Album.plays.desc()).all()\n return artists","async def artists(self, ctx: BBContext):\n\n query = \"\"\"SELECT DISTINCT artist_name, COUNT(*)\n FROM extras.arts\n WHERE artist_name IS NOT NULL\n GROUP BY artist_name\n ORDER BY COUNT(*) DESC\"\"\"\n\n args = [query]\n\n con = await ctx.get_connection()\n data: List[asyncpg.Record] = await con.fetch(*args)\n view = ArtsLeaderboardPagination(data, ctx.author) # type: ignore (Direct messages intent is not being used so author can only be a member)\n await view.start(ctx.channel)","def get_top_song_metadata():\n cache_buster = '?v=%s' % get_timestamp()\n response = requests.get(MUSIC_DIR + 'top_meta.json' + cache_buster)\n return response.json()","def get_popular_authors():\n query_command = \"SELECT * from popular authors LIMIT 3\"\n query_data = run_query(query_command)\n return query_data","def test_top_songs(self):\n \n rss = AppleRSS()\n objs = rss.get_top_songs(limit=10)\n \n self.__test_artists('top_songs', objs)","def topAuthors():\n c = db.cursor()\n c.execute(\"select name, sum(hits) as hits\\\n from authorhits group by name\\\n order by hits desc;\")\n results = c.fetchall()\n c.close()\n return results","def top_authors():\n\n cur.execute(\"\"\"\n SELECT author, count(*) AS article_author\n FROM article_summary\n GROUP BY author\n ORDER BY article_author DESC;\n \"\"\")\n result = cur.fetchall()\n return result","def artist_top_tracks(req):\n\n artist = req.get('result').get('parameters').get('artist')\n logger.info('received {0} request for artist=\"{1}\"'.format('artist_top_tracks', artist))\n top_tracks = cached_result('get_artist_top_tracks', [artist], {})\n speech = 'Unable to locate top tracks for {artist}'.format(artist=artist)\n\n if top_tracks is not None:\n speech = 'The most popular songs for {artist} are'.format(artist=artist)\n for track in top_tracks:\n speech += '. ' + track\n\n return jsonify(\n {'speech': speech,\n 'displayText': speech,\n 'source': 'last-assist'})","def search_for_artist_top_tracks(name):\n\tartist_id = search_for_artist(name)\n\ttoken = get_token()\n\tif artist_id and token:\n\t\theaders = {\"Content-Type\": \"application/json\", \"Authorization\": \"Bearer \" + token}\n\t\toptions = {'country': 'TR'}\n\t\tresponse = requests.get(\n\t\t\t'https://api.spotify.com/v1/artists/'+artist_id+'/top-tracks',\n\t\t\theaders=headers,\n\t\t\tparams=options\n\t\t)\n\t\tif response.status_code == 200:\n\t\t\tcontent = json.loads(response.content.decode('utf-8'))\n\t\t\tif content:\n\t\t\t\treturn content['tracks']\n\t\t\telse: return None\n\t\telse:\n\t\t\treturn None\n\telse:\n\t\treturn None","def get_top_artists(\n self, period: Period, limit: int = 50, page: int = 1\n ) -> ListModel[Artist]:\n assert isinstance(period, Period)\n return self.retrieve(\n bind=Artist,\n flatten=\"artist\",\n params=dict(\n method=\"user.getTopArtists\",\n user=self.name,\n limit=limit,\n page=page,\n period=period.value,\n ),\n )","def generate_artist_data(name, use_id=False):\n if use_id:\n query = \"http://54.235.241.196/{0}\".format(name)\n artist_json_data = get_raw_json(query)\n return artist_json_data\n\n query = \"http://54.235.241.196/search?t=artist&q={0}&geo=US\".format(\n quote(name))\n json_data = get_raw_json(query)\n top_hit_json = json_data[\"data\"][0]\n\n return top_hit_json","def query_article():\r\n conn, cur = connect()\r\n query1 = (\"select * from article limit 3\")\r\n cur.execute(query1)\r\n res = cur.fetchall()\r\n conn.close()\r\n print (\"\\nThe most popular three articles of all time:\\n\")\r\n for i in range(0, len(res), 1):\r\n print (res[i][0] + \" --> \" + str(res[i][1]) + \" views\")","def get_popular_article():\n query_command = \"SELECT * from popular_posts LIMIT 3\"\n query_data = run_query(query_command)\n return query_data","def find_top_tracks(self, artist, N=10):\n tracklist = []\n try:\n result = self.sp.artist_top_tracks(artist)\n except ConnectionError as e:\n print (\"ERROR: connection pool is closed; searching Spotify for top tracks for this artist: \" + artist)\n result = self.sp.artist_top_tracks(artist)\n print (\"tried again\")\n print (result)\n raise e\n\n tracklist.extend(result.get(\"tracks\"))\n if len(tracklist) > N:\n return tracklist[0:N]\n else:\n return tracklist","def current_user_top_artists(\n self, limit=20, offset=0, time_range=TimeRange.MEDIUM_TERM, **kwargs\n ):\n return self._get(\n API.MY_TOP.value.format(type=\"artists\"), # pylint: disable=no-member\n time_range=TimeRange(time_range).value,\n limit=limit,\n offset=offset,\n **kwargs,\n )","def question_2():\n cursor.execute(mostPopAuthors)\n output = cursor.fetchall()\n return output","def get_artists_recent_played(session_):\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\n artists = session_.query(Artist).order_by(Artist.played_at.asc()).all()\n return artists","async def get_top(self, limit, iterator):\n if iterator == 'ITERATOR_LE':\n iterator = 'DESC'\n if iterator == 'ITERATOR_GE':\n iterator = 'ASC'\n sql = (\n \"select data from stickers order by (data->>1)::int {} limit {}\"\n ).format(iterator, limit)\n result = await self.db.fetch(sql)\n ret = []\n for i in result:\n ret.append(json.loads(i[0]))\n return ret","def get_most_popular_articles():\n\tdb = psycopg2.connect(database=DBNAME)\n\tc = db.cursor()\n\tc.execute(\"select t2.title, count(*) as total from log as t1,articles as t2 where t1.path=concat('/article/',t2.slug) group by t2.title order by total desc limit 3 ;\")\n\tdata = c.fetchall()\n\tdb.close()\n\treturn data","def select_artists(conn):\n cur = conn.cursor()\n cur.execute(\"SELECT * FROM artists\")\n \n rows = cur.fetchall()\n \n for row in rows:\n print(row)","def popular_authors() :\n query = \"\"\"SELECT authors.name,count(*) AS total_views FROM authors,articles,log WHERE log.path like concat ('/article/',articles.slug)\n AND articles.author=authors.id group by authors.name order by total_views desc\"\"\"\n result = get_data(query)\n print(\" 2. The most popular articles authors of all time:\")\n print(\"\")\n for record in result :\n print(' ' +' ' + str(record[0]) + ' -' + ' ' + str(record[1]) + ' ' +'views')\n print(\" \")","async def arts(self, ctx: BBContext, artist: Optional[discord.Member] = None):\n\n if artist:\n query = f'SELECT url, artist_name FROM {TABLE_ARTS} WHERE artist_id = $1 LIMIT 20'\n args = [query, artist.id]\n else:\n query = f'SELECT url, artist_name FROM {TABLE_ARTS} ORDER BY random() LIMIT 20'\n args = [query]\n\n con = await ctx.get_connection()\n data: List[asyncpg.Record] = await con.fetch(*args)\n\n view = ArtsPagination(data, ctx.author) # type: ignore (Direct messages intent is not being used so author can only be a member)\n await view.start(ctx.channel)","def get_artist(artist_id):\n return query_single(artist_id, Artist, artist_schema)","def get_most_popular_authors():\n\tdb = psycopg2.connect(database=DBNAME)\n\tc = db.cursor()\n\tc.execute(\" select t1.name,count(*) as total from authors as t1, articles as t2,log as t3 where t3.path=concat('/article/',t2.slug) and t1.id=t2.author group by t1.name order by total desc limit 3;\")\n\tdata = c.fetchall()\n\tdb.close()\n\n\treturn data","def top3_articles():\n\n cur.execute(\"\"\"\n SELECT title, COUNT(*) AS article_title\n FROM article_summary\n GROUP BY title\n ORDER BY article_title DESC\n LIMIT 3;\n \"\"\")\n result = cur.fetchall()\n return result","def printTopAuthors():\n query = \"\"\"\n SELECT author_article_popularity_view.author,\n SUM(author_article_popularity_view.views) AS total_views\n FROM author_article_popularity_view\n GROUP BY author_article_popularity_view.author\n ORDER BY total_views DESC;\n \"\"\"\n cursor = connection.cursor()\n cursor.execute(query)\n results = cursor.fetchall()\n print(\"\\nTop authors of all time: \")\n for i, result in enumerate(results):\n print(\"{}. {} - {:,} views\".format(i + 1, result[0], result[1]))","def most_popular_artist(our_data):\n counter_dict = {}\n for artist in all_artists(our_data):\n if artist in counter_dict:\n counter_dict[artist] += 1\n else:\n counter_dict[artist] = 1\n maximum_albums = max(counter_dict.values())\n artist_lists = []\n for keys, values in counter_dict.items():\n if values == maximum_albums:\n artist_lists.append(keys) \n return artist_lists","def most_popular_articles():\n print '1. The most popular articles are...'\n return (\"\"\"SELECT articles.title, COUNT(*) as num FROM articles, log\"\"\"\n \"\"\" WHERE SUBSTRING (log.path FROM 10) = articles.slug and\"\"\"\n \"\"\" log.path != '/' Group By articles.title ORDER By num\"\"\"\n \"\"\" DESC LIMIT 3;\"\"\")","def _get_top_tracks(artist, limit):\n\n l = []\n for track in _lastfm.get_artist(artist).get_top_tracks(limit=limit):\n track = track.item\n l.append({\"artist\": track.get_artist().get_name(), \"title\": track.get_title()})\n \n return l","def get_top(self):\n\n sql = \"SELECT username FROM Users ORDER BY score DESC LIMIT 10\"\n self.cursor.execute(sql)\n return self.cursor.fetchall()","def get_top_authors():\n query2 = \"\"\"select name, count(*) as views\n from authors, articles, log\n where authors.id = articles.author\n and log.path like '%' || articles.slug\n group by name\n order by views desc;\"\"\"\n results = execute_query(query2)\n for result in results:\n print(\"- %s — %s views\" % (result[0], result[1]))","def parse_json_artist(JSON_ARTIST_FILE, num_show=10):\n with open(JSON_ARTIST_FILE) as f:\n data = json.load(f)\n num_artist = len(data['artists']['items'])\n print(f'For word \"{ARTIST}\" has been found {num_artist} artists')\n Artist = namedtuple('Artist', 'name popularity genres')\n artist_list = []\n for num in range(num_artist):\n name = data['artists']['items'][num]['name']\n popularity = data['artists']['items'][num]['popularity']\n genres = ', '.join(data['artists']['items'][num]['genres'])\n if not genres:\n genres = '-'\n artist_list.append(Artist(name=name, popularity=popularity, \\\n genres=genres))\n sorted_artist_list = sorted(artist_list, key=lambda x: -x.popularity)\n print(tb(sorted_artist_list[:num_show], headers=artist_list[0]._fields))\n return None","def popular_articles():\n query = \"\"\"SELECT articles.title,count(*) AS total_views FROM articles,log WHERE log.path like concat('/article/',articles.slug)\n group by articles.title order by total_views desc limit 3\"\"\"\n result = get_data(query)\n print(\" 1. The most popular three articles of all time:\")\n print(\"\")\n for record in result :\n print(' ' + '\\\"' + str(record[0]) + '\\\"' + '-' + ' ' + str(record[1]) + ' '+ 'views')\n print(\" \")","def print_top_articles():\n\n output = get_query_results(\n '''SELECT articles.title, COUNT(path) AS views\n FROM articles\n JOIN log\n ON log.path=CONCAT('/article/', articles.slug)\n GROUP BY title\n ORDER BY views DESC\n LIMIT 3;'''\n )\n print(\"\\nMost Popular Articles: \\n\")\n for title, views in output:\n print(\"\\\"{}\\\" -- {} views\".format(title, views))","def read_artist_page(artist):\n url = BASE_URL + '/artist/' + artist\n print(f'reading artist page: {url}')\n artist_page = requests.get(url, headers=HEADERS)\n return artist_page.text","def top_tracks(genre):\n\tartist = random.choice(genre_artist[genre])\n\ttop_tracks = search_for_artist_top_tracks(artist)\n\titems = []\n\tif top_tracks:\n\t\tfor track in top_tracks:\n\t\t\titems.append({\"artist\": track[\"artists\"][0][\"name\"], \"popularity\": track[\"popularity\"], \"track\": track[\"name\"],\n\t\t\t\t \"preview_url\": track[\"preview_url\"], \"album_image_url\": track[\"album\"][\"images\"][2][\"url\"]})\n\t\titems = sorted(items, key=lambda x: x['popularity'], reverse=True)\n\t\tfor item in items:\n\t\t\tdel item['popularity']\n\t\treturn items\n\telse:\n\t\treturn None","def top(self, **kwargs):\n return self.client.api.top(self.id, **kwargs)","def get_albums_recent_played(session_):\n artists = session_.query(Album).order_by(Album.played_at.desc()).all()\n return artists","def most_popular_article_authors():\n\n # To print information\n information_string = '2. The most popular article ' \\\n 'authors of all time are:\\n'\n\n # Query string\n query = \"\"\" select x.author , count(1) as qtd from (\n SELECT b.name as author\n FROM articles a join authors b on(a.author = b.id)\n join log c on(c.path = '/article/' ||a.slug)\n ) x group by x.author order by 2 desc;\"\"\"\n\n print(information_string)\n for result in query_db(query):\n print('\\t' + str(result[0]) + ' - ' + str(result[1]) + ' views')\n\n print(\"\\n\")","def printTopThreeArticles():\n query = \"\"\"\n SELECT author_article_popularity_view.article,\n author_article_popularity_view.views\n FROM author_article_popularity_view\n LIMIT 3;\n \"\"\"\n cursor = connection.cursor()\n cursor.execute(query)\n results = cursor.fetchall()\n print(\"\\nTop 3 articles of all time: \")\n for i, result in enumerate(results):\n print(\"{}. \\\"{}\\\" - {:,} views\".format(i + 1, result[0], result[1]))","def query_artist(self, artist_name):\n # Check if the artist is in the database\n try:\n a = Artist.objects.get(searched_name = artist_name)\n return ArtistObject(searched_name=artist_name, db_model=a)\n\n # If the artist isn't in the database, search Spotify\n except Artist.DoesNotExist:\n print(\"Artist not found in database: \", artist_name)\n result = self.search_spotify(artist_name)\n\n # If there were any errors searching Spotify, don't continue\n if result is None:\n # SKIP FOR TEST NOW\n ArtistObject(searched_name=artist_name).save_to_db()\n return None\n else:\n artist = self.filter_spotify_result(result, artist_name)\n\n if artist is None:\n ArtistObject(searched_name=artist_name).save_to_db()\n return None\n\n top_tracks = self.find_top_tracks(artist.uri)\n artist.add_songs(top_tracks)\n\n # Save artist URI to the database for faster results next time\n print(\"About to save artist with name {} and object: \".format(artist_name), artist)\n artist.save_to_db()\n\n return artist","def popular_articles():\n db = psycopg2.connect(\"dbname=news\")\n \"\"\"Connect to news database.\"\"\"\n c = db.cursor()\n \"\"\"Open a cursor to perform database operation.\"\"\"\n query = \"\"\"select title, count(path) as view from articles, log \n where '/article/' || articles.slug = log.path group by title, path \n order by view desc limit 3;\"\"\"\n \"\"\"The cursor runs query and fetches result.\"\"\"\n c.execute(query)\n \"\"\"Execute query using cursor.\"\"\"\n rows = c.fetchall()\n print \"Most popular three articles of all time: \"\n print \"---------------------------------------- \"\n for row in rows:\n print row[0], \"--\", row[1], \" views\"\n db.close()","def top(self):","def test_top_albums(self):\n \n rss = AppleRSS()\n objs = rss.get_top_albums(limit=10)\n \n self.__test_artists('top_albums', objs)","def get_artist_audio_features(q, interactive = False, genre_delimiter = '-!!-', to_file = '', client = None):\n query = client.search(q = q, type = \"artist\")\n items = query['artists']['items']\n\n if not items:\n raise Exception(\"No artists found\")\n\n if interactive:\n print(\"Select the artist to use...\")\n print(\"\\n\".join(\"[{}]: {}\".format(ii, entry['name']) for ii, entry in enumerate(items)))\n artist_indx = int(input(\"artist number: \").strip())\n if artist_indx > len(items):\n raise IndexError(\"Selected number higher than options available\")\n artist = items[artist_indx]\n else:\n artist = items[0]\n\n # get artist genres\n artist_genres = genre_delimiter.join(artist['genres']) if genre_delimiter else None\n\n # get artist albums\n albums = get_artist_albums(artist['id'])\n albums['artist_genres'] = artist_genres\n\n # get album popularity\n album_popularity = get_album_popularity(albums.id)\n\n # get album tracks\n tracks = get_album_tracks(albums.id)\n\n # get track audio features\n features = get_track_features(tracks.id)\n\n # get track popularity\n popularity = get_track_popularity(tracks.id)\n\n album_data = albums.merge(album_popularity, 'left', 'id')\n\n track_data = tracks \\\n .drop(columns = ['type']) \\\n .merge(popularity, 'left', 'id') \\\n .merge(features.drop(columns = ['uri', 'type', 'duration_ms']), 'left', 'id')\n\n\n merged = prefix_merge(album_data, track_data, ['album_', 'track_'], how = 'left', on = 'album_id')\n\n if to_file:\n merged.to_csv(to_file)\n\n return merged","def most_popular_authors():\n print '2. The most popular authors are...'\n return (\"\"\"SELECT authors.name, count(*) as num from\"\"\"\n \"\"\" authors, articles, log WHERE SUBSTRING (log.path FROM 10)\"\"\"\n \"\"\" = articles.slug and articles.author = authors.id and\"\"\"\n \"\"\" log.path != '/' Group By authors.name ORDER by num\"\"\"\n \"\"\" DESC LIMIT 20;\"\"\")","def article_rank():\n db, c = connect(DBNAME)\n c.execute(\"select title, count(title) as views from \\\"pathslug\\\" \"\n \"group by title order by views desc limit 3\")\n article_table = c.fetchall()\n db.close()\n print \"\\nThree Most Popular Articles All Time:\"\n for article in article_table:\n print str(article[0]) + \" - \" + str(article[1]) + \" views\"","def topTags(db, topN=1000):\n c=db.cursor()\n c.execute(\"\"\"\n SELECT\n tag\n FROM tags\n GROUP BY tag\n ORDER BY COUNT(*) DESC\n LIMIT %d\n \"\"\" % topN)\n tops = [tag0[0] for tag0 in c.fetchall()]\n c.close()\n return tops","def get_popular_articles():\n db = psycopg2.connect(database=DBNAME)\n c = db.cursor()\n query_popular_articles = \"\"\"\n SELECT art.title, COUNT(lg.id) as views\n FROM articles as art\n JOIN log as lg\n ON art.slug = substring(lg.path,10)\n AND lg.status = '200 OK'\n GROUP BY art.title\n ORDER BY views desc\n LIMIT 3; \"\"\"\n c.execute(query_popular_articles)\n articles = from_db_cursor(c)\n db.close()\n return articles","def get_artists_alpha(session_):\n # artists = session_.query(Artist).order_by(Artist.name.desc()).paginate()\n artists = session_.query(Artist).order_by(Artist.name.asc()).all()\n return artists","def get_popular_authors():\n db = psycopg2.connect(database=DBNAME)\n c = db.cursor()\n # counting views that had status 200\n c.execute(\"select authors.name, count(*) as num \"\n \"from articles, authors, log \"\n \"where articles.author = authors.id \"\n \"and log.path like concat('%', articles.slug, '%') \"\n \"and log.status = '200 OK' \"\n \"group by authors.name order by num desc\")\n results = c.fetchall()\n text_file = open(\"text.txt\", \"a+\") # append to text file\n text_file.write(\"The most popular authors of all time are:\\n\\n\")\n # for loop to print each author\n for name, num in results:\n text_file.write(\"\\\"\" + name + \"\\\"\" + \" - \" + str(num) + \" views\\n\")\n text_file.write(\"\\n\")\n text_file.close()\n db.close","def do_top(cs, args):\n resp, data = cs.repositories.get_top(args.count)\n utils.print_list(data, ['name', 'count'], sortby='count')","def getdata_from_db(number):\n print(\"Connecting to database\")\n query = sqlite3.connect(DB_PATH).cursor()\n query.execute(\n \"SELECT text FROM data ORDER BY id DESC LIMIT \" + str(number) + \"; \")\n tweets = [line[0] for line in query.fetchall()]\n print(\"Tweets from databases: %d tweets\" % (len(tweets)))\n return tweets","def get_artists_recent_added(session_):\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\n artists = session_.query(Artist).order_by(Artist.added_at.asc()).all()\n return artists","def get_most_popular_artists(data):\r\n #list of artists\r\n artists = []\r\n for key in data:\r\n if key[-1] != \"$\":\r\n for x in data[key]:\r\n artists += [x]\r\n sorted_artists = selection_sort(artists)\r\n count = 1\r\n max_count = 1\r\n max_artists = []\r\n for i in range(len(sorted_artists)-1):\r\n #ends at second to last index because I use i and i + 1\r\n if sorted_artists[i] == sorted_artists[i+1]:\r\n count += 1\r\n else:\r\n if count == max_count:\r\n max_artists += [sorted_artists[i]]\r\n count = 1\r\n elif count > max_count:\r\n max_artists = []\r\n max_artists += [sorted_artists[i]]\r\n max_count = count\r\n count = 1\r\n return max_artists","def get_amarok_data(item, db):\n\n if hasattr(item, 'amarok_uid') and item.amarok_uid:\n condition = \"REPLACE(uniqueid, 'amarok-sqltrackuid://', '') = '%s'\" % MySQLdb.escape_string(item.amarok_uid)\n else:\n condition = \"REPLACE(CONCAT_WS('/',lastmountpoint, rpath), '/./', '/') = '%s'\" % MySQLdb.escape_string(item.path)\n\n query = \"SELECT REPLACE(uniqueid, 'amarok-sqltrackuid://', '') AS uniqueid, rating, score \\\n FROM statistics \\\n INNER JOIN urls ON statistics.url = urls.id \\\n INNER JOIN devices ON devices.id = urls.deviceid \\\n WHERE %s \\\n LIMIT 1\" % condition\n\n try:\n cursor = db.cursor()\n\n cursor.execute(query)\n\n row = cursor.fetchone()\n\n except MySQLdb.Error, e:\n log.error(u'Could not fetch metadata from amarok database: {0}'.format(e))\n row = (None, 0, 0)\n\n if row is None:\n log.info(u'Could not find entry for \\'{0}\\' in amarok database'.format(displayable_path(item.path)))\n row = (None, 0, 0)\n\n item.amarok_uid = row[0]\n\n showdiff_rating = False\n showdiff_score = False\n\n if hasattr(item, 'rating') and item.rating and long(item.rating) != row[1]:\n showdiff_rating = True\n if hasattr(item, 'score') and item.score and float(item.score) != row[2]:\n showdiff_score = True\n\n if showdiff_rating or showdiff_score:\n print item.artist, \" - \", item.album, \" - \", item.title\n\n if showdiff_rating:\n ui.commands._showdiff('rating', item.rating, row[1])\n\n if showdiff_score:\n ui.commands._showdiff('score', item.score, row[2])\n\n item.rating = row[1]\n item.score = row[2]","def _get_artist(self):\n artists = FileRecord.query(FileRecord.artist).distinct().filter(\n FileRecord.album == self.name).filter(\n FileRecord.year == self.year).all()\n\n if len(artists) > 1:\n return \"Various Artists\"\n elif len(artists) == 1:\n return artists[0][0]\n else:\n return \"(Unknown)\"","def query2():\n\n print(\"2. Who are the most popular article authors of all time?\\n\")\n\n query = \"\"\"\n SELECT authors.name, subq_author.hits FROM authors\n LEFT JOIN\n (SELECT articles.author, CAST(SUM(subq_article.hits) AS INTEGER)\n AS hits FROM articles\n LEFT JOIN\n (SELECT COUNT(log.path) AS hits, log.path FROM log\n WHERE log.path LIKE '/article/%'\n AND log.status = '200 OK' AND log.method = 'GET'\n GROUP BY log.path) AS subq_article\n ON subq_article.path LIKE '/article/'||articles.slug\n GROUP BY articles.author) AS subq_author\n ON authors.id = subq_author.author\n ORDER BY subq_author.hits DESC;\n \"\"\"\n\n response = db_query(query)\n\n for i, j in enumerate(response):\n # Convert tuple to list to allow writing. Format \"hits\" with comma\n # seperator. Print output.\n j = list(j)\n j[1] = str(format(j[1], ',d'))\n print(\" Author: '{}' - {} views\".format(*j))","def get_top_stories(self):\n stories = requests.get(f\"{HN_API_URL}/topstories.json\")\n stories_ids = json.loads(stories.text)\n urls = [f\"{HN_API_URL}/item/{story_id}.json\" for story_id in stories_ids]\n fetched_stories = asyncio.run(self.fetch_all(urls))\n sorted_stories = sorted(\n fetched_stories, key=lambda k: k[\"score\"], reverse=True)\n return sorted_stories[:STORIES_NUMBER]","def get_first_artist_from_result(result):\n return result['metadata']['music'][0]['external_metadata']['spotify']['artists'][0]['name']","def get_top_articles(update=False):\n # use caching to avoid running unnecessary DB queries at each page load\n key = 'top_ten'\n articles = memcache.get(key)\n\n logging.warn('MEMCACHE | Wiki articles %s' % str(articles))\n\n if (articles is None) or (len(articles) == 0) or update:\n # necessary artificial delay when a new article has just been persisted to the datastore\n if update:\n time.sleep(2)\n\n articles = db.GqlQuery('SELECT * FROM Article ORDER BY updated DESC LIMIT 10')\n articles = list(articles)\n memcache.set(key, articles)\n\n logging.warn('DATASTORE | Wiki articles count %s' % str(len(articles)))\n return articles","def retrieve_data():\n con = sqlite3.connect(\"/home/cyxnide/websites/ssdnewsnow/ssdnewsnow.sqlite3\")\n cur = con.cursor()\n iid = cur.execute(\"SELECT max(id) FROM news_article\")\n return iid","def top_by_ratings(self, n, metric=average):\n return top_movies","def top(self):\n return self.List_store[len(self.List_store)]","def get_popular_authors():\n db = psycopg2.connect(database=DBNAME)\n c = db.cursor()\n query_popular_authors = \"\"\"\n SELECT aut.name, COUNT(lg.id) AS views\n FROM articles AS art\n JOIN log AS lg ON art.slug = SUBSTRING(lg.path,10)\n AND lg.status = '200 OK'\n JOIN authors AS aut ON aut.id = art.author\n GROUP BY aut.name\n ORDER BY views desc; \"\"\"\n c.execute(query_popular_authors)\n authors = from_db_cursor(c)\n db.close()\n return authors","def three_most_popular_articles():\n\n # To print information\n information_string = '1. The 3 most popular articles of all time are:\\n'\n\n # Query string\n query = \"\"\"select title,count(*) as num from\n articles,log where\n log.path=CONCAT('/article/',articles.slug)\n group by articles.title\n order by num DESC limit 3;\"\"\"\n\n print(information_string)\n for result in query_db(query):\n print('\\t\"' + str(result[0]) + '\" - ' + str(result[1]) + ' views')\n\n print(\"\\n\")","def main():\n path = os.path.dirname(os.path.abspath(__file__))\n conn = sqlite3.connect(path+'/music.db')\n cur = conn.cursor()\n\n #Creates a list of tuples with the songs and the follower counts from the Follower_Data table\n cur.execute('SELECT follower_count, song FROM Follower_Data')\n follower_counts_list = cur.fetchall()\n follower_counts = []\n song_names = []\n for tup in follower_counts_list:\n follower_counts.append(tup[0])\n song_names.append(tup[1])\n\n #Creates a list of the Twitter favorites each song has per about 100 mentions.\n cur.execute('SELECT song_favorites FROM Twitter_Data')\n favorite_counts_list = cur.fetchall()\n favorite_counts = []\n for tup in favorite_counts_list:\n favorite_counts.append(tup[0])\n\n #Creates a list of the weeks each song has been on the Billboard Hot 100 chart.\n cur.execute('SELECT weeks_on_chart FROM Hot100')\n week_counts_list = cur.fetchall()\n week_counts = []\n for tup in week_counts_list:\n week_counts.append(tup[0])\n\n #Creates a list of the rankings of each song. The unique id of each song is the same as its ranking on the Billboard Hot 100.\n cur.execute('SELECT creation_id FROM Hot100')\n rank_list = cur.fetchall()\n rank_on_chart = []\n for tup in rank_list:\n rank_on_chart.append(tup[0])\n\n #Creates a three lists by using a LEFT JOIN.\n cur.execute(\"SELECT Spotify_Data.popularity, Spotify_Data.song, Hot100.creation_id FROM Spotify_Data LEFT JOIN Hot100 ON Hot100.song = Spotify_Data.song\")\n results = cur.fetchall()\n #Lists of the popularity, ranks, and songs.\n popularity_list = []\n rank_list = []\n song_name_list = []\n for res in results:\n popularity_list.append(res[0])\n rank_list.append(res[2])\n song_name_list.append(res[1])\n\n\n\n #Creates a scatter plot of each song's ranking on the chart that shows the number of favorites and their ranking to see if there is a correlation.\n fig2 = go.Figure()\n fig2.add_trace(go.Scatter(\n x=rank_on_chart,\n y=song_names,\n marker=dict(color=\"rgb(204,255,255)\", size=12),\n mode=\"markers\",\n name=\"Rank on chart\",\n ))\n fig2.add_trace(go.Scatter(\n x=favorite_counts,\n y=song_names,\n marker=dict(color=\"rgb(0, 153, 153)\", size=12),\n mode=\"markers\",\n name=\"Favorites on Twitter per 100 Tweets\",\n ))\n\n fig2.update_layout(title = \"Popularity of songs on Twitter vs. Billboard 100\",\n xaxis_title=\"Number of favorites/rank\", yaxis_title=\"Songs\", xaxis=dict(range=[0, 250]))\n \n fig2.show()\n\n\n\n\n #Creates a dot plot comparing the number of weeks a song has been on the Billboard Hot 100 with the number of weeks it has been on the chart.\n fig3 = go.Figure()\n fig3.add_trace(go.Scatter(\n x=rank_on_chart,\n y=song_names,\n marker=dict(color=\"rgb(204,255,255)\", size=12),\n mode=\"markers\",\n name=\"Rank on chart\",\n ))\n fig3.add_trace(go.Scatter(\n x=week_counts,\n y=song_names,\n marker=dict(color=\"rgb(0, 153, 153)\", size=12),\n mode=\"markers\",\n name=\"Weeks on chart\",\n ))\n\n fig3.update_layout(title = \"Weeks vs Ranking of Songs on Billboard Hot 100\",\n xaxis_title=\"Number of weeks/rank\", yaxis_title=\"Songs\")\n \n fig3.show()\n\n\n\n\n #Creates a scatterplot of comparing popularity of a song on Spotify versus its ranking on the Billboard Hot 100.\n fig = go.Figure(data=go.Scatter(x=popularity_list,\n y=rank_list,\n mode='markers',\n text=song_name_list, marker_color = \"rgb(153, 0, 153)\"))\n fig.update_traces(mode='markers', marker_line_width=2, marker_size=15)\n fig.update_layout(title='Song Ranking on Billboard Hot 100 vs Popularity on Spotify', xaxis_title=\"Popularity on Spotify\", yaxis_title=\"Ranking on Billboard Hot 100\")\n fig.show()\n\n\n\n\n #Creates a bar chart demonstrating the popularity of songs on Twitter in the order of their ranking on the Billboard Hot 100.\n barfig = go.Figure([go.Bar(y=popularity_list, x=song_name_list)])\n barfig.update_traces(marker_color=\"rgb(204, 153, 255)\", marker_line_color=\"rgb(51, 0, 102)\", marker_line_width=3, opacity=.7)\n barfig.update_layout(title_text = \"Popularity of Songs on Spotify\", xaxis_title=\"Songs in order of Hot100 Ranking\", yaxis_title=\"Popularity\", yaxis=dict(range=[0, 100]))\n barfig.show()\n\n\n\n #Creates a bar chart comparing the song favorites on Twitter versus their ranking on the Hot 100 chart\n barfig1 = go.Figure([go.Bar(y=favorite_counts, x=song_name_list)])\n barfig1.update_traces(marker_color=\"rgb(0, 153, 153)\", marker_line_color=\"rgb(153, 153, 255)\", marker_line_width=3, opacity=.7)\n barfig1.update_layout(title_text = \"Song Favorites on Twitter\", xaxis_title=\"Songs in order of Hot100 Ranking\", yaxis_title=\"Favorites on Twitter per Tweepy search (appx. 100 Tweets)\", yaxis=dict(range=[0, 250]))\n barfig1.show()","def artist(artistname):\n charts = session.query(\n Chart.artist, Chart.title)\\\n .filter(Chart.artist==artistname)\\\n .group_by(Chart.artist, Chart.title)\\\n .all()\n return charts","def display_all():\n results = artwork_db.get_all_artwork()\n for artist in results:\n print(artist)","def get_top_3_articles():\n query1 = \"\"\"select title, count(*) as views\n from articles, log\n where log.path like '%' || articles.slug\n group by title\n order by views desc\n limit 3;\"\"\"\n results = execute_query(query1)\n for result in results:\n print(\"- \\\"%s\\\" — %s views\" % (result[0], result[1]))","def author_rank():\n db, c = connect(DBNAME)\n c.execute(\"select name, count(name) as views from \\\"authorpath\\\" \"\n \"group by name order by views desc\")\n author_table = c.fetchall()\n db.close()\n print \"\\nMost Popular Article Authors of All Time:\"\n for author in author_table:\n print str(author[0]) + \" - \" + str(author[1]) + \" views\"","def get_top_news_and_the_rest(self):\n queryset = self.news.order_by('-marked', '-publication_date')\n return queryset.first(), queryset[1:]","def artist(self, q, page=None):\r\n return self.get('artist', q, page)","def top(self, **kwargs) -> Dict[str, Any]:","def query1():\n\n print(\"1. What are the most popular three articles of all time? Which \" +\n \"articles have been accessed the most?\\n\")\n\n query = \"\"\"\n SELECT articles.title, subq.hits FROM articles\n LEFT JOIN\n (SELECT COUNT(log.path) AS hits, log.path FROM log\n WHERE log.path LIKE '/article/%'\n AND log.status = '200 OK' AND log.method = 'GET'\n GROUP BY log.path) AS subq\n ON subq.path LIKE '/article/'||articles.slug\n ORDER BY subq.hits DESC LIMIT 3;\n \"\"\"\n\n response = db_query(query)\n\n for i, j in enumerate(response):\n # Convert tuple to list to allow writing. Format \"hits\" with comma\n # seperator. Print output.\n j = list(j)\n j[1] = str(format(j[1], ',d'))\n print(\" Title: '{}' - {} views\".format(*j))","def get_popular_titles():\n db = psycopg2.connect(database=DBNAME)\n c = db.cursor()\n # counting views that had status 200\n c.execute(\"select articles.title, count(*) as views \"\n \"from articles, log \"\n \"where log.path like concat('%', articles.slug, '%') \"\n \"and log.status = '200 OK' \"\n \"group by articles.title \"\n \"order by views desc limit 3\")\n results = c.fetchall()\n text_file = open(\"text.txt\", \"a+\") # append to text file\n text_file.write(\"The three most popular articles of all time are:\\n\\n\")\n # for loop to print each article\n for title, views in results:\n text_file.write(\"\\\"\" + title + \"\\\"\" + \" - \" + str(views) + \" views\\n\")\n text_file.write(\"\\n\")\n text_file.close()\n db.close","def question_1():\n cursor.execute(mostPopArticles)\n output = cursor.fetchall()\n return output","def how_popular_most_popular(data):\r\n #list of artists\r\n artists = []\r\n for key in data:\r\n if key[-1] != \"$\":\r\n for x in data[key]:\r\n artists += [x]\r\n sorted_artists = selection_sort(artists)\r\n count = 1\r\n max_count = 1\r\n max_artists = []\r\n for i in range(len(sorted_artists)-1):\r\n #ends at second to last index because I use i and i + 1\r\n if sorted_artists[i] == sorted_artists[i+1]:\r\n count += 1\r\n else:\r\n if count == max_count:\r\n max_artists += [sorted_artists[i]]\r\n count = 1\r\n elif count > max_count:\r\n max_artists = []\r\n max_artists += [sorted_artists[i]]\r\n max_count = count\r\n count = 1\r\n return max_count","def doQuery( connection ): # function definition\r\n cursor = connection.cursor()\r\n \r\n query = \"\"\"select Title, sum( UnitPrice ) as cost\r\n from Album natural join Track\r\n group by AlbumId\r\n order by cost desc\"\"\"\r\n \r\n cursor.execute( query )\r\n \r\n print( \"Album titles and cost of tracks\" )\r\n print( \"Title\\t\\t\\t\\tCost\" )\r\n for (Title, cost) in cursor:\r\n print( Title, \"\\t\\t\\t$\", cost )\r\n \r\n cursor.close()","def most_viewed_authors():\n query = \"\"\"\n SELECT authors.name, COUNT(*) AS views\n FROM articles\n JOIN log\n ON log.path = '/article/' || articles.slug\n JOIN authors\n ON authors.id = articles.author\n WHERE log.status ='200 OK'\n GROUP BY authors.name ORDER BY views DESC LIMIT 3;\n \"\"\"\n results = psql_connection(query)\n\n print(\"Most viewed authors:\")\n for result in results:\n print '{author} - {count} views'.format(\n author=result[0], count=result[1])","def print_top_authors():\n\n output = get_query_results(\n '''SELECT authors.name, COUNT(*) AS views\n FROM authors\n JOIN(SELECT articles.title, articles.author FROM articles\n JOIN log ON log.path=CONCAT('/article/', articles.slug))\n AS popular\n ON authors.id=popular.author\n GROUP BY name\n ORDER BY views DESC;'''\n )\n print(\"\\nPopularity of Authors: \\n\")\n for author, views in output:\n print(\"\\\"{}\\\" -- {} views\".format(author, views))","def get_top_articles(\n limit: int = 5,\n date: int = int(datetime.now().strftime(\"%Y%m%d\"))\n):\n\n res = articles_db.get_top_articles_mongo(\n articles,\n limit,\n date\n )\n\n return res","def most_viewed_articles():\n query = \"\"\"\n SELECT articles.title, COUNT(*) AS views\n FROM articles\n JOIN log\n ON log.path = '/article/' || articles.slug\n WHERE log.status ='200 OK'\n GROUP BY articles.title ORDER BY views DESC LIMIT 3;\n \"\"\"\n results = psql_connection(query)\n\n print(\"Most viewed articles:\")\n for result in results:\n print '{article} - {count} views'.format(\n article=result[0], count=result[1])","def sort_artist(self):\n return self.sort('artist')","def read_artists():\n list_a = [(x.first_name, x.last_name, str(x.id)) for x in dmla.list_artists()]\n list_c = [x['artist'] for x in dmlc.list_artists()]\n return list_a, list_c","def top_authors(cursor):\n top_auth = 'No authors found.'\n try:\n cursor.execute(\"\"\"\n select name, hits\n from authors, views_by_id as views_by_id\n where id = author\n group by name, hits\n order by hits desc\"\"\")\n\n authors = cursor.fetchall()\n # If no authors were found, return\n if len(authors) <= 0:\n return top_auth\n\n except psycopg2.Error as e:\n print('Fetching authors by popularity: \\r\\n{}'.format(e.pgerror))\n\n # If the query returns any authors, return the results.\n else:\n top_auth = 'Top authors by article views: \\r\\n'\n for auth in authors:\n top_auth += ' {} - {} views\\r\\n'.format(auth[0], auth[1])\n return top_auth","def top(self):\r\n return self.topele","def get_albums_recent_added(session_):\n artists = session_.query(Album).order_by(Album.added_at.desc()).all()\n return artists","def read_from_db(cursor):\n\tcursor.execute('''SELECT * FROM (\n\t\tSELECT * FROM Kombucha_data ORDER BY Time DESC LIMIT 20)\n\t\tORDER BY Time ASC;''')\n\n\trows = cursor.fetchall()\n\treturn rows","def read_from_db(cursor):\n\tcursor.execute('''SELECT * FROM (\n\t\tSELECT * FROM Kombucha_data ORDER BY Time DESC LIMIT 20)\n\t\tORDER BY Time ASC;''')\n\n\trows = cursor.fetchall()\n\treturn rows","def most_popular_articles():\n\n results = query_database(QUERIES[0])\n print('\\nWhat are the most popular three articles of all time?\\n')\n for title, views in results:\n print(' * \"{}\" -- {} views'.format(title, views))","def read_table(self):\n\n db = self.connection(database=\"imdb\")\n\n try:\n cur = db.cursor()\n sql = \"SELECT title FROM film;\"\n cur.execute(sql)\n return cur.fetchall()\n except:\n print(\"Cannot read from table!\")\n\n db.close()","def get_mostPopularAuthors():\n\n query = \"\"\"\n SELECT authors.name,COUNT(*) as views\n FROM articles join authors\n ON articles.author=authors.id\n JOIN log ON log.path LIKE ('/article/' || articles.slug)\n GROUP BY authors.name\n ORDER BY views DESC\n \"\"\"\n\n posts = execute_query(query)\n print('\\nWho are the most popular article authors of all time?')\n for author, views in posts:\n print(author + \" - \" + str(views) + \" views\")","def show_artist(artist_id):\n\n result = db.session.query(Artist).filter(Artist.id == artist_id)\n result = result[0]\n\n past_shows_count = 0\n upcoming_shows_count = 0\n\n past_shows = []\n upcoming_shows = []\n\n all_shows = Shows.query.all()\n\n print(all_shows)\n\n for show in all_shows:\n if show.artist_id == result.id:\n show_time = datetime.strptime(show.start_time, '%Y-%m-%d %H:%M:%S')\n if show_time > datetime.now() :\n upcoming_shows.append(show)\n else: \n past_shows.append(show)\n \n past_shows_count = len(past_shows)\n upcoming_shows_count = len(upcoming_shows)\n\n resdata = {\n \"id\": result.id,\n \"name\": result.name,\n \"genres\": json.loads(result.genres),\n \"city\": result.city,\n \"state\": result.state,\n \"phone\": result.phone,\n \"website\": result.website,\n \"facebook_link\": result.facebook_link,\n \"seeking_venue\": result.seeking_venue,\n \"seeking_description\": result.seeking_description,\n \"image_link\": result.image_link,\n \"past_shows\": past_shows,\n \"upcoming_shows\": upcoming_shows,\n \"past_shows_count\": past_shows_count,\n \"upcoming_shows_count\": upcoming_shows_count,\n }\n\n data = list(filter(lambda d: d[\"id\"] == artist_id, [resdata]))[0]\n return render_template(\"pages/show_artist.html\", artist=data)","def get_synopsis():\n #get all movies from db\n movies_df = movie_helper.get_movies_df() \n \n with tqdm(total=len(movies_df)) as pbar:\n for index, row in movies_df.iterrows(): \n \n #if imdb id exists use it to look up the API\n if (row['imdbId']):\n \n #get synponsis and update the db\n movie = ia.get_movie(str(row['imdbId']), info='synopsis')\n try:\n synopsis = movie['synopsis']\n database_helper.insert_data(\"synopsis\", {\"movieId\" : row[\"movieId\"], \"summary\" : synopsis}) \n except:\n #throw exception and print to console if synopsis does not exist\n print(row['title'] + ' (' + row['imdbId'] + ')')\n \n pbar.update(1)","def get_artists(self, offset=None):\n return self.__get('artists')","def top(self) -> int:\n return self.q[0]"],"string":"[\n \"def get_artists_most_played(session_):\\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\\n artists = session_.query(Artist).order_by(Artist.plays.desc()).all()\\n return artists\",\n \"def top_artists_from_API(api_results):\\r\\n df = pd.DataFrame(api_results[\\\"items\\\"])\\r\\n cols = [\\\"name\\\",\\\"id\\\",\\\"genres\\\",\\\"popularity\\\",\\\"uri\\\"]\\r\\n return df[cols]\",\n \"def topArticles():\\n c = db.cursor()\\n c.execute(\\\"select titles.title, tophits.hits\\\\\\n from tophits, titles\\\\\\n where tophits.path = titles.slug\\\\\\n order by hits desc limit 3;\\\")\\n results = c.fetchall()\\n c.close()\\n return results\",\n \"def get_albums_most_played(session_):\\n artists = session_.query(Album).order_by(Album.plays.desc()).all()\\n return artists\",\n \"async def artists(self, ctx: BBContext):\\n\\n query = \\\"\\\"\\\"SELECT DISTINCT artist_name, COUNT(*)\\n FROM extras.arts\\n WHERE artist_name IS NOT NULL\\n GROUP BY artist_name\\n ORDER BY COUNT(*) DESC\\\"\\\"\\\"\\n\\n args = [query]\\n\\n con = await ctx.get_connection()\\n data: List[asyncpg.Record] = await con.fetch(*args)\\n view = ArtsLeaderboardPagination(data, ctx.author) # type: ignore (Direct messages intent is not being used so author can only be a member)\\n await view.start(ctx.channel)\",\n \"def get_top_song_metadata():\\n cache_buster = '?v=%s' % get_timestamp()\\n response = requests.get(MUSIC_DIR + 'top_meta.json' + cache_buster)\\n return response.json()\",\n \"def get_popular_authors():\\n query_command = \\\"SELECT * from popular authors LIMIT 3\\\"\\n query_data = run_query(query_command)\\n return query_data\",\n \"def test_top_songs(self):\\n \\n rss = AppleRSS()\\n objs = rss.get_top_songs(limit=10)\\n \\n self.__test_artists('top_songs', objs)\",\n \"def topAuthors():\\n c = db.cursor()\\n c.execute(\\\"select name, sum(hits) as hits\\\\\\n from authorhits group by name\\\\\\n order by hits desc;\\\")\\n results = c.fetchall()\\n c.close()\\n return results\",\n \"def top_authors():\\n\\n cur.execute(\\\"\\\"\\\"\\n SELECT author, count(*) AS article_author\\n FROM article_summary\\n GROUP BY author\\n ORDER BY article_author DESC;\\n \\\"\\\"\\\")\\n result = cur.fetchall()\\n return result\",\n \"def artist_top_tracks(req):\\n\\n artist = req.get('result').get('parameters').get('artist')\\n logger.info('received {0} request for artist=\\\"{1}\\\"'.format('artist_top_tracks', artist))\\n top_tracks = cached_result('get_artist_top_tracks', [artist], {})\\n speech = 'Unable to locate top tracks for {artist}'.format(artist=artist)\\n\\n if top_tracks is not None:\\n speech = 'The most popular songs for {artist} are'.format(artist=artist)\\n for track in top_tracks:\\n speech += '. ' + track\\n\\n return jsonify(\\n {'speech': speech,\\n 'displayText': speech,\\n 'source': 'last-assist'})\",\n \"def search_for_artist_top_tracks(name):\\n\\tartist_id = search_for_artist(name)\\n\\ttoken = get_token()\\n\\tif artist_id and token:\\n\\t\\theaders = {\\\"Content-Type\\\": \\\"application/json\\\", \\\"Authorization\\\": \\\"Bearer \\\" + token}\\n\\t\\toptions = {'country': 'TR'}\\n\\t\\tresponse = requests.get(\\n\\t\\t\\t'https://api.spotify.com/v1/artists/'+artist_id+'/top-tracks',\\n\\t\\t\\theaders=headers,\\n\\t\\t\\tparams=options\\n\\t\\t)\\n\\t\\tif response.status_code == 200:\\n\\t\\t\\tcontent = json.loads(response.content.decode('utf-8'))\\n\\t\\t\\tif content:\\n\\t\\t\\t\\treturn content['tracks']\\n\\t\\t\\telse: return None\\n\\t\\telse:\\n\\t\\t\\treturn None\\n\\telse:\\n\\t\\treturn None\",\n \"def get_top_artists(\\n self, period: Period, limit: int = 50, page: int = 1\\n ) -> ListModel[Artist]:\\n assert isinstance(period, Period)\\n return self.retrieve(\\n bind=Artist,\\n flatten=\\\"artist\\\",\\n params=dict(\\n method=\\\"user.getTopArtists\\\",\\n user=self.name,\\n limit=limit,\\n page=page,\\n period=period.value,\\n ),\\n )\",\n \"def generate_artist_data(name, use_id=False):\\n if use_id:\\n query = \\\"http://54.235.241.196/{0}\\\".format(name)\\n artist_json_data = get_raw_json(query)\\n return artist_json_data\\n\\n query = \\\"http://54.235.241.196/search?t=artist&q={0}&geo=US\\\".format(\\n quote(name))\\n json_data = get_raw_json(query)\\n top_hit_json = json_data[\\\"data\\\"][0]\\n\\n return top_hit_json\",\n \"def query_article():\\r\\n conn, cur = connect()\\r\\n query1 = (\\\"select * from article limit 3\\\")\\r\\n cur.execute(query1)\\r\\n res = cur.fetchall()\\r\\n conn.close()\\r\\n print (\\\"\\\\nThe most popular three articles of all time:\\\\n\\\")\\r\\n for i in range(0, len(res), 1):\\r\\n print (res[i][0] + \\\" --> \\\" + str(res[i][1]) + \\\" views\\\")\",\n \"def get_popular_article():\\n query_command = \\\"SELECT * from popular_posts LIMIT 3\\\"\\n query_data = run_query(query_command)\\n return query_data\",\n \"def find_top_tracks(self, artist, N=10):\\n tracklist = []\\n try:\\n result = self.sp.artist_top_tracks(artist)\\n except ConnectionError as e:\\n print (\\\"ERROR: connection pool is closed; searching Spotify for top tracks for this artist: \\\" + artist)\\n result = self.sp.artist_top_tracks(artist)\\n print (\\\"tried again\\\")\\n print (result)\\n raise e\\n\\n tracklist.extend(result.get(\\\"tracks\\\"))\\n if len(tracklist) > N:\\n return tracklist[0:N]\\n else:\\n return tracklist\",\n \"def current_user_top_artists(\\n self, limit=20, offset=0, time_range=TimeRange.MEDIUM_TERM, **kwargs\\n ):\\n return self._get(\\n API.MY_TOP.value.format(type=\\\"artists\\\"), # pylint: disable=no-member\\n time_range=TimeRange(time_range).value,\\n limit=limit,\\n offset=offset,\\n **kwargs,\\n )\",\n \"def question_2():\\n cursor.execute(mostPopAuthors)\\n output = cursor.fetchall()\\n return output\",\n \"def get_artists_recent_played(session_):\\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\\n artists = session_.query(Artist).order_by(Artist.played_at.asc()).all()\\n return artists\",\n \"async def get_top(self, limit, iterator):\\n if iterator == 'ITERATOR_LE':\\n iterator = 'DESC'\\n if iterator == 'ITERATOR_GE':\\n iterator = 'ASC'\\n sql = (\\n \\\"select data from stickers order by (data->>1)::int {} limit {}\\\"\\n ).format(iterator, limit)\\n result = await self.db.fetch(sql)\\n ret = []\\n for i in result:\\n ret.append(json.loads(i[0]))\\n return ret\",\n \"def get_most_popular_articles():\\n\\tdb = psycopg2.connect(database=DBNAME)\\n\\tc = db.cursor()\\n\\tc.execute(\\\"select t2.title, count(*) as total from log as t1,articles as t2 where t1.path=concat('/article/',t2.slug) group by t2.title order by total desc limit 3 ;\\\")\\n\\tdata = c.fetchall()\\n\\tdb.close()\\n\\treturn data\",\n \"def select_artists(conn):\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * FROM artists\\\")\\n \\n rows = cur.fetchall()\\n \\n for row in rows:\\n print(row)\",\n \"def popular_authors() :\\n query = \\\"\\\"\\\"SELECT authors.name,count(*) AS total_views FROM authors,articles,log WHERE log.path like concat ('/article/',articles.slug)\\n AND articles.author=authors.id group by authors.name order by total_views desc\\\"\\\"\\\"\\n result = get_data(query)\\n print(\\\" 2. The most popular articles authors of all time:\\\")\\n print(\\\"\\\")\\n for record in result :\\n print(' ' +' ' + str(record[0]) + ' -' + ' ' + str(record[1]) + ' ' +'views')\\n print(\\\" \\\")\",\n \"async def arts(self, ctx: BBContext, artist: Optional[discord.Member] = None):\\n\\n if artist:\\n query = f'SELECT url, artist_name FROM {TABLE_ARTS} WHERE artist_id = $1 LIMIT 20'\\n args = [query, artist.id]\\n else:\\n query = f'SELECT url, artist_name FROM {TABLE_ARTS} ORDER BY random() LIMIT 20'\\n args = [query]\\n\\n con = await ctx.get_connection()\\n data: List[asyncpg.Record] = await con.fetch(*args)\\n\\n view = ArtsPagination(data, ctx.author) # type: ignore (Direct messages intent is not being used so author can only be a member)\\n await view.start(ctx.channel)\",\n \"def get_artist(artist_id):\\n return query_single(artist_id, Artist, artist_schema)\",\n \"def get_most_popular_authors():\\n\\tdb = psycopg2.connect(database=DBNAME)\\n\\tc = db.cursor()\\n\\tc.execute(\\\" select t1.name,count(*) as total from authors as t1, articles as t2,log as t3 where t3.path=concat('/article/',t2.slug) and t1.id=t2.author group by t1.name order by total desc limit 3;\\\")\\n\\tdata = c.fetchall()\\n\\tdb.close()\\n\\n\\treturn data\",\n \"def top3_articles():\\n\\n cur.execute(\\\"\\\"\\\"\\n SELECT title, COUNT(*) AS article_title\\n FROM article_summary\\n GROUP BY title\\n ORDER BY article_title DESC\\n LIMIT 3;\\n \\\"\\\"\\\")\\n result = cur.fetchall()\\n return result\",\n \"def printTopAuthors():\\n query = \\\"\\\"\\\"\\n SELECT author_article_popularity_view.author,\\n SUM(author_article_popularity_view.views) AS total_views\\n FROM author_article_popularity_view\\n GROUP BY author_article_popularity_view.author\\n ORDER BY total_views DESC;\\n \\\"\\\"\\\"\\n cursor = connection.cursor()\\n cursor.execute(query)\\n results = cursor.fetchall()\\n print(\\\"\\\\nTop authors of all time: \\\")\\n for i, result in enumerate(results):\\n print(\\\"{}. {} - {:,} views\\\".format(i + 1, result[0], result[1]))\",\n \"def most_popular_artist(our_data):\\n counter_dict = {}\\n for artist in all_artists(our_data):\\n if artist in counter_dict:\\n counter_dict[artist] += 1\\n else:\\n counter_dict[artist] = 1\\n maximum_albums = max(counter_dict.values())\\n artist_lists = []\\n for keys, values in counter_dict.items():\\n if values == maximum_albums:\\n artist_lists.append(keys) \\n return artist_lists\",\n \"def most_popular_articles():\\n print '1. The most popular articles are...'\\n return (\\\"\\\"\\\"SELECT articles.title, COUNT(*) as num FROM articles, log\\\"\\\"\\\"\\n \\\"\\\"\\\" WHERE SUBSTRING (log.path FROM 10) = articles.slug and\\\"\\\"\\\"\\n \\\"\\\"\\\" log.path != '/' Group By articles.title ORDER By num\\\"\\\"\\\"\\n \\\"\\\"\\\" DESC LIMIT 3;\\\"\\\"\\\")\",\n \"def _get_top_tracks(artist, limit):\\n\\n l = []\\n for track in _lastfm.get_artist(artist).get_top_tracks(limit=limit):\\n track = track.item\\n l.append({\\\"artist\\\": track.get_artist().get_name(), \\\"title\\\": track.get_title()})\\n \\n return l\",\n \"def get_top(self):\\n\\n sql = \\\"SELECT username FROM Users ORDER BY score DESC LIMIT 10\\\"\\n self.cursor.execute(sql)\\n return self.cursor.fetchall()\",\n \"def get_top_authors():\\n query2 = \\\"\\\"\\\"select name, count(*) as views\\n from authors, articles, log\\n where authors.id = articles.author\\n and log.path like '%' || articles.slug\\n group by name\\n order by views desc;\\\"\\\"\\\"\\n results = execute_query(query2)\\n for result in results:\\n print(\\\"- %s — %s views\\\" % (result[0], result[1]))\",\n \"def parse_json_artist(JSON_ARTIST_FILE, num_show=10):\\n with open(JSON_ARTIST_FILE) as f:\\n data = json.load(f)\\n num_artist = len(data['artists']['items'])\\n print(f'For word \\\"{ARTIST}\\\" has been found {num_artist} artists')\\n Artist = namedtuple('Artist', 'name popularity genres')\\n artist_list = []\\n for num in range(num_artist):\\n name = data['artists']['items'][num]['name']\\n popularity = data['artists']['items'][num]['popularity']\\n genres = ', '.join(data['artists']['items'][num]['genres'])\\n if not genres:\\n genres = '-'\\n artist_list.append(Artist(name=name, popularity=popularity, \\\\\\n genres=genres))\\n sorted_artist_list = sorted(artist_list, key=lambda x: -x.popularity)\\n print(tb(sorted_artist_list[:num_show], headers=artist_list[0]._fields))\\n return None\",\n \"def popular_articles():\\n query = \\\"\\\"\\\"SELECT articles.title,count(*) AS total_views FROM articles,log WHERE log.path like concat('/article/',articles.slug)\\n group by articles.title order by total_views desc limit 3\\\"\\\"\\\"\\n result = get_data(query)\\n print(\\\" 1. The most popular three articles of all time:\\\")\\n print(\\\"\\\")\\n for record in result :\\n print(' ' + '\\\\\\\"' + str(record[0]) + '\\\\\\\"' + '-' + ' ' + str(record[1]) + ' '+ 'views')\\n print(\\\" \\\")\",\n \"def print_top_articles():\\n\\n output = get_query_results(\\n '''SELECT articles.title, COUNT(path) AS views\\n FROM articles\\n JOIN log\\n ON log.path=CONCAT('/article/', articles.slug)\\n GROUP BY title\\n ORDER BY views DESC\\n LIMIT 3;'''\\n )\\n print(\\\"\\\\nMost Popular Articles: \\\\n\\\")\\n for title, views in output:\\n print(\\\"\\\\\\\"{}\\\\\\\" -- {} views\\\".format(title, views))\",\n \"def read_artist_page(artist):\\n url = BASE_URL + '/artist/' + artist\\n print(f'reading artist page: {url}')\\n artist_page = requests.get(url, headers=HEADERS)\\n return artist_page.text\",\n \"def top_tracks(genre):\\n\\tartist = random.choice(genre_artist[genre])\\n\\ttop_tracks = search_for_artist_top_tracks(artist)\\n\\titems = []\\n\\tif top_tracks:\\n\\t\\tfor track in top_tracks:\\n\\t\\t\\titems.append({\\\"artist\\\": track[\\\"artists\\\"][0][\\\"name\\\"], \\\"popularity\\\": track[\\\"popularity\\\"], \\\"track\\\": track[\\\"name\\\"],\\n\\t\\t\\t\\t \\\"preview_url\\\": track[\\\"preview_url\\\"], \\\"album_image_url\\\": track[\\\"album\\\"][\\\"images\\\"][2][\\\"url\\\"]})\\n\\t\\titems = sorted(items, key=lambda x: x['popularity'], reverse=True)\\n\\t\\tfor item in items:\\n\\t\\t\\tdel item['popularity']\\n\\t\\treturn items\\n\\telse:\\n\\t\\treturn None\",\n \"def top(self, **kwargs):\\n return self.client.api.top(self.id, **kwargs)\",\n \"def get_albums_recent_played(session_):\\n artists = session_.query(Album).order_by(Album.played_at.desc()).all()\\n return artists\",\n \"def most_popular_article_authors():\\n\\n # To print information\\n information_string = '2. The most popular article ' \\\\\\n 'authors of all time are:\\\\n'\\n\\n # Query string\\n query = \\\"\\\"\\\" select x.author , count(1) as qtd from (\\n SELECT b.name as author\\n FROM articles a join authors b on(a.author = b.id)\\n join log c on(c.path = '/article/' ||a.slug)\\n ) x group by x.author order by 2 desc;\\\"\\\"\\\"\\n\\n print(information_string)\\n for result in query_db(query):\\n print('\\\\t' + str(result[0]) + ' - ' + str(result[1]) + ' views')\\n\\n print(\\\"\\\\n\\\")\",\n \"def printTopThreeArticles():\\n query = \\\"\\\"\\\"\\n SELECT author_article_popularity_view.article,\\n author_article_popularity_view.views\\n FROM author_article_popularity_view\\n LIMIT 3;\\n \\\"\\\"\\\"\\n cursor = connection.cursor()\\n cursor.execute(query)\\n results = cursor.fetchall()\\n print(\\\"\\\\nTop 3 articles of all time: \\\")\\n for i, result in enumerate(results):\\n print(\\\"{}. \\\\\\\"{}\\\\\\\" - {:,} views\\\".format(i + 1, result[0], result[1]))\",\n \"def query_artist(self, artist_name):\\n # Check if the artist is in the database\\n try:\\n a = Artist.objects.get(searched_name = artist_name)\\n return ArtistObject(searched_name=artist_name, db_model=a)\\n\\n # If the artist isn't in the database, search Spotify\\n except Artist.DoesNotExist:\\n print(\\\"Artist not found in database: \\\", artist_name)\\n result = self.search_spotify(artist_name)\\n\\n # If there were any errors searching Spotify, don't continue\\n if result is None:\\n # SKIP FOR TEST NOW\\n ArtistObject(searched_name=artist_name).save_to_db()\\n return None\\n else:\\n artist = self.filter_spotify_result(result, artist_name)\\n\\n if artist is None:\\n ArtistObject(searched_name=artist_name).save_to_db()\\n return None\\n\\n top_tracks = self.find_top_tracks(artist.uri)\\n artist.add_songs(top_tracks)\\n\\n # Save artist URI to the database for faster results next time\\n print(\\\"About to save artist with name {} and object: \\\".format(artist_name), artist)\\n artist.save_to_db()\\n\\n return artist\",\n \"def popular_articles():\\n db = psycopg2.connect(\\\"dbname=news\\\")\\n \\\"\\\"\\\"Connect to news database.\\\"\\\"\\\"\\n c = db.cursor()\\n \\\"\\\"\\\"Open a cursor to perform database operation.\\\"\\\"\\\"\\n query = \\\"\\\"\\\"select title, count(path) as view from articles, log \\n where '/article/' || articles.slug = log.path group by title, path \\n order by view desc limit 3;\\\"\\\"\\\"\\n \\\"\\\"\\\"The cursor runs query and fetches result.\\\"\\\"\\\"\\n c.execute(query)\\n \\\"\\\"\\\"Execute query using cursor.\\\"\\\"\\\"\\n rows = c.fetchall()\\n print \\\"Most popular three articles of all time: \\\"\\n print \\\"---------------------------------------- \\\"\\n for row in rows:\\n print row[0], \\\"--\\\", row[1], \\\" views\\\"\\n db.close()\",\n \"def top(self):\",\n \"def test_top_albums(self):\\n \\n rss = AppleRSS()\\n objs = rss.get_top_albums(limit=10)\\n \\n self.__test_artists('top_albums', objs)\",\n \"def get_artist_audio_features(q, interactive = False, genre_delimiter = '-!!-', to_file = '', client = None):\\n query = client.search(q = q, type = \\\"artist\\\")\\n items = query['artists']['items']\\n\\n if not items:\\n raise Exception(\\\"No artists found\\\")\\n\\n if interactive:\\n print(\\\"Select the artist to use...\\\")\\n print(\\\"\\\\n\\\".join(\\\"[{}]: {}\\\".format(ii, entry['name']) for ii, entry in enumerate(items)))\\n artist_indx = int(input(\\\"artist number: \\\").strip())\\n if artist_indx > len(items):\\n raise IndexError(\\\"Selected number higher than options available\\\")\\n artist = items[artist_indx]\\n else:\\n artist = items[0]\\n\\n # get artist genres\\n artist_genres = genre_delimiter.join(artist['genres']) if genre_delimiter else None\\n\\n # get artist albums\\n albums = get_artist_albums(artist['id'])\\n albums['artist_genres'] = artist_genres\\n\\n # get album popularity\\n album_popularity = get_album_popularity(albums.id)\\n\\n # get album tracks\\n tracks = get_album_tracks(albums.id)\\n\\n # get track audio features\\n features = get_track_features(tracks.id)\\n\\n # get track popularity\\n popularity = get_track_popularity(tracks.id)\\n\\n album_data = albums.merge(album_popularity, 'left', 'id')\\n\\n track_data = tracks \\\\\\n .drop(columns = ['type']) \\\\\\n .merge(popularity, 'left', 'id') \\\\\\n .merge(features.drop(columns = ['uri', 'type', 'duration_ms']), 'left', 'id')\\n\\n\\n merged = prefix_merge(album_data, track_data, ['album_', 'track_'], how = 'left', on = 'album_id')\\n\\n if to_file:\\n merged.to_csv(to_file)\\n\\n return merged\",\n \"def most_popular_authors():\\n print '2. The most popular authors are...'\\n return (\\\"\\\"\\\"SELECT authors.name, count(*) as num from\\\"\\\"\\\"\\n \\\"\\\"\\\" authors, articles, log WHERE SUBSTRING (log.path FROM 10)\\\"\\\"\\\"\\n \\\"\\\"\\\" = articles.slug and articles.author = authors.id and\\\"\\\"\\\"\\n \\\"\\\"\\\" log.path != '/' Group By authors.name ORDER by num\\\"\\\"\\\"\\n \\\"\\\"\\\" DESC LIMIT 20;\\\"\\\"\\\")\",\n \"def article_rank():\\n db, c = connect(DBNAME)\\n c.execute(\\\"select title, count(title) as views from \\\\\\\"pathslug\\\\\\\" \\\"\\n \\\"group by title order by views desc limit 3\\\")\\n article_table = c.fetchall()\\n db.close()\\n print \\\"\\\\nThree Most Popular Articles All Time:\\\"\\n for article in article_table:\\n print str(article[0]) + \\\" - \\\" + str(article[1]) + \\\" views\\\"\",\n \"def topTags(db, topN=1000):\\n c=db.cursor()\\n c.execute(\\\"\\\"\\\"\\n SELECT\\n tag\\n FROM tags\\n GROUP BY tag\\n ORDER BY COUNT(*) DESC\\n LIMIT %d\\n \\\"\\\"\\\" % topN)\\n tops = [tag0[0] for tag0 in c.fetchall()]\\n c.close()\\n return tops\",\n \"def get_popular_articles():\\n db = psycopg2.connect(database=DBNAME)\\n c = db.cursor()\\n query_popular_articles = \\\"\\\"\\\"\\n SELECT art.title, COUNT(lg.id) as views\\n FROM articles as art\\n JOIN log as lg\\n ON art.slug = substring(lg.path,10)\\n AND lg.status = '200 OK'\\n GROUP BY art.title\\n ORDER BY views desc\\n LIMIT 3; \\\"\\\"\\\"\\n c.execute(query_popular_articles)\\n articles = from_db_cursor(c)\\n db.close()\\n return articles\",\n \"def get_artists_alpha(session_):\\n # artists = session_.query(Artist).order_by(Artist.name.desc()).paginate()\\n artists = session_.query(Artist).order_by(Artist.name.asc()).all()\\n return artists\",\n \"def get_popular_authors():\\n db = psycopg2.connect(database=DBNAME)\\n c = db.cursor()\\n # counting views that had status 200\\n c.execute(\\\"select authors.name, count(*) as num \\\"\\n \\\"from articles, authors, log \\\"\\n \\\"where articles.author = authors.id \\\"\\n \\\"and log.path like concat('%', articles.slug, '%') \\\"\\n \\\"and log.status = '200 OK' \\\"\\n \\\"group by authors.name order by num desc\\\")\\n results = c.fetchall()\\n text_file = open(\\\"text.txt\\\", \\\"a+\\\") # append to text file\\n text_file.write(\\\"The most popular authors of all time are:\\\\n\\\\n\\\")\\n # for loop to print each author\\n for name, num in results:\\n text_file.write(\\\"\\\\\\\"\\\" + name + \\\"\\\\\\\"\\\" + \\\" - \\\" + str(num) + \\\" views\\\\n\\\")\\n text_file.write(\\\"\\\\n\\\")\\n text_file.close()\\n db.close\",\n \"def do_top(cs, args):\\n resp, data = cs.repositories.get_top(args.count)\\n utils.print_list(data, ['name', 'count'], sortby='count')\",\n \"def getdata_from_db(number):\\n print(\\\"Connecting to database\\\")\\n query = sqlite3.connect(DB_PATH).cursor()\\n query.execute(\\n \\\"SELECT text FROM data ORDER BY id DESC LIMIT \\\" + str(number) + \\\"; \\\")\\n tweets = [line[0] for line in query.fetchall()]\\n print(\\\"Tweets from databases: %d tweets\\\" % (len(tweets)))\\n return tweets\",\n \"def get_artists_recent_added(session_):\\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\\n artists = session_.query(Artist).order_by(Artist.added_at.asc()).all()\\n return artists\",\n \"def get_most_popular_artists(data):\\r\\n #list of artists\\r\\n artists = []\\r\\n for key in data:\\r\\n if key[-1] != \\\"$\\\":\\r\\n for x in data[key]:\\r\\n artists += [x]\\r\\n sorted_artists = selection_sort(artists)\\r\\n count = 1\\r\\n max_count = 1\\r\\n max_artists = []\\r\\n for i in range(len(sorted_artists)-1):\\r\\n #ends at second to last index because I use i and i + 1\\r\\n if sorted_artists[i] == sorted_artists[i+1]:\\r\\n count += 1\\r\\n else:\\r\\n if count == max_count:\\r\\n max_artists += [sorted_artists[i]]\\r\\n count = 1\\r\\n elif count > max_count:\\r\\n max_artists = []\\r\\n max_artists += [sorted_artists[i]]\\r\\n max_count = count\\r\\n count = 1\\r\\n return max_artists\",\n \"def get_amarok_data(item, db):\\n\\n if hasattr(item, 'amarok_uid') and item.amarok_uid:\\n condition = \\\"REPLACE(uniqueid, 'amarok-sqltrackuid://', '') = '%s'\\\" % MySQLdb.escape_string(item.amarok_uid)\\n else:\\n condition = \\\"REPLACE(CONCAT_WS('/',lastmountpoint, rpath), '/./', '/') = '%s'\\\" % MySQLdb.escape_string(item.path)\\n\\n query = \\\"SELECT REPLACE(uniqueid, 'amarok-sqltrackuid://', '') AS uniqueid, rating, score \\\\\\n FROM statistics \\\\\\n INNER JOIN urls ON statistics.url = urls.id \\\\\\n INNER JOIN devices ON devices.id = urls.deviceid \\\\\\n WHERE %s \\\\\\n LIMIT 1\\\" % condition\\n\\n try:\\n cursor = db.cursor()\\n\\n cursor.execute(query)\\n\\n row = cursor.fetchone()\\n\\n except MySQLdb.Error, e:\\n log.error(u'Could not fetch metadata from amarok database: {0}'.format(e))\\n row = (None, 0, 0)\\n\\n if row is None:\\n log.info(u'Could not find entry for \\\\'{0}\\\\' in amarok database'.format(displayable_path(item.path)))\\n row = (None, 0, 0)\\n\\n item.amarok_uid = row[0]\\n\\n showdiff_rating = False\\n showdiff_score = False\\n\\n if hasattr(item, 'rating') and item.rating and long(item.rating) != row[1]:\\n showdiff_rating = True\\n if hasattr(item, 'score') and item.score and float(item.score) != row[2]:\\n showdiff_score = True\\n\\n if showdiff_rating or showdiff_score:\\n print item.artist, \\\" - \\\", item.album, \\\" - \\\", item.title\\n\\n if showdiff_rating:\\n ui.commands._showdiff('rating', item.rating, row[1])\\n\\n if showdiff_score:\\n ui.commands._showdiff('score', item.score, row[2])\\n\\n item.rating = row[1]\\n item.score = row[2]\",\n \"def _get_artist(self):\\n artists = FileRecord.query(FileRecord.artist).distinct().filter(\\n FileRecord.album == self.name).filter(\\n FileRecord.year == self.year).all()\\n\\n if len(artists) > 1:\\n return \\\"Various Artists\\\"\\n elif len(artists) == 1:\\n return artists[0][0]\\n else:\\n return \\\"(Unknown)\\\"\",\n \"def query2():\\n\\n print(\\\"2. Who are the most popular article authors of all time?\\\\n\\\")\\n\\n query = \\\"\\\"\\\"\\n SELECT authors.name, subq_author.hits FROM authors\\n LEFT JOIN\\n (SELECT articles.author, CAST(SUM(subq_article.hits) AS INTEGER)\\n AS hits FROM articles\\n LEFT JOIN\\n (SELECT COUNT(log.path) AS hits, log.path FROM log\\n WHERE log.path LIKE '/article/%'\\n AND log.status = '200 OK' AND log.method = 'GET'\\n GROUP BY log.path) AS subq_article\\n ON subq_article.path LIKE '/article/'||articles.slug\\n GROUP BY articles.author) AS subq_author\\n ON authors.id = subq_author.author\\n ORDER BY subq_author.hits DESC;\\n \\\"\\\"\\\"\\n\\n response = db_query(query)\\n\\n for i, j in enumerate(response):\\n # Convert tuple to list to allow writing. Format \\\"hits\\\" with comma\\n # seperator. Print output.\\n j = list(j)\\n j[1] = str(format(j[1], ',d'))\\n print(\\\" Author: '{}' - {} views\\\".format(*j))\",\n \"def get_top_stories(self):\\n stories = requests.get(f\\\"{HN_API_URL}/topstories.json\\\")\\n stories_ids = json.loads(stories.text)\\n urls = [f\\\"{HN_API_URL}/item/{story_id}.json\\\" for story_id in stories_ids]\\n fetched_stories = asyncio.run(self.fetch_all(urls))\\n sorted_stories = sorted(\\n fetched_stories, key=lambda k: k[\\\"score\\\"], reverse=True)\\n return sorted_stories[:STORIES_NUMBER]\",\n \"def get_first_artist_from_result(result):\\n return result['metadata']['music'][0]['external_metadata']['spotify']['artists'][0]['name']\",\n \"def get_top_articles(update=False):\\n # use caching to avoid running unnecessary DB queries at each page load\\n key = 'top_ten'\\n articles = memcache.get(key)\\n\\n logging.warn('MEMCACHE | Wiki articles %s' % str(articles))\\n\\n if (articles is None) or (len(articles) == 0) or update:\\n # necessary artificial delay when a new article has just been persisted to the datastore\\n if update:\\n time.sleep(2)\\n\\n articles = db.GqlQuery('SELECT * FROM Article ORDER BY updated DESC LIMIT 10')\\n articles = list(articles)\\n memcache.set(key, articles)\\n\\n logging.warn('DATASTORE | Wiki articles count %s' % str(len(articles)))\\n return articles\",\n \"def retrieve_data():\\n con = sqlite3.connect(\\\"/home/cyxnide/websites/ssdnewsnow/ssdnewsnow.sqlite3\\\")\\n cur = con.cursor()\\n iid = cur.execute(\\\"SELECT max(id) FROM news_article\\\")\\n return iid\",\n \"def top_by_ratings(self, n, metric=average):\\n return top_movies\",\n \"def top(self):\\n return self.List_store[len(self.List_store)]\",\n \"def get_popular_authors():\\n db = psycopg2.connect(database=DBNAME)\\n c = db.cursor()\\n query_popular_authors = \\\"\\\"\\\"\\n SELECT aut.name, COUNT(lg.id) AS views\\n FROM articles AS art\\n JOIN log AS lg ON art.slug = SUBSTRING(lg.path,10)\\n AND lg.status = '200 OK'\\n JOIN authors AS aut ON aut.id = art.author\\n GROUP BY aut.name\\n ORDER BY views desc; \\\"\\\"\\\"\\n c.execute(query_popular_authors)\\n authors = from_db_cursor(c)\\n db.close()\\n return authors\",\n \"def three_most_popular_articles():\\n\\n # To print information\\n information_string = '1. The 3 most popular articles of all time are:\\\\n'\\n\\n # Query string\\n query = \\\"\\\"\\\"select title,count(*) as num from\\n articles,log where\\n log.path=CONCAT('/article/',articles.slug)\\n group by articles.title\\n order by num DESC limit 3;\\\"\\\"\\\"\\n\\n print(information_string)\\n for result in query_db(query):\\n print('\\\\t\\\"' + str(result[0]) + '\\\" - ' + str(result[1]) + ' views')\\n\\n print(\\\"\\\\n\\\")\",\n \"def main():\\n path = os.path.dirname(os.path.abspath(__file__))\\n conn = sqlite3.connect(path+'/music.db')\\n cur = conn.cursor()\\n\\n #Creates a list of tuples with the songs and the follower counts from the Follower_Data table\\n cur.execute('SELECT follower_count, song FROM Follower_Data')\\n follower_counts_list = cur.fetchall()\\n follower_counts = []\\n song_names = []\\n for tup in follower_counts_list:\\n follower_counts.append(tup[0])\\n song_names.append(tup[1])\\n\\n #Creates a list of the Twitter favorites each song has per about 100 mentions.\\n cur.execute('SELECT song_favorites FROM Twitter_Data')\\n favorite_counts_list = cur.fetchall()\\n favorite_counts = []\\n for tup in favorite_counts_list:\\n favorite_counts.append(tup[0])\\n\\n #Creates a list of the weeks each song has been on the Billboard Hot 100 chart.\\n cur.execute('SELECT weeks_on_chart FROM Hot100')\\n week_counts_list = cur.fetchall()\\n week_counts = []\\n for tup in week_counts_list:\\n week_counts.append(tup[0])\\n\\n #Creates a list of the rankings of each song. The unique id of each song is the same as its ranking on the Billboard Hot 100.\\n cur.execute('SELECT creation_id FROM Hot100')\\n rank_list = cur.fetchall()\\n rank_on_chart = []\\n for tup in rank_list:\\n rank_on_chart.append(tup[0])\\n\\n #Creates a three lists by using a LEFT JOIN.\\n cur.execute(\\\"SELECT Spotify_Data.popularity, Spotify_Data.song, Hot100.creation_id FROM Spotify_Data LEFT JOIN Hot100 ON Hot100.song = Spotify_Data.song\\\")\\n results = cur.fetchall()\\n #Lists of the popularity, ranks, and songs.\\n popularity_list = []\\n rank_list = []\\n song_name_list = []\\n for res in results:\\n popularity_list.append(res[0])\\n rank_list.append(res[2])\\n song_name_list.append(res[1])\\n\\n\\n\\n #Creates a scatter plot of each song's ranking on the chart that shows the number of favorites and their ranking to see if there is a correlation.\\n fig2 = go.Figure()\\n fig2.add_trace(go.Scatter(\\n x=rank_on_chart,\\n y=song_names,\\n marker=dict(color=\\\"rgb(204,255,255)\\\", size=12),\\n mode=\\\"markers\\\",\\n name=\\\"Rank on chart\\\",\\n ))\\n fig2.add_trace(go.Scatter(\\n x=favorite_counts,\\n y=song_names,\\n marker=dict(color=\\\"rgb(0, 153, 153)\\\", size=12),\\n mode=\\\"markers\\\",\\n name=\\\"Favorites on Twitter per 100 Tweets\\\",\\n ))\\n\\n fig2.update_layout(title = \\\"Popularity of songs on Twitter vs. Billboard 100\\\",\\n xaxis_title=\\\"Number of favorites/rank\\\", yaxis_title=\\\"Songs\\\", xaxis=dict(range=[0, 250]))\\n \\n fig2.show()\\n\\n\\n\\n\\n #Creates a dot plot comparing the number of weeks a song has been on the Billboard Hot 100 with the number of weeks it has been on the chart.\\n fig3 = go.Figure()\\n fig3.add_trace(go.Scatter(\\n x=rank_on_chart,\\n y=song_names,\\n marker=dict(color=\\\"rgb(204,255,255)\\\", size=12),\\n mode=\\\"markers\\\",\\n name=\\\"Rank on chart\\\",\\n ))\\n fig3.add_trace(go.Scatter(\\n x=week_counts,\\n y=song_names,\\n marker=dict(color=\\\"rgb(0, 153, 153)\\\", size=12),\\n mode=\\\"markers\\\",\\n name=\\\"Weeks on chart\\\",\\n ))\\n\\n fig3.update_layout(title = \\\"Weeks vs Ranking of Songs on Billboard Hot 100\\\",\\n xaxis_title=\\\"Number of weeks/rank\\\", yaxis_title=\\\"Songs\\\")\\n \\n fig3.show()\\n\\n\\n\\n\\n #Creates a scatterplot of comparing popularity of a song on Spotify versus its ranking on the Billboard Hot 100.\\n fig = go.Figure(data=go.Scatter(x=popularity_list,\\n y=rank_list,\\n mode='markers',\\n text=song_name_list, marker_color = \\\"rgb(153, 0, 153)\\\"))\\n fig.update_traces(mode='markers', marker_line_width=2, marker_size=15)\\n fig.update_layout(title='Song Ranking on Billboard Hot 100 vs Popularity on Spotify', xaxis_title=\\\"Popularity on Spotify\\\", yaxis_title=\\\"Ranking on Billboard Hot 100\\\")\\n fig.show()\\n\\n\\n\\n\\n #Creates a bar chart demonstrating the popularity of songs on Twitter in the order of their ranking on the Billboard Hot 100.\\n barfig = go.Figure([go.Bar(y=popularity_list, x=song_name_list)])\\n barfig.update_traces(marker_color=\\\"rgb(204, 153, 255)\\\", marker_line_color=\\\"rgb(51, 0, 102)\\\", marker_line_width=3, opacity=.7)\\n barfig.update_layout(title_text = \\\"Popularity of Songs on Spotify\\\", xaxis_title=\\\"Songs in order of Hot100 Ranking\\\", yaxis_title=\\\"Popularity\\\", yaxis=dict(range=[0, 100]))\\n barfig.show()\\n\\n\\n\\n #Creates a bar chart comparing the song favorites on Twitter versus their ranking on the Hot 100 chart\\n barfig1 = go.Figure([go.Bar(y=favorite_counts, x=song_name_list)])\\n barfig1.update_traces(marker_color=\\\"rgb(0, 153, 153)\\\", marker_line_color=\\\"rgb(153, 153, 255)\\\", marker_line_width=3, opacity=.7)\\n barfig1.update_layout(title_text = \\\"Song Favorites on Twitter\\\", xaxis_title=\\\"Songs in order of Hot100 Ranking\\\", yaxis_title=\\\"Favorites on Twitter per Tweepy search (appx. 100 Tweets)\\\", yaxis=dict(range=[0, 250]))\\n barfig1.show()\",\n \"def artist(artistname):\\n charts = session.query(\\n Chart.artist, Chart.title)\\\\\\n .filter(Chart.artist==artistname)\\\\\\n .group_by(Chart.artist, Chart.title)\\\\\\n .all()\\n return charts\",\n \"def display_all():\\n results = artwork_db.get_all_artwork()\\n for artist in results:\\n print(artist)\",\n \"def get_top_3_articles():\\n query1 = \\\"\\\"\\\"select title, count(*) as views\\n from articles, log\\n where log.path like '%' || articles.slug\\n group by title\\n order by views desc\\n limit 3;\\\"\\\"\\\"\\n results = execute_query(query1)\\n for result in results:\\n print(\\\"- \\\\\\\"%s\\\\\\\" — %s views\\\" % (result[0], result[1]))\",\n \"def author_rank():\\n db, c = connect(DBNAME)\\n c.execute(\\\"select name, count(name) as views from \\\\\\\"authorpath\\\\\\\" \\\"\\n \\\"group by name order by views desc\\\")\\n author_table = c.fetchall()\\n db.close()\\n print \\\"\\\\nMost Popular Article Authors of All Time:\\\"\\n for author in author_table:\\n print str(author[0]) + \\\" - \\\" + str(author[1]) + \\\" views\\\"\",\n \"def get_top_news_and_the_rest(self):\\n queryset = self.news.order_by('-marked', '-publication_date')\\n return queryset.first(), queryset[1:]\",\n \"def artist(self, q, page=None):\\r\\n return self.get('artist', q, page)\",\n \"def top(self, **kwargs) -> Dict[str, Any]:\",\n \"def query1():\\n\\n print(\\\"1. What are the most popular three articles of all time? Which \\\" +\\n \\\"articles have been accessed the most?\\\\n\\\")\\n\\n query = \\\"\\\"\\\"\\n SELECT articles.title, subq.hits FROM articles\\n LEFT JOIN\\n (SELECT COUNT(log.path) AS hits, log.path FROM log\\n WHERE log.path LIKE '/article/%'\\n AND log.status = '200 OK' AND log.method = 'GET'\\n GROUP BY log.path) AS subq\\n ON subq.path LIKE '/article/'||articles.slug\\n ORDER BY subq.hits DESC LIMIT 3;\\n \\\"\\\"\\\"\\n\\n response = db_query(query)\\n\\n for i, j in enumerate(response):\\n # Convert tuple to list to allow writing. Format \\\"hits\\\" with comma\\n # seperator. Print output.\\n j = list(j)\\n j[1] = str(format(j[1], ',d'))\\n print(\\\" Title: '{}' - {} views\\\".format(*j))\",\n \"def get_popular_titles():\\n db = psycopg2.connect(database=DBNAME)\\n c = db.cursor()\\n # counting views that had status 200\\n c.execute(\\\"select articles.title, count(*) as views \\\"\\n \\\"from articles, log \\\"\\n \\\"where log.path like concat('%', articles.slug, '%') \\\"\\n \\\"and log.status = '200 OK' \\\"\\n \\\"group by articles.title \\\"\\n \\\"order by views desc limit 3\\\")\\n results = c.fetchall()\\n text_file = open(\\\"text.txt\\\", \\\"a+\\\") # append to text file\\n text_file.write(\\\"The three most popular articles of all time are:\\\\n\\\\n\\\")\\n # for loop to print each article\\n for title, views in results:\\n text_file.write(\\\"\\\\\\\"\\\" + title + \\\"\\\\\\\"\\\" + \\\" - \\\" + str(views) + \\\" views\\\\n\\\")\\n text_file.write(\\\"\\\\n\\\")\\n text_file.close()\\n db.close\",\n \"def question_1():\\n cursor.execute(mostPopArticles)\\n output = cursor.fetchall()\\n return output\",\n \"def how_popular_most_popular(data):\\r\\n #list of artists\\r\\n artists = []\\r\\n for key in data:\\r\\n if key[-1] != \\\"$\\\":\\r\\n for x in data[key]:\\r\\n artists += [x]\\r\\n sorted_artists = selection_sort(artists)\\r\\n count = 1\\r\\n max_count = 1\\r\\n max_artists = []\\r\\n for i in range(len(sorted_artists)-1):\\r\\n #ends at second to last index because I use i and i + 1\\r\\n if sorted_artists[i] == sorted_artists[i+1]:\\r\\n count += 1\\r\\n else:\\r\\n if count == max_count:\\r\\n max_artists += [sorted_artists[i]]\\r\\n count = 1\\r\\n elif count > max_count:\\r\\n max_artists = []\\r\\n max_artists += [sorted_artists[i]]\\r\\n max_count = count\\r\\n count = 1\\r\\n return max_count\",\n \"def doQuery( connection ): # function definition\\r\\n cursor = connection.cursor()\\r\\n \\r\\n query = \\\"\\\"\\\"select Title, sum( UnitPrice ) as cost\\r\\n from Album natural join Track\\r\\n group by AlbumId\\r\\n order by cost desc\\\"\\\"\\\"\\r\\n \\r\\n cursor.execute( query )\\r\\n \\r\\n print( \\\"Album titles and cost of tracks\\\" )\\r\\n print( \\\"Title\\\\t\\\\t\\\\t\\\\tCost\\\" )\\r\\n for (Title, cost) in cursor:\\r\\n print( Title, \\\"\\\\t\\\\t\\\\t$\\\", cost )\\r\\n \\r\\n cursor.close()\",\n \"def most_viewed_authors():\\n query = \\\"\\\"\\\"\\n SELECT authors.name, COUNT(*) AS views\\n FROM articles\\n JOIN log\\n ON log.path = '/article/' || articles.slug\\n JOIN authors\\n ON authors.id = articles.author\\n WHERE log.status ='200 OK'\\n GROUP BY authors.name ORDER BY views DESC LIMIT 3;\\n \\\"\\\"\\\"\\n results = psql_connection(query)\\n\\n print(\\\"Most viewed authors:\\\")\\n for result in results:\\n print '{author} - {count} views'.format(\\n author=result[0], count=result[1])\",\n \"def print_top_authors():\\n\\n output = get_query_results(\\n '''SELECT authors.name, COUNT(*) AS views\\n FROM authors\\n JOIN(SELECT articles.title, articles.author FROM articles\\n JOIN log ON log.path=CONCAT('/article/', articles.slug))\\n AS popular\\n ON authors.id=popular.author\\n GROUP BY name\\n ORDER BY views DESC;'''\\n )\\n print(\\\"\\\\nPopularity of Authors: \\\\n\\\")\\n for author, views in output:\\n print(\\\"\\\\\\\"{}\\\\\\\" -- {} views\\\".format(author, views))\",\n \"def get_top_articles(\\n limit: int = 5,\\n date: int = int(datetime.now().strftime(\\\"%Y%m%d\\\"))\\n):\\n\\n res = articles_db.get_top_articles_mongo(\\n articles,\\n limit,\\n date\\n )\\n\\n return res\",\n \"def most_viewed_articles():\\n query = \\\"\\\"\\\"\\n SELECT articles.title, COUNT(*) AS views\\n FROM articles\\n JOIN log\\n ON log.path = '/article/' || articles.slug\\n WHERE log.status ='200 OK'\\n GROUP BY articles.title ORDER BY views DESC LIMIT 3;\\n \\\"\\\"\\\"\\n results = psql_connection(query)\\n\\n print(\\\"Most viewed articles:\\\")\\n for result in results:\\n print '{article} - {count} views'.format(\\n article=result[0], count=result[1])\",\n \"def sort_artist(self):\\n return self.sort('artist')\",\n \"def read_artists():\\n list_a = [(x.first_name, x.last_name, str(x.id)) for x in dmla.list_artists()]\\n list_c = [x['artist'] for x in dmlc.list_artists()]\\n return list_a, list_c\",\n \"def top_authors(cursor):\\n top_auth = 'No authors found.'\\n try:\\n cursor.execute(\\\"\\\"\\\"\\n select name, hits\\n from authors, views_by_id as views_by_id\\n where id = author\\n group by name, hits\\n order by hits desc\\\"\\\"\\\")\\n\\n authors = cursor.fetchall()\\n # If no authors were found, return\\n if len(authors) <= 0:\\n return top_auth\\n\\n except psycopg2.Error as e:\\n print('Fetching authors by popularity: \\\\r\\\\n{}'.format(e.pgerror))\\n\\n # If the query returns any authors, return the results.\\n else:\\n top_auth = 'Top authors by article views: \\\\r\\\\n'\\n for auth in authors:\\n top_auth += ' {} - {} views\\\\r\\\\n'.format(auth[0], auth[1])\\n return top_auth\",\n \"def top(self):\\r\\n return self.topele\",\n \"def get_albums_recent_added(session_):\\n artists = session_.query(Album).order_by(Album.added_at.desc()).all()\\n return artists\",\n \"def read_from_db(cursor):\\n\\tcursor.execute('''SELECT * FROM (\\n\\t\\tSELECT * FROM Kombucha_data ORDER BY Time DESC LIMIT 20)\\n\\t\\tORDER BY Time ASC;''')\\n\\n\\trows = cursor.fetchall()\\n\\treturn rows\",\n \"def read_from_db(cursor):\\n\\tcursor.execute('''SELECT * FROM (\\n\\t\\tSELECT * FROM Kombucha_data ORDER BY Time DESC LIMIT 20)\\n\\t\\tORDER BY Time ASC;''')\\n\\n\\trows = cursor.fetchall()\\n\\treturn rows\",\n \"def most_popular_articles():\\n\\n results = query_database(QUERIES[0])\\n print('\\\\nWhat are the most popular three articles of all time?\\\\n')\\n for title, views in results:\\n print(' * \\\"{}\\\" -- {} views'.format(title, views))\",\n \"def read_table(self):\\n\\n db = self.connection(database=\\\"imdb\\\")\\n\\n try:\\n cur = db.cursor()\\n sql = \\\"SELECT title FROM film;\\\"\\n cur.execute(sql)\\n return cur.fetchall()\\n except:\\n print(\\\"Cannot read from table!\\\")\\n\\n db.close()\",\n \"def get_mostPopularAuthors():\\n\\n query = \\\"\\\"\\\"\\n SELECT authors.name,COUNT(*) as views\\n FROM articles join authors\\n ON articles.author=authors.id\\n JOIN log ON log.path LIKE ('/article/' || articles.slug)\\n GROUP BY authors.name\\n ORDER BY views DESC\\n \\\"\\\"\\\"\\n\\n posts = execute_query(query)\\n print('\\\\nWho are the most popular article authors of all time?')\\n for author, views in posts:\\n print(author + \\\" - \\\" + str(views) + \\\" views\\\")\",\n \"def show_artist(artist_id):\\n\\n result = db.session.query(Artist).filter(Artist.id == artist_id)\\n result = result[0]\\n\\n past_shows_count = 0\\n upcoming_shows_count = 0\\n\\n past_shows = []\\n upcoming_shows = []\\n\\n all_shows = Shows.query.all()\\n\\n print(all_shows)\\n\\n for show in all_shows:\\n if show.artist_id == result.id:\\n show_time = datetime.strptime(show.start_time, '%Y-%m-%d %H:%M:%S')\\n if show_time > datetime.now() :\\n upcoming_shows.append(show)\\n else: \\n past_shows.append(show)\\n \\n past_shows_count = len(past_shows)\\n upcoming_shows_count = len(upcoming_shows)\\n\\n resdata = {\\n \\\"id\\\": result.id,\\n \\\"name\\\": result.name,\\n \\\"genres\\\": json.loads(result.genres),\\n \\\"city\\\": result.city,\\n \\\"state\\\": result.state,\\n \\\"phone\\\": result.phone,\\n \\\"website\\\": result.website,\\n \\\"facebook_link\\\": result.facebook_link,\\n \\\"seeking_venue\\\": result.seeking_venue,\\n \\\"seeking_description\\\": result.seeking_description,\\n \\\"image_link\\\": result.image_link,\\n \\\"past_shows\\\": past_shows,\\n \\\"upcoming_shows\\\": upcoming_shows,\\n \\\"past_shows_count\\\": past_shows_count,\\n \\\"upcoming_shows_count\\\": upcoming_shows_count,\\n }\\n\\n data = list(filter(lambda d: d[\\\"id\\\"] == artist_id, [resdata]))[0]\\n return render_template(\\\"pages/show_artist.html\\\", artist=data)\",\n \"def get_synopsis():\\n #get all movies from db\\n movies_df = movie_helper.get_movies_df() \\n \\n with tqdm(total=len(movies_df)) as pbar:\\n for index, row in movies_df.iterrows(): \\n \\n #if imdb id exists use it to look up the API\\n if (row['imdbId']):\\n \\n #get synponsis and update the db\\n movie = ia.get_movie(str(row['imdbId']), info='synopsis')\\n try:\\n synopsis = movie['synopsis']\\n database_helper.insert_data(\\\"synopsis\\\", {\\\"movieId\\\" : row[\\\"movieId\\\"], \\\"summary\\\" : synopsis}) \\n except:\\n #throw exception and print to console if synopsis does not exist\\n print(row['title'] + ' (' + row['imdbId'] + ')')\\n \\n pbar.update(1)\",\n \"def get_artists(self, offset=None):\\n return self.__get('artists')\",\n \"def top(self) -> int:\\n return self.q[0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6849134","0.66032416","0.65351725","0.6413231","0.63552356","0.63133323","0.62837493","0.6265987","0.6252838","0.6200527","0.61681056","0.6130825","0.6129044","0.61084133","0.61036533","0.60961986","0.6052323","0.6035289","0.6007485","0.5997498","0.5984089","0.59652245","0.59351385","0.592745","0.58895904","0.58893996","0.5851415","0.58378494","0.583716","0.5817037","0.5802095","0.5800646","0.5786499","0.57819027","0.5780147","0.5754947","0.57385314","0.573591","0.57216465","0.5721386","0.5718753","0.57160854","0.5708639","0.56920075","0.5688113","0.5677372","0.5676607","0.5665364","0.56572026","0.5649163","0.5645442","0.56426936","0.56415313","0.5638105","0.5631265","0.5624055","0.5623024","0.56169075","0.56129825","0.5611091","0.5608985","0.55841935","0.5583212","0.556302","0.5561313","0.5532402","0.55168706","0.5514485","0.5512634","0.5496431","0.5482824","0.5477048","0.5476628","0.5474446","0.54712725","0.54505026","0.54476655","0.544042","0.54366994","0.543321","0.54222137","0.5405678","0.53640425","0.5356321","0.534957","0.53488135","0.5343538","0.53316146","0.53268826","0.53142184","0.52960926","0.5293983","0.5293983","0.5281979","0.5278193","0.52585626","0.52571094","0.5246383","0.5235016","0.5232264"],"string":"[\n \"0.6849134\",\n \"0.66032416\",\n \"0.65351725\",\n \"0.6413231\",\n \"0.63552356\",\n \"0.63133323\",\n \"0.62837493\",\n \"0.6265987\",\n \"0.6252838\",\n \"0.6200527\",\n \"0.61681056\",\n \"0.6130825\",\n \"0.6129044\",\n \"0.61084133\",\n \"0.61036533\",\n \"0.60961986\",\n \"0.6052323\",\n \"0.6035289\",\n \"0.6007485\",\n \"0.5997498\",\n \"0.5984089\",\n \"0.59652245\",\n \"0.59351385\",\n \"0.592745\",\n \"0.58895904\",\n \"0.58893996\",\n \"0.5851415\",\n \"0.58378494\",\n \"0.583716\",\n \"0.5817037\",\n \"0.5802095\",\n \"0.5800646\",\n \"0.5786499\",\n \"0.57819027\",\n \"0.5780147\",\n \"0.5754947\",\n \"0.57385314\",\n \"0.573591\",\n \"0.57216465\",\n \"0.5721386\",\n \"0.5718753\",\n \"0.57160854\",\n \"0.5708639\",\n \"0.56920075\",\n \"0.5688113\",\n \"0.5677372\",\n \"0.5676607\",\n \"0.5665364\",\n \"0.56572026\",\n \"0.5649163\",\n \"0.5645442\",\n \"0.56426936\",\n \"0.56415313\",\n \"0.5638105\",\n \"0.5631265\",\n \"0.5624055\",\n \"0.5623024\",\n \"0.56169075\",\n \"0.56129825\",\n \"0.5611091\",\n \"0.5608985\",\n \"0.55841935\",\n \"0.5583212\",\n \"0.556302\",\n \"0.5561313\",\n \"0.5532402\",\n \"0.55168706\",\n \"0.5514485\",\n \"0.5512634\",\n \"0.5496431\",\n \"0.5482824\",\n \"0.5477048\",\n \"0.5476628\",\n \"0.5474446\",\n \"0.54712725\",\n \"0.54505026\",\n \"0.54476655\",\n \"0.544042\",\n \"0.54366994\",\n \"0.543321\",\n \"0.54222137\",\n \"0.5405678\",\n \"0.53640425\",\n \"0.5356321\",\n \"0.534957\",\n \"0.53488135\",\n \"0.5343538\",\n \"0.53316146\",\n \"0.53268826\",\n \"0.53142184\",\n \"0.52960926\",\n \"0.5293983\",\n \"0.5293983\",\n \"0.5281979\",\n \"0.5278193\",\n \"0.52585626\",\n \"0.52571094\",\n \"0.5246383\",\n \"0.5235016\",\n \"0.5232264\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7609244"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80599,"cells":{"query":{"kind":"string","value":"Add uniform noise to a given dataset. Function to add uniform random noise to a given dataset. Uniform noise in range [510^(p), 510^(p)] is added to each data entry. For integervalued sequences, p = 1."},"document":{"kind":"string","value":"def add_uniform_noise(data, p=1):\n if p < 1:\n raise ValueError(\"'p' has to be greater or equal to 1.\")\n noise = np.random.uniform(-5.*10**(-p), 5*10**(-p), size = len(data))\n randomized_data = data + noise\n # ensure there are no negative entries after noise is added\n randomized_data = \\\n randomized_data[np.where(randomized_data > 0)]\n return randomized_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_noise(self, data):","def uniform_noise_like(\n da: xr.DataArray, low: float = 1e-6, high: float = 1e-3\n) -> xr.DataArray:\n if uses_dask(da):\n mod = dsk\n kw = {\"chunks\": da.chunks}\n else:\n mod = np\n kw = {}\n\n return da.copy(\n data=(high - low) * mod.random.random_sample(size=da.shape, **kw) + low\n )","def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)","def noise_data(self, x):\n return x + np.random.normal(size=x.shape)","def add_noise_m(self, data):\n return self.range_to_m(self.add_noise(self.m_to_range(data)))","def add_noise(self, noise):\n if noise > 0.0:\n for key in self.counts:\n self.counts[key] *= 1.0 + noise * np.random.random_sample()","def addNoise(data, amp, scale):\n lfnData = addLFNoise(data, amp, scale)\n noisyData = addHFNoise(hfnData, amp)\n\n return noisyData","def _add_noise(X, n_noise, random_state=None):\n np.random.seed(random_state)\n noise = np.random.randn(X.shape[0], n_noise)\n return np.hstack((X, noise))","def add_noise(Y, sigma):\r\n return Y + np.random.normal(0, sigma, Y.shape)","def noise(self, xs, ys):\n raise NotImplementedError","def addNoise(x,y,noise):\n n = len(x)\n theta = np.random.random(n)*(2*np.pi) # random angle in [0,2*pi[\n d = np.random.random(n)*noise # random amplitude in [0,noise[\n x += np.cos(theta)*d\n y += np.sin(theta)*d","def addNoise(pure,snr):\r\n watts = pure**2\r\n # Calculate signal power and convert to dB \r\n sig_avg_watts = np.mean(watts)\r\n sig_avg_db = 10 * np.log10(sig_avg_watts)\r\n # Calculate noise according to [2] then convert to watts\r\n noise_avg_db = sig_avg_db - snr\r\n noise_avg_watts = 10 ** (noise_avg_db / 10)\r\n # Generate an sample of white noise\r\n mean_noise = 0\r\n noise = np.random.normal(mean_noise, np.sqrt(noise_avg_watts), len(watts))\r\n \r\n return pure+noise","def add_noise(self, data):\n noise = self._get_noise(data.shape, data.dtype)\n return np.clip(data + noise, self._clipping_lower_bound,\n self._clipping_upper_bound)","def add_noise(self, data):\n noise = self._get_noise(data.shape, data.dtype)\n return np.clip(data + noise, self._clipping_lower_bound,\n self._clipping_upper_bound)","def add_noise(arr, sigma):\n dims = arr.shape\n arr += sigma * noise(*dims)","def add_noise(image):\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\n \n return image","def add_noise(self, low, high, loc=None):\n loc = slice(0, len(self.Y)) if loc is None else loc\n self.Y[loc] += np.random.uniform(\n low=low,\n high=high,\n size=len(self.Y[loc]),\n )","def addNoise (image,noise_type=\"gauss\",var = .01):\n row,col,ch= image.shape\n if noise_type == \"gauss\": \n mean = 0.0\n #var = 0.001\n sigma = var**0.5\n gauss = np.array(image.shape)\n gauss = np.random.normal(mean,sigma,(row,col,ch))\n gauss = gauss.reshape(row,col,ch)\n #print(gauss)\n noisy = image + gauss*255\n return noisy.astype('uint8')\n elif noise_type == \"s&p\":\n s_vs_p = 0.5\n amount = 0.09\n out = image\n # Generate Salt '1' noise\n num_salt = np.ceil(amount * image.size * s_vs_p)\n coords = [np.random.randint(0, i - 1, int(num_salt))\n for i in image.shape]\n out[coords] = 255\n # Generate Pepper '0' noise\n num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\n coords = [np.random.randint(0, i - 1, int(num_pepper))\n for i in image.shape]\n out[coords] = 0\n return out\n elif noise_type == \"poisson\":\n vals = len(np.unique(image))\n vals = 2 ** np.ceil(np.log2(vals))\n noisy = np.random.poisson(image * vals) / float(vals)\n return noisy\n elif noise_type ==\"speckle\":\n gauss = np.random.randn(row,col,ch)\n gauss = gauss.reshape(row,col,ch) \n noisy = image + image * gauss\n return noisy\n else:\n return image","def make_noise(self, num):\n return np.random.randn(num, self.seq_length, self.noise_dim)","def apply_noise(self, input):\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \n noisy_input = mask * input\n \n return noisy_input","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\n self.image += self.noise\n return","def add_noise(pc, variance,distribution='gaussian'):\n pc_out = []\n\n if distribution=='gaussian':\n for pt in pc:\n pc_out.append(pt + numpy.random.normal(0, variance, (2, 1)))\n elif distribution=='uniform':\n for pt in pc:\n pc_out.append(pt + numpy.random.uniform(-variance, variance, (2, 1)))\n else:\n raise ValueError(['Unknown distribution type: ', distribution])\n return pc_out","def noise(self, freq: int, /) -> None:","def add_noise(self):\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\n self.im += self.noise\n return","def add_noise(self, u):\n noise = torch.randn_like(u)\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\n\n # bias repeatability (without in run bias stability)\n b0 = self.uni.sample(u[:, 0].shape).cuda()\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\n u = u + noise + b0.transpose(1, 2)\n return u","def addNoise(array,counts):\r\n if array.dtype == 'complex' :\r\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\r\n else :\r\n if np.float64(counts) == 0.0e0 :\r\n arrayout = np.zeros(array.shape, dtype=arrayout.dtype)\r\n elif np.float64(counts) < 0.0e0 :\r\n print 'bg.addNoise : warning counts < 0'\r\n elif np.float64(counts) > 1.0e9 :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = normaliseInt(array)\r\n arrayout = np.random.normal(arrayout*np.float64(counts),np.sqrt(arrayout*np.float64(counts)))/np.float64(counts)\r\n tot = np.sum(array)\r\n arrayout = normaliseInt(arrayout,tot)\r\n else :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = normaliseInt(array)\r\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\r\n tot = np.sum(array)\r\n arrayout = normaliseInt(arrayout,tot)\r\n return arrayout","def noise(self, stddev):\n #add noise to weights\n pass","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def _add_noise(signal: np.array, noise_power: float) -> np.array:\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\n return signal + noise","def create_synthetic_noise_dataset(cfg):\n from colorednoise import powerlaw_psd_gaussian\n\n betas = np.linspace(cfg['data.mix_synthetic_noise.min_beta'],\n cfg['data.mix_synthetic_noise.max_beta'],\n num=cfg['data.mix_synthetic_noise.num_samples'])\n sample_rate = cfg['data.sample_rate']\n segment_length = 2 * cfg['data.len_min']\n wavs = [powerlaw_psd_gaussian(beta, sample_rate * segment_length)\n for beta in betas]\n wavs = [audio.normalize(wav, low=-1, high=1) for wav in wavs]\n return NoiseDataset(wavs)","def make_noise(self, num):\n return np.random.randn(num, self.seq_length + 2 * self.seq_pad,\n self.noise_dim)","def create_shared_noise(count):\n seed = 123\n noise = np.random.RandomState(seed).randn(count).astype(np.float32)\n return noise","def gen_noise(sample_size, latent):\r\n\treturn Variable(torch.randn(sample_size, latent))","def add_gaussian_noise(x, std):\n noise = x.new_zeros(x.size()).normal_(std=std)\n return x + noise","def fill_noise(x, noise_type):\n if noise_type == 'u':\n x.uniform_()\n elif noise_type == 'n':\n x.normal_() \n else:\n assert False","def noiseAtten(atten) :\n s.noiseAtten(atten)","def addNoise(self, sigma=1.0):\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\n self.image += noise\n return","def _make_noisy(x, the_noise):\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\n x.shape[0],\n replace=False)]\n return x + noise_sample","def add_silent_values(noiseValues):\n for i in range(0, groupSize):\n noiseRecord = random.choice(noiseValues)\n noiseValue = noiseRecord.audio\n newSample = AudioData(\n noiseValue,\n \"W6\",\n 1,\n \"Washing Room\"\n )\n newSample.processedValue = noiseValue\n newSample.noiseValue = noiseValue\n db.session.add(newSample)\n db.session.commit()","def derandomize(self, xs, noises):\n raise NotImplementedError","def add_noise_features(data, num_noise, binary=False, p=0.5):\n\n # Do nothing if no noise feature to add\n if not num_noise:\n return data, None\n\n # Number of nodes in the dataset\n num_nodes = data.x.size(0)\n\n # Define some random features, in addition to existing ones\n m = torch.distributions.bernoulli.Bernoulli(torch.tensor([p]))\n noise_feat = m.sample((num_noise, num_nodes)).T[0]\n # noise_feat = torch.randint(2,size=(num_nodes, num_noise))\n if not binary:\n noise_feat_bis = torch.rand((num_nodes, num_noise))\n # noise_feat_bis = noise_feat_bis - noise_feat_bis.mean(1, keepdim=True)\n noise_feat = torch.min(noise_feat, noise_feat_bis)\n data.x = torch.cat([noise_feat, data.x], dim=-1)\n\n return data, noise_feat","def add_noise(pointcloud, stddev=0.01):\n result = pointcloud\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\n return result","def noise_input_fn(params):\n batch_size = params['batch_size']\n noise_dim = params['noise_dim']\n # Use constant seed to obtain same noise\n np.random.seed(0)\n noise_dataset = tf.data.Dataset.from_tensors(\n {'random_noise': tf.constant(\n np.random.randn(batch_size, noise_dim), dtype=tf.float32)\n })\n noise = noise_dataset.make_one_shot_iterator().get_next()\n tf.logging.debug('Noise input %s', noise)\n return noise_dataset","def add_noise(self, portion, amplitude):\n # TODO: Implement the add_noise function. Remember to record the\n # boolean value is_add_noise. You can try uniform noise or Gaussian\n # noise or others ones that you think appropriate.\n self.is_add_noise = True\n noise = np.random.normal(0, 1, size = self.x.shape)\n noNoiseIndices = np.random.choice(self.x.shape[0], size = int(np.round(self.x.shape[0]*(1 - portion))), replace = False)\n noise = (noise*amplitude).astype(np.uint8)\n noise[noNoiseIndices,:] = 0\n self.x += noise\n self.x = np.clip(self.x, 0, 255, out=self.x)\n \n \n \n \n # raise NotImplementedError\n #######################################################################\n # #\n # #\n # TODO: YOUR CODE HERE #\n # #\n # #\n #######################################################################","def white_noise():\n return random.randint(-32767, 32767)","def generate_fake_noise(inputs, size):\n return np.random.normal(-0.0289923828125, 1.9391296947313124, (inputs, size)).astype(np.float32)","def addNoise(img, sigma=2.0, mean=0):\n img2 = np.random.normal(mean, sigma, size=img.shape)\n\n img2 += img\n img2 = np.uint8(img2.clip(0, 255))\n return img2","def _get_noise(self, shape, dtype=None):\n return np.random.uniform(self._low, self._high, shape).astype(dtype)","def resample_data(data, n_data_points=None, seed=None):\n if seed is not None: _np.random.seed(seed)\n if n_data_points is None: n_data_points = _np.sum(data)\n p_ml = _np.array(data) / _np.sum(data)\n resampled = _np.random.multinomial(n_data_points, p_ml)\n return resampled","def ternary_noise(N_stimuli, Nx, Ny):\n return np.random.randint(-1, 2, size=(N_stimuli, Nx, Ny))","def add_noise(image, noise, rate=0.05):\n\n if noise == \"gaussian\":\n row, col = image.shape\n var = ndimage.laplace(image).var()\n sigma = (var*rate) ** 0.5\n print(var, sigma)\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\n noisy = image + gauss\n # noisy = image + gauss\n return noisy\n\n elif noise == \"salt_pepper\":\n output = image.copy()\n black = 0\n white = 255\n probs = np.random.random(image.shape[:2])\n output[probs < (rate / 2)] = black\n output[probs > 1 - (rate / 2)] = white\n\n return output\n\n else:\n return image","def benchmark_noise(features, data_parameters, experiment_parameters):\n # Gets the noise parameters from the settings\n scaled_noise, _ = _convert_power_variables(\n experiment_parameters,\n data_parameters\n )\n\n # Runs the benchmark\n logging.info(\"Starting benchmark 1 -- Add noise to a sparse floating point vector\")\n start = time.time()\n\n noise = np.random.normal(scale=scaled_noise, size=features.shape)\n noisy_features = features + noise\n\n end = time.time()\n exec_time = (end - start) * 1000\n logging.info(\"Benchmark 1 execution time: %.3f milliseconds\", exec_time)\n return noisy_features","def make_noise(self, signal_only):\n\n #print >> sys.stdout, \"generating noise...\"\n\n if signal_only:\n\n # the noise is just a time series of zeros\n \n self.td_noise = pycbc.types.timeseries.TimeSeries(\n initial_array=np.zeros(self.duration/self.delta_t),\n delta_t=self.delta_t, epoch=self.epoch)\n\n else:\n # Generate noise \n self.assign_noise_curve()\n\n # Generate time-domain noise\n # XXX: minimum duration seems to be 1 second. I'll hack around this by\n # reducing the 1 second to the desired duration\n tmplen=max(self.duration,1.0)/self.delta_t\n self.td_noise = pycbc.noise.noise_from_psd(int(tmplen), self.delta_t,\n self.psd, seed=self.seed)\n\n self.td_noise = \\\n pycbc.types.TimeSeries(self.td_noise.data[:self.duration/self.delta_t],\n delta_t=self.delta_t)\n\n # XXX not sure if this is a good idea...\n self.td_noise.start_time = float(self.epoch)\n\n self.fd_noise = self.td_noise.to_frequencyseries()","def add_uniform_noise(rates, percent):\n raise 0 < percent < 1 or AssertionError\n rtemp = rates.copy().getA()\n noise = np.random.uniform(1 - percent, 1 + percent, np.shape(rtemp))\n rtemp = rtemp * noise\n return np.matrix(rtemp)","def addNoise_amp(array,counts):\r\n if array.dtype == 'complex' :\r\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\r\n else :\r\n if np.float64(counts) == 0.0e0 :\r\n arrayout = np.copy(array)\r\n elif np.float64(counts) < 0.0e0 :\r\n print 'bg.addNoise : warning counts < 0'\r\n else :\r\n arrayout = np.zeros(array.shape)\r\n arrayout = np.square(normalise(array))\r\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\r\n arrayout = np.sqrt(arrayout)\r\n tot = np.sum(np.abs(array)**2)\r\n arrayout = normalise(arrayout,tot)\r\n return arrayout","def create_noise_data_from_original():\n # Get the noise values we'll choose from.\n noiseValues = AudioDataOriginal.query.filter(\n AudioDataOriginal.datetime >= '2017-06-14 07:26:24',\n AudioDataOriginal.datetime <= '2017-06-14 07:27:54',\n ).all()\n # Add a noise value to each record with a `processedValue`, as these are the\n # only ones used in the model generation later on.\n audioSamples = AudioDataOriginal.query.filter(\n AudioDataOriginal.datetime > '2017-06-14 07:27:54',\n AudioDataOriginal.processedValue.isnot(None)\n ).all()\n for sample in audioSamples:\n noiseRecord = random.choice(noiseValues)\n sample.noiseValue = noiseRecord.audio\n db.session.commit()","def get_noise(n_samples, noise_dims):\n return torch.randn(n_samples, noise_dims).to(device)","def add_noise(image, shot_noise=0.01, read_noise=0.0005):\n variance = image * shot_noise + read_noise\n noise = torch.FloatTensor(image.shape).normal_().to(image.device)*variance.sqrt()\n return image + noise","def noise(x: np.ndarray) -> np.ndarray:\n\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)","def add_noise(spectra: np.ndarray, maxLevel: float = 0.1, seed: int = 42) -> np.ndarray:\n np.random.seed(seed)\n spectra = spectra.copy()\n spectra[:, 1:] *= (1-maxLevel/2) + np.random.rand(spectra.shape[0], spectra.shape[1]-1) * maxLevel\n return spectra","def add_noise(self,fing):\r\n\t\tfingerprint = copy.deepcopy(fing)\r\n\t\tl = len(fingerprint)\r\n\t\tnp.random.seed()\t\r\n\t\tif self.noise_type == 'SNR':\r\n\t\t\tnoise = np.random.normal(0, 1, l)\r\n\t\t\tsignal_Power = np.linalg.norm(fingerprint)\r\n\t\t\tnoise_Power = np.linalg.norm(noise)\r\n\t\t\tcst = signal_Power / (noise_Power * self.noise_level)\r\n\t\t\tnoise = noise * cst\r\n\t\telif self.noise_type == 'Standard':\r\n\t\t\tnoise = np.random.normal(0, self.noise_level, l)\r\n\t\tfingerprint += noise\r\n\t\tif self.trparas.normalization == 'Noisy_input':\r\n\t\t\treturn fingerprint / np.linalg.norm(fingerprint)\r\n\t\telse:\r\n\t\t\treturn fingerprint","def add_noise(spectrum,rms):\n noise = np.random.randn(spectrum.data.shape[0])*rms\n noisy_data = spectrum.data + noise\n noisy_spec = pyspeckit.Spectrum(xarr=spectrum.xarr,data=noisy_data)\n return noisy_spec","def mock_noise(scale, size):\n return np_repeat(scale, size)","def predict_w_noise(self, xs, stochastic=True, **kwargs):\n raise NotImplementedError","def noise(voxels, volume_dim, voxel_dim, protein_noise):\n ab_std = 100.0 / np.array(voxel_dim)#200 nm seems to work well as std\n gaussian = np.stack([np.random.normal(0, std, len(voxels)) for std in ab_std], axis=-1)\n #Get random subset\n non_noisy = int((1 - protein_noise) * len(voxels))\n indices = np.random.choice(len(voxels), size=non_noisy)\n #Set these to 0\n gaussian[indices, :] = [0, 0, 0]\n #Add noise\n voxels = np.round(voxels + gaussian).astype(np.int32)\n #Remove out of bounds voxels\n low, high = np.array([0, 0, 0]), np.array(volume_dim)\n inidx = np.all(np.logical_and(low <= voxels, voxels < high), axis=1)\n return voxels[inidx]","def sample_noise(batch_size, dim):\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\n\n return temp","def noiseReduction(self):\n pass","def sim_brown_noise(N):\n return np.cumsum(np.random.randn(N))","def add_noise(mat,\n pseudocount=1,\n percent_normal=0.1,\n percent_random=0.1,\n random_count=1,\n add_missing_at_random=False,\n percent_missing=0.1):\n\n # transform mat into ALR space for\n # adding normal dist. noise\n mat_noise = alr(mat + pseudocount)\n\n # add homo-scedastic noise\n err = percent_normal * np.ones_like(mat_noise)\n mat_noise = normal(mat_noise, err)\n\n # add hetero-scedastic noise\n err = percent_random * np.ones_like(mat_noise)\n n_entries = int(percent_random * np.count_nonzero(mat_noise))\n i = randint(0, err.shape[0], n_entries)\n j = randint(0, err.shape[1], n_entries)\n err[i, j] = random_count\n mat_noise = normal(mat_noise, err)\n\n # transform back\n mat_noise = alr_inv(mat_noise)\n\n # finally add sparsity\n # Note: there will be no zeros after\n # using the pseudocount\n if add_missing_at_random:\n n_entries = int(percent_missing * np.count_nonzero(mat_noise))\n i = randint(0, mat_noise.shape[0], n_entries)\n j = randint(0, mat_noise.shape[1], n_entries)\n mat_noise[i, j] = 0\n else:\n i, j = np.nonzero(mat == 0)\n mat_noise[i, j] = 0\n\n return mat_noise","def create_noise_dataset(cfg):\n here = os.path.dirname(__file__)\n basedir = os.path.join(here, cfg['data.mix_background_noise.audio_dir'])\n audio_files = find_files(basedir,\n cfg['data.mix_background_noise.audio_regexp'])\n sample_rate = cfg['data.sample_rate']\n audios = [audio.WavFile(fn, sample_rate=sample_rate)\n for fn in tqdm.tqdm(audio_files, 'Reading noise',\n ascii=bool(cfg['tqdm.ascii']))]\n segment_files = [os.path.splitext(fn)[0] + '.csv' for fn in audio_files]\n segments = [read_noise_csv(fn, sample_rate, len(wav))\n if os.path.exists(fn)\n else [(0, len(wav))]\n for fn, wav in zip(segment_files, audios)]\n return NoiseDataset(audios, segments,\n min_length=sample_rate * cfg['data.len_min'])","def _get_noise(self, shape, dtype=None):\n return np.random.normal(self._bias, self._scale, shape).astype(dtype)","def generate_data(Amp, freq, noise_amp):\n x = np.arange(0.,80.,0.01)\n y = Amp * np.sin(freq * x)\n y += noise_amp * np.random.randn(len(y))\n return x, y","def _addNoise(self):\n self.dispNoise = self.dispRaw.copy()\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\n return","def apply_poisson_noise(data, seed=None):\n data = np.asanyarray(data)\n if np.any(data < 0):\n raise ValueError('data must not contain any negative values')\n\n rng = np.random.default_rng(seed)\n\n return rng.poisson(data)","def img_add_random_noise(arr, noise_perc = 0.05):\r\n assert len(arr.shape) == 3, \"'arr' input array must be three dimensional\"\r\n arr_copy = arr.copy()\r\n noise = np.random.randint(np.max(arr), size = arr.shape)\r\n rand_numbers = random.sample(range(100), int(noise_perc * 100))\r\n for x in range(arr.shape[0]):\r\n for y in range(arr.shape[1]):\r\n for z in range(arr.shape[2]):\r\n if random.choice(range(100)) in rand_numbers:\r\n arr_copy[x][y][z] += noise[x][y][z]\r\n return arr_copy","def noise(self):\r\n if self.buffer_offset + self.frames_per_buffer - 1 > self.x_max:\r\n #relleno con ceros al final si es necesario\r\n xs = np.arange(self.buffer_offset, self.x_max)\r\n tmp = np.random.random_sample(len(xs)) #ruido\r\n out = np.append(tmp, np.zeros(self.frames_per_buffer-len(tmp)))\r\n else:\r\n xs = np.arange(self.buffer_offset,\r\n self.buffer_offset + self.frames_per_buffer)\r\n out = np.random.random_sample(len(xs))\r\n self.buffer_offset += self.frames_per_buffer\r\n return out","def add_noise(np_image, amount):\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\n norm_noise = abs(noise/np.max(noise))\n np_image = np_image + norm_noise*np.max(np_image)*amount\n \n return np_image","def add_white_noise(rates, numreg):\n rtemp = rates.copy().getA()\n sdrates = np.sqrt(rtemp * (1 - rtemp) / numreg) + 1e-10\n noise = np.random.normal(0, sdrates)\n rtemp += noise\n return np.matrix(rtemp)","def _sample_new_noise(self, *, tf_sess=None):\n if self.framework == \"tf\":\n tf_sess.run(self.tf_sample_new_noise_op)\n elif self.framework == \"tf2\":\n self._tf_sample_new_noise_op()\n else:\n for i in range(len(self.noise)):\n self.noise[i] = torch.normal(\n mean=torch.zeros(self.noise[i].size()), std=self.stddev\n ).to(self.device)","def augment_by_additive_noise(ds, noise_datadir, snr_list, copy_noise_files_to_tmpdir=False):\n logger.info(\"Augmenting dataset with additive noise from '%s'.\", noise_datadir)\n if not os.path.isdir(noise_datadir):\n logger.error(\"Noise source dir '%s' does not exist.\", noise_datadir)\n return\n\n id2type = dict(lidbox.iter_metadata_file(os.path.join(noise_datadir, \"id2label\"), 2))\n type2paths = collections.defaultdict(list)\n for noise_id, path in lidbox.iter_metadata_file(os.path.join(noise_datadir, \"id2path\"), 2):\n type2paths[id2type[noise_id]].append(path)\n del id2type\n\n if copy_noise_files_to_tmpdir:\n tmpdir = os.path.join(os.environ.get(\"TMPDIR\", \"/tmp\"), \"lidbox_noise_signals\")\n logger.info(\"Copying all noise files to TMPDIR '%s'\", tmpdir)\n for noise_type, paths in list(type2paths.items()):\n new_paths = []\n for src in paths:\n dst = os.path.join(tmpdir, noise_type, os.path.basename(src))\n logger.debug(\"%s -> %s\", src, dst)\n os.makedirs(os.path.dirname(dst), exist_ok=True)\n shutil.copyfile(src, dst)\n new_paths.append(dst)\n type2paths[noise_type] = new_paths\n\n type2paths = {t: tf.constant(paths, tf.string) for t, paths in type2paths.items()}\n\n def _update_element_meta(new_id, mixed_signal, x):\n return dict(x, id=new_id, signal=mixed_signal)\n\n def _add_random_noise_and_flatten(x):\n \"\"\"\n Using snr_list, choose len(snr_list) noise signals randomly and create new signal samples by mixing the chosen noise signals with x[\"signal\"] using random SNR dB levels.\n \"\"\"\n # Random noise path indexes and random snr levels\n rand_noise = [\n (noise_type,\n tf.random.uniform([], 0, tf.size(type2paths[noise_type]), tf.int32),\n tf.random.uniform([], snr_low, snr_high, tf.float32))\n for noise_type, snr_low, snr_high in snr_list]\n # Select random noise signals by drawn indexes and read contents from files\n rand_noise = [\n (audio_features.read_wav(type2paths[noise_type][rand_index]), snr)\n for noise_type, rand_index, snr in rand_noise]\n\n # Assert sample rates\n # TODO maybe add inline resampling of noise signals so they match the speech sr\n for (noise, sample_rate), snr in rand_noise:\n tf.debugging.assert_equal(sample_rate, x[\"sample_rate\"], message=\"Invalid noise signals are being used, all noise signals must have same sample rate as speech signals that are being augmented\")\n\n # Fix noise signal length to match x[\"signal\"] by repeating the noise signal if it is too short and then slicing it\n rand_noise = [\n # How many multiples of `noise` fits in x[\"signal\"]\n (tf.cast(tf.size(x[\"signal\"]) / tf.size(noise), tf.int32), noise, snr)\n for (noise, _), snr in rand_noise]\n rand_noise = [\n # Repeat noise and slice\n (tf.tile(noise, [1 + noise_length_ratio])[:tf.size(x[\"signal\"])], snr)\n for noise_length_ratio, noise, snr in rand_noise]\n\n # Mix x[\"signal\"] and chosen noise signals\n mixed_signals = [audio_features.snr_mixer(x[\"signal\"], noise, snr)[2] for noise, snr in rand_noise]\n # Create new utterance ids that contain the mixed noise type and SNR level\n new_ids = [\n tf.strings.join((\n \"augmented\",\n x[\"id\"],\n noise_type,\n tf.strings.join((\"snr\", tf.strings.as_string(snr, precision=2)))),\n separator=\"-\")\n for (noise_type, _, _), (_, snr) in zip(snr_list, rand_noise)]\n\n # Create new elements from the mixed signals and return as dataset\n return (tf.data.Dataset\n .zip((tf.data.Dataset.from_tensor_slices(new_ids),\n tf.data.Dataset.from_tensor_slices(mixed_signals),\n tf.data.Dataset.from_tensors(x).repeat(len(mixed_signals))))\n .map(_update_element_meta))\n\n return ds.interleave(\n _add_random_noise_and_flatten,\n block_length=len(snr_list),\n num_parallel_calls=TF_AUTOTUNE)","def add_noise(image, type=\"s&p\"):\n # Get the width and height of the image\n w, h = image.size\n\n # Add salt and pepper noise\n if type == \"s&p\":\n # Choose a random amount of noise (lower number = more noise)\n salt = np.random.randint(100, 400)\n # Generate an array to determine location of noise\n noise = np.random.randint(salt+1, size=(h, w))\n\n # Find the index of the salt and pepper (respectively location with max/min random value)\n idx_salt = noise == salt\n idx_pepper = noise == 0\n\n # Create a numpy array from the initial image and add the salt and pepper\n np_img = np.array(image)\n np_img[idx_salt, :] = 255\n np_img[idx_pepper, :] = 0\n\n return Image.fromarray(np.uint8(np_img))\n\n # Add gaussian noise to image\n if type == \"gauss\":\n # Get the number of channels\n c = len(image.getbands())\n\n # Get a random value for the mean and the standard deviation of the noise\n mean = np.random.randint(-4, 5)\n std = np.random.randint(5)\n\n # Generate the noise array\n noise = np.random.normal(mean, std, (h, w, c))\n\n # Add noise to the image\n return Image.fromarray(np.uint8(np.array(image) + noise))\n\n else:\n # If the name of the given noise is not correct\n return image","def add_noise_at_snr(channel_in, snr):\n\n rms_channel = np.sqrt(np.mean(channel_in ** 2.0))\n noise_std = rms_channel / np.sqrt(10.0 ** (snr/10.0))\n\n return channel_in + np.random.normal(size=channel_in.shape, scale=noise_std)","def make_time_series_noise(dates, mean=0., std=1.):\n # TODO: implement Gaussian noise with mean/std\n # TODO: add kwarg to parametrize noise from clouds/shadows\n pass","def noiseless_function(x):\n return 1/(1+np.exp(-x+5))-0.5","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def awgn(input, noise_std):\n\tif not isinstance(noise_std, (list, tuple)):\n\t\tsigma = noise_std\n\telse: # uniform sampling of sigma\n\t\tsigma = noise_std[0] + \\\n\t\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\n\treturn input + torch.randn_like(input) * (sigma/255)","def add_noise(emg):\n MAX_AMPLITUDE = 32767\n\n # Sampling\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\n Ts = 1/EMG_F_SAMPLE\n\n # Time vector\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\n\n # Noise\n randAmplitudeScale = np.random.random()*0.1\n randOffset = np.random.random() * 2*np.pi\n \n fNoise = 50; # Frequency [Hz]\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\n\n # Add noise to signal\n for channel in [\"emg1\", \"emg2\", \"emg3\", \"emg4\", \"emg5\", \"emg6\"]:\n emg[channel] += noise\n return emg","def add_noise_batch(self,fingerprints):\r\n\t\tif self.trparas.complex:\r\n\t\t\tn,l,r = fingerprints.shape\r\n\t\t\tnp.random.seed()\r\n\r\n\t\t\t# noise_level = 0.002\r\n\t\t\tnoise_level = self.noise_level\r\n\t\t\t# add noise to real and imag part seperately with different noise level\r\n\t\t\tnoise_real = np.random.normal(0, noise_level, (n, l))\r\n\t\t\tnoise_imag = np.random.normal(0, noise_level, (n, l))\r\n\t\t\tnoise = np.stack([noise_real,noise_imag],axis=2) # n,l,r 4000,666,2\r\n\t\t\tfingerprints += noise\r\n\t\t\treturn fingerprints\r\n\r\n\t\telse:\t\r\n\t\t\tn,l = fingerprints.shape\r\n\t\t\tnp.random.seed()\r\n\t\t\tif self.noise_type == 'SNR':\r\n\t\t\t\tnoise = np.random.normal(0, 1, (n,l))\r\n\t\t\t\tsignal_Power = np.linalg.norm(fingerprints, axis=1)\r\n\t\t\t\tnoise_Power = np.linalg.norm(noise,axis=1)\r\n\t\t\t\tcst = signal_Power / (noise_Power * self.noise_level)\r\n\t\t\t\tnoise = noise * np.tile(cst.reshape(-1,1),(1,l))\r\n\t\t\telif self.noise_type == 'Standard':\r\n\t\t\t\tnoise = np.random.normal(0, self.noise_level, (n,l))\r\n\t\t\tfingerprints += noise\r\n\t\t\tif self.trparas.normalization == 'Noisy_input':\r\n\t\t\t\treturn fingerprints / np.tile(np.linalg.norm(fingerprints,axis=1).reshape(-1,1), (1,l))\r\n\t\t\telse:\r\n\t\t\t\treturn fingerprints","def _get_noise(self, shape, dtype=None):","def __call__(self, input: torch.Tensor) -> torch.Tensor:\n # Get noise\n noise = self.mean + torch.randn_like(input) * self.std\n # Apply nose to image\n input = input + noise\n return input","def gaussian_noise(tensor, mean, stddev):\n noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))\n return tensor + noise","def generate_normal_data(avg_strike, avg_dip, n=10, noise_std=5, porp=2):\n opp_strike = avg_strike + 180\n if opp_strike > 360: \n opp_strike -= 360\n strike = avg_strike * np.ones(n)\n strike[n//porp:] = opp_strike\n dip = avg_dip * np.ones(n)\n \n # Add noise\n strike += noise_std * np.random.randn(n)\n dip += noise_std * np.random.randn(n)\n\n # Filter out things out of a reasonable range\n strike[dip > 90] -= 180\n dip[dip > 90] = 180 - dip[dip>90]\n\n strike[dip < 0] -= 180\n dip[dip < 0] *= -1\n\n strike[strike < 0] += 360\n strike[strike > 360] -= 360\n \n\n normal = geometric_functions.plane2normal(strike, dip)\n slip = geometric_functions.normal_slip(*normal)\n\n return strike, dip, normal, slip","def add_gaussian_noise(X, mu=0, sigma=0.1):\n noise = np.random.normal(0.0, sigma, size=X.size)\n return X + noise.reshape(X.shape)","def random_gaussian_noise(self, img, p = 0.5):\n if self.decision(p):\n mean = 30.0\n std = 80.0\n img = img + np.random.normal(mean, std, img.shape)\n\n img = np.clip(img, 0, 255).astype('uint8')\n return img","def add_noise(self, low, high, loc=None):\n loc = dtloc2pos(loc, self.X)\n return super().add_noise(low, high, loc=loc)","def _sample_noise(self) -> np.ndarray:\n return np.random.randn(self.actor_action_size)","def add_noise(self, mdct_norm, masking_threshold):\n return self.psychoacoustic.add_noise(mdct_norm, masking_threshold)","def add_noise(self, snr, unit=None):\n return self.from_time(self.fs, noisify(self.in_time, snr, unit=unit))","def noise(self, noise):\n\n self._noise = noise","def generate_synth_data(n):"],"string":"[\n \"def add_noise(self, data):\",\n \"def uniform_noise_like(\\n da: xr.DataArray, low: float = 1e-6, high: float = 1e-3\\n) -> xr.DataArray:\\n if uses_dask(da):\\n mod = dsk\\n kw = {\\\"chunks\\\": da.chunks}\\n else:\\n mod = np\\n kw = {}\\n\\n return da.copy(\\n data=(high - low) * mod.random.random_sample(size=da.shape, **kw) + low\\n )\",\n \"def add_noise(a: np.ndarray, noise: float) -> np.ndarray:\\n return np.clip(a + np.random.normal(0, noise, len(a)), -1, 1)\",\n \"def noise_data(self, x):\\n return x + np.random.normal(size=x.shape)\",\n \"def add_noise_m(self, data):\\n return self.range_to_m(self.add_noise(self.m_to_range(data)))\",\n \"def add_noise(self, noise):\\n if noise > 0.0:\\n for key in self.counts:\\n self.counts[key] *= 1.0 + noise * np.random.random_sample()\",\n \"def addNoise(data, amp, scale):\\n lfnData = addLFNoise(data, amp, scale)\\n noisyData = addHFNoise(hfnData, amp)\\n\\n return noisyData\",\n \"def _add_noise(X, n_noise, random_state=None):\\n np.random.seed(random_state)\\n noise = np.random.randn(X.shape[0], n_noise)\\n return np.hstack((X, noise))\",\n \"def add_noise(Y, sigma):\\r\\n return Y + np.random.normal(0, sigma, Y.shape)\",\n \"def noise(self, xs, ys):\\n raise NotImplementedError\",\n \"def addNoise(x,y,noise):\\n n = len(x)\\n theta = np.random.random(n)*(2*np.pi) # random angle in [0,2*pi[\\n d = np.random.random(n)*noise # random amplitude in [0,noise[\\n x += np.cos(theta)*d\\n y += np.sin(theta)*d\",\n \"def addNoise(pure,snr):\\r\\n watts = pure**2\\r\\n # Calculate signal power and convert to dB \\r\\n sig_avg_watts = np.mean(watts)\\r\\n sig_avg_db = 10 * np.log10(sig_avg_watts)\\r\\n # Calculate noise according to [2] then convert to watts\\r\\n noise_avg_db = sig_avg_db - snr\\r\\n noise_avg_watts = 10 ** (noise_avg_db / 10)\\r\\n # Generate an sample of white noise\\r\\n mean_noise = 0\\r\\n noise = np.random.normal(mean_noise, np.sqrt(noise_avg_watts), len(watts))\\r\\n \\r\\n return pure+noise\",\n \"def add_noise(self, data):\\n noise = self._get_noise(data.shape, data.dtype)\\n return np.clip(data + noise, self._clipping_lower_bound,\\n self._clipping_upper_bound)\",\n \"def add_noise(self, data):\\n noise = self._get_noise(data.shape, data.dtype)\\n return np.clip(data + noise, self._clipping_lower_bound,\\n self._clipping_upper_bound)\",\n \"def add_noise(arr, sigma):\\n dims = arr.shape\\n arr += sigma * noise(*dims)\",\n \"def add_noise(image):\\n image += 10e-10 * np.random.randn(image.shape[0], image.shape[1], 1)\\n \\n return image\",\n \"def add_noise(self, low, high, loc=None):\\n loc = slice(0, len(self.Y)) if loc is None else loc\\n self.Y[loc] += np.random.uniform(\\n low=low,\\n high=high,\\n size=len(self.Y[loc]),\\n )\",\n \"def addNoise (image,noise_type=\\\"gauss\\\",var = .01):\\n row,col,ch= image.shape\\n if noise_type == \\\"gauss\\\": \\n mean = 0.0\\n #var = 0.001\\n sigma = var**0.5\\n gauss = np.array(image.shape)\\n gauss = np.random.normal(mean,sigma,(row,col,ch))\\n gauss = gauss.reshape(row,col,ch)\\n #print(gauss)\\n noisy = image + gauss*255\\n return noisy.astype('uint8')\\n elif noise_type == \\\"s&p\\\":\\n s_vs_p = 0.5\\n amount = 0.09\\n out = image\\n # Generate Salt '1' noise\\n num_salt = np.ceil(amount * image.size * s_vs_p)\\n coords = [np.random.randint(0, i - 1, int(num_salt))\\n for i in image.shape]\\n out[coords] = 255\\n # Generate Pepper '0' noise\\n num_pepper = np.ceil(amount* image.size * (1. - s_vs_p))\\n coords = [np.random.randint(0, i - 1, int(num_pepper))\\n for i in image.shape]\\n out[coords] = 0\\n return out\\n elif noise_type == \\\"poisson\\\":\\n vals = len(np.unique(image))\\n vals = 2 ** np.ceil(np.log2(vals))\\n noisy = np.random.poisson(image * vals) / float(vals)\\n return noisy\\n elif noise_type ==\\\"speckle\\\":\\n gauss = np.random.randn(row,col,ch)\\n gauss = gauss.reshape(row,col,ch) \\n noisy = image + image * gauss\\n return noisy\\n else:\\n return image\",\n \"def make_noise(self, num):\\n return np.random.randn(num, self.seq_length, self.noise_dim)\",\n \"def apply_noise(self, input):\\n mask = np.random.binomial(1, 1-self.noise_prob, len(input)) \\n noisy_input = mask * input\\n \\n return noisy_input\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.image.shape)\\n self.image += self.noise\\n return\",\n \"def add_noise(pc, variance,distribution='gaussian'):\\n pc_out = []\\n\\n if distribution=='gaussian':\\n for pt in pc:\\n pc_out.append(pt + numpy.random.normal(0, variance, (2, 1)))\\n elif distribution=='uniform':\\n for pt in pc:\\n pc_out.append(pt + numpy.random.uniform(-variance, variance, (2, 1)))\\n else:\\n raise ValueError(['Unknown distribution type: ', distribution])\\n return pc_out\",\n \"def noise(self, freq: int, /) -> None:\",\n \"def add_noise(self):\\n self.noise = np.random.poisson(lam=self.lam, size=self.im.shape)\\n self.im += self.noise\\n return\",\n \"def add_noise(self, u):\\n noise = torch.randn_like(u)\\n noise[:, :, :3] = noise[:, :, :3] * self.imu_std[0]\\n noise[:, :, 3:6] = noise[:, :, 3:6] * self.imu_std[1]\\n\\n # bias repeatability (without in run bias stability)\\n b0 = self.uni.sample(u[:, 0].shape).cuda()\\n b0[:, :, :3] = b0[:, :, :3] * self.imu_b0[0]\\n b0[:, :, 3:6] = b0[:, :, 3:6] * self.imu_b0[1]\\n u = u + noise + b0.transpose(1, 2)\\n return u\",\n \"def addNoise(array,counts):\\r\\n if array.dtype == 'complex' :\\r\\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\\r\\n else :\\r\\n if np.float64(counts) == 0.0e0 :\\r\\n arrayout = np.zeros(array.shape, dtype=arrayout.dtype)\\r\\n elif np.float64(counts) < 0.0e0 :\\r\\n print 'bg.addNoise : warning counts < 0'\\r\\n elif np.float64(counts) > 1.0e9 :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = normaliseInt(array)\\r\\n arrayout = np.random.normal(arrayout*np.float64(counts),np.sqrt(arrayout*np.float64(counts)))/np.float64(counts)\\r\\n tot = np.sum(array)\\r\\n arrayout = normaliseInt(arrayout,tot)\\r\\n else :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = normaliseInt(array)\\r\\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\\r\\n tot = np.sum(array)\\r\\n arrayout = normaliseInt(arrayout,tot)\\r\\n return arrayout\",\n \"def noise(self, stddev):\\n #add noise to weights\\n pass\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def _add_noise(signal: np.array, noise_power: float) -> np.array:\\n noise = np.sqrt(noise_power / 2) * np.random.randn(signal.size)\\n return signal + noise\",\n \"def create_synthetic_noise_dataset(cfg):\\n from colorednoise import powerlaw_psd_gaussian\\n\\n betas = np.linspace(cfg['data.mix_synthetic_noise.min_beta'],\\n cfg['data.mix_synthetic_noise.max_beta'],\\n num=cfg['data.mix_synthetic_noise.num_samples'])\\n sample_rate = cfg['data.sample_rate']\\n segment_length = 2 * cfg['data.len_min']\\n wavs = [powerlaw_psd_gaussian(beta, sample_rate * segment_length)\\n for beta in betas]\\n wavs = [audio.normalize(wav, low=-1, high=1) for wav in wavs]\\n return NoiseDataset(wavs)\",\n \"def make_noise(self, num):\\n return np.random.randn(num, self.seq_length + 2 * self.seq_pad,\\n self.noise_dim)\",\n \"def create_shared_noise(count):\\n seed = 123\\n noise = np.random.RandomState(seed).randn(count).astype(np.float32)\\n return noise\",\n \"def gen_noise(sample_size, latent):\\r\\n\\treturn Variable(torch.randn(sample_size, latent))\",\n \"def add_gaussian_noise(x, std):\\n noise = x.new_zeros(x.size()).normal_(std=std)\\n return x + noise\",\n \"def fill_noise(x, noise_type):\\n if noise_type == 'u':\\n x.uniform_()\\n elif noise_type == 'n':\\n x.normal_() \\n else:\\n assert False\",\n \"def noiseAtten(atten) :\\n s.noiseAtten(atten)\",\n \"def addNoise(self, sigma=1.0):\\n noise = numpy.random.normal(loc=0, scale=sigma, size=(self.ny, self.nx))\\n self.image += noise\\n return\",\n \"def _make_noisy(x, the_noise):\\n noise_sample = the_noise[np.random.choice(the_noise.shape[0],\\n x.shape[0],\\n replace=False)]\\n return x + noise_sample\",\n \"def add_silent_values(noiseValues):\\n for i in range(0, groupSize):\\n noiseRecord = random.choice(noiseValues)\\n noiseValue = noiseRecord.audio\\n newSample = AudioData(\\n noiseValue,\\n \\\"W6\\\",\\n 1,\\n \\\"Washing Room\\\"\\n )\\n newSample.processedValue = noiseValue\\n newSample.noiseValue = noiseValue\\n db.session.add(newSample)\\n db.session.commit()\",\n \"def derandomize(self, xs, noises):\\n raise NotImplementedError\",\n \"def add_noise_features(data, num_noise, binary=False, p=0.5):\\n\\n # Do nothing if no noise feature to add\\n if not num_noise:\\n return data, None\\n\\n # Number of nodes in the dataset\\n num_nodes = data.x.size(0)\\n\\n # Define some random features, in addition to existing ones\\n m = torch.distributions.bernoulli.Bernoulli(torch.tensor([p]))\\n noise_feat = m.sample((num_noise, num_nodes)).T[0]\\n # noise_feat = torch.randint(2,size=(num_nodes, num_noise))\\n if not binary:\\n noise_feat_bis = torch.rand((num_nodes, num_noise))\\n # noise_feat_bis = noise_feat_bis - noise_feat_bis.mean(1, keepdim=True)\\n noise_feat = torch.min(noise_feat, noise_feat_bis)\\n data.x = torch.cat([noise_feat, data.x], dim=-1)\\n\\n return data, noise_feat\",\n \"def add_noise(pointcloud, stddev=0.01):\\n result = pointcloud\\n result[0:2, :] = np.random.normal(pointcloud[0:2, :], stddev)\\n return result\",\n \"def noise_input_fn(params):\\n batch_size = params['batch_size']\\n noise_dim = params['noise_dim']\\n # Use constant seed to obtain same noise\\n np.random.seed(0)\\n noise_dataset = tf.data.Dataset.from_tensors(\\n {'random_noise': tf.constant(\\n np.random.randn(batch_size, noise_dim), dtype=tf.float32)\\n })\\n noise = noise_dataset.make_one_shot_iterator().get_next()\\n tf.logging.debug('Noise input %s', noise)\\n return noise_dataset\",\n \"def add_noise(self, portion, amplitude):\\n # TODO: Implement the add_noise function. Remember to record the\\n # boolean value is_add_noise. You can try uniform noise or Gaussian\\n # noise or others ones that you think appropriate.\\n self.is_add_noise = True\\n noise = np.random.normal(0, 1, size = self.x.shape)\\n noNoiseIndices = np.random.choice(self.x.shape[0], size = int(np.round(self.x.shape[0]*(1 - portion))), replace = False)\\n noise = (noise*amplitude).astype(np.uint8)\\n noise[noNoiseIndices,:] = 0\\n self.x += noise\\n self.x = np.clip(self.x, 0, 255, out=self.x)\\n \\n \\n \\n \\n # raise NotImplementedError\\n #######################################################################\\n # #\\n # #\\n # TODO: YOUR CODE HERE #\\n # #\\n # #\\n #######################################################################\",\n \"def white_noise():\\n return random.randint(-32767, 32767)\",\n \"def generate_fake_noise(inputs, size):\\n return np.random.normal(-0.0289923828125, 1.9391296947313124, (inputs, size)).astype(np.float32)\",\n \"def addNoise(img, sigma=2.0, mean=0):\\n img2 = np.random.normal(mean, sigma, size=img.shape)\\n\\n img2 += img\\n img2 = np.uint8(img2.clip(0, 255))\\n return img2\",\n \"def _get_noise(self, shape, dtype=None):\\n return np.random.uniform(self._low, self._high, shape).astype(dtype)\",\n \"def resample_data(data, n_data_points=None, seed=None):\\n if seed is not None: _np.random.seed(seed)\\n if n_data_points is None: n_data_points = _np.sum(data)\\n p_ml = _np.array(data) / _np.sum(data)\\n resampled = _np.random.multinomial(n_data_points, p_ml)\\n return resampled\",\n \"def ternary_noise(N_stimuli, Nx, Ny):\\n return np.random.randint(-1, 2, size=(N_stimuli, Nx, Ny))\",\n \"def add_noise(image, noise, rate=0.05):\\n\\n if noise == \\\"gaussian\\\":\\n row, col = image.shape\\n var = ndimage.laplace(image).var()\\n sigma = (var*rate) ** 0.5\\n print(var, sigma)\\n gauss = np.random.normal(loc=0, scale=sigma, size=(row, col)) * rate\\n noisy = image + gauss\\n # noisy = image + gauss\\n return noisy\\n\\n elif noise == \\\"salt_pepper\\\":\\n output = image.copy()\\n black = 0\\n white = 255\\n probs = np.random.random(image.shape[:2])\\n output[probs < (rate / 2)] = black\\n output[probs > 1 - (rate / 2)] = white\\n\\n return output\\n\\n else:\\n return image\",\n \"def benchmark_noise(features, data_parameters, experiment_parameters):\\n # Gets the noise parameters from the settings\\n scaled_noise, _ = _convert_power_variables(\\n experiment_parameters,\\n data_parameters\\n )\\n\\n # Runs the benchmark\\n logging.info(\\\"Starting benchmark 1 -- Add noise to a sparse floating point vector\\\")\\n start = time.time()\\n\\n noise = np.random.normal(scale=scaled_noise, size=features.shape)\\n noisy_features = features + noise\\n\\n end = time.time()\\n exec_time = (end - start) * 1000\\n logging.info(\\\"Benchmark 1 execution time: %.3f milliseconds\\\", exec_time)\\n return noisy_features\",\n \"def make_noise(self, signal_only):\\n\\n #print >> sys.stdout, \\\"generating noise...\\\"\\n\\n if signal_only:\\n\\n # the noise is just a time series of zeros\\n \\n self.td_noise = pycbc.types.timeseries.TimeSeries(\\n initial_array=np.zeros(self.duration/self.delta_t),\\n delta_t=self.delta_t, epoch=self.epoch)\\n\\n else:\\n # Generate noise \\n self.assign_noise_curve()\\n\\n # Generate time-domain noise\\n # XXX: minimum duration seems to be 1 second. I'll hack around this by\\n # reducing the 1 second to the desired duration\\n tmplen=max(self.duration,1.0)/self.delta_t\\n self.td_noise = pycbc.noise.noise_from_psd(int(tmplen), self.delta_t,\\n self.psd, seed=self.seed)\\n\\n self.td_noise = \\\\\\n pycbc.types.TimeSeries(self.td_noise.data[:self.duration/self.delta_t],\\n delta_t=self.delta_t)\\n\\n # XXX not sure if this is a good idea...\\n self.td_noise.start_time = float(self.epoch)\\n\\n self.fd_noise = self.td_noise.to_frequencyseries()\",\n \"def add_uniform_noise(rates, percent):\\n raise 0 < percent < 1 or AssertionError\\n rtemp = rates.copy().getA()\\n noise = np.random.uniform(1 - percent, 1 + percent, np.shape(rtemp))\\n rtemp = rtemp * noise\\n return np.matrix(rtemp)\",\n \"def addNoise_amp(array,counts):\\r\\n if array.dtype == 'complex' :\\r\\n arrayout = addNoise(np.real(array),counts) + 1.0J * addNoise(np.imag(array),counts)\\r\\n else :\\r\\n if np.float64(counts) == 0.0e0 :\\r\\n arrayout = np.copy(array)\\r\\n elif np.float64(counts) < 0.0e0 :\\r\\n print 'bg.addNoise : warning counts < 0'\\r\\n else :\\r\\n arrayout = np.zeros(array.shape)\\r\\n arrayout = np.square(normalise(array))\\r\\n arrayout = np.random.poisson(arrayout*np.float64(counts))/np.float64(counts)\\r\\n arrayout = np.sqrt(arrayout)\\r\\n tot = np.sum(np.abs(array)**2)\\r\\n arrayout = normalise(arrayout,tot)\\r\\n return arrayout\",\n \"def create_noise_data_from_original():\\n # Get the noise values we'll choose from.\\n noiseValues = AudioDataOriginal.query.filter(\\n AudioDataOriginal.datetime >= '2017-06-14 07:26:24',\\n AudioDataOriginal.datetime <= '2017-06-14 07:27:54',\\n ).all()\\n # Add a noise value to each record with a `processedValue`, as these are the\\n # only ones used in the model generation later on.\\n audioSamples = AudioDataOriginal.query.filter(\\n AudioDataOriginal.datetime > '2017-06-14 07:27:54',\\n AudioDataOriginal.processedValue.isnot(None)\\n ).all()\\n for sample in audioSamples:\\n noiseRecord = random.choice(noiseValues)\\n sample.noiseValue = noiseRecord.audio\\n db.session.commit()\",\n \"def get_noise(n_samples, noise_dims):\\n return torch.randn(n_samples, noise_dims).to(device)\",\n \"def add_noise(image, shot_noise=0.01, read_noise=0.0005):\\n variance = image * shot_noise + read_noise\\n noise = torch.FloatTensor(image.shape).normal_().to(image.device)*variance.sqrt()\\n return image + noise\",\n \"def noise(x: np.ndarray) -> np.ndarray:\\n\\n return np.random.normal(loc=MEAN, scale=1e-2, size=1)\",\n \"def add_noise(spectra: np.ndarray, maxLevel: float = 0.1, seed: int = 42) -> np.ndarray:\\n np.random.seed(seed)\\n spectra = spectra.copy()\\n spectra[:, 1:] *= (1-maxLevel/2) + np.random.rand(spectra.shape[0], spectra.shape[1]-1) * maxLevel\\n return spectra\",\n \"def add_noise(self,fing):\\r\\n\\t\\tfingerprint = copy.deepcopy(fing)\\r\\n\\t\\tl = len(fingerprint)\\r\\n\\t\\tnp.random.seed()\\t\\r\\n\\t\\tif self.noise_type == 'SNR':\\r\\n\\t\\t\\tnoise = np.random.normal(0, 1, l)\\r\\n\\t\\t\\tsignal_Power = np.linalg.norm(fingerprint)\\r\\n\\t\\t\\tnoise_Power = np.linalg.norm(noise)\\r\\n\\t\\t\\tcst = signal_Power / (noise_Power * self.noise_level)\\r\\n\\t\\t\\tnoise = noise * cst\\r\\n\\t\\telif self.noise_type == 'Standard':\\r\\n\\t\\t\\tnoise = np.random.normal(0, self.noise_level, l)\\r\\n\\t\\tfingerprint += noise\\r\\n\\t\\tif self.trparas.normalization == 'Noisy_input':\\r\\n\\t\\t\\treturn fingerprint / np.linalg.norm(fingerprint)\\r\\n\\t\\telse:\\r\\n\\t\\t\\treturn fingerprint\",\n \"def add_noise(spectrum,rms):\\n noise = np.random.randn(spectrum.data.shape[0])*rms\\n noisy_data = spectrum.data + noise\\n noisy_spec = pyspeckit.Spectrum(xarr=spectrum.xarr,data=noisy_data)\\n return noisy_spec\",\n \"def mock_noise(scale, size):\\n return np_repeat(scale, size)\",\n \"def predict_w_noise(self, xs, stochastic=True, **kwargs):\\n raise NotImplementedError\",\n \"def noise(voxels, volume_dim, voxel_dim, protein_noise):\\n ab_std = 100.0 / np.array(voxel_dim)#200 nm seems to work well as std\\n gaussian = np.stack([np.random.normal(0, std, len(voxels)) for std in ab_std], axis=-1)\\n #Get random subset\\n non_noisy = int((1 - protein_noise) * len(voxels))\\n indices = np.random.choice(len(voxels), size=non_noisy)\\n #Set these to 0\\n gaussian[indices, :] = [0, 0, 0]\\n #Add noise\\n voxels = np.round(voxels + gaussian).astype(np.int32)\\n #Remove out of bounds voxels\\n low, high = np.array([0, 0, 0]), np.array(volume_dim)\\n inidx = np.all(np.logical_and(low <= voxels, voxels < high), axis=1)\\n return voxels[inidx]\",\n \"def sample_noise(batch_size, dim):\\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\\n\\n return temp\",\n \"def noiseReduction(self):\\n pass\",\n \"def sim_brown_noise(N):\\n return np.cumsum(np.random.randn(N))\",\n \"def add_noise(mat,\\n pseudocount=1,\\n percent_normal=0.1,\\n percent_random=0.1,\\n random_count=1,\\n add_missing_at_random=False,\\n percent_missing=0.1):\\n\\n # transform mat into ALR space for\\n # adding normal dist. noise\\n mat_noise = alr(mat + pseudocount)\\n\\n # add homo-scedastic noise\\n err = percent_normal * np.ones_like(mat_noise)\\n mat_noise = normal(mat_noise, err)\\n\\n # add hetero-scedastic noise\\n err = percent_random * np.ones_like(mat_noise)\\n n_entries = int(percent_random * np.count_nonzero(mat_noise))\\n i = randint(0, err.shape[0], n_entries)\\n j = randint(0, err.shape[1], n_entries)\\n err[i, j] = random_count\\n mat_noise = normal(mat_noise, err)\\n\\n # transform back\\n mat_noise = alr_inv(mat_noise)\\n\\n # finally add sparsity\\n # Note: there will be no zeros after\\n # using the pseudocount\\n if add_missing_at_random:\\n n_entries = int(percent_missing * np.count_nonzero(mat_noise))\\n i = randint(0, mat_noise.shape[0], n_entries)\\n j = randint(0, mat_noise.shape[1], n_entries)\\n mat_noise[i, j] = 0\\n else:\\n i, j = np.nonzero(mat == 0)\\n mat_noise[i, j] = 0\\n\\n return mat_noise\",\n \"def create_noise_dataset(cfg):\\n here = os.path.dirname(__file__)\\n basedir = os.path.join(here, cfg['data.mix_background_noise.audio_dir'])\\n audio_files = find_files(basedir,\\n cfg['data.mix_background_noise.audio_regexp'])\\n sample_rate = cfg['data.sample_rate']\\n audios = [audio.WavFile(fn, sample_rate=sample_rate)\\n for fn in tqdm.tqdm(audio_files, 'Reading noise',\\n ascii=bool(cfg['tqdm.ascii']))]\\n segment_files = [os.path.splitext(fn)[0] + '.csv' for fn in audio_files]\\n segments = [read_noise_csv(fn, sample_rate, len(wav))\\n if os.path.exists(fn)\\n else [(0, len(wav))]\\n for fn, wav in zip(segment_files, audios)]\\n return NoiseDataset(audios, segments,\\n min_length=sample_rate * cfg['data.len_min'])\",\n \"def _get_noise(self, shape, dtype=None):\\n return np.random.normal(self._bias, self._scale, shape).astype(dtype)\",\n \"def generate_data(Amp, freq, noise_amp):\\n x = np.arange(0.,80.,0.01)\\n y = Amp * np.sin(freq * x)\\n y += noise_amp * np.random.randn(len(y))\\n return x, y\",\n \"def _addNoise(self):\\n self.dispNoise = self.dispRaw.copy()\\n self.dispNoise[:, 0] += self.sigmaEast * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 1] += self.sigmaNorth * numpy.random.randn(self.numStations)\\n self.dispNoise[:, 2] += self.sigmaUp * numpy.random.randn(self.numStations)\\n return\",\n \"def apply_poisson_noise(data, seed=None):\\n data = np.asanyarray(data)\\n if np.any(data < 0):\\n raise ValueError('data must not contain any negative values')\\n\\n rng = np.random.default_rng(seed)\\n\\n return rng.poisson(data)\",\n \"def img_add_random_noise(arr, noise_perc = 0.05):\\r\\n assert len(arr.shape) == 3, \\\"'arr' input array must be three dimensional\\\"\\r\\n arr_copy = arr.copy()\\r\\n noise = np.random.randint(np.max(arr), size = arr.shape)\\r\\n rand_numbers = random.sample(range(100), int(noise_perc * 100))\\r\\n for x in range(arr.shape[0]):\\r\\n for y in range(arr.shape[1]):\\r\\n for z in range(arr.shape[2]):\\r\\n if random.choice(range(100)) in rand_numbers:\\r\\n arr_copy[x][y][z] += noise[x][y][z]\\r\\n return arr_copy\",\n \"def noise(self):\\r\\n if self.buffer_offset + self.frames_per_buffer - 1 > self.x_max:\\r\\n #relleno con ceros al final si es necesario\\r\\n xs = np.arange(self.buffer_offset, self.x_max)\\r\\n tmp = np.random.random_sample(len(xs)) #ruido\\r\\n out = np.append(tmp, np.zeros(self.frames_per_buffer-len(tmp)))\\r\\n else:\\r\\n xs = np.arange(self.buffer_offset,\\r\\n self.buffer_offset + self.frames_per_buffer)\\r\\n out = np.random.random_sample(len(xs))\\r\\n self.buffer_offset += self.frames_per_buffer\\r\\n return out\",\n \"def add_noise(np_image, amount):\\n noise = np.random.randn(np_image.shape[0],np_image.shape[1])\\n norm_noise = abs(noise/np.max(noise))\\n np_image = np_image + norm_noise*np.max(np_image)*amount\\n \\n return np_image\",\n \"def add_white_noise(rates, numreg):\\n rtemp = rates.copy().getA()\\n sdrates = np.sqrt(rtemp * (1 - rtemp) / numreg) + 1e-10\\n noise = np.random.normal(0, sdrates)\\n rtemp += noise\\n return np.matrix(rtemp)\",\n \"def _sample_new_noise(self, *, tf_sess=None):\\n if self.framework == \\\"tf\\\":\\n tf_sess.run(self.tf_sample_new_noise_op)\\n elif self.framework == \\\"tf2\\\":\\n self._tf_sample_new_noise_op()\\n else:\\n for i in range(len(self.noise)):\\n self.noise[i] = torch.normal(\\n mean=torch.zeros(self.noise[i].size()), std=self.stddev\\n ).to(self.device)\",\n \"def augment_by_additive_noise(ds, noise_datadir, snr_list, copy_noise_files_to_tmpdir=False):\\n logger.info(\\\"Augmenting dataset with additive noise from '%s'.\\\", noise_datadir)\\n if not os.path.isdir(noise_datadir):\\n logger.error(\\\"Noise source dir '%s' does not exist.\\\", noise_datadir)\\n return\\n\\n id2type = dict(lidbox.iter_metadata_file(os.path.join(noise_datadir, \\\"id2label\\\"), 2))\\n type2paths = collections.defaultdict(list)\\n for noise_id, path in lidbox.iter_metadata_file(os.path.join(noise_datadir, \\\"id2path\\\"), 2):\\n type2paths[id2type[noise_id]].append(path)\\n del id2type\\n\\n if copy_noise_files_to_tmpdir:\\n tmpdir = os.path.join(os.environ.get(\\\"TMPDIR\\\", \\\"/tmp\\\"), \\\"lidbox_noise_signals\\\")\\n logger.info(\\\"Copying all noise files to TMPDIR '%s'\\\", tmpdir)\\n for noise_type, paths in list(type2paths.items()):\\n new_paths = []\\n for src in paths:\\n dst = os.path.join(tmpdir, noise_type, os.path.basename(src))\\n logger.debug(\\\"%s -> %s\\\", src, dst)\\n os.makedirs(os.path.dirname(dst), exist_ok=True)\\n shutil.copyfile(src, dst)\\n new_paths.append(dst)\\n type2paths[noise_type] = new_paths\\n\\n type2paths = {t: tf.constant(paths, tf.string) for t, paths in type2paths.items()}\\n\\n def _update_element_meta(new_id, mixed_signal, x):\\n return dict(x, id=new_id, signal=mixed_signal)\\n\\n def _add_random_noise_and_flatten(x):\\n \\\"\\\"\\\"\\n Using snr_list, choose len(snr_list) noise signals randomly and create new signal samples by mixing the chosen noise signals with x[\\\"signal\\\"] using random SNR dB levels.\\n \\\"\\\"\\\"\\n # Random noise path indexes and random snr levels\\n rand_noise = [\\n (noise_type,\\n tf.random.uniform([], 0, tf.size(type2paths[noise_type]), tf.int32),\\n tf.random.uniform([], snr_low, snr_high, tf.float32))\\n for noise_type, snr_low, snr_high in snr_list]\\n # Select random noise signals by drawn indexes and read contents from files\\n rand_noise = [\\n (audio_features.read_wav(type2paths[noise_type][rand_index]), snr)\\n for noise_type, rand_index, snr in rand_noise]\\n\\n # Assert sample rates\\n # TODO maybe add inline resampling of noise signals so they match the speech sr\\n for (noise, sample_rate), snr in rand_noise:\\n tf.debugging.assert_equal(sample_rate, x[\\\"sample_rate\\\"], message=\\\"Invalid noise signals are being used, all noise signals must have same sample rate as speech signals that are being augmented\\\")\\n\\n # Fix noise signal length to match x[\\\"signal\\\"] by repeating the noise signal if it is too short and then slicing it\\n rand_noise = [\\n # How many multiples of `noise` fits in x[\\\"signal\\\"]\\n (tf.cast(tf.size(x[\\\"signal\\\"]) / tf.size(noise), tf.int32), noise, snr)\\n for (noise, _), snr in rand_noise]\\n rand_noise = [\\n # Repeat noise and slice\\n (tf.tile(noise, [1 + noise_length_ratio])[:tf.size(x[\\\"signal\\\"])], snr)\\n for noise_length_ratio, noise, snr in rand_noise]\\n\\n # Mix x[\\\"signal\\\"] and chosen noise signals\\n mixed_signals = [audio_features.snr_mixer(x[\\\"signal\\\"], noise, snr)[2] for noise, snr in rand_noise]\\n # Create new utterance ids that contain the mixed noise type and SNR level\\n new_ids = [\\n tf.strings.join((\\n \\\"augmented\\\",\\n x[\\\"id\\\"],\\n noise_type,\\n tf.strings.join((\\\"snr\\\", tf.strings.as_string(snr, precision=2)))),\\n separator=\\\"-\\\")\\n for (noise_type, _, _), (_, snr) in zip(snr_list, rand_noise)]\\n\\n # Create new elements from the mixed signals and return as dataset\\n return (tf.data.Dataset\\n .zip((tf.data.Dataset.from_tensor_slices(new_ids),\\n tf.data.Dataset.from_tensor_slices(mixed_signals),\\n tf.data.Dataset.from_tensors(x).repeat(len(mixed_signals))))\\n .map(_update_element_meta))\\n\\n return ds.interleave(\\n _add_random_noise_and_flatten,\\n block_length=len(snr_list),\\n num_parallel_calls=TF_AUTOTUNE)\",\n \"def add_noise(image, type=\\\"s&p\\\"):\\n # Get the width and height of the image\\n w, h = image.size\\n\\n # Add salt and pepper noise\\n if type == \\\"s&p\\\":\\n # Choose a random amount of noise (lower number = more noise)\\n salt = np.random.randint(100, 400)\\n # Generate an array to determine location of noise\\n noise = np.random.randint(salt+1, size=(h, w))\\n\\n # Find the index of the salt and pepper (respectively location with max/min random value)\\n idx_salt = noise == salt\\n idx_pepper = noise == 0\\n\\n # Create a numpy array from the initial image and add the salt and pepper\\n np_img = np.array(image)\\n np_img[idx_salt, :] = 255\\n np_img[idx_pepper, :] = 0\\n\\n return Image.fromarray(np.uint8(np_img))\\n\\n # Add gaussian noise to image\\n if type == \\\"gauss\\\":\\n # Get the number of channels\\n c = len(image.getbands())\\n\\n # Get a random value for the mean and the standard deviation of the noise\\n mean = np.random.randint(-4, 5)\\n std = np.random.randint(5)\\n\\n # Generate the noise array\\n noise = np.random.normal(mean, std, (h, w, c))\\n\\n # Add noise to the image\\n return Image.fromarray(np.uint8(np.array(image) + noise))\\n\\n else:\\n # If the name of the given noise is not correct\\n return image\",\n \"def add_noise_at_snr(channel_in, snr):\\n\\n rms_channel = np.sqrt(np.mean(channel_in ** 2.0))\\n noise_std = rms_channel / np.sqrt(10.0 ** (snr/10.0))\\n\\n return channel_in + np.random.normal(size=channel_in.shape, scale=noise_std)\",\n \"def make_time_series_noise(dates, mean=0., std=1.):\\n # TODO: implement Gaussian noise with mean/std\\n # TODO: add kwarg to parametrize noise from clouds/shadows\\n pass\",\n \"def noiseless_function(x):\\n return 1/(1+np.exp(-x+5))-0.5\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def awgn(input, noise_std):\\n\\tif not isinstance(noise_std, (list, tuple)):\\n\\t\\tsigma = noise_std\\n\\telse: # uniform sampling of sigma\\n\\t\\tsigma = noise_std[0] + \\\\\\n\\t\\t (noise_std[1] - noise_std[0])*torch.rand(len(input),1,1,1, device=input.device)\\n\\treturn input + torch.randn_like(input) * (sigma/255)\",\n \"def add_noise(emg):\\n MAX_AMPLITUDE = 32767\\n\\n # Sampling\\n # 1 second of data requires 600 frames. And 600 fps is 600 Hz, sampling rate of EMG.\\n Ts = 1/EMG_F_SAMPLE\\n\\n # Time vector\\n t = np.arange(0, len(emg)/EMG_F_SAMPLE, Ts) # each unit of t is a second\\n\\n # Noise\\n randAmplitudeScale = np.random.random()*0.1\\n randOffset = np.random.random() * 2*np.pi\\n \\n fNoise = 50; # Frequency [Hz]\\n aNoise = randAmplitudeScale*MAX_AMPLITUDE # Amplitude\\n noise = aNoise * np.sin(2 * np.pi * t * fNoise + randOffset)\\n\\n # Add noise to signal\\n for channel in [\\\"emg1\\\", \\\"emg2\\\", \\\"emg3\\\", \\\"emg4\\\", \\\"emg5\\\", \\\"emg6\\\"]:\\n emg[channel] += noise\\n return emg\",\n \"def add_noise_batch(self,fingerprints):\\r\\n\\t\\tif self.trparas.complex:\\r\\n\\t\\t\\tn,l,r = fingerprints.shape\\r\\n\\t\\t\\tnp.random.seed()\\r\\n\\r\\n\\t\\t\\t# noise_level = 0.002\\r\\n\\t\\t\\tnoise_level = self.noise_level\\r\\n\\t\\t\\t# add noise to real and imag part seperately with different noise level\\r\\n\\t\\t\\tnoise_real = np.random.normal(0, noise_level, (n, l))\\r\\n\\t\\t\\tnoise_imag = np.random.normal(0, noise_level, (n, l))\\r\\n\\t\\t\\tnoise = np.stack([noise_real,noise_imag],axis=2) # n,l,r 4000,666,2\\r\\n\\t\\t\\tfingerprints += noise\\r\\n\\t\\t\\treturn fingerprints\\r\\n\\r\\n\\t\\telse:\\t\\r\\n\\t\\t\\tn,l = fingerprints.shape\\r\\n\\t\\t\\tnp.random.seed()\\r\\n\\t\\t\\tif self.noise_type == 'SNR':\\r\\n\\t\\t\\t\\tnoise = np.random.normal(0, 1, (n,l))\\r\\n\\t\\t\\t\\tsignal_Power = np.linalg.norm(fingerprints, axis=1)\\r\\n\\t\\t\\t\\tnoise_Power = np.linalg.norm(noise,axis=1)\\r\\n\\t\\t\\t\\tcst = signal_Power / (noise_Power * self.noise_level)\\r\\n\\t\\t\\t\\tnoise = noise * np.tile(cst.reshape(-1,1),(1,l))\\r\\n\\t\\t\\telif self.noise_type == 'Standard':\\r\\n\\t\\t\\t\\tnoise = np.random.normal(0, self.noise_level, (n,l))\\r\\n\\t\\t\\tfingerprints += noise\\r\\n\\t\\t\\tif self.trparas.normalization == 'Noisy_input':\\r\\n\\t\\t\\t\\treturn fingerprints / np.tile(np.linalg.norm(fingerprints,axis=1).reshape(-1,1), (1,l))\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\treturn fingerprints\",\n \"def _get_noise(self, shape, dtype=None):\",\n \"def __call__(self, input: torch.Tensor) -> torch.Tensor:\\n # Get noise\\n noise = self.mean + torch.randn_like(input) * self.std\\n # Apply nose to image\\n input = input + noise\\n return input\",\n \"def gaussian_noise(tensor, mean, stddev):\\n noise = Variable(tensor.data.new(tensor.size()).normal_(mean, std))\\n return tensor + noise\",\n \"def generate_normal_data(avg_strike, avg_dip, n=10, noise_std=5, porp=2):\\n opp_strike = avg_strike + 180\\n if opp_strike > 360: \\n opp_strike -= 360\\n strike = avg_strike * np.ones(n)\\n strike[n//porp:] = opp_strike\\n dip = avg_dip * np.ones(n)\\n \\n # Add noise\\n strike += noise_std * np.random.randn(n)\\n dip += noise_std * np.random.randn(n)\\n\\n # Filter out things out of a reasonable range\\n strike[dip > 90] -= 180\\n dip[dip > 90] = 180 - dip[dip>90]\\n\\n strike[dip < 0] -= 180\\n dip[dip < 0] *= -1\\n\\n strike[strike < 0] += 360\\n strike[strike > 360] -= 360\\n \\n\\n normal = geometric_functions.plane2normal(strike, dip)\\n slip = geometric_functions.normal_slip(*normal)\\n\\n return strike, dip, normal, slip\",\n \"def add_gaussian_noise(X, mu=0, sigma=0.1):\\n noise = np.random.normal(0.0, sigma, size=X.size)\\n return X + noise.reshape(X.shape)\",\n \"def random_gaussian_noise(self, img, p = 0.5):\\n if self.decision(p):\\n mean = 30.0\\n std = 80.0\\n img = img + np.random.normal(mean, std, img.shape)\\n\\n img = np.clip(img, 0, 255).astype('uint8')\\n return img\",\n \"def add_noise(self, low, high, loc=None):\\n loc = dtloc2pos(loc, self.X)\\n return super().add_noise(low, high, loc=loc)\",\n \"def _sample_noise(self) -> np.ndarray:\\n return np.random.randn(self.actor_action_size)\",\n \"def add_noise(self, mdct_norm, masking_threshold):\\n return self.psychoacoustic.add_noise(mdct_norm, masking_threshold)\",\n \"def add_noise(self, snr, unit=None):\\n return self.from_time(self.fs, noisify(self.in_time, snr, unit=unit))\",\n \"def noise(self, noise):\\n\\n self._noise = noise\",\n \"def generate_synth_data(n):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7465272","0.7017835","0.69086975","0.68982387","0.68722546","0.68413025","0.68310094","0.6785632","0.6685227","0.664166","0.6633581","0.6620472","0.6596529","0.6596529","0.6562329","0.6559136","0.6473762","0.64221513","0.63911885","0.6359188","0.6347256","0.6328552","0.63273257","0.63262284","0.6306101","0.63040787","0.62755513","0.62606597","0.62606597","0.62600976","0.62363136","0.6229986","0.622648","0.6200574","0.6191275","0.6184828","0.61737823","0.61650735","0.6162374","0.61554706","0.61521715","0.6138424","0.6136111","0.61258787","0.6120466","0.61201644","0.6104206","0.60981876","0.6080096","0.60745716","0.60710716","0.60667914","0.6044431","0.60338974","0.60221934","0.60184544","0.60153466","0.59930533","0.5992179","0.59888434","0.59686244","0.5962533","0.5953695","0.59270746","0.5918051","0.59027344","0.59000707","0.5893267","0.5891154","0.58838403","0.58441466","0.5839438","0.5836741","0.58304405","0.5826807","0.5817575","0.5815417","0.5814911","0.58142895","0.57996136","0.579586","0.57583493","0.5755049","0.575182","0.57507426","0.57507426","0.57485133","0.5746984","0.57314736","0.5717891","0.57171553","0.5705677","0.5702197","0.5700583","0.5695201","0.5682426","0.5681865","0.5681159","0.56722057","0.56664914"],"string":"[\n \"0.7465272\",\n \"0.7017835\",\n \"0.69086975\",\n \"0.68982387\",\n \"0.68722546\",\n \"0.68413025\",\n \"0.68310094\",\n \"0.6785632\",\n \"0.6685227\",\n \"0.664166\",\n \"0.6633581\",\n \"0.6620472\",\n \"0.6596529\",\n \"0.6596529\",\n \"0.6562329\",\n \"0.6559136\",\n \"0.6473762\",\n \"0.64221513\",\n \"0.63911885\",\n \"0.6359188\",\n \"0.6347256\",\n \"0.6328552\",\n \"0.63273257\",\n \"0.63262284\",\n \"0.6306101\",\n \"0.63040787\",\n \"0.62755513\",\n \"0.62606597\",\n \"0.62606597\",\n \"0.62600976\",\n \"0.62363136\",\n \"0.6229986\",\n \"0.622648\",\n \"0.6200574\",\n \"0.6191275\",\n \"0.6184828\",\n \"0.61737823\",\n \"0.61650735\",\n \"0.6162374\",\n \"0.61554706\",\n \"0.61521715\",\n \"0.6138424\",\n \"0.6136111\",\n \"0.61258787\",\n \"0.6120466\",\n \"0.61201644\",\n \"0.6104206\",\n \"0.60981876\",\n \"0.6080096\",\n \"0.60745716\",\n \"0.60710716\",\n \"0.60667914\",\n \"0.6044431\",\n \"0.60338974\",\n \"0.60221934\",\n \"0.60184544\",\n \"0.60153466\",\n \"0.59930533\",\n \"0.5992179\",\n \"0.59888434\",\n \"0.59686244\",\n \"0.5962533\",\n \"0.5953695\",\n \"0.59270746\",\n \"0.5918051\",\n \"0.59027344\",\n \"0.59000707\",\n \"0.5893267\",\n \"0.5891154\",\n \"0.58838403\",\n \"0.58441466\",\n \"0.5839438\",\n \"0.5836741\",\n \"0.58304405\",\n \"0.5826807\",\n \"0.5817575\",\n \"0.5815417\",\n \"0.5814911\",\n \"0.58142895\",\n \"0.57996136\",\n \"0.579586\",\n \"0.57583493\",\n \"0.5755049\",\n \"0.575182\",\n \"0.57507426\",\n \"0.57507426\",\n \"0.57485133\",\n \"0.5746984\",\n \"0.57314736\",\n \"0.5717891\",\n \"0.57171553\",\n \"0.5705677\",\n \"0.5702197\",\n \"0.5700583\",\n \"0.5695201\",\n \"0.5682426\",\n \"0.5681865\",\n \"0.5681159\",\n \"0.56722057\",\n \"0.56664914\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7983066"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":805,"numItemsPerPage":100,"numTotalItems":95772,"offset":80500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjIxNjExMiwianRpIjoiNGRiYTFjNTMtYjI3NS00MjkzLThmYWYtN2M3YjVhOWI3MzAwIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMTk3MTIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.l_zhhdhuEEHTmok3l8Pudz4k4YVtdTL9x18kI5b5cPvW3hljAu3fUbp0k8koo3JrDhbtSYfX7O2l_WcZZjOICQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Remove chain if zero var. | def RemoveZeroVar(chain):
return chain[:, np.invert((np.sum(np.var(chain, axis=0), axis=1)<1e-10)), :] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RemoveZeroVar(chain):\n\treturn chain[:, np.invert((np.sum(np.var(chain, axis=0), axis=1)<1e-10)), :]",
"def remove_causal_chain_from_local_Q(self, trial_name, chain_idx):\n for state in range(self.local_Q[trial_name].shape[0]):\n self.local_Q[trial_name][state][chain_idx] = 0",
"def remo... | [
"0.75237256",
"0.65207744",
"0.61948866",
"0.5943889",
"0.5856726",
"0.579234",
"0.55565387",
"0.55563855",
"0.5513278",
"0.5393509",
"0.53831285",
"0.5355641",
"0.53278524",
"0.52536255",
"0.52277136",
"0.5119385",
"0.5117619",
"0.50989103",
"0.50953203",
"0.50734174",
"0.50... | 0.72741723 | 1 |
>>> soup = BeautifulSoup(open("../../data/share/posts/1009.html").read()) >>> ifValidSERP(soup) True >>> soup2 = BeautifulSoup(open("../../data/share/posts/2406.html").read()) >>> ifValidSERP(soup2) False | def ifValidSERP(soupObject):
return soupObject.find("p", class_="noresult_tit") is None and soupObject.title is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_format_wrong(soup):\n a = soup.find('a')\n if a.has_attr('faire'):\n return True\n return False",
"def broken_page(soup):\n ps = soup.find_all(\"p\")\n ps = map(lambda x: x.text, ps)\n unexpected_error = True in map(lambda x: \"unexpected error\" in x, ps)\n \n no_grades = s... | [
"0.6150946",
"0.6123322",
"0.57974476",
"0.56922346",
"0.5682742",
"0.5637584",
"0.5608051",
"0.55979985",
"0.5595201",
"0.55802923",
"0.55608934",
"0.5534084",
"0.55069125",
"0.54980284",
"0.54980284",
"0.54980284",
"0.54980284",
"0.54954755",
"0.5489522",
"0.5457203",
"0.54... | 0.67786336 | 0 |
Which queue to execute in | def queue_name(is_parallel):
return QUEUE_NAMES[int(bool(is_parallel))] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curr_queue(self):\n pass",
"def get_queue(self):\n if self.queue is not None:\n return self.queue\n state = self.get_state()\n self.queue = state.get_queue()\n # print(\"IQ\", self.queue)\n return self.queue",
"def _get_queue(self):\n return self.__qu... | [
"0.77458423",
"0.73086584",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.729819",
"0.71492094",
"0.71492094",
"0.69831365",
"0.69831365",
"0.6983136... | 0.62823564 | 59 |
Call simulation's in run_background with run_dir | def start_simulation(cmd, run_dir):
# Avoid circular import
from sirepo import simulation_db
run_dir = py.path.local(run_dir)
simulation_db.hack_nfs_write_status('running', run_dir)
with pkio.save_chdir(run_dir):
pksubprocess.check_call_with_signals(
cmd,
msg=pkdlog,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_simulation(run):\n # Write the argument file used by metrosim.\n simulation = run.simulation\n metrosim_dir = settings.BASE_DIR + '/metrosim_files/'\n metrosim_file = '{0}execs/metrosim'.format(metrosim_dir)\n arg_file = (\n '{0}arg_files/simulation_{1!s}_run_{2!s}.txt'.format(metrosi... | [
"0.6785062",
"0.6433013",
"0.636961",
"0.6257974",
"0.62099516",
"0.6203374",
"0.61503863",
"0.6149338",
"0.61456555",
"0.6127702",
"0.6124985",
"0.60598016",
"0.60587966",
"0.60583586",
"0.59858763",
"0.59568614",
"0.5947441",
"0.59464675",
"0.5935185",
"0.59265864",
"0.5924... | 0.6317826 | 3 |
Returns number of books read | def get_books_read(self):
return len(self.books) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(self):\n return Library.functions.count(self._book)",
"def book_count(self):\n\n try:\n cur = self._db.cursor()\n cur.execute('SELECT COUNT(*) FROM books')\n return cur.fetchone()[0]\n except sqlite3.Error as e:\n ... | [
"0.7992762",
"0.7731883",
"0.7612036",
"0.6803979",
"0.6539564",
"0.65282",
"0.6519381",
"0.6475682",
"0.6453176",
"0.6382742",
"0.6382742",
"0.6382742",
"0.6382742",
"0.6376332",
"0.6367946",
"0.6364944",
"0.6364356",
"0.63492286",
"0.6307586",
"0.63016653",
"0.62689745",
... | 0.8106499 | 0 |
Add read book to dict | def read_book(self, book, rating=None):
if isinstance(book, Book):
self.books.update({book: rating})
else:
print("{book} does not appear to be a Book object.".format(book=book)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_book(name, author):\n BOOKS.append({'name': name, 'author': author, 'read': False})",
"def addBook(self, book):\n self._books[book.getTitle()] = book",
"def get_book_details(book_id, key):\n\n # call goodreads search method with book id here\n payload = {\"key\": key}\n\n query = req... | [
"0.70027494",
"0.6613055",
"0.61070997",
"0.5929484",
"0.5909699",
"0.58513135",
"0.58490425",
"0.5800447",
"0.57466835",
"0.5695358",
"0.5646428",
"0.5639521",
"0.5612244",
"0.55981535",
"0.5580011",
"0.55505365",
"0.5531264",
"0.550869",
"0.54914147",
"0.5406447",
"0.536724... | 0.63098526 | 2 |
Calculate and return average rating | def get_average_rating(self):
count = 0
total = 0
num_books = len(self.books)
if num_books > 0:
for rating in self.books.values():
if rating:
count += 1
total += rating
average = total / count
if coun... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def average_rating(self):\n return ( self.rating_1 + self.rating_2 + self.rating_3) / 3",
"def average_rating(self):\n ratings = AttractionRating.objects.filter(attraction=self)\n total_rating = 0\n for rating in ratings:\n total_rating += rating.rating\n\n # If ther... | [
"0.8740609",
"0.8564026",
"0.8496057",
"0.84087116",
"0.831127",
"0.8271486",
"0.8252964",
"0.81941754",
"0.7935517",
"0.7797809",
"0.7769728",
"0.7713802",
"0.76922464",
"0.76497185",
"0.75058794",
"0.74698275",
"0.74556196",
"0.739389",
"0.73206496",
"0.7304481",
"0.7226037... | 0.7991875 | 8 |
Returns name, email, read count, and average rating | def __repr__(self):
count=0
for item in self.books.keys():
count += 1
return "User {name} with email address {email} has read {count} book(s) with an average rating of {rating}".format(name=self.name, email=self.email, count=count, rating=self.get_average_rating()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_average_rating(self):\n count = 0\n total = 0\n num_books = len(self.books)\n if num_books > 0:\n for rating in self.books.values():\n if rating:\n count += 1\n total += rating\n average = total / count\n... | [
"0.67255265",
"0.6498956",
"0.6255957",
"0.6089639",
"0.6080379",
"0.6029295",
"0.6007349",
"0.5960972",
"0.5883649",
"0.584985",
"0.5846773",
"0.58460647",
"0.5828495",
"0.5820474",
"0.57930464",
"0.5786282",
"0.57826287",
"0.57763314",
"0.5750481",
"0.5746483",
"0.57452625"... | 0.60270447 | 6 |
Is one of these items not like the other? | def __eq__(self, other_user):
if isinstance(other_user, User):
return self.name == other_user.name and self.email == other_user.get_email()
else:
other_user_type = type(other_user)
print("{other_user} is not a User object, it is of type: {type}".format(other_user=othe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def monkey_trouble(a_smile, b_smile):\r\n return a_smile == b_smile",
"def got_both(self):\r\n if Item.A in self.items and Item.B in self.items:\r\n return True",
"def monkey_trouble(a_smile, b_smile):\n if (a_smile and b_smile) or (not(a_smile) and not(b_smile)):\n return True\n... | [
"0.6570952",
"0.6535601",
"0.6506679",
"0.6503425",
"0.6453794",
"0.6407242",
"0.63862014",
"0.63140756",
"0.62963206",
"0.62380195",
"0.62060326",
"0.6189615",
"0.6150055",
"0.6142019",
"0.610952",
"0.6098643",
"0.60957783",
"0.6089502",
"0.6085284",
"0.60772216",
"0.6075057... | 0.0 | -1 |
Book Parent Class constructor | def __init__(self, title, isbn):
self.title = title
self.isbn = isbn
self.ratings = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n\n\t\tsuper().__init__(child_class = self.Book)",
"def __init__(self, name, isbn, author, tags=None):\n super().__init__(name, isbn, tags)\n self.author = author\n self.resource_type = \"Book\"",
"def __init__(self, bookAuthor, ISBN, numPurchased, bookTitle, numChecked... | [
"0.8750904",
"0.7605091",
"0.6969576",
"0.6868256",
"0.6854031",
"0.67320985",
"0.67320985",
"0.67320985",
"0.6729849",
"0.6729849",
"0.66908675",
"0.6662483",
"0.65881366",
"0.65264964",
"0.64747626",
"0.64687496",
"0.6450625",
"0.6415018",
"0.63792264",
"0.63792264",
"0.637... | 0.6014829 | 89 |
Adds a rating if it meets criteria | def add_rating(self, rating):
if not rating or rating < 0 or rating > 4:
return "Rating {rating} is not valid. Valid ratings are between 0 and 4".format(rating=rating)
else:
self.ratings.append(rating) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_rating(self, rating):\n if rating >= 0 and rating <= 4:\n self.ratings.append(rating)\n else:\n print(\"Invalid Rating\")",
"def add_rating(user, item, rating):\n users.append(user)\n items.append(item)\n ratings.append(rating)",
"def add_rating(self):\n ... | [
"0.78625226",
"0.63722396",
"0.6271171",
"0.60921353",
"0.6090529",
"0.6087433",
"0.6034467",
"0.5894537",
"0.58583003",
"0.58511144",
"0.5834168",
"0.580135",
"0.5800364",
"0.57674557",
"0.57537365",
"0.57537365",
"0.5751292",
"0.57333684",
"0.5727925",
"0.5715088",
"0.57114... | 0.7357697 | 1 |
Returns average rating or prints none available | def get_average_rating(self):
count = 0
total = 0
ratings_length = len(self.ratings)
if ratings_length > 0:
for rating in self.ratings:
count += 1
total += rating
average = total / count
return average
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_average_rating(self):\n count = 0\n total = 0\n num_books = len(self.books)\n if num_books > 0:\n for rating in self.books.values():\n if rating:\n count += 1\n total += rating\n average = total / count\n... | [
"0.78994644",
"0.77764827",
"0.76753175",
"0.76248264",
"0.75925076",
"0.75614244",
"0.748261",
"0.7427136",
"0.71799606",
"0.717904",
"0.71507555",
"0.7121672",
"0.6946089",
"0.6856904",
"0.68340194",
"0.6830731",
"0.67425144",
"0.67189294",
"0.66959345",
"0.668871",
"0.6650... | 0.8252819 | 0 |
Is one of these items not like the other? | def __eq__(self):
if isinstance(other_book, Book):
return self.title == other_book.title and self.isbn == other_book.isbn
else:
book_type=type(other_book)
print("{other_book} is of type: {type}, and should be a User type".format(other_book=other_book, type=book_type)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def monkey_trouble(a_smile, b_smile):\r\n return a_smile == b_smile",
"def got_both(self):\r\n if Item.A in self.items and Item.B in self.items:\r\n return True",
"def monkey_trouble(a_smile, b_smile):\n if (a_smile and b_smile) or (not(a_smile) and not(b_smile)):\n return True\n... | [
"0.6570952",
"0.6535601",
"0.6506679",
"0.6503425",
"0.6453794",
"0.6407242",
"0.63862014",
"0.63140756",
"0.62963206",
"0.62380195",
"0.62060326",
"0.6189615",
"0.6150055",
"0.6142019",
"0.610952",
"0.6098643",
"0.60957783",
"0.6089502",
"0.6085284",
"0.60772216",
"0.6075057... | 0.0 | -1 |
Returns hash of book | def __hash__(self):
return hash((self.title, self.isbn)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash(self) -> bytes:",
"def hash(self) -> str:\r\n ...",
"def get_hash(self):\r\n return",
"def hash(self) -> str:\n return pulumi.get(self, \"hash\")",
"def get_hash(self):\n source = \"\"\n for cell in self.original_cells:\n source += \"\\n\".join(get_sou... | [
"0.72355944",
"0.7082014",
"0.7071481",
"0.7000493",
"0.6883297",
"0.6867283",
"0.67737263",
"0.67702335",
"0.67687285",
"0.6761425",
"0.67514795",
"0.6711301",
"0.66213644",
"0.66213644",
"0.6589381",
"0.65639246",
"0.6561698",
"0.65491515",
"0.6539704",
"0.65378046",
"0.651... | 0.7334127 | 0 |
Returns a book instance | def create_book(self, title, isbn):
isbn_list = [book.get_isbn() for book in self.books.keys()]
if isbn in isbn_list:
print("ISBN {isbn} already exists. Please provide a unique ISBN.".format(isbn=isbn))
else:
return Book(title, isbn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_book():\n soup = Soup(CONTENT)\n dotd = soup.find(id='deal-of-the-day')\n image_base = dotd.find(class_='dotd-main-book-image')\n title_base = dotd.find(class_='dotd-title')\n\n title = title_base.find('h2').text.strip()\n description = title_base.parent.find_all('div')[2].text.strip()\n ... | [
"0.74620706",
"0.7454659",
"0.7390694",
"0.73847526",
"0.730507",
"0.7147083",
"0.6957809",
"0.67317843",
"0.67173606",
"0.66938126",
"0.66826653",
"0.66736996",
"0.6550934",
"0.6543831",
"0.6543831",
"0.6543831",
"0.64776856",
"0.6468723",
"0.6286811",
"0.6248327",
"0.618378... | 0.62817115 | 19 |
Returns Fiction Book instance | def create_novel(self, title, author, isbn):
isbn_list = [book.get_isbn() for book in self.books.keys()]
if isbn in isbn_list:
print("ISBN {isbn} already exists. Please provide a unique ISBN.".format(isbn=isbn))
else:
return Fiction(title, author, isbn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_book():\n soup = Soup(CONTENT)\n dotd = soup.find(id='deal-of-the-day')\n image_base = dotd.find(class_='dotd-main-book-image')\n title_base = dotd.find(class_='dotd-title')\n\n title = title_base.find('h2').text.strip()\n description = title_base.parent.find_all('div')[2].text.strip()\n ... | [
"0.6196444",
"0.6091821",
"0.60510933",
"0.60232943",
"0.59225523",
"0.58122814",
"0.58122814",
"0.5743209",
"0.5696704",
"0.56678516",
"0.56678516",
"0.56678516",
"0.56304383",
"0.552855",
"0.5503822",
"0.54369086",
"0.5419088",
"0.53848004",
"0.5366238",
"0.53569156",
"0.53... | 0.54304785 | 16 |
Adds book and rating if exists | def add_book_to_user(self, book, email, rating=None):
if self.users.get(email):
self.users[email].read_book(book, rating)
self.books[book] = self.books.get(book, 0) + 1
if rating:
book.add_rating(rating)
else:
print("{email} address not fou... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_book(self, data):\n exists = self.check_if_exists(data['isbn'])\n\n if exists:\n query = f\"\"\"UPDATE {TABLE} SET quantity = quantity + 10 WHERE bookID = '{data[\"isbn\"]}'\"\"\"\n else:\n query = f\"\"\"INSERT INTO {TABLE}(bookID, title, authors, avg_rating, rat... | [
"0.6787978",
"0.6579681",
"0.6568055",
"0.6551944",
"0.6508678",
"0.6425218",
"0.6392102",
"0.6381456",
"0.61407083",
"0.61249",
"0.6027362",
"0.59443843",
"0.59425426",
"0.59305996",
"0.58900917",
"0.584182",
"0.5823926",
"0.5782583",
"0.57586634",
"0.57273984",
"0.57060885"... | 0.67295533 | 1 |
Prints books in dictionary | def print_catalog(self):
for book in self.books.keys():
print(book) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def display_book(self):\r\n print(\"Available Books are:\")\r\n for item in self.books:\r\n print(f\"{self.books.index(item)+1}. {item}\")",
"def display_book(self):\n print(\"List of books available is: \")\n for book in books_list :\n print(\"- \",book)",
"de... | [
"0.7210097",
"0.70254695",
"0.6883923",
"0.6709422",
"0.6676588",
"0.66465443",
"0.65207547",
"0.65199316",
"0.64732736",
"0.63754284",
"0.62558043",
"0.6226128",
"0.6200351",
"0.61736345",
"0.6163209",
"0.61529285",
"0.61524075",
"0.608258",
"0.60664874",
"0.59934986",
"0.59... | 0.79404205 | 1 |
Prints users in dictionary | def print_users(self):
for user in self.users.values():
print(user) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_users(self):\n for i, item in enumerate(self.users):\n print(\"{}. {}\".format(i, item.name))",
"def users_view():\n data = get_data()\n return [{'user_id': i, 'name': 'User {0}'.format(str(i))}\n for i in data.keys()]",
"def display_users():\n users = storage.al... | [
"0.765939",
"0.72263163",
"0.70733106",
"0.6875003",
"0.6696791",
"0.66603804",
"0.6646293",
"0.6608518",
"0.6589131",
"0.65826404",
"0.65524274",
"0.6548652",
"0.6523387",
"0.6450315",
"0.6441693",
"0.6434259",
"0.64076483",
"0.63903874",
"0.6368943",
"0.63630533",
"0.635990... | 0.8323811 | 0 |
Returns most read book | def most_read_book(self):
reading_max = 0
most_reads = ""
for book in self.books.keys():
rating = book.get_average_rating()
if rating > reading_max:
most_reads = book
reading_max = rating
else:
continue
r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def highest_rated_book(self):\n rating_max = 0\n best_rated_book = \"\"\n for book in self.books.keys():\n rating = book.get_average_rating()\n if rating > rating_max:\n rating_max = rating\n best_rated_book = book\n else:\n ... | [
"0.7724168",
"0.7483818",
"0.71411234",
"0.6562405",
"0.63577133",
"0.62896013",
"0.62841135",
"0.6251964",
"0.62414163",
"0.6132677",
"0.6107795",
"0.6106943",
"0.6083038",
"0.607377",
"0.60098064",
"0.6000276",
"0.5960912",
"0.59562415",
"0.59394085",
"0.5935878",
"0.592481... | 0.8725137 | 0 |
Returns highest rated book | def highest_rated_book(self):
rating_max = 0
best_rated_book = ""
for book in self.books.keys():
rating = book.get_average_rating()
if rating > rating_max:
rating_max = rating
best_rated_book = book
else:
continu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def highest_rated_book(self):\n highest_rated = 0.0\n top_rated_book = \"\"\n\n for book in self.books.keys():\n book_rating = book.get_average_rating()\n if book_rating > highest_rated:\n highest_rated = book_rating\n top_rated_book = book.t... | [
"0.83557385",
"0.7634373",
"0.64668053",
"0.646497",
"0.64457583",
"0.6311305",
"0.62297416",
"0.6174505",
"0.6174505",
"0.60736984",
"0.6066756",
"0.6059369",
"0.6034711",
"0.6018782",
"0.6013541",
"0.59976643",
"0.5940475",
"0.59375906",
"0.5909446",
"0.5899124",
"0.5861581... | 0.8604043 | 0 |
Returns user with highest average rating | def most_positive_user(self):
rating_max = 0
rating_max_user = ""
for user in self.users.values():
rating = user.get_average_rating()
if rating > rating_max:
rating_max = rating
rating_max_user = user
else:
conti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_average_rating(self):\n count = 0\n total = 0\n num_books = len(self.books)\n if num_books > 0:\n for rating in self.books.values():\n if rating:\n count += 1\n total += rating\n average = total / count\n... | [
"0.70983166",
"0.6912731",
"0.68344504",
"0.6794513",
"0.67550117",
"0.6752274",
"0.6622795",
"0.6618791",
"0.657425",
"0.655887",
"0.6550182",
"0.65312135",
"0.6514526",
"0.65007603",
"0.64462924",
"0.64313",
"0.6414315",
"0.6395596",
"0.638889",
"0.6372267",
"0.63228005",
... | 0.7960793 | 0 |
Returns the number of most read books | def get_n_most_read_books(self, n):
if type(n) != int:
print("The argument n = {n} is not an integer. Try again with an integer".format(n=n))
else:
sorted_books = [ book for book in sorted(self.books, key=self.books.get, reverse=True)]
return sorted_books | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def most_read_book(self):\n reading_max = 0\n most_reads = \"\"\n for book in self.books.keys():\n rating = book.get_average_rating()\n if rating > reading_max:\n most_reads = book\n reading_max = rating\n else:\n co... | [
"0.8219369",
"0.71462387",
"0.66454923",
"0.6578928",
"0.65045106",
"0.64410865",
"0.6415552",
"0.63523734",
"0.63387",
"0.63387",
"0.62491214",
"0.6203123",
"0.61888176",
"0.6156324",
"0.6140114",
"0.6134548",
"0.6096439",
"0.60852206",
"0.60635096",
"0.6039976",
"0.6030021"... | 0.7380969 | 1 |
Sends a message to each recipient in recipient list. | def send_email(subject, message, recipient_list, from_email=None,
fail_silently=False, connection=None):
if not from_email:
from_email = _s('SERVER_EMAIL') or _s('DEFAULT_FROM_EMAIL')
try:
subj = unicode(subject)
except UnicodeDecodeError:
subj = subject.decode('utf8')... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_mass_messages(self, recipient_list, sender, message=\"\", subject=\"\"):\n try:\n for s in recipient_list:\n self.send_message(to=s, sender=sender, message=message, subject=subject)\n except TypeError:\n return -1\n return 1",
"def send_to_all(se... | [
"0.7732485",
"0.6727123",
"0.6595336",
"0.65631413",
"0.65069544",
"0.6475225",
"0.631243",
"0.63047963",
"0.62675667",
"0.62623197",
"0.62423515",
"0.6212081",
"0.6170951",
"0.61361974",
"0.6125608",
"0.6124741",
"0.61145",
"0.6103919",
"0.6092619",
"0.60910547",
"0.6080257"... | 0.59426886 | 34 |
Send debug email to admins. | def send_debug_email(subject, message):
if not subject:
site = get_current_site()
subj = _s('DEBUG_MSG_SUBJECT') or _msg('subject_debug_msg')
subject = '%s: %s' % (site.name, subj)
mail_admins(subject, message, fail_silently=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def email_admins(subject, message):\n mail_admins(subject, message=message)",
"def mail_admins(subject, message, fail_silently=False):\n _mail_group(settings.ADMINS, subject, message, fail_silently)",
"def sendadminlog( override=0 ):\n\n global admin_notify_time\n global adminlog\n\n if override... | [
"0.700624",
"0.69679296",
"0.66619134",
"0.66101164",
"0.6536322",
"0.6381845",
"0.6261297",
"0.62524307",
"0.6221707",
"0.6198986",
"0.6173385",
"0.6040536",
"0.6029444",
"0.5963833",
"0.58713526",
"0.58485705",
"0.5809431",
"0.5787586",
"0.5785166",
"0.5740776",
"0.5717475"... | 0.71638185 | 0 |
Send emails to a group. | def send_email_to_group(group, subject, message, fail_silently=False):
if isinstance(group, basestring):
members = get_users_in_group(group)
recipients = [user.email for user in members if user.email]
elif isinstance(group, (list, tuple)):
recipients = group
try:
assert recip... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _mail_group(group, subject, message, fail_silently=False):\n if group:\n mail.send_mail(settings.EMAIL_SUBJECT_PREFIX + subject, message,\n settings.SERVER_EMAIL, [a[1] for a in group],\n fail_silently)\n return\n # If the group had no recipients defined,... | [
"0.80707854",
"0.6781871",
"0.65694135",
"0.63916755",
"0.63060516",
"0.6281303",
"0.62803423",
"0.62803423",
"0.62693524",
"0.6259856",
"0.6252528",
"0.62140393",
"0.6206107",
"0.618567",
"0.6172113",
"0.61584634",
"0.6157868",
"0.6145838",
"0.61180377",
"0.6111764",
"0.6086... | 0.72258323 | 1 |
Send email with text and html versions. | def send_html_email(subject,
recipient_list,
template,
context,
from_email=None,
text_content=None):
if not from_email:
from_email = _s('SERVER_EMAIL') or _s('DEFAULT_FROM_EMAIL')
try:
subj = unic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send_email(subject, sender, recipients, text_body, html_body):\n msg = Message(subject=subject, sender=sender, recipients=recipients)\n msg.body = text_body\n msg.html = html_body\n mail.send(msg)",
"def send_email(subject, sender, recipients, text_body, html_body):\n\t\tmsg = Message(subject, se... | [
"0.8020456",
"0.8002626",
"0.75018513",
"0.7394364",
"0.73103356",
"0.72513235",
"0.72427714",
"0.7189764",
"0.70869297",
"0.7059591",
"0.6988997",
"0.6967605",
"0.6927166",
"0.68253386",
"0.67581195",
"0.6730767",
"0.6715298",
"0.6687154",
"0.6687154",
"0.66812897",
"0.66779... | 0.70089954 | 10 |
Private helper to convert results in dict format to CSV file. | def __save_aggregate_scores(self):
results = pd.DataFrame(
columns=self.results[list(self.results.keys())[0]],
index=self.results.keys(),
)
for row_name, time_bins in self.results.items():
for column_name, value in time_bins.items():
results.lo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_results(results):\n fields = results[0].keys()\n with open('results.csv', 'w') as f:\n dw = csv.DictWriter(f, fieldnames=fields, delimiter='|')\n dw.writer.writerow(list(dw.fieldnames))\n dw.writerows(results)",
"def dict_to_csv(filename, dictionary, paramdict=True):\n if ... | [
"0.7583564",
"0.6895519",
"0.68203294",
"0.68120426",
"0.67319053",
"0.66475886",
"0.6629474",
"0.66274077",
"0.6614341",
"0.6597433",
"0.6587587",
"0.6584862",
"0.65786135",
"0.6501687",
"0.6476363",
"0.6458015",
"0.6393849",
"0.63806397",
"0.6377519",
"0.6320072",
"0.631364... | 0.0 | -1 |
Private helper to aggregate SHAP values into bins of related features. | def __calculate_agg_shap_scores(self):
self.agg_stats_timer = SimbaTimer(start=True)
for clf_state, clf_state_name in zip(range(2), ["ABSENT", "PRESENT"]):
self.results = {}
self.df_save_path = os.path.join(
self.shap_logs_path,
"SHAP_summary_{}_{}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform_bins(self, X):\n binner = self.binner_\n if hasattr(binner, \"tree_\"):\n dec_path = self.binner_.decision_path(X)\n association = numpy.zeros((X.shape[0],))\n association[:] = -1\n for j in self.leaves_:\n ind = dec_path[:, j] ... | [
"0.536685",
"0.53028756",
"0.5297548",
"0.52773046",
"0.527647",
"0.52717435",
"0.52448034",
"0.5239028",
"0.52265066",
"0.51943",
"0.5178747",
"0.51728415",
"0.516949",
"0.5167684",
"0.51604414",
"0.5151585",
"0.5139538",
"0.51359856",
"0.5125312",
"0.5120589",
"0.51111573",... | 0.62239313 | 0 |
Private helper to create the base (axes, icons ticks etc) of the aggregate shap value visualization. | def __create_base_shap_img(self):
self.img = 255 * np.ones([1680, 1680, 3], dtype=np.uint8)
self.baseline_scale_img = cv2.imread(self.scale_img_dict["baseline_scale"])
self.baseline_scale_top_left = (100, 800)
baseline_scale_bottom_right = (
self.baseline_scale_top_left[0] +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _handle_axes(self, drawable, option):\n # If we already have an axes object, ignore this one\n if self._axes_object is not None:\n return\n\n # Grab the histogram used for axes style/range manipulation\n if is_stack(drawable) or is_graph(drawable):\n axes_histo... | [
"0.60737693",
"0.5814595",
"0.56521565",
"0.562601",
"0.557705",
"0.5575706",
"0.5516756",
"0.54805434",
"0.5476639",
"0.543038",
"0.54277986",
"0.5423361",
"0.5419598",
"0.53922915",
"0.5385813",
"0.5385489",
"0.5379207",
"0.5366411",
"0.53519034",
"0.5343925",
"0.5336223",
... | 0.57938874 | 2 |
Private helper to insert the data (i.e., colored arrows, text etc.) into the aggregate shap value visualization and save the results. | def __insert_data_in_img(self):
data_df = pd.read_csv(
os.path.join(
self.shap_logs_path,
"SHAP_summary_{}_{}_{}.csv".format(
self.classifier_name, "PRESENT", self.datetime
),
),
index_col=0,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def processData(self):\n recordSet = AresChartsService.toMultiSeries(self.vals, self.chartKeys, self.selectedX , self.chartVals, extKeys=self.extKeys)\n self.aresObj.jsGlobal.add(\"data_%s = %s\" % (self.htmlId, json.dumps(recordSet)))",
"def visualise(self):\n\n scores, education = self.get_data()\... | [
"0.56197286",
"0.55523324",
"0.55266005",
"0.5514512",
"0.548664",
"0.54803073",
"0.54062796",
"0.5351485",
"0.5340591",
"0.5303771",
"0.5253525",
"0.52418655",
"0.52133983",
"0.5205377",
"0.5180938",
"0.51616275",
"0.51548773",
"0.5126836",
"0.5116849",
"0.5104162",
"0.50907... | 0.6141829 | 0 |
Randomized n questions from the test set and evaluates each of them | def evaluate(encoder, decoder, input_tokenizer, output_tokenizer, test_pairs, max_len, n=None, verbose=False):
y_true = []
y_pred = []
if n is not None:
data = [random.choice(test_pairs) for i in range(n)]
else:
data = test_pairs
for question, equation in data:
y_true.appen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_questions(self, number_of_questions):",
"def evaluate_questions(self):\n for question in self.question_list:\n question.evaluate_question()",
"def q_v_random(n=1000):\n for i in range(5):\n p1_strategy = strategies.QStrategy('X')\n p2_strategy = strategies.RandomStrat... | [
"0.722723",
"0.6895135",
"0.67801404",
"0.6731325",
"0.6563463",
"0.64386594",
"0.63654375",
"0.6347008",
"0.6347008",
"0.6347008",
"0.6347008",
"0.6344698",
"0.6344698",
"0.6344698",
"0.63365906",
"0.6287557",
"0.62312144",
"0.6226248",
"0.62173843",
"0.62171423",
"0.6210546... | 0.5719189 | 53 |
Given a sample question, evaluates it and plot the attention of each parts | def evaluate_and_show_attention(approach, encoder, decoder, input_tokenizer, output_tokenizer, max_len, input_sentence):
output_words, attentions = evaluate_sample(encoder, decoder, input_tokenizer, output_tokenizer, input_sentence, max_len)
print('input =', input_sentence)
print('output =', ' '.join(output... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_attention( img, result, attention_plot,fn='plot_att.png'):\n # denormalize\n img[0] = img[0] * 0.229\n img[1] = img[1] * 0.224\n img[2] = img[2] * 0.225\n img[0] += 0.485\n img[1] += 0.456\n img[2] += 0.456\n\n image = img.cpu().numpy().transpose((1,... | [
"0.6325219",
"0.59655464",
"0.57061",
"0.5688024",
"0.5606901",
"0.5603356",
"0.5569556",
"0.5539447",
"0.5482672",
"0.5480325",
"0.5478518",
"0.54607755",
"0.54607034",
"0.54592013",
"0.54525006",
"0.54242206",
"0.5423777",
"0.5415969",
"0.54118747",
"0.5401263",
"0.53908634... | 0.56990063 | 3 |
Extract features from a sentence represented as a list of words. Includes a flag add_to_indexer to | def extract_features(self, ex_words: List[str], add_to_indexer: bool) -> List[int]:
raise Exception("Don't call me, call my subclasses") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_features(self, ex_words: List[str], add_to_indexer: bool=False) -> List[int]:\n raise Exception(\"Don't call me, call my subclasses\")",
"def _sentence_to_features(self,sentence):\n\n configured_features = self.configFeatures\n sentence_features = []\n\n for word_idx in ra... | [
"0.73790205",
"0.70586795",
"0.6696932",
"0.66269016",
"0.66092473",
"0.6585194",
"0.65552074",
"0.65417784",
"0.65111244",
"0.64883614",
"0.64856535",
"0.647473",
"0.64737093",
"0.6448127",
"0.64132744",
"0.63529783",
"0.631795",
"0.63178784",
"0.62807816",
"0.62771124",
"0.... | 0.739767 | 0 |
Train a classifier with the perceptron. | def train_perceptron(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> PerceptronClassifier:
raise Exception("Must be implemented") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n sys.stderr.write(\"Training Multi-layer Perceptron classifier...\")\n self.clf.fit(self.m_features,self.target)\n sys.stderr.write(\"\\n\")\n \n # save the trained model to file\n with open(os.path.join(self.conf[\"paths\"][\"dir\"],self.conf[\"paths\"][... | [
"0.7362925",
"0.72427166",
"0.7166918",
"0.6913629",
"0.6894902",
"0.6865036",
"0.6854908",
"0.6839923",
"0.6704421",
"0.6680698",
"0.66646695",
"0.66574335",
"0.6651779",
"0.66505635",
"0.6620633",
"0.659549",
"0.65892136",
"0.6542741",
"0.6473617",
"0.64566743",
"0.64548427... | 0.80276585 | 0 |
Train a logistic regression model. | def train_logistic_regression(train_exs: List[SentimentExample],
feat_extractor: FeatureExtractor) -> LogisticRegressionClassifier:
indexer = feat_extractor.get_indexer()
weights = np.transpose(np.zeros(indexer.__len__(), dtype=int))
learning_rate = 0.1
for i in range(15):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_logistic_regression(train_x, train_y):\n\n logistic_regression_model = LogisticRegression(penalty='l2', C=1.0)\n logistic_regression_model.fit(train_x, train_y)\n return logistic_regression_model",
"def train_model(self):\r\n alpha, accuracy_rate = self.select_model()\r\n # Initi... | [
"0.8386761",
"0.81879395",
"0.7966216",
"0.76690257",
"0.7537518",
"0.74895674",
"0.73374444",
"0.7324982",
"0.7299413",
"0.7291719",
"0.7240203",
"0.7221663",
"0.7200861",
"0.71392286",
"0.7133594",
"0.710384",
"0.7097528",
"0.70433974",
"0.6994356",
"0.69783026",
"0.6971683... | 0.67574 | 29 |
Main entry point for your modifications. Trains and returns one of several models depending on the args passed in from the main method. You may modify this function, but probably will not need to. | def train_model(args, train_exs: List[SentimentExample]) -> SentimentClassifier:
indexer = Indexer()
stop_words = set(stopwords.words('english'))
punkt = (',', '.', '...', '?', '\'', '\'\'', '!', ':', ';')
# Initialize feature extractor
if args.model == "TRIVIAL":
feat_extractor = None
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(argv):\n cfg = defaults(argv)\n repo = create_repository(cfg)\n model = Model()\n developer_gen = next_member(cfg)\n for git_date in commit_datetime_string_gen(cfg):\n repo, model = add_commit(repo, cfg, model, developer_gen, git_date)\n if model.ticket is not None and model.c... | [
"0.6445336",
"0.62378997",
"0.6103279",
"0.6101256",
"0.5988604",
"0.598683",
"0.59613985",
"0.5912522",
"0.5882124",
"0.58568376",
"0.5845838",
"0.5844697",
"0.58185214",
"0.5818334",
"0.5796767",
"0.5793016",
"0.57815635",
"0.5752345",
"0.5737359",
"0.5714961",
"0.57074076"... | 0.0 | -1 |
Create a board with goal at position 100 and checks that goal is | def test_goal_reached(self):
board = ss.Board(goal=100)
assert board.goal_reached(5) is False
assert board.goal_reached(90) is False
assert board.goal_reached(100) is True
board = ss.Board()
assert board.goal_reached(90) is True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __generate_goal_board(self):\n element = 1\n array = []\n\n for row in range(self._n):\n row_to_append = []\n for col in range(self._n):\n row_to_append.append(element)\n element += 1\n array.append(row_to_append)\n\n ar... | [
"0.7304421",
"0.69853777",
"0.67523277",
"0.6653536",
"0.6625291",
"0.65876365",
"0.65181404",
"0.6511576",
"0.65101814",
"0.6355516",
"0.6329743",
"0.6316789",
"0.62672085",
"0.6259777",
"0.62528485",
"0.6251963",
"0.6240587",
"0.6193472",
"0.6187519",
"0.6186028",
"0.617878... | 0.6914275 | 2 |
Checks that position_adjustment returns the correct number of steps to be subtracted or added when the position is on the top of a snake or the bottom of a ladder. Checks that position_adjustment returns 0 when the position is elsewhere. | def test_position_adjustment(self):
board = ss.Board()
assert board.position_adjustment(8) == 10-8
assert board.position_adjustment(56) == 37-56
assert board.position_adjustment(63) == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position_adjustment(self, position):\n changed_position = 0\n if position in self.ladders:\n return self.ladders[position] - position\n elif position in self.snakes:\n return self.snakes[position] - position\n return changed_position",
"def move(self): # A... | [
"0.7006407",
"0.57940966",
"0.5752311",
"0.5737879",
"0.5507167",
"0.5448012",
"0.5397324",
"0.53276736",
"0.53084916",
"0.5283515",
"0.51824796",
"0.5147287",
"0.5136505",
"0.50920564",
"0.5078422",
"0.50565064",
"0.50441754",
"0.50383854",
"0.50056046",
"0.49715185",
"0.494... | 0.6700563 | 1 |
Test that ResilientPlayer takes one extra step after sliding down a snake | def test_move_default_extra_steps(self):
player = ss.ResilientPlayer()
random.seed(2)
player.move()
random.seed(1)
player.move()
random.seed(2)
player.move()
assert player.position == 32 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_move_dropped_steps_greater_than_move(self):\n player = ss.LazyPlayer(dropped_steps=3)\n random.seed(2)\n player.move()\n random.seed(2)\n player.move()\n assert player.position == 40",
"def test_move_default_dropped_steps(self):\n player = ss.LazyPlayer()... | [
"0.70096105",
"0.68935305",
"0.6807493",
"0.6662498",
"0.6447271",
"0.64209694",
"0.6270427",
"0.62414765",
"0.62204564",
"0.615403",
"0.6151527",
"0.6132511",
"0.6118273",
"0.6114965",
"0.609501",
"0.6090467",
"0.6063974",
"0.6044024",
"0.59939027",
"0.59865755",
"0.5981301"... | 0.69973004 | 1 |
Test that LazyPlayer takes one step less after going up a ladders. | def test_move_default_dropped_steps(self):
player = ss.LazyPlayer()
random.seed(2)
player.move()
random.seed(5)
player.move()
assert player.position == 44 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_move_dropped_steps_greater_than_move(self):\n player = ss.LazyPlayer(dropped_steps=3)\n random.seed(2)\n player.move()\n random.seed(2)\n player.move()\n assert player.position == 40",
"def test_move_default_extra_steps(self):\n player = ss.ResilientPlaye... | [
"0.75017583",
"0.6730324",
"0.66294205",
"0.63773066",
"0.6272609",
"0.6240576",
"0.61570513",
"0.60627896",
"0.60356265",
"0.5989407",
"0.59687805",
"0.5958815",
"0.5957419",
"0.5949568",
"0.5922356",
"0.59057784",
"0.5904189",
"0.58874583",
"0.58812684",
"0.58393806",
"0.58... | 0.7022837 | 1 |
Tests that LazyPlayer dont move backwards when dropped steps are greater than the next move | def test_move_dropped_steps_greater_than_move(self):
player = ss.LazyPlayer(dropped_steps=3)
random.seed(2)
player.move()
random.seed(2)
player.move()
assert player.position == 40 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_move_default_dropped_steps(self):\n player = ss.LazyPlayer()\n random.seed(2)\n player.move()\n random.seed(5)\n player.move()\n assert player.position == 44",
"def test_move_default_extra_steps(self):\n player = ss.ResilientPlayer()\n random.seed(... | [
"0.7334365",
"0.6641269",
"0.6475652",
"0.61387503",
"0.6134772",
"0.61291",
"0.61152625",
"0.61019933",
"0.60483176",
"0.6041911",
"0.60396975",
"0.6018119",
"0.59843713",
"0.59796757",
"0.59768015",
"0.59652007",
"0.5950277",
"0.5939433",
"0.59343606",
"0.58857846",
"0.5875... | 0.8197672 | 0 |
Tests that single_game returns a tuple. | def test_single_game_returns_tuple(self):
sim = ss.Simulation()
assert type(sim.single_game()) == tuple, 'single_game should return ' \
'tuple' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_single_tuple(self):\n conn = self.connect()\n c = conn.cursor()\n self.safe_create_table(\n conn, \"mystuff\", \"create table mystuff (id integer primary key)\"\n )\n c.execute(\"insert into mystuff (id) values (1)\")\n c.execute(\"insert into mystuff (... | [
"0.6713088",
"0.6669579",
"0.66490626",
"0.6488279",
"0.638762",
"0.6362186",
"0.63546574",
"0.62094206",
"0.6190039",
"0.6178856",
"0.6135326",
"0.6129589",
"0.60323733",
"0.59669423",
"0.5964204",
"0.5952256",
"0.593679",
"0.590705",
"0.58496106",
"0.58379227",
"0.5782221",... | 0.89493525 | 0 |
Tests that two games of single_game is different from each other, when the seed is different. | def test_single_game_works(self):
sim = ss.Simulation(seed=154)
game1 = sim.single_game()
sim = ss.Simulation(seed=79)
game2 = sim.single_game()
assert game1 != game2, 'Your method single_game is not working.' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_single_game_seed_works(self):\n sim = ss.Simulation(seed=23)\n game1 = sim.single_game()\n sim = ss.Simulation(seed=23)\n game2 = sim.single_game()\n assert game1 == game2, 'Your seed in Simulation class is not working.'",
"def test_equal(self):\r\n\r\n a_players = ... | [
"0.81157404",
"0.7059727",
"0.69203585",
"0.66897315",
"0.6630781",
"0.66151136",
"0.6483109",
"0.64159",
"0.64131045",
"0.6410941",
"0.6346281",
"0.6270911",
"0.62650096",
"0.6246768",
"0.6201503",
"0.6187887",
"0.617865",
"0.6160666",
"0.6155558",
"0.615349",
"0.61270845",
... | 0.8136826 | 0 |
Tests that two games of single_game is equal, when the seed is the same. | def test_single_game_seed_works(self):
sim = ss.Simulation(seed=23)
game1 = sim.single_game()
sim = ss.Simulation(seed=23)
game2 = sim.single_game()
assert game1 == game2, 'Your seed in Simulation class is not working.' | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_single_game_works(self):\n sim = ss.Simulation(seed=154)\n game1 = sim.single_game()\n sim = ss.Simulation(seed=79)\n game2 = sim.single_game()\n assert game1 != game2, 'Your method single_game is not working.'",
"def test_equal(self):\r\n\r\n a_players = [ZeroPlaye... | [
"0.81622756",
"0.7525932",
"0.67783153",
"0.6768772",
"0.6753167",
"0.65783197",
"0.6494036",
"0.63991237",
"0.6323125",
"0.63176376",
"0.6263558",
"0.6230478",
"0.6161638",
"0.6111521",
"0.60287315",
"0.6027688",
"0.60109663",
"0.60015196",
"0.5999746",
"0.5993655",
"0.59832... | 0.84178203 | 0 |
Tests that run_simulation returns nothing | def test_run_simulation_returns_nothing(self):
sim = ss.Simulation()
assert sim.run_simulation(10) is None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_empty_simulation(self):\n config = {\n 'network_params': {\n 'path': join(ROOT, 'test.gexf')\n },\n 'agent_type': 'BaseAgent',\n 'environment_params': {\n }\n }\n s = simulation.from_config(config)\n s.run_si... | [
"0.77626854",
"0.77274764",
"0.74112415",
"0.7303463",
"0.7178668",
"0.71074367",
"0.7069148",
"0.70681214",
"0.69160265",
"0.6719179",
"0.667552",
"0.6662267",
"0.6497731",
"0.6358623",
"0.6342628",
"0.63359886",
"0.63049287",
"0.6286854",
"0.62855214",
"0.62635136",
"0.6245... | 0.89247197 | 0 |
Tests that run_simulation stores the results | def test_run_simulation_stores_result(self):
sim = ss.Simulation()
assert sim.results == []
sim.run_simulation(10)
assert sim.results != []
assert len(sim.results) == 10 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_results_returns_all_results(self):\n sim = ss.Simulation()\n sim.run_simulation(7)\n assert len(sim.get_results()) == 7",
"def test_simulation(self):\n\t\tprint \"Simulation is being tested\"\n\n\t\tif toggles.DEBUG_FLAG:\n\t\t\tprint \"Debug Flag Set!\"\n\t\t\tprint self.getCon... | [
"0.72314996",
"0.7085128",
"0.6999844",
"0.6956875",
"0.69383395",
"0.69112194",
"0.6830327",
"0.667656",
"0.6667437",
"0.6664308",
"0.66560996",
"0.66404295",
"0.66325206",
"0.6628107",
"0.6608726",
"0.6588195",
"0.65533656",
"0.6500293",
"0.6482116",
"0.6476763",
"0.6472531... | 0.86449283 | 0 |
Tests that get_results returns a list consisting of tuples. | def test_get_results_returns_list_of_tuples(self):
sim = ss.Simulation()
sim.run_simulation(5)
assert type(sim.get_results()) == list
assert type(sim.get_results()[0]) == tuple | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_results(self):\n result = self.test_client._results\n\n assert isinstance(result, list)\n assert len(result) == 1",
"def test_get_results(self):\n pass",
"def getResults():",
"def assertManyResults(self, function, args, results):\r\n for arg, result in zip(args, re... | [
"0.738146",
"0.7208044",
"0.69072825",
"0.6727127",
"0.65326715",
"0.650097",
"0.64806813",
"0.6463932",
"0.6344955",
"0.6324502",
"0.63131404",
"0.6305193",
"0.6211632",
"0.6172891",
"0.613735",
"0.6124938",
"0.61014163",
"0.6091535",
"0.6090757",
"0.6073068",
"0.60141456",
... | 0.8084668 | 0 |
Tests that get_results contains the same number of winners as games played. | def test_get_results_returns_all_results(self):
sim = ss.Simulation()
sim.run_simulation(7)
assert len(sim.get_results()) == 7 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def number_results(self):\n pass",
"def test_update_results(self, count_key, hand_key, net_winnings, overall_bet, increment, expected):\n s = SimulationStats()\n s.create_count_key(count_key=0)\n s.update_results(\n count_key=count_key,\n hand_key=hand_key,\n ... | [
"0.6485536",
"0.64334744",
"0.63969475",
"0.63891816",
"0.63779795",
"0.6332883",
"0.63238555",
"0.62757146",
"0.625677",
"0.6246163",
"0.6239472",
"0.62343186",
"0.62041014",
"0.61753535",
"0.6164736",
"0.61493677",
"0.61451954",
"0.6142789",
"0.6133456",
"0.6119115",
"0.610... | 0.6243277 | 10 |
Tests that winners_per_type returns a dictionary | def test_winners_per_type_returns_dict(self):
sim = ss.Simulation()
assert type(sim.winners_per_type()) == dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type(self):\n sim = ss.Simulation()\n assert type(sim.players_per_type()) == dict",
"def test_winners_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = si... | [
"0.7460475",
"0.73244834",
"0.7059976",
"0.7026087",
"0.68466777",
"0.6143772",
"0.5960847",
"0.5940492",
"0.5801115",
"0.57970756",
"0.57904345",
"0.57599425",
"0.5712648",
"0.56462806",
"0.5638244",
"0.56253624",
"0.56001174",
"0.5587972",
"0.5526351",
"0.54692185",
"0.5445... | 0.85515326 | 0 |
Tests that all types of players are present | def test_winners_per_type_num_players(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]
sim = ss.Simulation(player_field=type_of_player)
run = sim.winners_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer']",
"def test_players... | [
"0.7568893",
"0.74713135",
"0.7188392",
"0.7174332",
"0.6631124",
"0.6494987",
"0.6482031",
"0.63635993",
"0.6339381",
"0.631974",
"0.6221002",
"0.62074506",
"0.6085961",
"0.60554427",
"0.6048676",
"0.60445374",
"0.6012698",
"0.5990195",
"0.5984317",
"0.5971757",
"0.5967089",... | 0.72397536 | 2 |
Tests that all types of players that are playing are present, but not those who aren't. | def test_winners_per_type_num_players_less(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]
sim = ss.Simulation(player_field=type_of_player)
run = sim.winners_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players_less(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer']",
"def test_players_per_type_num_players(s... | [
"0.6836289",
"0.66635007",
"0.6472525",
"0.64168954",
"0.6361755",
"0.6325538",
"0.6318714",
"0.6308488",
"0.62345076",
"0.6177351",
"0.61126137",
"0.6100637",
"0.60837114",
"0.6056955",
"0.6039496",
"0.5998204",
"0.5997768",
"0.5993413",
"0.59918576",
"0.5989119",
"0.5974849... | 0.6529068 | 2 |
Tests that total wins are equal to numbers of simulation. | def test_winners_per_type_sum(self):
sim = ss.Simulation()
sim.run_simulation(14)
winners = sim.winners_per_type()
assert sum(winners.values()) == 14 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_play_game_hard(self):\r\n wins = [0,0,0]\r\n\r\n for i in range(1,10):\r\n a_player_1_id = 1\r\n a_player_2_id = 2\r\n a_players = [RandomPlayer(a_player_1_id), RandomPlayer(a_player_2_id)]\r\n a_x_dist = i\r\n a_y_dist = i\r\n a_num_to_win = 3\r\n a_game = Game(a_... | [
"0.66540855",
"0.6641283",
"0.651022",
"0.6439688",
"0.6402664",
"0.639706",
"0.63893235",
"0.6287492",
"0.62694687",
"0.62559384",
"0.6249074",
"0.6247421",
"0.62210906",
"0.62149644",
"0.6180857",
"0.6174532",
"0.6166144",
"0.61484927",
"0.6138867",
"0.6131443",
"0.6127531"... | 0.6798297 | 0 |
Tests that durations_per_type returns a dictionary | def test_durations_per_type(self):
sim = ss.Simulation()
assert type(sim.durations_per_type()) == dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def durations_per_type(self):\n pass",
"def test_durations_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.durations_per_type()\n assert list(run.keys()) == ['Player', '... | [
"0.76126635",
"0.69130933",
"0.6763132",
"0.64169866",
"0.6288302",
"0.62874055",
"0.6248118",
"0.6223497",
"0.61402684",
"0.60638607",
"0.60624653",
"0.5815379",
"0.58149046",
"0.5737329",
"0.572361",
"0.57040614",
"0.56947976",
"0.56464267",
"0.56448644",
"0.56156546",
"0.5... | 0.87039316 | 0 |
Tests that all types of players are present | def test_durations_per_type_num_players(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]
sim = ss.Simulation(player_field=type_of_player)
run = sim.durations_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer']",
"def test_players... | [
"0.7568893",
"0.74713135",
"0.72397536",
"0.7188392",
"0.7174332",
"0.6631124",
"0.6482031",
"0.63635993",
"0.6339381",
"0.631974",
"0.6221002",
"0.62074506",
"0.6085961",
"0.60554427",
"0.6048676",
"0.60445374",
"0.6012698",
"0.5990195",
"0.5984317",
"0.5971757",
"0.5967089"... | 0.6494987 | 6 |
Tests that all types of players that are playing are present, but not those who aren't. | def test_durations_per_type_num_players_less(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]
sim = ss.Simulation(player_field=type_of_player)
run = sim.durations_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players_less(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer']",
"def test_players_per_type_num_players(s... | [
"0.6836289",
"0.66635007",
"0.6529068",
"0.6472525",
"0.64168954",
"0.6361755",
"0.6325538",
"0.6318714",
"0.6308488",
"0.62345076",
"0.61126137",
"0.6100637",
"0.60837114",
"0.6056955",
"0.6039496",
"0.5998204",
"0.5997768",
"0.5993413",
"0.59918576",
"0.5989119",
"0.5974849... | 0.6177351 | 10 |
Tests that players_per_type returns dictionary | def test_players_per_type(self):
sim = ss.Simulation()
assert type(sim.players_per_type()) == dict | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer']",
"def test_winners... | [
"0.75420964",
"0.74724466",
"0.7354364",
"0.7230678",
"0.7132466",
"0.7039844",
"0.6974464",
"0.6378547",
"0.6147127",
"0.61053926",
"0.60057855",
"0.59874344",
"0.5845814",
"0.5840158",
"0.58341056",
"0.58270174",
"0.5779566",
"0.56687707",
"0.56667966",
"0.56376815",
"0.563... | 0.86458623 | 0 |
Tests that all types of players are present | def test_players_per_type_num_players(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]
sim = ss.Simulation(player_field=type_of_player)
run = sim.players_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players_less(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer']",
"def test_winners_per_type_num_players(s... | [
"0.747361",
"0.72424835",
"0.71909654",
"0.7176628",
"0.66306865",
"0.6498127",
"0.6485009",
"0.6362596",
"0.63391715",
"0.6321425",
"0.62221444",
"0.62081015",
"0.6085177",
"0.6054983",
"0.604946",
"0.60428005",
"0.60109454",
"0.5990627",
"0.598319",
"0.59704417",
"0.5966648... | 0.7571244 | 0 |
Tests that all types of players are present, but not those who aren't | def test_players_per_type_num_players_less(self):
type_of_player = [ss.Player, ss.LazyPlayer, ss.Player]
sim = ss.Simulation(player_field=type_of_player)
run = sim.players_per_type()
assert list(run.keys()) == ['Player', 'LazyPlayer'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_players_per_type_num_players(self):\n type_of_player = [ss.Player, ss.LazyPlayer, ss.ResilientPlayer]\n sim = ss.Simulation(player_field=type_of_player)\n run = sim.players_per_type()\n assert list(run.keys()) == ['Player', 'LazyPlayer', 'ResilientPlayer']",
"def test_winners... | [
"0.69676596",
"0.6959566",
"0.66561633",
"0.6559737",
"0.6464441",
"0.6401887",
"0.63817614",
"0.61773103",
"0.6123407",
"0.61129445",
"0.6079212",
"0.6024275",
"0.60000664",
"0.5969238",
"0.59636134",
"0.5949633",
"0.5917091",
"0.5904456",
"0.58702326",
"0.5864484",
"0.58623... | 0.72699636 | 0 |
have to reimplement as there is an import loop when using __init__ | def get_dataset(name):
if name == 'cityscapes':
return Cityscapes | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__():",
"def _init(self):\n pass",
"def __init__(object):",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__self__):\n pass",
"def __init__(__s... | [
"0.8456002",
"0.79643214",
"0.7935814",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.79343504",
"0.77920854",
"0.77789736",
"0.77660185",
"0.77537453",
"0.77537453",
"0.77537453",
"0.77537453",
... | 0.0 | -1 |
Monkey patches Project.Basecamp for testing. | def _mock_basecamp_access(self, klass=TestBasecampProject):
self._real_Basecamp = Project.BasecampProject
Project.BasecampProject = klass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _unmock_basecamp_access(self):\n Project.BasecampProject = self._real_Basecamp",
"def test_patch_project(self):\n pass",
"def test_4_4_1_1(self):\n pass",
"def test_replace_project(self):\n pass",
"def _setup(self):",
"def _setup(self):",
"def __upgrade(self):",
"def t... | [
"0.69486105",
"0.66815156",
"0.5994686",
"0.58670104",
"0.58383346",
"0.58383346",
"0.5837995",
"0.5779714",
"0.5716145",
"0.5716145",
"0.5716145",
"0.56978476",
"0.5674083",
"0.56722325",
"0.56632423",
"0.56433165",
"0.5641671",
"0.5641671",
"0.5641671",
"0.5641671",
"0.5632... | 0.66815084 | 2 |
Undoes the Project.Basecamp monkeypatching. | def _unmock_basecamp_access(self):
Project.BasecampProject = self._real_Basecamp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tearDown(self):\n builtins.__import__ = self.original_imports",
"def monkeymodule():\n from _pytest.monkeypatch import MonkeyPatch\n\n mpatch = MonkeyPatch()\n yield mpatch\n mpatch.undo()",
"def _mock_basecamp_access(self, klass=TestBasecampProject):\n self._real_Basecamp = Proje... | [
"0.59395653",
"0.58390504",
"0.58148414",
"0.5738623",
"0.566452",
"0.5581741",
"0.55454665",
"0.5515342",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5504153",
"0.5496307",
"0.5442506",
"0.54260296",... | 0.75654894 | 0 |
Creates a Project instance, using valid test defaults unless overridden in kwargs. | def create_project(self, **kwargs):
save = kwargs.get('save', True)
if kwargs.has_key('save'):
del(kwargs['save'])
index = self.object_index()
defaults = dict(slug = "test-project-%s" % index,
basecamp_url = "https://foo.basecamphq.com/projects/%s/log" % index)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_project(self):\n pass",
"def test_create_project(self):\n pass",
"def test_create_project(self):\n pass",
"def make_instance(self, include_optional):\n # model = openapi_client.models.project.Project() # noqa: E501\n if include_optional :\n retur... | [
"0.67377275",
"0.67377275",
"0.67377275",
"0.6733338",
"0.6641121",
"0.6638232",
"0.65400493",
"0.6437412",
"0.6354441",
"0.6295501",
"0.6262486",
"0.6259553",
"0.6158875",
"0.6155135",
"0.6154907",
"0.6152247",
"0.613277",
"0.6126964",
"0.6112704",
"0.60817903",
"0.6050086",... | 0.76378614 | 0 |
Create a Dashboard object, using the optional kwargs. If save=False the object is returned without saving. | def create_dashboard(self, save=True, **kwargs):
index = self.object_index()
if not kwargs: kwargs = dict(name="Test Dashboard %s" % index, slug="test-dashboard-%s" % index)
d = Dashboard(**kwargs)
if not save: return d
d.save()
self.assert_(d.id) #Cheap validit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createNewDashboard(userId, name):\n if Dashboard.objects(analystId=userId,name=name):\n return\n newDash = Dashboard()\n newDash.name = name\n newDash.analystId = userId\n newDash.save()\n return newDash",
"def create_dashboard_for_model(self, model_id, model_version=None):\r\n ... | [
"0.6506736",
"0.594477",
"0.59374374",
"0.59303516",
"0.5777631",
"0.57741624",
"0.57482916",
"0.5740831",
"0.56932694",
"0.56458133",
"0.5591037",
"0.5591037",
"0.5591037",
"0.5546158",
"0.55446786",
"0.55230343",
"0.5511173",
"0.5475626",
"0.54752666",
"0.54465854",
"0.5432... | 0.8463067 | 0 |
When given a proper URL it should be able to set it's project_id field. | def test_project_id_detection(self):
tests = {
2907852: self.url_parsing_tests['valid'],
None: self.url_parsing_tests['invalid'],
}
for basecamp_id, test_cases in tests.items():
for case in test_cases:
actual = Project.extract_basecamp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_project_id(self, request):\n project_id = request.environ[\"masakari.context\"].project_id\n if project_id in request.url:\n return project_id\n return ''",
"def update_url(self, project: str, new_url: str) -> dict:\n assert self.exists(project), f'Project {project... | [
"0.65453565",
"0.6395679",
"0.62130207",
"0.6121916",
"0.60963386",
"0.60863894",
"0.60863894",
"0.6049931",
"0.6032225",
"0.59363747",
"0.58792937",
"0.58767974",
"0.5826079",
"0.5822284",
"0.5744862",
"0.5708999",
"0.5691837",
"0.5643602",
"0.56158346",
"0.5602425",
"0.5601... | 0.5393246 | 53 |
If no name is provided, it should be loaded from Basecamp. | def test_name_detection(self):
self.project.name = ''
self.project.detect_name()
self.assertEqual("Kobol's Last Gleaming", self.project.name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __load__(self, name):\n raise KeyError(name)",
"def __init__(self, name: Optional[str] = None):\n self.name = name",
"def __init__(self, name: str):\n self.name = name",
"def __init__(self, name= None):\n self.name = name",
"def __init__(self, name: str) -> None:\n se... | [
"0.6246043",
"0.6124254",
"0.60217863",
"0.599673",
"0.5958792",
"0.59133345",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.5857884",
"0.58452326",
"0.5831441",
"0.58216715",
... | 0.5314611 | 70 |
Name and basecamp_id should be populated if URL provided. | def test_save(self):
p = self.create_project(save=False,
basecamp_url='https://foo.basecamphq.com/projects/1701/log/',
basecamp_id=None,
name='')
p.save()
self.assertEqual(1701, p.basecamp_id)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def barbican_url(self):",
"def test_campers(self):\n response = self.app.get(\"/campers\")\n self.assertTrue(response.status_code, 200)",
"def Url(self) -> str:",
"def _parsing_url(self, base_url):\n url2 = f\"{self.location}?apikey={self.api_key}&details=true\"\n absolute_url = u... | [
"0.57726336",
"0.5522064",
"0.54583406",
"0.54573566",
"0.544681",
"0.53497696",
"0.53304684",
"0.52976954",
"0.52683765",
"0.52449167",
"0.52449167",
"0.523963",
"0.52159864",
"0.52159864",
"0.52159864",
"0.52123135",
"0.52078366",
"0.5205166",
"0.51757467",
"0.5121823",
"0.... | 0.50372845 | 25 |
When fetched a summary should be present and the record should show that it is updated. | def test_summary_updates(self):
self.project.update_summary()
self.project = Project.objects.get(id=self.project.id) #Reload from db
self.assertNotEqual(None, self.project.basecamp_updated_at)
self.assert_(self.project.summary, "There should be a populated project summary.")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_if_summmary(self):\n if self._is_summary:\n self.update(True)",
"def test_update_summary(cards_db):\n i = cards_db.add_card(Card(\"foo\", owner=\"me\", state=\"done\"))\n cards_db.update_card(i, Card(summary=\"bar\", state=None))\n\n mod = cards_db.get_card(i)\n assert m... | [
"0.7387756",
"0.71113634",
"0.7079997",
"0.6472972",
"0.613627",
"0.613627",
"0.613627",
"0.6046484",
"0.59644055",
"0.59561294",
"0.5894259",
"0.58534086",
"0.5850773",
"0.58299714",
"0.58195233",
"0.5780534",
"0.57665604",
"0.5760335",
"0.5735073",
"0.5711779",
"0.56743854"... | 0.6777138 | 3 |
Returns new proposed values of position and momentum | def get_proposed_values(self):
return self.new_position, self.new_momentum, self.new_grad_logp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_proposed_values(self):\n # Take half step in time for updating momentum\n momentum_bar = self.momentum + 0.5*self.stepsize*self.model.grad_logp(self.position)\n\n # Take full step in time for updating position position\n position_bar = self.position + self.stepsize * momentum_bar\n\n grad_l... | [
"0.7411179",
"0.666384",
"0.6383803",
"0.62856805",
"0.6269769",
"0.6232472",
"0.62020135",
"0.602636",
"0.6011399",
"0.5948838",
"0.59457713",
"0.591209",
"0.5779166",
"0.57611746",
"0.5720674",
"0.5699017",
"0.5695794",
"0.56951565",
"0.5688441",
"0.5683125",
"0.566046",
... | 0.7505171 | 0 |
Method to perform time splitting using leapfrog | def _get_proposed_values(self):
# Take half step in time for updating momentum
momentum_bar = self.momentum + 0.5*self.stepsize*self.model.grad_logp(self.position)
# Take full step in time for updating position position
position_bar = self.position + self.stepsize * momentum_bar
grad_log = self.mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split(self, time: float) -> Tuple['Trajectory','Trajectory']:\n if time <= self.times[0]:\n #split before start of trajectory\n return self.constructor()([time],[self.milestones[0]]),self.constructor()([time]+self.times,[self.milestones[0]]+self.milestones)\n elif time >= se... | [
"0.6121401",
"0.59868795",
"0.5886748",
"0.57120126",
"0.55018634",
"0.5468108",
"0.5431289",
"0.5370495",
"0.5326395",
"0.53052074",
"0.52659476",
"0.5264801",
"0.52602696",
"0.5259747",
"0.5254812",
"0.52509403",
"0.5225097",
"0.5220186",
"0.5172791",
"0.5167863",
"0.516074... | 0.0 | -1 |
Control and query info about VDI sessions | def cli(ctx, host, user, no_ask):
from ._ssh import open_ssh
from .vdi import vdi_ctl
try:
ssh, ssh_cfg = open_ssh(host, user, no_ask=no_ask)
except:
click.echo('Failed to connect to "{}{}"'.format(user+'@' if user else '', host))
ctx.exit()
ctl = vdi_ctl(ssh)
ctx.obj ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_session_info():\n query = {\"type\": \"op\", \"cmd\": \"<show><session><info></info></session></show>\"}\n\n return __proxy__[\"panos.call\"](query)",
"def __init__(self):\r\n # create a session id\r\n self.session = ViSession()",
"def describe_sessions(StackName=None, FleetName=Non... | [
"0.6748842",
"0.63345075",
"0.6210047",
"0.61612386",
"0.6086457",
"0.594069",
"0.59307086",
"0.588004",
"0.5864997",
"0.58546567",
"0.5853752",
"0.5852688",
"0.5827602",
"0.5821524",
"0.58095425",
"0.57243055",
"0.568249",
"0.5674089",
"0.566321",
"0.5642942",
"0.5619833",
... | 0.0 | -1 |
Launch session if not running | def launch(ctx, force):
ctl = ctx.ctl
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
if len(jobs) != 0 and not force:
click.echo('Job already running', err=True)
sys.exit(1)
job = ctl('launch', '--partition', 'main')
click.echo(job.get('id'))
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n run_manual_session()\n # run_automated_session()",
"async def start_session(self):\n\t\t...",
"def _start_stop(self):\n if not self.running:\n #get configuration from gui\n self._start_session()\n else:\n self._stop_session()",
"def start_s... | [
"0.6921677",
"0.691715",
"0.68208355",
"0.6514407",
"0.6453011",
"0.6448769",
"0.63575375",
"0.6351494",
"0.63205147",
"0.6289441",
"0.6273304",
"0.6238755",
"0.6238755",
"0.6238755",
"0.6238755",
"0.6220544",
"0.6208992",
"0.61791897",
"0.61247176",
"0.6105644",
"0.6075375",... | 0.0 | -1 |
Shutdown session (all sessions actually) | def terminate(ctx):
ctl = ctx.ctl
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
for job in jobs:
jobid = job['id']
click.echo('Terminating {}'.format(jobid))
ctl('terminate', '--jobid', jobid) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shutdown(self) -> None:\n logger.info(\"shutting down all sessions\")\n while self.sessions:\n _, session = self.sessions.popitem()\n session.shutdown()",
"def session_shutdown(self, session):\n self.remove_session(session)",
"def shutdown(self):\n logging.... | [
"0.8046575",
"0.80323315",
"0.7747297",
"0.766137",
"0.76423067",
"0.75125694",
"0.75125694",
"0.7350594",
"0.73483306",
"0.7274264",
"0.7265721",
"0.72521734",
"0.72521734",
"0.72521734",
"0.7211544",
"0.71438706",
"0.71430176",
"0.7135877",
"0.7103759",
"0.7096072",
"0.7091... | 0.0 | -1 |
Print hostname for every active session | def hostname(ctx):
ctl = ctx.ctl
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
if len(jobs) == 0:
click.echo('No jobs running', err=True)
sys.exit(1)
for job in jobs:
host = ctl('get-host', '--jobid', job['id']).get('host')
click.echo(host)
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_hosts():\n host_str = \"\"\n data = parse(\"/tmp/cc/calls.log\")\n for ip in data:\n ln = \"{}: {}\".format(ip, data[ip]) + \"\\n\"\n host_str += ln\n return host_str",
"def show_hostname(self):\n if self.hostname is None:\n self.get_version()\n print s... | [
"0.713286",
"0.70321065",
"0.67711055",
"0.6726317",
"0.64537567",
"0.6428883",
"0.63933355",
"0.6332168",
"0.6319371",
"0.63166237",
"0.63104427",
"0.6284228",
"0.625256",
"0.6224729",
"0.6186821",
"0.6157728",
"0.6157728",
"0.61485595",
"0.6127928",
"0.6109017",
"0.61058676... | 0.6160609 | 15 |
Print display number for active session (s) | def display_nbr(ctx, as_port=False):
ctl = ctx.ctl
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
if len(jobs) == 0:
click.echo('No jobs running', err=True)
sys.exit(1)
for job in jobs:
info = collect_vnc_info(ctl, job['id'], ctx.ssh_cfg)
if as_port:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def showlinuxsession():\n print('\\nAPI-KEY: {0}'.format(middleware.ixn.apiKey))\n print('Session ID: {0}'.format(middleware.ixn.sessionId.split('/')[-1]))\n print()",
"def nice_output(self):\n return 'Inning {0}'.format(self.num)",
"def display_number(com,count):\n print \"NUM: ... | [
"0.67021835",
"0.62630767",
"0.6156052",
"0.58835924",
"0.5844819",
"0.58337957",
"0.58275574",
"0.5784338",
"0.5745291",
"0.5731504",
"0.5729567",
"0.5720762",
"0.57092357",
"0.5697654",
"0.5697105",
"0.569234",
"0.56872183",
"0.5678447",
"0.5677368",
"0.5674415",
"0.5670849... | 0.67820513 | 0 |
Print port forwarding command | def vnc_tunnel_cmd(ctx, local_port=0):
ctl = ctx.ctl
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
if len(jobs) == 0:
click.echo('No jobs running', err=True)
sys.exit(1)
local_port = local_port or randint(10000, 65000)
for job in jobs:
cmd = get_vnc_tunne... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmd_port(args):",
"def port_show(switch, port):\n print client.port.show(switch, port)",
"def port(self, arguments):\n instance_name = arguments['<instance>']\n instance_name = self.activate(instance_name)\n\n vmrun = VMrun(self.vmx, user=self.user, password=self.password)\n ... | [
"0.7035356",
"0.6920912",
"0.64945924",
"0.6319031",
"0.6299037",
"0.6251619",
"0.6245748",
"0.60753006",
"0.5955333",
"0.5913083",
"0.5902333",
"0.5899721",
"0.58415",
"0.5819029",
"0.57943815",
"0.57721925",
"0.57478744",
"0.5740907",
"0.57306814",
"0.5701392",
"0.56610006"... | 0.53877825 | 54 |
Connect to notebook on VDI | def nbconnect(ctx, local_port=0, runtime_dir=None):
from ._ssh import mk_ssh
from .nbconnect import run_nb_tunnel
ctl = ctx.ctl
ssh_cfg = ctx.ssh_cfg
jobs = ctl('list-avail', '--partition', 'main', flatten=False)
if len(jobs) == 0:
click.echo('No jobs running', err=True)
sys.e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect():\n if not is_notebook():\n print('Python session is not running in a Notebook Kernel')\n return\n\n global _comm\n\n kernel = get_ipython().kernel\n kernel.comm_manager.register_target('tdb', handle_comm_opened)\n # initiate connection to frontend.\n _comm = Comm(targe... | [
"0.7302616",
"0.66039044",
"0.63957196",
"0.6359534",
"0.625341",
"0.61476827",
"0.5933724",
"0.58434105",
"0.5814478",
"0.5782654",
"0.5782654",
"0.5765337",
"0.57637745",
"0.57462305",
"0.57228035",
"0.5720646",
"0.56900316",
"0.56900316",
"0.56900316",
"0.56900316",
"0.569... | 0.5402611 | 47 |
Initializes a model by invoking the _declarative_constructor in SQLAlchemy. We do this for full control over construction of an object | def __init__(self, **kwargs):
_declarative_constructor(self, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_model(self):\n pass",
"def init_model(self):\n pass",
"def initialize_model(self):\n model = self.model_class()\n return model",
"def initialize(self, model):\n pass",
"def __init__(self):\n self.conf = None\n self.section = None\n self... | [
"0.73547405",
"0.73199743",
"0.73054415",
"0.71788186",
"0.7161744",
"0.7003624",
"0.6982105",
"0.6978932",
"0.6933112",
"0.6892595",
"0.6869878",
"0.68538994",
"0.6825778",
"0.6809685",
"0.680115",
"0.6790181",
"0.67675006",
"0.6754955",
"0.67461616",
"0.6728338",
"0.6725077... | 0.79548216 | 0 |
Counts how many of the words in words is in the string | def count(words: list, string: str) -> int:
count = 0
for word in words:
if word in string:
count += 1
return count | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def word_count(string):\n counts = dict()\n words = string.split()\n\n for word in words:\n if word in counts:\n counts[word] += 1\n else:\n counts[word] = 1\n\n return len(counts)",
"def word_count(phrase):\n return collections.Counter(phrase.split())",
"def ... | [
"0.8396281",
"0.8102105",
"0.8020761",
"0.79431856",
"0.79333764",
"0.78711873",
"0.78288954",
"0.77515197",
"0.76638436",
"0.7632681",
"0.75856996",
"0.7585386",
"0.75299984",
"0.75235",
"0.7513716",
"0.7484651",
"0.74768686",
"0.7471442",
"0.73890334",
"0.738431",
"0.735072... | 0.8242722 | 1 |
returns True if should be applied inline | def is_inline(self):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _isinline(self, tagname):\n return False",
"def is_inline(self):\n\t\treturn self.name in get_elements_collection(self.__res, 'inline_level')",
"async def toggle_inline(self,ctx):\n self.inline = not self.inline",
"def inline(self, *args, **kwargs):\n pass",
"def check_inline(self,... | [
"0.77492195",
"0.7354087",
"0.6929993",
"0.67634755",
"0.67171144",
"0.65181583",
"0.6015258",
"0.59730154",
"0.58445996",
"0.5717896",
"0.566447",
"0.5585809",
"0.55486566",
"0.5530199",
"0.552938",
"0.55007964",
"0.5497933",
"0.5411998",
"0.5401784",
"0.5384311",
"0.5361384... | 0.83974105 | 0 |
Creates shape based on argument passed | def make_shape(type, name, divisions):
if type == 'cube':
mc.polyCube(n=name, sx=divisions, sy=divisions, sz=divisions)
elif type == 'cone':
mc.polyCone(n=name, sx=divisions, sy=divisions, sz=divisions)
elif type == 'cylinder':
mc.polyCylinder(n=name, sx=divisions, sy=divisions, sz=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shape(self) -> Shape:",
"def convert_shape(node, **kwargs):\n return create_basic_op_node('Shape', node, kwargs)",
"def shape(self):",
"def shape(self):",
"def create_helper_shape_node(input_name, output_name):\n shape_node = onnx.helper.make_node(\n \"Shape\",\n inputs=[input_name]... | [
"0.6973547",
"0.6951561",
"0.68281937",
"0.68281937",
"0.6700044",
"0.668615",
"0.6627734",
"0.66211987",
"0.656545",
"0.6553772",
"0.65018815",
"0.64977",
"0.6407365",
"0.6397423",
"0.63803166",
"0.63372326",
"0.633629",
"0.6289472",
"0.628697",
"0.6280554",
"0.62646955",
... | 0.6377532 | 15 |
Registration view This function get email and password from json request, check if email isn't in db add email and password into db, set status_id to 'Non_active', generate and send urltoken to user email. | def registration_view(request):
json = request.json_body
user_query = User.get_user_by_email(request, request.json['email'])
nickname_query = User\
.get_user_by_nickname(request, request.json['nickname'])
if user_query is None:
if nickname_query is None:
url_token_confirmatio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register():\n if request.method == 'POST':\n details = request.get_json()\n name = details.get('name')\n email = details.get('email')\n national_id = details.get('national_id')\n is_admin = details.get('admin')\n password = details.get('password')\n confirm_p... | [
"0.71419096",
"0.7078366",
"0.69472104",
"0.693519",
"0.6849618",
"0.6833757",
"0.6800396",
"0.67971",
"0.6776243",
"0.6734129",
"0.672741",
"0.6721706",
"0.67000985",
"0.6641306",
"0.6616081",
"0.6606314",
"0.6594442",
"0.6594169",
"0.65885717",
"0.65880513",
"0.6569257",
... | 0.79071903 | 0 |
Confirm registration view This function get url_token, check if it isn't in db return the 404 Error. If url_token is in db, this function create url address, change status_id to 'Active', and set role_id to 'user' | def confirm_registration_view(request):
user_email_token = request.matchdict['email_confirm']
non_active_user = User.get_one(request, url_token=user_email_token)
if non_active_user is None:
return {"msg": "Error404 HTTPNotFound"}
else:
non_active_user.status_id = UserStatus\
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def registration_view(request):\n json = request.json_body\n user_query = User.get_user_by_email(request, request.json['email'])\n nickname_query = User\\\n .get_user_by_nickname(request, request.json['nickname'])\n if user_query is None:\n if nickname_query is None:\n url_toke... | [
"0.6548345",
"0.6258552",
"0.61127406",
"0.608939",
"0.58567214",
"0.57589483",
"0.5681468",
"0.5643639",
"0.5612052",
"0.5604041",
"0.5584628",
"0.55466235",
"0.55418366",
"0.5535246",
"0.55350983",
"0.55026156",
"0.5497721",
"0.5479488",
"0.5478785",
"0.5464513",
"0.5454822... | 0.6808517 | 0 |
Test on creating todo using various string | def test_creating_todo(todoApp, input):
# Create new todo
new_todo_input = todoApp.find_new_todo_input()
print new_todo_input
new_todo_input.send_keys(input, Keys.ENTER)
# ASSERTION
# Check whether the new todo exist in the todo list or not.
todo = todoApp.find_todo(input)
# Check the new todo sta... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_a_todo(self):\n # hit the API endpoint\n response = self.make_a_request(\n kind=\"post\",\n version=\"v1\",\n data=self.valid_data\n )\n self.assertEqual(response.data, self.valid_data)\n self.assertEqual(response.status_code, stat... | [
"0.7448695",
"0.7200586",
"0.7179226",
"0.70477134",
"0.67458063",
"0.6732294",
"0.67137444",
"0.6646171",
"0.658738",
"0.64375156",
"0.6411311",
"0.6406063",
"0.63943994",
"0.63770974",
"0.6347952",
"0.63256353",
"0.6297843",
"0.6278811",
"0.61461645",
"0.60870665",
"0.60866... | 0.74891263 | 0 |
Init client with Config | def __init__(
self,
config: shuziwuliu_models.Config,
):
if UtilClient.is_unset(config):
raise TeaException({
'code': 'ParameterMissing',
'message': "'config' can not be unset"
})
self._access_key_id = config.access_key_id
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n self.config = kwargs[\"config\"]\n self.cli = client.DefaultClient(app_key=self.config[\"app_key\"], app_secret=self.config[\"app_secret\"])\n self.req = None",
"def client_setup(self):\n self.client = Client()",
"def Init(self, config):\r\n pass",... | [
"0.77205205",
"0.748969",
"0.72411644",
"0.72370625",
"0.70527494",
"0.7052649",
"0.6980011",
"0.68673897",
"0.67569655",
"0.67425776",
"0.66892445",
"0.6673647",
"0.66587555",
"0.66520613",
"0.6649865",
"0.6626396",
"0.6625521",
"0.6571919",
"0.65580463",
"0.6548734",
"0.654... | 0.6140049 | 84 |
Encapsulate the request and invoke the network | def do_request(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
runtime.validate()
_runtime = {
'tim... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _request(self, *args):\n raise NotImplementedError",
"def request(self, flow: mitmproxy.http.HTTPFlow):",
"def request(self, flow: mitmproxy.http.HTTPFlow):",
"def _request(self, *args, **kwargs):\n raise NotImplementedError()",
"def _request(self, method, url, payload=None, **params):\n ... | [
"0.73217505",
"0.7197748",
"0.7197748",
"0.7048525",
"0.7036744",
"0.70269066",
"0.7022818",
"0.6974834",
"0.6882881",
"0.68694514",
"0.6863585",
"0.68612176",
"0.68199706",
"0.6787917",
"0.6735247",
"0.6733511",
"0.66759455",
"0.6661492",
"0.6628497",
"0.6589683",
"0.6576732... | 0.639922 | 30 |
Encapsulate the request and invoke the network | async def do_request_async(
self,
version: str,
action: str,
protocol: str,
method: str,
pathname: str,
request: dict,
headers: Dict[str, str],
runtime: util_models.RuntimeOptions,
) -> dict:
runtime.validate()
_runtime = {
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _request(self, *args):\n raise NotImplementedError",
"def request(self, flow: mitmproxy.http.HTTPFlow):",
"def request(self, flow: mitmproxy.http.HTTPFlow):",
"def _request(self, *args, **kwargs):\n raise NotImplementedError()",
"def _request(self, method, url, payload=None, **params):\n ... | [
"0.7322879",
"0.7198152",
"0.7198152",
"0.70495856",
"0.703823",
"0.7027944",
"0.70223516",
"0.6975768",
"0.68829155",
"0.6870372",
"0.6864595",
"0.6862463",
"0.682029",
"0.67883766",
"0.67363423",
"0.67352724",
"0.66783005",
"0.6662441",
"0.66296285",
"0.6591807",
"0.657711"... | 0.0 | -1 |
Identifies red lights in the incoming camera image and publishes the index of the waypoint closest to the red light's stop line to /traffic_waypoint | def image_cb(self, msg):
light_wp = self.last_wp
state = self.state
self.has_image = True
self.camera_image = msg
light_wp, state = self.process_traffic_lights()
'''
Publish upcoming red lights at camera frequency.
Each predicted state has to occ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_traffic_lights(self):\n light = None\n\n #some plausability checks before starting the processing\n if None is self.waypoints:\n return -1, TrafficLight.UNKNOWN\n if None is self.pose:\n return -1, TrafficLight.UNKNOWN\n if len( self.stopLineIndex) =... | [
"0.7070285",
"0.7041899",
"0.6967643",
"0.6816919",
"0.6754921",
"0.6677822",
"0.6675664",
"0.6624752",
"0.6600227",
"0.64905286",
"0.6460968",
"0.63963324",
"0.6225359",
"0.6108355",
"0.6083328",
"0.5994978",
"0.59109867",
"0.57418406",
"0.5628054",
"0.5600468",
"0.55992246"... | 0.56167054 | 19 |
Identifies the closest path waypoint to the given position | def get_closest_waypoint(self, pose):
wpclosestDist = sys.maxint
for index in range(len(self.waypoints.waypoints)):
wp = self.waypoints.waypoints[index]
wpdist = self.calcDistance_PoseStamped(pose, wp.pose)
if(wpclosestDist > wpdist):
wpclosestDist = wpdist
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_closest_waypoint(self, pose):\n #TODO implement - Done\n # Iterate the base_waypoints' x value with current position's x value and find the closest\n # match, and pick that waypoint location index. \n min_idx = 0\n min_dist = None\n cur_x = pose.position.x\n ... | [
"0.7640383",
"0.718817",
"0.7167996",
"0.7131444",
"0.7131107",
"0.70338064",
"0.7031135",
"0.7023831",
"0.70102865",
"0.6980016",
"0.69242376",
"0.6840171",
"0.68167746",
"0.67727935",
"0.67419153",
"0.6639293",
"0.6608368",
"0.66068965",
"0.65030026",
"0.6495123",
"0.648817... | 0.67397225 | 15 |
Finds closest visible traffic light, if one exists, and determines its location and color | def process_traffic_lights(self):
light = None
#some plausability checks before starting the processing
if None is self.waypoints:
return -1, TrafficLight.UNKNOWN
if None is self.pose:
return -1, TrafficLight.UNKNOWN
if len( self.stopLineIndex) == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_traffic_lights(self):\n #DONE find the closest visible traffic light (if one exists within LOOKAHEAD_WPS)\n if self.init:\n state = self.get_light_state(0)\n return -1, TrafficLight.UNKNOWN\n elif self.ntlwp:\n state = self.get_light_state(self.ntlw... | [
"0.706805",
"0.7047184",
"0.6819055",
"0.6764632",
"0.67316353",
"0.6700383",
"0.65447426",
"0.6457697",
"0.64285344",
"0.63972515",
"0.62802887",
"0.6241258",
"0.6087701",
"0.6074844",
"0.6063886",
"0.6034228",
"0.60252565",
"0.5981899",
"0.59716964",
"0.59051466",
"0.589391... | 0.6203305 | 12 |
Handles putio.get_items request with better error handling. Since the putio API will hand back HTTP exception all the time this function will allow them to happen without crashing your script. If there are no items in a directory we return an empty list. Return A list of Item objects (from putio class...) or an empty l... | def get_items(self, parent=None, id_Number=None):
sigkill = 0
while 1:
try:
value = self.API.get_items(parent_id=parent, id=id_Number)
return value
except putio.PutioError as err:
if str(err) == "You have no items to show... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_items():\n return requester.perform_request(Uri.items)",
"def test_get_all_item(self, app, item):\n res = app.store_items.get_all_items(\n header=item.header,\n type_response=ItemsResponse,\n )\n assert res.status_code == 200",
"async def get_items(\n ... | [
"0.7251653",
"0.62557507",
"0.61749214",
"0.61535305",
"0.60895795",
"0.60632527",
"0.60632527",
"0.6048731",
"0.5943761",
"0.5902527",
"0.58333397",
"0.5765952",
"0.5759044",
"0.5714463",
"0.5705385",
"0.56921226",
"0.56823844",
"0.5629779",
"0.56284565",
"0.56101763",
"0.56... | 0.6713535 | 1 |
Get entire put.io account and and save it to a dict called contents. This function will iterate over your entire put.io account and download all files. It saves the following attribuites to the | def getAllItems(self):
control = []
for folder in self.get_items():
control.append(folder.id)
while len(control) > 0:
try:
for item in self.get_items(parent=control.pop()):
print("Getting content for: " + item.name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_output_files(self):\n bucket_list = self.bucket.list(\"output/part\")\n for bucket_entry in bucket_list:\n key_string = str(bucket_entry.key)\n # check if file exists locally, if not: download it\n if not os.path.exists(key_string):\n bucke... | [
"0.5624332",
"0.5565257",
"0.5325051",
"0.5309067",
"0.53066105",
"0.5221628",
"0.51972795",
"0.51733166",
"0.5163463",
"0.512532",
"0.5081053",
"0.50756407",
"0.507155",
"0.5058799",
"0.5047412",
"0.5042756",
"0.49936804",
"0.498855",
"0.49836323",
"0.49819744",
"0.49795422"... | 0.47829255 | 55 |
Figures out the full path to a file on Put.io itemID equals the id of the file which you want to determine the path. returns a string that contains the path of the file /foo/bar.txt | def putioPath(self, itemID=None):
path = self.get_items(id_Number=itemID)[0].name
while 1:
itemID = self.get_items(id_Number=itemID)[0].parent_id
if itemID == "0":
break
else:
path = self.get_items(id_Number=itemID)[0].name +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetchPutIOFile(self, fileID=None, fileDir=None):\r\n\r\n sigkill = 0\r\n\r\n if fileID == None or fileDir == None:\r\n raise ValueError('You must send a putio item id and file path.')\r\n\r\n if not fileID in self.contents:\r\n self.getItem(fileID)\r\n\r\n file... | [
"0.65508145",
"0.6093909",
"0.605057",
"0.60210365",
"0.59997284",
"0.5959347",
"0.5940371",
"0.59336776",
"0.59185827",
"0.5912623",
"0.5863045",
"0.58628094",
"0.58371645",
"0.5830468",
"0.5817235",
"0.579462",
"0.5781786",
"0.5779269",
"0.5740309",
"0.5699368",
"0.5698278"... | 0.7573712 | 0 |
Check whether local directory tree exists. Create if not. | def createLocalDirectory(self, file=None):
if file == None:
raise ValueError("Pass a file path!")
path, fileName = os.path.split(file)
try:
if not os.path.exists(path):
os.makedirs(path)
except OSError as err:
print("ERROR... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_local_directory(dirpath: pathlib.Path):\n if dirpath.exists():\n return False\n\n # TODO: Debug and improve this in order to catch particular exceptions\n try:\n dirpath.mkdir(parents=True)\n except Exception as error:\n raise SrtUtilsException(\n f'Directory ... | [
"0.7586968",
"0.752541",
"0.72212356",
"0.7198572",
"0.7167625",
"0.70522654",
"0.7001844",
"0.69993913",
"0.69269073",
"0.6925842",
"0.6918411",
"0.6912752",
"0.6870089",
"0.68536395",
"0.685239",
"0.68481475",
"0.6830266",
"0.6827925",
"0.67800814",
"0.67182344",
"0.6705626... | 0.0 | -1 |
We will fetch a file and store it locally. fileID is the file ID of the file you want to download from put.io fileDir The file name and local directory to save the file. | def fetchPutIOFile(self, fileID=None, fileDir=None):
sigkill = 0
if fileID == None or fileDir == None:
raise ValueError('You must send a putio item id and file path.')
if not fileID in self.contents:
self.getItem(fileID)
fileName = self.contents[file... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_file(self, file_id, filename=''):\n method = 'getFile?' + 'file_id=' + str(file_id)\n res = requests.post(self.api_url + method, file_id)\n try:\n file_path = res.json()['result']['file_path']\n # Determine the fileName. Use modified file_path if none given.\n ... | [
"0.67713237",
"0.6571637",
"0.6508179",
"0.6468049",
"0.6434974",
"0.63675445",
"0.6354371",
"0.6251986",
"0.6228547",
"0.62186724",
"0.62175226",
"0.621723",
"0.6213369",
"0.61421895",
"0.61183006",
"0.6111253",
"0.60803854",
"0.60776365",
"0.60721976",
"0.6070534",
"0.60533... | 0.76239014 | 0 |
Gets all the files in our local putio directory The reason for this function is os.path.exists is so slow. Walking the local directory and then doing a list lookup is a lot faster. We also clean up the path t o make it TODO support other drives in windows other than C. returns a list containing the full path of each fi... | def getLocalFiles(self):
for dirpath, dirnames, filenames in os.walk(self.dlLocation):
for name in filenames:
currentPath = os.path.join(dirpath, name)
currentPath = re.sub('^\w:', '', currentPath)
currentPath = re.sub(r"\\",'/', currentPath)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_all_files(root):\n local_files = []\n for path, dirs, files in os.walk(os_path(root), followlinks=False):\n if len(files) > 0:\n path_wo_root = path[(len(root) + len(slash)):] # remove root part\n local_files.extend([os.path.join(path_wo_root, f) for f in files])\n r... | [
"0.7015901",
"0.68982315",
"0.6829185",
"0.67371505",
"0.6656817",
"0.662845",
"0.65805537",
"0.6536745",
"0.6507714",
"0.6487095",
"0.6482098",
"0.6480075",
"0.64740694",
"0.6470006",
"0.6440682",
"0.6436125",
"0.64173836",
"0.6416718",
"0.637361",
"0.63688713",
"0.6312427",... | 0.6604958 | 6 |
calculate the point of intersection of axes of wheels F and B | def calc_O(F:Vec3, B:Vec3, theta:float):
if F == B:
raise ValueError('F cannot be equal to B')
if theta == 0.0:
raise ValueError('theta cannot be equal to 0.0')
L = F - B
Ox = norm2(L) / tan(theta)
phi = atan2(L.y, L.x)
alpha = phi - pi/2.0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection(self, axis2):",
"def intersection(x, y, f, p):",
"def fun(x0, x1, y0, y1, xx, yy): \n\n # Look for point of intersection between interpolated curve between nodes in x, y\n # and the normal to the face between nodes (x0, y0) and (x1, y1)\n # Transform coordinate axes\n # Center o... | [
"0.646259",
"0.641344",
"0.6152979",
"0.5793187",
"0.57662004",
"0.5640328",
"0.5593812",
"0.55634004",
"0.55567926",
"0.5550685",
"0.55491304",
"0.5429276",
"0.5378254",
"0.537555",
"0.5375357",
"0.5359578",
"0.53533936",
"0.53409344",
"0.5306884",
"0.52935976",
"0.5290464",... | 0.50560206 | 62 |
rotate point P about O by dtheta radians | def rotate_point_by(P:Vec3, O:Vec3, dtheta:float):
PO = P - O
R = norm2(PO)
cos_theta = PO.x / R
sin_theta = PO.y / R
cos_dtheta = cos(dtheta)
sin_dtheta = sin(dtheta)
cos_theta_plus_dtheta = cos_theta*cos_dtheta - sin_theta*sin_dtheta
sin_theta_plus_dthet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rotate_about(self, p, theta):\n result = self.clone()\n result.translate(-p.x, -p.y)\n result.rotate(theta)\n result.translate(p.x, p.y)\n return result",
"def rotate(self, theta, point):\n r = self - point\n x = r.x * math.cos(theta) - r.y * math.sin(theta)\n... | [
"0.7366025",
"0.7336842",
"0.7231373",
"0.697945",
"0.6894734",
"0.68924886",
"0.6783059",
"0.67477643",
"0.6742044",
"0.6718778",
"0.6710311",
"0.66871434",
"0.665914",
"0.6606632",
"0.65712065",
"0.6569933",
"0.6564392",
"0.65294605",
"0.6525388",
"0.652423",
"0.6508847",
... | 0.88402575 | 0 |
Function to perform read operation with the database to get the top artist | def get_top_artist_tracks(session, number_of_artist):
try:
if not issubclass(type(session), sqlalchemy.orm.session.Session):
raise AttributeError("session not passed correctly, should be of type 'sqlalchemy.orm.session.Session' ")
if not issubclass(type(number_of_artist), int) or number... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_artists_most_played(session_):\n # artists = session_.query(Artist).order_by(Artist.name.asc()).paginate()\n artists = session_.query(Artist).order_by(Artist.plays.desc()).all()\n return artists",
"def top_artists_from_API(api_results):\r\n df = pd.DataFrame(api_results[\"items\"])\r\n col... | [
"0.6849134",
"0.66032416",
"0.65351725",
"0.6413231",
"0.63552356",
"0.63133323",
"0.62837493",
"0.6265987",
"0.6252838",
"0.6200527",
"0.61681056",
"0.6130825",
"0.6129044",
"0.61084133",
"0.61036533",
"0.60961986",
"0.6052323",
"0.6035289",
"0.6007485",
"0.5997498",
"0.5984... | 0.7609244 | 0 |
Add uniform noise to a given dataset. Function to add uniform random noise to a given dataset. Uniform noise in range [510^(p), 510^(p)] is added to each data entry. For integervalued sequences, p = 1. | def add_uniform_noise(data, p=1):
if p < 1:
raise ValueError("'p' has to be greater or equal to 1.")
noise = np.random.uniform(-5.*10**(-p), 5*10**(-p), size = len(data))
randomized_data = data + noise
# ensure there are no negative entries after noise is added
randomized_data = \
ra... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_noise(self, data):",
"def uniform_noise_like(\n da: xr.DataArray, low: float = 1e-6, high: float = 1e-3\n) -> xr.DataArray:\n if uses_dask(da):\n mod = dsk\n kw = {\"chunks\": da.chunks}\n else:\n mod = np\n kw = {}\n\n return da.copy(\n data=(high - low) * ... | [
"0.7465272",
"0.7017835",
"0.69086975",
"0.68982387",
"0.68722546",
"0.68413025",
"0.68310094",
"0.6785632",
"0.6685227",
"0.664166",
"0.6633581",
"0.6620472",
"0.6596529",
"0.6596529",
"0.6562329",
"0.6559136",
"0.6473762",
"0.64221513",
"0.63911885",
"0.6359188",
"0.6347256... | 0.7983066 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.